TweetFollow Us on Twitter

Doodats
Volume Number:5
Issue Number:9
Column Tag:C Workshop

Three Doodats

By Lee A. Neuse, Manassas, VA

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

[Lee Neuse started in the days you built them before programmed them. He was lured away from IBM compatibles to the Mac in 1982 and been there ever since. Currently, he is working for Computer Science Corporation designing and implementing Mac software as part of CSC research. His Mousehole handle is "Noisy".]

Three Doodats

Doodat -- a trivial problem guaranteed to make a programmer’s life miserable; from the expression “How did he do dat?”.

It seems like every programmer, at one time or another, is faced with the same dilemma: wanting to use a feature in a program, but not wanting to spend the time to figure out the technique. For example, we all know that a Balanced B-Tree index is wonderfully efficient, but how many of us really want to sit down and write the code? One solution is to start reading back issues of MacTutor, hoping that some kind soul has already published useable source code. Another is to scour public domain software for an author willing to impart knowledge in exchange for a shareware donation. Either way, it’s usually faster (and easier) to find and adapt someone else’s code instead of doing it yourself.

The purpose of ‘Doodats’ is to provide generic solutions to the little problems, so the programmer can spend his or her time working on the big problems (like what the program does).

Doodat #1

Problem: how to determine if the user has tried to abort something by pressing the Cmd-’.’ keys. EventAvail() returns only the first keystroke event in the queue, and the user may have pressed some other keys since the last keystroke event was read by the application. Either GetNextEvent() or WaitNextEvent() return all keystroke events, forcing the application to store them or ignore them (a Bad Thing). Moreover, if MultiFinder is running, calling any of these event-related traps may cause the application to be switched out, which could cause problems.

Solution: Doodat #1 is a routine called check_abort(), which directly scans the ToolBox’s internal event queue for Cmd-’.’ abort events.

The routine starts by setting a pointer to head of the event queue (stored in the system global EventQueue), then examining the next event in the queue. If the event is a Cmd-’.’ event, it is removed by calling Dequeue(), and the ‘found’ flag set. If the pointer does not match the event queue tail, it is advanced to the next event, otherwise, the function returns. This technique solves all of the problems posed by normal event processing:

1. It doesn’t affect any other keystroke events in the queue.

2. If the user has generated multiple aborts (by holding the keys down), it removes all of them.

3. It does not call EventAvail() or WaitNextEvent(), so no chance of being switched in or out under MultiFinder.

To use check_abort(), call it from within any place where the user might want to abort. For example:

/* 1 */

for (page = 1; page < last_page; page++)
 {
 /* print a page */
 if (check_abort())
 break;
 }

/*************************************************
**
** check_abort() - Lightspeed C Version
**
** This routine returns scans the low-level
** event queue in search of a Cmd-’.’ key event
** Each one found is removed from the event
** queue.
**
** In:  N/A
**
** Out: TRUE if Cmd-’.’ found, FALSE otherwise.
**
*/

