/****************************************************************************

Crosshair 1.0
Michael Durland
[email protected]
May 20, 2004

This macro provides a movable crosshair on the screen which makes it easy
to line up text vertically and horizontally.  For example, if the cursor
is near the bottom of the screen, it can be used to visually identify
what is directly above the cursor near the top of the screen.  This is
also useful across multiple open windows for visually checking lineup.

The crosshair can be moved around the screen using the cursor keys.
The ENTER key will remove the crosshair and set the cursor to the
crosshair location.  Any other key will remove the crosshair and restore
the cursor to its original position.

The macro is most useful when assigned to a hotkey of your choosing.

Feel free to use/modify/distribute/etc. however you want.
This macro was developed under version TSE Pro v4.0.
Portions of this macro are based on ruler.s by Glenn Alcott.

*****************************************************************************/

integer start_column = 0
integer start_line = 0
integer start_x = 0
integer start_y = 0
integer cross_x = 0
integer cross_y = 0
integer edge_top = 1
integer edge_bottom = 0
integer edge_left = 1
integer edge_right = 0

integer cross_color = Color(bright black on blue)
// Other interesting colors:
//integer cross_color = Color(bright red on blue)
//integer cross_color = Color(bright blue on blue)
//integer cross_color = Color(bright cyan on blue)
//integer cross_color = Color(bright yellow on blue)
//integer cross_color = Color(bright magenta on blue)
//integer cross_color = Color(white on blue)
//integer cross_color = Color(red on blue)

proc paint_crosshair()
    integer i = 0
    string  s[1] = ""

    UpdateDisplay(_ALL_WINDOWS_REFRESH_)

    // Paint the horizontal line
    for i = edge_left to edge_right
        GetStrXY(i, cross_y, s, 1)
        // Only paint line in blank spaces, and skip the crosshair intersection
        if Asc(s) == 32 and i <> cross_x
            PutOEMStrXY(i, cross_y, Chr(196), cross_color)
        endif
    endfor

    // Paint the vertical line
    for i = edge_top to edge_bottom
        GetStrXY(cross_x, i, s, 1)
        // Only paint line in blank spaces
        if Asc(s) == 32
            if i == cross_y
                // Paint the intersection
                PutOEMStrXY(cross_x, i, Chr(197), cross_color)
            else
                PutOEMStrXY(cross_x, i, Chr(179), cross_color)
            endif
        endif
    endfor

    // Show the current crosshair position in the status bar
    Message("L ", start_line + cross_y - start_y : -8, "C ", start_column + cross_x - start_x)
end

proc Main()
    integer cursor_state = Query(Cursor)
    integer done = FALSE

    Set(Cursor, OFF)

    // Save current cursor position in buffer
    start_column = CurrCol()
    start_line = CurrLine()

    // Save absolute starting position
    start_x = WhereX()
    start_y = WhereY()

    // Initialize absolete crosshair position
    cross_x = WhereX()
    cross_y = WhereY()

    // Initialize crosshair width range
    if Query(DisplayBoxed)
        edge_left = 2
        edge_right = Query(ScreenCols) - 1
    else
        edge_left = 1
        edge_right = Query(ScreenCols)
    endif

    // Initialize crosshair height range
    // Note these may be slightly off depending on current customizations.
    edge_top = 3
    edge_bottom = Query(ScreenRows) - 2

    // Do it
    repeat
        paint_crosshair()
        case GetKey()
            when <CursorDown>
                // Move down one row
                cross_y = iif(cross_y >= edge_bottom, edge_bottom, cross_y + 1)

            when <CursorUp>
                // Move up one row
                cross_y = iif(cross_y <= edge_top, edge_top, cross_y - 1)

            when <CursorLeft>
                // Move left one column
                cross_x = iif(cross_x <= edge_left, edge_left, cross_x - 1)

            when <CursorRight>
                // Move right one column
                cross_x = iif(cross_x >= edge_right, edge_right, cross_x + 1)

            when <Home>
                // Move to the left edge of the screen
                cross_x = edge_left

            when <End>
                // Move to the right edge of the screen
                cross_x = edge_right

            when <PgUp>
                // Move to the top of the screen
                cross_y = edge_top

            when <PgDn>
                // Move to the bottom of the screen
                cross_y = edge_bottom

            when <Enter>
                // Exit the crosshair mode, setting the cursor to the
                // current crosshair location.
                GotoRow(CurrRow() + (cross_y - start_y))
                GotoColumn(start_column + cross_x - start_x)
                done = TRUE

            otherwise
                // Exit the crosshair mode, restoring the original
                // cursor position.
                done = TRUE
        endcase
    until done
    UpdateDisplay(_ALL_WINDOWS_REFRESH_)
    Set(Cursor, cursor_state)
