Cursor Control 1
Volume Number: 6
Issue Number: 6
Column Tag: abC
By Bob Gordon, Minneapolis, MN
Note: Source code files accompanying article are located on MacTech CD-ROM orsource code disks.
Managing Cursors
I know how to curse
Shakespeare, The Tempest (Act 1, Scene 2)
If you remember from last time, I had introduced the idea of adding some
additional data structures at the end of the window record to aid in keeping track of the
data that hangs around with a window. At the end of that article I said we would
illustrate the use of the added data in managing the cursor. We will cover that, but
first I would like to comment on a nice piece of work by John Nairn in the April issue.
John has presented a full-blown Scrolling Manager to handle all the issues
involved with creating and maintaining scrolling windows. While there are a number
of differences between what he has done and what I am describing in this column, a
couple common points are worth mentioning. First, the approach is to isolate the user
interface control from the actual application. That is, as much as possible, develop
generic code to handle the basic operation of the windows (or menus or dialogs, for that
matter). Second, this generic code will probably require some place to keep the
information it uses; develop a data structure to hold this, and attach it in some way to
the window (or menu or dialog). There is actually a bit more commonality (I have the
advantage of being able to see the parts I have written but not yet published), and we
will explore one of those in this article.
One point of difference. John uses the window’s refCon to hold his additional data
structure. His new data structure includes its own refCon for the window’s contents. I
added the data on to the end of the window’s structure itself. I feel this simplifies
things somewhat, and at least for now it does not seem to violate any rules. If you liked
John’s article as I did, you certainly have my permission to use the technique I’ve
outlined in implementing it. While I haven’t met John, I’m reasonably sure he won’t
mind.
Cursors
The cursor attached to the mouse changes its shape as you move the mouse around
the screen. In addition, the user can often affect its shape directly by selecting a tool
from a toolbox (usually found in graphics or page layout applications). The problem
we deal with this month is how to manage the cursor so it is handled as automatically as
possible.
The first issue is getting cursors. There are five built in to the Mac: arrow,
crosshairs, plus, clock, i-beam. You can also make your own with ResEdit or some
other resource tool. Once we have decided the cursors to use (and made their
resources), we need to control the appearance on the screen. What I will describe this
month is one way to manage the change of cursor shape as the user moves the mouse
around the screen. I am not covering the setting of the cursor’s via tool box or menus.
In June I suggested the use of window margins. The window margin is that area
between the window’s frame, which is handled by the Macintosh toolbox routines, and
the window’s actual contents, which is what your application is about. The objects that
might be in a window margin include scroll bars, rulers, and tool boxes. These are
such common components of windows that they can be handled by generic code apart
from your application. The other property of the window margin is that the cursor
typically changes into the arrow as it is moved into the scroll bar, ruler, etc.
Cursorhelp
Cursorhelp consists of three functions and an include file to aid in the setting and
automatic changing of cursors. These functions assume the window structure described
in June. The window margins (mtop,mbottom, mright, mleft) are stored with the
window. More importantly, the rectangle that surrounds the actual window contents
(cursrt) is also stored (I assume rectangular windows). This rectangle is the area in
which the cursor is the shape the user selected (i beam, cross, etc.). I put it in the
window structure simply to avoid having to calculate it each time. The final piece is the
cursor itself (mouser). That is, the cursor’s shape as selected by the user is a
property of the window. With a multi-window application the user can have one
window editing text, another editing a graphic, and a third editing a spreadsheet (I am
not suggesting anyone actually write something like this), and the appropriate cursor
will be displayed automatically as the user selects each window. The main loop need
know nothing of the cursors.
The main loop does need to set the cursor. There are two places where this can
occur: the users specifies a cursor in some way or, the application displays the watch
(or other indicator) to indicate the passage of time. The program calls CursorToUse
passing the window and the number of the desired cursor.
The program also needs to set the cursor rectangle. This must be done every time
the window’s size is changed or the window margins are changed (for example,
choosing to show rulers or not).A call to CursorRect() does that. Note that the window
margins must have been previously set.
To actually control the cursor, the program calls CursorMaintain() as it runs
through the event loop.
Include Files
/* windowhelp.h */
#include “TextEdit.h”
#ifndef WINDOWHELP_H
#define WINDOWHELP_H
#include “abc.h” /* window add-on structure */
#define WindowStruct struct w_struct
WindowStruct
{
WindowRecord wr; /* the original window record */
uchar mtop; /* margin indents */
uchar mleft;
uchar mbottom;
uchar mright;
Rect cursrt; /* used for cursor control */
char mouser; /* mouse pointer id */
char changed; /* if contents were changed */
long ckind; /* kind of contents */
short fileref; /* associated file, if any */
TEHandle curtext; /* handle to current text */
};
WindowStruct *WindowNew();
#define Woffset 18
#define SBarWidth 15
/* these definitions allow easy generation of the four square
cornered titled windows. The basic (simplest) window is the WDOC
(NoGrowDocProc). To this optionally add WGROW to add a grow box
and/or WZOOM to add a zoom box.
*/
#define WDOC 4
#define WGROW -4
#define WZOOM 8
#define WVBAR 16
#define WHBAR 32
/* Value placed in windowKind field of WindowRecord by WindowNew if
the window has a grow box. This is used by routines that redraw the
window to decide whether to draw the grow box or not
*/
#define HASGROW 9
#endif
/* cursorhelp.h
* header file for cursorhelp
*/
#define ARROW 0
#define IBEAM 1
#define CROSS 2
#define PLUS 3
#define WATCH 4
CursorHelp Functions
#include “abc.h”
#include “Quickdraw.h”
#include “ windowMgr.h”
#include “ windowhelp.h”
#include “cursorhelp.h”
/* CursorMaintain
* Adjusts the cursor according to the value
* set in the window and the rectangle currect.
* If the mouse is in the rectangle, the cursor
* set to the current cursor, otherwise it is
* set to the arrow.
* The if statement checks to see if there is a
* valid window and if the window belongs to the
* application. If it does not belong to the application
* it is a DA. If the DA is controlling the cursor, there
* will be a conflict as both programs attempt to control
* it.
*/
CursorMaintain(ws)
WindowStruct *ws;
{
Point pt;
CursHandle curs;
short curcursor; /* current cursor */
if (ws && (((WindowRecord *)ws)-> windowKind > 7) )
{
GetMouse(&pt);
curcursor = ws->mouser; /* cursor kind is stored in the window
struct */
if ((PtInRect(pt, &(ws->cursrt))) && (curcursor))
{
curs = (Cursor **)GetCursor(curcursor);
SetCursor(*curs);
}
else if (curcursor != WATCH)
{
InitCursor();
}
}
if (ws == NIL)
InitCursor();
}
/* CursorRect
* Uses the portRect of the window passed in
* to set the current rectangle. Adjusts the size
* of the rectangle to account for window margins.
* By keeping the rectangle around, we eliminate doing
* this each time through the event loop.
*/
CursorRect(ws)
WindowStruct *ws;
{
ws->cursrt = ((GrafPort *)ws)->portRect;
AdjustRect(&(ws->cursrt),ws->mtop,ws->mleft,ws->mbottom,ws->mright)
;
}
/* CursorToUse
* Sets the cursor to be displayed in the
* rectangle of the current window.
* Either pass a pointer to the window struct
* or a NULL pointer. If a NULL pointer is passed,
* CursorToUse() will use the front window.
* Note: At least one window must exist for this
* to work, but if no windows exist, it
* will not hurt.
*/
CursorToUse(ws,c)
WindowStruct *ws; /* window struct to set cursor for */
short c; /* cursor code to use */
{
if (!ws)
ws = (WindowStruct *)FrontWindow();
if (ws)
ws->mouser = c;
}
Using CursorMaintain()
The following fragment shows the call to CursorMaintain() in the main event
loop.
EventLoop()
{
EventRecord theEvent;
char c;
short windowcode;
WindowPtr wp;
WindowStruct *ws;
while(True)
{
wp = FrontWindow();
SystemTask();
CursorMaintain(wp);
if (wp)
{
AppTask(wp);
}
if (GetNextEvent(everyEvent,&theEvent))
switch(theEvent.what)
Other Comments
Check John Nairn’s article for other things to do to automate cursor control. You
will note he checks for certain keys being pressed to change the cursor to allow window
scrolling (e.g. with a hand).
Last Time
I have a minor error in June’s column. I included some space in the window
structure to handle window zooming. These are not needed as zooming is fully supported
by the Mac Toolbox. I hadn’t used them for anything yet.
Next Time
Next time I am going to show a quick and very dirty way to help deal with menus.
P.S. Comments are welcome. Send your notes to MacTutor, and please include a
phone number.
Referenced by (2):