Boolean
check_abort()
{
EvQElPtreq_p;
Boolean f_found = false;

/* start at head of internal queue */
eq_p = (EvQElPtr)(EventQueue.qHead);

while (true)
 {
 if ((eq_p->evtQWhat == keyDown ||
 (eq_p->evtQWhat == autoKey) &&
 (eq_p->evtQModifiers & cmdKey) &&
 (eq_p->evtQMessage & charCodeMask) == ‘.’)
 {
/* remove the event from the queue */
 Dequeue((QElemPtr)eq_p, &EventQueue);
 f_found = true;
 }
/* test for end of queue */
 if (eq_p == (EvQElPtr)EventQueue.qTail)
 break;

/* continue with next queue entry */
 eq_p = (EvQEl *)(eq_p->qLink);
 }
return(f_found);
}/* end of check_abort() */

Doodat #2

Problem: Many windows contain items such as lines, icons, pictures, or text strings that are there for decoration; these items don’t change in appearance, and clicking on them has no effect. While the code to draw these items is relatively simple, it is also very boring to write, and frequently quite lengthy. In addition, trying to figure out exactly which horizontal and vertical co-ordinates to use can be time-consuming and frustrating.

Solution: Doodat #2 is an attempt to save time (and code!) by making ResEdit and the Resource Manager do most of the work. This involves a two-step approach:

Step 1 is to use ResEdit (or any other Resource tool) to create a ‘DITL’ resource (Dialog Item List) that contains all of the items desired. ResEdit is particularly handy, as the items can be arranged visually within the window. The DITL resource may be created and edited normally, with all items being set to disabled. No Control or EditText items should be included (they will be ignored if you do), and the items may be in any order. The finished DITL resource is then included in the application’s resources for later use.

UserItems in the item list are handled in one of two ways: either as a dividing line or as frame. If the horizontal or vertical co-ordinates are equal, i.e. the boundary rectangle is empty, it is drawn as a 50% gray line. If the rectangle is not empty, it is drawn as a black frame.

Text items are drawn (left-justified) in whatever font the window’s port is using when draw_ditl() is called. Different text characteristics could be supplied by reserving the first few characters of the text string but that’s for another time.

Step 2 is to use the routine below called draw_ditl() to actually read in and draw the items within the window. This routine accepts the ID number of a DITL resource, reads the resource into memory, then traverses the item list, drawing each item accordingly. For draw_ditl() to work properly, the DITL resource must be present in the application’s resource fork (or in an open resource file), and the port set to the desired window.

draw_ditl() uses the following definitions and structure:

/* 2 */

#define NIL 0L

/* Test a pointer for validity */
#define VALID_PTR(p) ((long)(p) &&
 ((long)(p) & 1L) == NIL)

/* Test a handle for validity */
#define VALID_HNDL(h)(VALID_PTR(h) &&
 VALID_PTR((long)(*(h)) & 0x00FFFFFF))

typedef struct
 {
 Handle hndl;
 Rect   frame;
 unsigned char   type;
 unsigned char   length;
 short  data[];
 } ditl_list;

/*************************************************
**
** draw_ditl() - Lightspeed C Version
**
** This routine reads in and draws the items in a
** Dialog Item List (DITL) resource.
**
** In:  resource id of DITL
**
** Out: N/A
**
*/

void
draw_ditl(ditl_id)
short   ditl_id;
{
Handle  ditl_h;
ditl_list *ditl_p;
PenStatesave_pen;
short   d_type, offset, num_items;

ditl_h = GetResource(‘DITL’, ditl_id);
if (ResError() != noErr || !VALID_HNDL(ditl_h))
 return;

HLock(ditl_h);
/* don’t change pen behind the window’s back */
GetPenState(&save_pen);
PenNormal();
/* get the number of items in list */
num_items = *((short *)(*ditl_h)) + 1;
/* set pointer to first item in list */
ditl_p = (ditl_list *)((*ditl_h) + sizeof(short));
while  (num_items--)
 {
/* mask out the item disabled bit */
 switch (ditl_p->type & 0x7F)
 {
 case statText:
 TextBox((char *)ditl_p->data,
 ditl_p->length, &(ditl_p->frame),
 teJustLeft);
 break;
 
 case iconItem:
 ditl_p->hndl =
 GetIcon(ditl_p->data[0]);
 if (VALID_HNDL(ditl_p->hndl))
 {
 PlotIcon(&(ditl_p->frame),
 ditl_p->hndl);
 ReleaseResource(ditl_p->hndl);
 }
 break;
 
 case picItem:
 ditl_p->hndl = GetResource(‘PICT’,
 ditl_p->data[0]);
 if (VALID_HNDL(ditl_p->hndl))
 {
 DrawPicture((PicHandle)ditl_p->hndl,
 &(ditl_p->frame));
 ReleaseReource(ditl_p->hndl);
 }
 break;
 
 case userItem:
 if (EmptyRect(&(ditl_p->frame)))
 {
 PenPat(gray);
 MoveTo(ditl_p->frame.left,
 ditl_p->frame.top);
 LineTo(ditl_p->frame.right,
 ditl_p->frame.bottom);
 PenPat(black);
 }
 else
 FrameRect(&(ditl_p->frame));
 break;
 }
/* force offset to a word (even) boundary */
 if ((offset = ditl_p->length) & 1)
 offset++;
/* advance pointer to next item */
 ditl_p = (ditl_list *)((char *)ditl_p +
 sizeof(ditl_list) + offset);
 }

HUnlock(ditl_h);
ReleaseResource(ditl_h);
/* restore pen to original condition */
SetPenState(&save_pen);
}/* end of draw_ditl() */