end

quote:

---

Originally posted by feline
Not as easy as having this built into VA, but I am not sure how well this would really fit into VA. It seems a very specific command.

---

quote:

---

Originally posted by feline

If I might be permitted a small rant?

A few years ago while working under UNIX (so nothing to do with Whole Tomato) I spent 2 solid weeks tracking down "my program crashes", only to eventually find the cause was the code:

char *pBuffer = (char *)malloc(6);
strcat(pBuffer, "hello");

---

quote:

---

After being the "lucky" person to fix a various other bugs caused by people overrunning their buffers by 1 character - often doing things like your piece of code, I was given the task of working through the entire code base, by hand, studying and removing all calls to sprintf, strcat, and their relatives.

Trust me on this one, hard coding the length of the string is a bad idea, unless your strings are SO set in stone they can NEVER, EVER, EVER change. Experience indicates this is very unlikely, even when people claim it is true.

Now back to your regular viewing experience

---

if (strlen(option) >= 12 && _memicmp(option, "some example", 12) == 0)
{
    // Code here
}

const char cgcSomeExample[] = "some example";

if (strlen(option) >= sizeof(cgcSomeExample) - 1 && _memicmp(option, cgcSomeExample, sizeof(cgcSomeExample) - 1) == 0)
{
    // Code here
}

inline int my_memicmp(const void* some_ptr , const char* some_constant_string)
{
    return memicmp (some_ptr, some_constant_string, strlen(some_constant_string));
}
// ...
if (my_memicmp (some_ptr, "some constant") == 0)

quote:

---

One nicely detailed email sent.

---

quote:

---

I just realized however, that short of interpreting manipulators (i. e. setw(int)) VAX would have little to no means of really be of help here, so I suppose my point is moot

---

static void formatReportText(...)
{
    char *pszLineOne =
"this is       the text         formatted          into\\n";
    char *pszLineTwo =
"columns       using a          rather low         tech\\n";
    char *pszLineThree =
"method\\n";
}

quote:

---

However this rather assumes that the hard coded length is close to the string...

---

quote:

---

When the hard coded length is in a different cpp file, 8 directories away, in a totally different directory tree, 16 function calls away...

Yes, I have been there, done that, got the t-shirt.

---

quote:

---

Rick you may not write errors into your code

---

quote:

---

Originally posted by RickHodgin

This would probably be true unless you happened to have an editor where you hit a one-key or two-key function to update the length for you if you happened to change the string.

---

quote:

---

Originally posted by RickHodgin

quote:

---

I spent years learning the hard way why defensive programming is a good idea

---

I've heard silly people say this kind of thing for years. But since I almost never write errors into my code... I mean really I just don't see the need.

---

quote:

---

Originally posted by RickHodgin

That code you had looks like it should work. strcat() would attempt to append "hello\\0", a 6-character string on to the end of a 0-length string (the initialized malloc() block). Why would that cause an error?

---

quote:

---

The problem with these bugs, this one included, is that they did NOT crash at, or even close to, the bad code, so the call stack was dubious.

---

quote:

---

I spent years learning the hard way why defensive programming is a good idea

---

quote:

---

hard coding the length of the string is a bad idea, unless your strings are SO set in stone they can NEVER, EVER, EVER change.

---

quote:

---

Originally posted by RickHodgin

quote:

---

only to eventually (two weeks later) find the cause was the code:

---

Fortunately with VS we have good debuggers with a call stack trace. :)

---

quote:

---

Originally posted by RickHodgin

quote:

---

only to eventually (two weeks later) find the cause was the code:

---

Fortunately with VS we have good debuggers with a call stack trace. :)

---

quote:

---

only to eventually (two weeks later) find the cause was the code:

---

char *pBuffer = (char *)malloc(6);
strcat(pBuffer, "hello");

const char *pszValue;
memicmp(some_ptr, pszValue, strlen(pszValue)