Doodat #3

Problem: Sooner or later, an application is going to need to access a data file of some sort, with fixed-length or variable-length records, keys, and so forth. Using the Resource Manager as a Poor Man’s Database is a Bad Thing according to Apple, and not everyone can afford (or write) a full ISAM (Indexed Sequential Access Method) utility.

Solution: Doodat #3, which includes some primitive (but useful) indexing routines. If used properly, they can be used for indexing files, arrays, or be used for look-up tables, etc.

All of the routines are based on the idea of a simple index, made up of 1-n index entries. Each index entry is a key value and it’s associated data value, and is defined in the index_entry structure below. The key and data values are always handled in pairs: for any given key, there is only one data value (provided it exists). Duplicate keys are not allowed, and both key and data values are limited to numeric values. What the key and data values actually represent depends on the application, an obvious example would be relating a part number to an offset into a file.

Several different indices can be manipulated using the same routines, it is the application’s responsibility to determine which index to use. If the indexes are small and/or few in number, they could be manually rebuilt each time the application is executed. Alternately, they could be saved between sessions, either as data files, or as resources: all that is needed the memory block referenced by the index handle (use GetHandleSize() to find it’s size). An elegant solution would be to save any or all data file indices as resources in the data file’s resource fork, but that would limit the index size to 32K.

Adding a new key to an index (or updating an existing key) is done by the db_insert_key() function: a pointer to the index handle, a key value, and the data value associated with the key are all passed as parameters. If the index handle is NIL, a new handle is allocated, otherwise, the index is expanded by one index entry, and the new key added to the index in ascending order. If the key value already exists in the index, the data value is updated with the new value.

Once an index has keys inserted into it, db_get_key() can be used to search the index for a given key value. The routine expects an index handle and a key value, then performs a binary search on the index. If the key value is found, the data value associated with the key is returned, otherwise -1 is returned to signal failure.

There may be times when it is necessary to find a key’s location in the index, thus db_get_seq_key() accepts an index handle and an entry number, then returns the key value found at that entry. Once again, -1 is returned to signal failure if the entry number is less than 1 or greater than the number of keys. This routine can be used to sequentially read through an index (in ascending order), using the following code:

/* 3 */

long  w_key, key_value;

w_key = 1L;
while (true)
 {
 key_value = db_get_seq_key(my_index, w_key++);
 if (key_value == -1L)
 break;

 my_data = db_get_key(my_index, key_value);
/*
** process my_data here
*/
 }

Some possible extensions to these routines include modifying them to store a character pointer as the key, providing non-numeric keys. For small indexes, the entire data record could be embedded as part of the index_entry structure, and a pointer to the structure returned by db_get_key().

The routines db_get_key(), db_get_seq_key(), and db_insert_key() all utilize the following definitions and structure:

/* 4 */

#define NIL 0L
/* Test a pointer for validity */
#define VALID_PTR(p) ((long)(p) &&
 ((long)(p) & 1L) == NIL)

/* Test a handle for validity */
#define VALID_HNDL(h)(VALID_PTR(h) &&
 VALID_PTR((long)(*(h)) & 0x00FFFFFF))

typedef struct
 {
 unsigned long   key;
 unsigned long   data;
 } index_entry;

/************************************************
**
** db_get_key()
**
** This routine performs a binary search on a
** list of index entries
**
** In:  index_hndl Handle to index
** target key value to find
**
** Out: -1 if NOT found, data value otherwise
**
*/

long
db_get_key(index_hndl, target)
Handle  index_hndl;
register long  target;
{
register index_entry *i_ptr;
register long    mid, low, high;

if (VALID_HNDL(index_hndl))
 {
 low = 1L;
 high = GetHandleSize(index_hndl) /
 sizeof(index_entry);

 while (low <= high)
 {
/* calculate the mid point of list */
 mid = ((low + high) >> 1) - 1;
 i_ptr = *index_hndl + (mid *
 sizeof(index_entry));

 if (i_ptr->key > target)
/* too big, so look in lower half  */
 high = mid;
 else if (i_ptr->key < target)
/* too small, so look in upper half */
 low = mid + 2;
 else
/* hmmm, guess we found it  */
 return(i_ptr->data);
 }
 }
return(-1L);
}/* end of db_get_key() */

/************************************************
**
** db_get_seq_key()
**
** This routine reads a list of index entries,
** returning a key based on a sequential number
**
** In:  index_hndl Handle to index
** key_numkey number to return
**
** Out: -1 if NOT found, key value otherwise
**
*/

long db_get_seq_key(index_hndl, key_num)
Handle  index_hndl;
short   key_num;
{
index_entry *i_ptr;
long    result = -1L;
short   num_keys;

if (VALID_HNDL(index_hndl)
 {
/* count number of keys in index */
 num_keys = GetHandleSize(index_hndl) /
 sizeof(index_entry);
 if (--key_num < num_keys)
 {
/* calculate offset into the index */
 i_ptr = *index_hndl + (key_num *
 sizeof(index_entry));
 result = i_ptr->key;
 }
 }

return(result);
}/* end of db_get_seq_key() */

/************************************************
**
** db_insert_key()
**
** This routine inserts a key into an index.
**
** In:  index_hndl Handle to index
** target key value to insert
** data data value associated
** with the key
**
** Out: N/A
*/

void
db_insert_key(index_hndl, target, data)
Handle  *index_hndl;
long    target;
long    data;
{
register index_entry *i_ptr, *n_ptr;
register long    mid, low, high, i_size;

/* empty list is special case! */
if (!VALID_HNDL(*index_hndl))
 {
/* allocate new handle */
 *index_hndl = NewHandle(sizeof(index_entry));
 ((index_entry *)(**index_hndl))->key = target;
 ((index_entry *)(**index_hndl))->data = data;
 }
else
 {
 low = 1L;
 high = i_size = GetHandleSize(*index_hndl) /
 sizeof(index_entry);

 while (low <= high)
 {
/* calculate the mid point of list */
 mid = ((low + high) >> 1) - 1;
 i_ptr = *index_hndl + (mid *
 sizeof(index_entry));

 if (i_ptr->key > target)
/* too big, so look in lower half */
 high = mid;
 else if (i_ptr->key < target)
/* too small, so look in upper half */
 low = mid + 2;
 else
/* found it, so store new key value */
 i_ptr->data = data;
 }

/* extend handle by size of one entry*/
 SetHandleSize(*index_hndl, (i_size + 1) *
 sizeof(index_entry));
/* test for memory error here */
 n_ptr = i_ptr = **index_hndl + (mid * 
 sizeof(index_entry));
 memcpy(++n_ptr, i_ptr, (i_size - mid) *
 sizeof(index_entry));
/* do we insert as right or left? */
 if (i_ptr->key < target)
 i_ptr = n_ptr;
/* and move in the new key and data value */
 i_ptr->key = target;
 i_ptr->data = data;
 }
}/* end of db_insert_key() */

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

How to deal with wind in Angry Birds Act...
Angry Birds Action! is a physics-based puzzler in which you're tasked with dragging and launching birds around an obstacle-littered field to achieve a set objective. It's simple enough at first, but when wind gets introduced things can get pretty... | Read more »
How to get three stars in every level of...
Angry Birds Action! is, essentially, a pinball-style take on the pull-and-fling action of the original games. When you first boot it up, you'll likely be wondering exactly what it is you have to do to get a good score. Well, never fear as 148Apps... | Read more »
The beginner's guide to Warbits
Warbits is a turn-based strategy that's clearly inspired by Nintendo's Advance Wars series. Since turn-based strategy games can be kind of tricky to dive into, see below for a few tips to help you in the beginning. Positioning is crucial [Read... | Read more »
How to upgrade your character in Spellsp...
So you’ve mastered the basics of Spellspire. By which I mean you’ve realised it’s all about spelling things in a spire. What next? Well you’re going to need to figure out how to toughen up your character. It’s all well and good being able to spell... | Read more »
5 slither.io mash-ups we'd love to...
If there's one thing that slither.io has proved, it's that the addictive gameplay of Agar.io can be transplanted onto basically anything and it will still be good fun. It wouldn't be surprising if we saw other developers jumping on the bandwagon,... | Read more »
How to navigate the terrain in Sky Charm...
Sky Charms is a whimsical match-'em up adventure that uses creative level design to really ramp up the difficulty. [Read more] | Read more »
Victorious Knight (Games)
Victorious Knight 1.3 Device: iOS Universal Category: Games Price: $1.99, Version: 1.3 (iTunes) Description: New challenges awaits you! Experience fresh RPG experience with a unique combat mechanic, packed with high quality 3D... | Read more »
Agent Gumball - Roguelike Spy Game (Gam...
Agent Gumball - Roguelike Spy Game 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: Someone’s been spying on Gumball. What the what?! Two can play at that game! GO UNDERCOVERSneak past enemy... | Read more »
Runaway Toad (Games)
Runaway Toad 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: It ain’t easy bein’ green! Tap, hold, and swipe to help Toad hop to safety in this gorgeous new action game from the creators of... | Read more »
PsyCard (Games)
PsyCard 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: From the makers och Card City Nights, Progress To 100 and Ittle Dew PSYCARD is a minesweeper-like game set in a cozy cyberpunk... | Read more »

Price Scanner via MacPrices.net

Price drops on clearance 2015 13-inch MacBook...
B&H Photo has dropped prices on clearance 2015 13″ MacBook Airs by up to $250. Shipping is free, and B&H charges NY sales tax only: - 13″ 1.6GHz/4GB/128GB MacBook Air (MJVE2LL/A): $799, $200... Read more
Mac minis on sale for up to $100 off MSRP
B&H Photo has Mac minis on sale for up to $100 off MSRP including free shipping plus NY sales tax only: - 1.4GHz Mac mini: $449 $50 off MSRP - 2.6GHz Mac mini: $649 $50 off MSRP - 2.8GHz Mac mini... Read more
13-inch Retina MacBook Pros on sale for up to...
B&H Photo has 13″ Retina MacBook Pros on sale for $130-$200 off MSRP. Shipping is free, and B&H charges NY tax only: - 13″ 2.7GHz/128GB Retina MacBook Pro: $1169 $130 off MSRP - 13″ 2.7GHz/... Read more
Apple price trackers, updated continuously
Scan our Apple Price Trackers for the latest information on sales, bundles, and availability on systems from Apple’s authorized internet/catalog resellers. We update the trackers continuously: - 15″... Read more
SanDisk Half-Terabyte SSD Optimized for Every...
SanDisk Corporation has announced the SanDisk Z410 SSD, a cost-competitive, half-terabyte solid state drive (SSD) that enables manufacturers to design for a broad range of desktop PCs and laptops.... Read more
Churchill Downs Racetrack Selects VenueNext t...
Churchill Downs Racetrack has announced an agreement with VenueNext to implement its technology platform for the start of Churchill Downs 2016 Spring Meet, which includes the 142nd running of the... Read more
Record 700 Million Pounds of CE Recycled in 2...
The Consumer Technology Association (CTA) reports that a record-setting 700 million pounds of consumer electronics (CE) have been recycled under the eCycling Leadership Initiative (ELI). According to... Read more
Price drops on clearance 12-inch Retina MacBo...
B&H Photo has dropped prices on leftover 2015 12″ Retina MacBooks with models now available starting at $999. Shipping is free, and B&H charges NY tax only: - 12″ 1.1GHz Gray Retina MacBook... Read more
15-inch Retina MacBook Pros available for $20...
B&H Photo has 15″ Retina MacBook Pros on sale for up to $210 off MSRP. Shipping is free, and B&H charges NY tax only: - 15″ 2.2GHz Retina MacBook Pro: $1799 $200 off MSRP - 15″ 2.5GHz Retina... Read more
Target offers Apple Watch Sport for $50 off M...
Target has Apple Watch Sports on sale for $50 off MSRP for a limited time. Choose free shipping or free local store pickup (if available). Sale prices for online orders only, in-store prices may vary... Read more

Jobs Board

*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
Simply Mac *Apple* Specialist- Service Repa...
Simply Mac is the largest premier retailer of Apple products in the nation. In order to support our growing customer base, we are currently looking for a driven Read more
*Apple* Retail - Multiple Positions - Apple,...
Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, you're also the Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.