TweetFollow Us on Twitter

Debug DA Window
Volume Number:6
Issue Number:9
Column Tag:C Workshop

Code Debugging Window

By Alexander S. Colwell, Redondo Beach, CA

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

Introduction

A friend of mine called me the other day about developing several 4th Dimension externals and ask for suggestions to make his life easier developing software on the Macintosh. As usual, I recommended buying Inside Macintosh Volumes 1, 2, 4, and 5, several other how-to-do programming books, get all of the Macintosh Technical Notes, and buy THINK C compiler or MPW with Pascal + MacApp and/or C depending on the programming project involved. In this case, my favorite is the THINK C compiler.

However, the major problem I encountered from programmers who have worked on VAXes and IBM main-framers is the ability to perform simple debugging techniques using a print statement such as “C” printf function. Most of these programmers usually do not want to deal with the 680XX assembly code using TMON or MacBugs as a debugging tool. The THINK C or MPW SADE symbolic debugger will help alleviate debugging their applications, but will not be much help on resource code debugging. So, in response to this problem, I thought this would be a good DA for resource code debugging and an article in MacTutor magazine.

So, “What good would the “Debugger Window” DA be?”. The THINK C symbolic debugger is an excellent tool at finding tough logic problems in your code. But programming on the Macintosh is much like real-time programming. Problems don’t show up very easily while using the symbolic debugger. Most bugs occur the nth execution time, but you would not know when that may occur. For example, tough bugs usually occur only in certain combinations of procedure/function calls. Hence, simple print statements showing the flow of the module calls can be used to determine when the problem occurs or when the program crashes the Mac. Then the symbolic debugger would be used to finish the debugging process. On the other hand, a symbolic debugger does not work on resource codes such as MDEF, WDEF, XCMD, 4DEX, and device drivers to name a few.

The ideal debugging print statement should look like the printf function statement found in the “C” language. Hence, a DbgPrint procedure would be used to perform in a similar manner as fprintf function. For example,

/* 1 */

 DbgPrint(dbgHdl, “WDEF: message - %d\n”, message);

would be used to output the WDEF’s message codes in the “Round Window” DA demo as shown in Figure 1. The dbgHdl is the debugger resource handle used to communicate between the two DA’s. The remainder arguments are the format string and its arguments to generate text stream output to the “Debugger Window” DA’s display.

Figure 1. Sample “Debugger Window” with another DA

Debugger Interface

The trick in getting debugging outputs delivered to the “Debugger Window” DA is the use of the Resource Manager. By using a resource data block, it can be used as a clearing house between DA and other resource codes. The DA will fill in the necessary information into the resource data for the other resource codes to determine if it can send the debugging outputs and to which DA. (I tend to think this resource data block is like a VAX/VMS shareable image for you VAX hackers).

The other trick is really quite simple. It requires defining a new DA control message (ie. accDbgPrint = 128 control message). Here is an interesting point: there is really no reason that desk accessory control messages cannot handle other messages defined by Inside Macintosh Volume I in Desk Manager Chapter such as accEvent, accRun, accCursor, accMenu, accUndo, accCut, etc. This brings up several interesting possiblities for a DA and other applications, resource codes, and/or DAs communications.

Let’s talk about the resource data block structure and its communication between DA and others.

/* 2 */

/* Debugger error types              */
typedef enum {
 dbgNoOvrFlw,   /* No, overflow      */
 dbgTableOvrFlw,/* Table overflow    */
 dbgDataOvrFlw, /* Data buf overflow */
 dbgBufOvrFlw   /* Buf size overflow */
 } DBGERROR;
 
/* Debugger interface data structure */
typedef struct {
 short daRefNbr;
 DBGERROR bufError;
 long bufTableIdx;
 long bufNextIdx;
 long bufDataIdx;
 long bufTableSize;
 long bufDataSize;
 long **bufTable;
 char **bufData;
 } DBGINTERFACE;

The daRefNbr variable is used to point to the “Debugger Window” DA. For every opened desk accessory, it has an associated reference number that identifies it from other DA or device drivers. If the variable is ZERO then the DA is not open and cannot accept any debugging outputs.

The remaining variables are primarily used for asynchronous debugging output operation. These variables are used in a ring-buffer fashion, where the bufTable variable is table of index offsets into the bufData holding the debugging output data streams. The bufTableIdx and bufNextIdx variables are indexes into the bufTable. The bufTableIdx is used by the “Debugger Window” DA to catch-up to the bufNextIdx incremented by the other resource codes. Finally, the bufTableSize and bufDataSize are handle sizes of the bufTable and bufData handles respectively. Please refer to DebuggerDA.c and Debugger.c source code on these variables implementation.

Now, why would anybody want to do synchronous or asynchronous debugging outputs? Suppose, you are trying to debug VBL or asynchronous I/O completion in your PBCall? They require no Memory Manager ROM call operations during its interrupt level processing. Therefore, it would require buffering for the DA’s communication.

The DBGERROR enum type is used to inform the DA that there has been a buffer overflow and there will be some data loss for asynchronous debugging processing. For example, the VBL could generate so much debugging outputs and overflow the buffer before the DA has a chance to display the text data streams. If this happens alot, then one could increase the table and data buffer sizes. But, you are always constrained by the size of available memory. Nothing is perfect.

Module Descriptions

The “Debugger Window” DA debugging outputs are broken-up into two parts: synchronous or asynchronous. The DbgPrint procedure is used for synchronous operations, while the DbgBufPrint is used for asynchronous operations. The DbgPrint and DbgBufPrint arguments are similar to the “C” language fprintf function. The first argument is the debugger resource handle which is used to communicate between the DA and other resource codes. The second argument is the format string, and the third and henceforth arguments are the parameters for the format string that is used to output debugging data stream to the DA. The primary responsibility of these procedures is to check if the DA is available to accept debugging outputs, and then make the necessary operations to send the debugging outputs to the DA for display.

The DbgGetRefHdl function will retrieve the debugger resource data to be used to communicate with the “Debugger Window” DA. If it returns a non-NIL resource handle then the DA is opened. This routine must not be called at non-interrupt level. For example, it cannot be called during a VBL. So, you must pass the debugger resource handle at the end of the VBLTask data structure. Refer to Round Window.c source code.

The DbgPrint procedure calls the DA directly via the Control toolbox function. This is where the resource code makes a direct call to the DA and passing the necessary information to be displayed in the DA’s window.

The DbgBufPrint procedure moves its arguments into a data buffer and schedule a DA’s accRun action (ie. schedule DA wake-up). Normally, a DA will be invoked for periodic actions specified by its delay timer defined in the Device Control Entry data block. During the DA’s idle processing loop it will check if there is debugging outputs to be displayed.

The DbgBufPrint must know how many bytes are on the stack (ie. the arguments) to be copied into the data buffer for later processing by the DA. This problem reminds me of my college professor famous saying : “Know thy Compiler”. This commandment is critical in making the DbgBufPrint procedure to work with THINK C compiler. Upon careful examination of THINK C code generation, it always has an ADD instruction after the DbgBufPrint’s JSR instruction. Note: MPW C does not always have an ADD instruction after the DbgBufPrint’s JSR instruction. Sometime, MPW C has ADD instruction or LEA instruction but it depends on the previous procedure/function calls’ arguments. Hence, you cannot use this function with MPW C compiler.

The DbgBufPrint procedure will analyze the return address of its caller that points to the ADD instruction and decodes the number of bytes it must pop-off the stack when the DbgBufPrint returns control back to the caller. This way it knows how many bytes to copy from the stack to the data buffer for later processing by the DA. This is really a weird code. One must understand how the compiler works in order to supply the module interface equivalent to the fprintf function. Anyway, this stuff works!

Debugger Window DA Files

The DA requires the standard ANSI-A4 and MacTraps libraries as shown in Figure 2. Note: the PE/DA.p project file is not part of the standard THINK C software package purchased by your friendly software dealer. Hence, you may obtain the PE/DA.p project file from the LightSpeed CAPPS’ software package.

The PE/DA.p project file is a general purpose RAM-base text editor. I use this to perform simple text output that is not limited to 32K of memory as the TextEdit ROM routines.

Round Window DA Demo

Figure 1 shows an example how the “Debugger Window” DA is used to debug several things concurrently with the “Round Window” DA demo. The “Round Window” DA sends its debugging output statements from its event message handlers, its WDEF window message handlers, and VBL messages to the “Debugger Window” DA.

This demonstrates how to use the “Debugger Window” DA via the DbgPrint and DbgBufPrint procedures. The DA demo will start-up a VBL using a resource code containing the VBL code and use its own WDEF window definition. The VBL will call DbgBufPrint procedure to display its every module invocation during the VBL processing. (Again, VBL resource code must use asynchronous debugging outputs since it is at interrupt level.) And, the WDEF window definition will call DbgPrint procedure to display every window message code. Finally the DA demo will call DbgPrint procedure to display every event it receives.

Figure 2. “Debugger Window” DA files

Wrapping It Up

The use of the resource data as a common data block between DA’s, resource codes, and applications would have interesting possibilities other than this DA demonstration. However the future System 7.0 version would eliminate this technique using InterApplication Communications Architecture (IAC). I would be able to send the equivalent printf debugging commands via the extended Event Manager’s Program-to-Program Communication (PPC) protocol. This would greatly reduce the code overhead in the Debugger.c source file communications between the DA and the resource code. But I had written this DA since late 1988 and had been using it ever since.

/*
 *  Source   - Debugger.h
 *  Author   - Alexander S. Colwell,
 *             Copyright (C) 1988, 1989
 *  Purpose  - This is the “Debugger Window” DA
 *             include file definition.
 */

#ifndef _Debugger_
#define _Debugger_

/* Debugger resource info                             */
#define debuggerType ‘Dbgr’  /* Debugger resource type*/
#define debuggerName “\pDebugger Reference”/* Res name*/

typedef enum {               /* Debugger error types  */
    dbgNoOvrFlw,             /* No, overflow          */
    dbgTableOvrFlw,          /* Table overflow        */
    dbgDataOvrFlw,           /* Data buffer overflow  */
    dbgBufOvrFlw             /* Buffer size overflow  */
    } DBGERROR;
    
typedef enum {               /* Debugger types        */
    accDbgPrint = 128,       /* Perform “print” action*/
    accDbgDump               /* Perform “dump” action */
    } DBGTYPE;

typedef struct {             /* Debugger Interface def*/
    short   daRefNbr;        /* DA’s reference number */
    DBGERROR bufError;       /* Buffer error indicator*/
    long    bufTableIdx;     /* Buffer index          */
    long    bufNextIdx;      /* Next buffer index     */
    long    bufDataIdx;      /* Buffer data index     */
    long    bufTableSize;    /* Buffer idx table size */
    long    bufDataSize;     /* Buffer data hdl size  */
    long    **bufTable;      /* Buffer index table    */
    char    **bufData;       /* Buffer data handle    */
    } DBGINTERFACE;
typedef DBGINTERFACE    *DBGPTR;
typedef DBGPTR          *DBGHDL;
                                    
DBGHDL  DbgGetRefHdl();      /* Debugging proto-types */
void DbgPrint(/* DBGHDL dbgRefHdl, char *fmt, var-args... */);
void DbgBufPrint(/* DBGHDL dbgRefHdl, char *fmt, var-args... */);
void DbgDump(DBGHDL dbgRefHdl, char *buffer, long size);
void DbgBufDump(DBGHDL dbgRefHdl, char *buffer, long size);
long DbgStrLen(char *str);

#endif

/*
 *  Source  - DebuggerDA.c
 *  Author  - Alexander S. Colwell,
 *            Copyright (C) 1988, 1989
 *  Purpose - This is the “Debugger Window” desk
 *            accessory to simplify debugging resource
 *            codes, DA’s or applications that does not
 *            have a debugging output window. This
 *            requires System 4.1 or greater version.
 */

#include “Debugger.h”        /* DA Debugger defs      */
#include <Color.h>           /* Color Manager defs    */
#include <CType.h>           /* C Type defs           */
#include <StdArg.h>          /* Standard Argument defs*/
#include <SetUpA4.h>         /* Desk Accessory defs   */
#include <PE.h>              /* Program Edit defs     */

                             /* Misc definitions      */
#define NIL     (0L)         /* NIL pointer           */
#define abs(a)  (a<0?-a:a)   /* Absolute macro func   */
#define min(a,b) (a<b?a:b)   /* Minumim macro function*/
#define max(a,b) (a<b?b:a)   /* Maximum macro function*/

                             /* Trap definitions      */
#define SysEnvironsTrap 0xa090/* System Enviorment    */
#define UnknownTrap     0xa89f/* Unknown trap instr   */

                             /* Limit definitions     */
#define maxColumns      132  /* Maximum # of columns  */

                             /* Resource ID #’s       */
#define windID          0    /* Window ID #           */
#define infoID          0    /* Info dialog ID #      */
#define errorID         1    /* Error dialog ID #     */
#define strID           0    /* String STR ID #       */
#define errID           1    /* Error STR ID #        */
#define optionsID       0    /* Options ID #          */
#define debuggerID      0    /* Debugger ID #         */

typedef enum {               /* Menu commands         */
    Info = 1,                /* On-line information   */
    NullItem2,
    StartOutput,             /* Start/Stop output     */
    Quit                     /* Quit from DA          */
    } MENU;
    
typedef enum {               /* String ID #’s         */
    itmStartOutput = 1,      /* “Start Output” item   */
    itmStopOutput,           /* “Stop Output” item    */
    bufTableOvrFlw,          /* Table overflow        */
    bufDataOvrFlw,           /* Data buffer overflow  */
    bufBufOvrFlw             /* Buffer size overflow  */
    } STRID;
                             /* Resource types        */
#define optionType ‘Opts’    /* Option definition type*/

typedef enum {               /* Error messages        */
    errFailOpenDA = 1,       /* Fail to open DA       */
    errNoGlobals,            /* Fail to alloc globals */
    errLowMemory,            /* Low memory error      */
    errOldSystem,            /* Old System file       */
    errLisaClone,            /* Lisa clone Macintosh  */
    errOriginalMac           /* Original 128/512 Mac! */
    } ERROR;
    
typedef struct {             /* Options definitions   */
    short   maxTextSize;     /* Maximum text size     */
    short   fontFamily;      /* Font ID family        */
    short   fontSize;        /* Font size             */
    short   spacesPerTab;    /* # of spaces per tab   */
    long    bufTableSize;    /* Buffer table size     */
    long    bufDataSize;     /* Buffer data size      */
    } OPT;
typedef OPT     *OPTPTR;
typedef OPTPTR  *OPTHDL;

                             /* Global variables      */
short           alreadyOpen = FALSE;/* DA open flag   */
SysEnvRec       sysEnv;      /* System enviroment     */
DCtlPtr         dce;         /* Device control entry  */
WindowPtr       wp = NIL;    /* My window pointer     */
Rect            originalRect;/* Original rect area    */
PEHandle        peHdl = NIL; /* PE handle             */
short           active = FALSE;/* Active flag         */
ControlHandle   hScrollBar = NIL;/* Horz scroll bar   */
ControlHandle   vScrollBar = NIL;/* Vert scroll bar   */
DBGHDL          dbgHdl = NIL;/* Debugger handle       */
OPTHDL          optHdl = NIL;/* Options handle        */
short           cursorMode = FALSE;/* Cursor mode     */
MenuHandle      menu = NIL;  /* Menu handle           */
short           menuID = 0;  /* Menu ID #             */
long            **bufTable = NIL;/* Buffer idx tbl hdl*/
char            **bufData = NIL;/* Buffer data handle */
short           outputEnable = TRUE;/* Output flag    */
char            PrintOutputBuf[1024];/* Print buffer  */

pascal void DoTextScroll();  /* Define forwared refa  */
pascal void DoClickScroll();
pascal void DoHighLite();
void        DoPrintChar();
DialogTHndl DoDlgCenter();

main(p,d,n)
 cntrlParam  *p;             /* Parameter block       */
 DCtlPtr     d;              /* Device control entry  */
 short       n;              /* Entry point selector  */
 {
  WindowPtr   savePort;      /* Save cur window port  */
  short       saveResFile;   /* Save cur resource file*/

  if (d->dCtlStorage == 0) { /* Check if got globals! */
   if (n == 0) {             /* Check if “Open”ing    */
    DoError(errNoGlobals);   /* Opps, fail get globals*/
    CloseDriver(d->dCtlRefNum);/* Close the DA        */
   }
  }

  else {                     /* Got globals then cont */
   RememberA4();             /* Remember A4 register  */
   GetPort(&savePort);       /* Get cur window port   */

   if (wp)                   /* Check if ptr valid    */
    SetPort(wp);             /* Set port to my window */
    dce = d;                 /* Save DCE ptr          */
    dce->dCtlFlags &= ~dCtlEnable;/*Set not re-entrant*/

    switch(n) {              /* Handle request:       */
     case 0:                 /*      “Open”           */
      DoOpen(); break;    
     case 2:                 /*      “Control”        */
      DoControl(p->csCode,p->csParam); break; 
     case 4:                 /*      “Close”          */
      DoClose(); break;
    }

    dce->dCtlFlags |= dCtlEnable;/* Enable it again   */
    SetPort(savePort);       /* OK, let’s restore it  */
   }
  return(0);                 /* Return default success*/
 }

DoOpen()
 {
  short           rom;       /* Working ROM id        */
  short           machine;   /* Working Mac id        */
  Rect            wRect;     /* Working wind rect area*/
  Point           pt;        /* Working point         */
  register PEPtr  pePtr;     /* Working edit pointer  */
  DBGPTR          dbgPtr;    /* Working debugger ptr  */
  register short  canDoIt;   /* Working can do it flag*/
  register short  errCode = errFailOpenDA;/*Error code*/
        
  dce->dCtlFlags |= dNeedLock|dNeedGoodBye;/*Set flags*/
  if (wp)                    /* Check if there window */
   if (wp != FrontWindow())  /* Check if not in front */
    SelectWindow(wp);        /* Bring our window front*/
            
  if (!alreadyOpen) {        /* Check if require inits*/
   Environs(&rom,&machine);  /* Get Mac’s evniroment  */
   if (machine == macXLMachine) {/* Check if “Lisa”   */
    canDoIt = FALSE;         /* It’s a “Lisa” computer*/
    errCode = errLisaClone;  /* Set error message     */
   }
   else if (rom >= 0x0078)   /* It’s Mac II           */
    canDoIt = TRUE;          /* It’s Mac II computer  */
   else if (rom >= 0x0076)   /* It’s Mac SE           */
    canDoIt = TRUE;          /* It’s Mac SE computer  */
   else if (rom >= 0x0075) { /* it’s 128K rom         */
    if (MemTop > (char *)(1024L * 512L))/* Mac 512KE? */
     canDoIt = TRUE;         /* It’s Mac 512K Enhanced*/
    else                     /* Must be Mac Plus      */
     canDoIt = TRUE;         /* Its Mac Plus computer */
   }
   else  if (rom >= 0x0069){ /* It’s 64K rom, it’s old*/
    canDoIt = FALSE;         /* It’s original Mac!    */
    errCode = errOriginalMac;/* Set error message     */
   }
            
   if (canDoIt) {            /* OK, we can do it!     */
                             /* Check if it’s valid   */
    if ((long)NGetTrapAddress(SysEnvironsTrap,OSTrap) != 
        (long)NGetTrapAddress(UnknownTrap,ToolTrap)) {
     SysEnvirons(1,&sysEnv); /* Get system enviroment */
     if (sysEnv.systemVersion >= 0x0410) {/* Latest?  */
      wp = GetNewWindow(GetResourceID(windID),NIL,-1L);
      if (wp) {              /* Check if got window   */
       ShowWindow(wp);       /* OK, let’s show it     */
       SetPort(wp);          /* Set port to our window*/
       alreadyOpen = TRUE;   /* Set open DA indicator */
                            
                             /*Save window association*/
       ((WindowPeek)wp)->windowKind = dce->dCtlRefNum;
       dce->dCtlWindow = wp;/* Tell device where I am */

       originalRect = wp->portRect;/* Save orig area  */
       LocalToGlobal(&originalRect.top);
       LocalToGlobal(&originalRect.bottom);

                             /* Check if create scroll*/
       wRect.left = wp->portRect.left - 1;
       wRect.top = wp->portRect.bottom - 15;
       wRect.right = wp->portRect.right - 14;
       wRect.bottom = wp->portRect.bottom + 1;
       hScrollBar = NewControl(wp,&wRect,””,FALSE,
                               0,0,0,scrollBarProc,0L);
                                
                             /* Check if create scroll*/
       wRect.left = wp->portRect.right - 15;
       wRect.top = wp->portRect.top - 1;
       wRect.right = wp->portRect.right + 1;
       wRect.bottom = wp->portRect.bottom - 14;
       vScrollBar = NewControl(wp,&wRect,””,FALSE,
                               0,0,0,scrollBarProc,0L);
                                
                             /* Get options defs      */
       optHdl = (OPTHDL)(GetResource(optionType,
                             GetResourceID(optionsID)));
                                                     
                             /* Get debugger defs     */
       dbgHdl = (DBGHDL)(GetResource(debuggerType,
                            GetResourceID(debuggerID)));
                                                 
       TextFace(0);          /* Set “Plain” style font*/
       if (optHdl) {         /*Check if got option hdl*/
        TextSize((*optHdl)->fontSize);
        TextFont((*optHdl)->fontFamily);
       }
       else {                /* Nope, set to default  */
        TextSize(9);
         TextFont(monaco);
       }

       wRect.left = wp->portRect.left;/* Set edit view*/
       wRect.top = wp->portRect.top + 5;
       wRect.right = wp->portRect.right - 15;
       wRect.bottom = wp->portRect.bottom - 15;

       if (peHdl = PENew(&wRect)) {/* Check if got it */
        pePtr = *peHdl;      /* Set edit pointer      */
                             /* Set auto scroll hook  */
        pePtr->clikLoop = (ProcPtr)DoClickScroll;
        if (sysEnv.hasColorQD)/* Check if has color   */
         pePtr->highHook = (ProcPtr)DoHighLite;
        pePtr->viewOrgH = -5;/* Set horizontal offset */
        pePtr->viewOrgV = 0; /* Set vertical offset   */
                             /*Set # of spaces per tab*/
        (*peHdl)->tabWidth = CharWidth(‘ ‘) * 
                                (*optHdl)->spacesPerTab;
        DoRestoreClippings();/* Restore text clipping */
       }

       menuID = GetResourceID(menuID);/* Get menu ID  */
       if (menu = GetMenu(menuID)) {/* Check if got it*/
        (**menu).menuID = menuID;/* Reset default ID  */
        dce->dCtlMenu = menuID;/* Set device menu ID  */
        if (!dbgHdl)         /*Check if fail to get it*/
         DisableItem(menu,StartOutput);/* Disable it  */
       }
       else                  /* Fail to get menu hdl  */
        menuID = 0;          /* Reset menu ID #       */
                                
       if (optHdl) {         /*Check if got option hdl*/
                             /* Allocate buffer table */
        bufTable = (long **)(NewHandle(
                       (long)((*optHdl)->bufTableSize) *
                       (long)(sizeof(long))));
                
        bufData = NewHandle(/* Allocate buffer data   */
                        (long)((*optHdl)->bufDataSize) *
                        (long)(sizeof(char)));
       }
                            /* Check if memory low    */
       if (!hScrollBar || !vScrollBar || !peHdl || 
           ! menu || !optHdl || !dbgHdl || 
           !bufTable || !bufData)
           DoError(errLowMemory);
                                
       if (dbgHdl) {         /* Check if got resource */
        SetHandleSize(dbgHdl,/* Make sure right size  */
 (long)(sizeof(DBGINTERFACE)));
        dbgPtr = *dbgHdl;    /* Set debugger pointer  */
        dbgPtr->bufError = dbgNoOvrFlw;/* Init buffer */
        dbgPtr->bufTableIdx = 0;
        dbgPtr->bufNextIdx = 0;
        dbgPtr->bufDataIdx = 0;
        dbgPtr->bufTableSize = 0L;
        dbgPtr->bufTable = NIL;
        dbgPtr->bufData = NIL;
        dbgPtr->bufDataSize = 0L;
        dbgPtr->daRefNbr = 0;
                             /* Check if tables valid */
        if (optHdl && bufTable && bufData) {
         dbgPtr->bufTableSize = (*optHdl)->bufTableSize;
         dbgPtr->bufTable = bufTable;
         dbgPtr->bufData = bufData;
         dbgPtr->bufDataSize = (*optHdl)->bufDataSize;
         dbgPtr->daRefNbr = dce->dCtlRefNum;
        }
        ChangedResource(dbgHdl);/* Update it          */
        WriteResource(dbgHdl);
       }
      }
     }
     else                    /* Require newer system  */
      errCode = errOldSystem;
    }
    else                     /* Require newer system  */
     errCode = errOldSystem;
   }
   if (!wp) {                /* Check if fail to open */
    DoError(errCode);        /* Fail to open DA       */
    DoQuit();                /* Let’s get out now!    */
   }
  }
 }

DoClose()
 {
  register Handle hdl;       /* Working handle        */
  Rect            curRect;   /* Working cur rect area */
  register Rect   **wRect;   /* Working window rect   */
        
  if (dbgHdl) {              /* Check if have handle  */
   (*dbgHdl)->daRefNbr = 0;  /* OK, let’s clear these */
   (*dbgHdl)->bufTable = NIL;
   (*dbgHdl)->bufData = NIL;
   ChangedResource(dbgHdl);  /* Update resource, too  */
   WriteResource(dbgHdl);
   dbgHdl = NIL;             /* Clear handle, but dont*/
                             /* release it since other*/
                             /* DA’s and etc will be  */
                             /* using it, too.        */
  }

  if (bufTable)              /* Check if it’s valid   */
   DisposHandle(bufTable);   /* Release it to mem mgr */
  bufTable = NIL;            /* Invalidate it         */
        
  if (bufData)               /* Check if it’s valid   */
   DisposHandle(bufData);    /* Release it to mem mgr */
  bufData = NIL;             /* Invalidate it         */
        
  if (optHdl)                /* Check if have option  */
   ReleaseResource(optHdl);  /* Release it            */
  optHdl = NIL;              /* Invalidate it too     */
        
  if (menu) {                /* Check if have menu hdl*/
   DeleteMenu(menuID);       /* Delete from menu bar  */
   DrawMenuBar();
   DisposeMenu(menu);        /* Release menu handle   */
   menu = NIL;               /* Invalidate menu handle*/
   dce->dCtlMenu = 0;        /* Clear-out menu ID #   */
  }
  
  if (peHdl) {                /* Check if it’s valid  */
   PEDispose(peHdl);          /* Release it now       */
   peHdl = NIL;               /* Invalidate edit hdl  */
  }
        
  if (wp) {                   /* Check if window valid*/
   curRect = wp->portRect;    /* Translate to global  */
   LocalToGlobal(&curRect.top);
   LocalToGlobal(&curRect.bottom);
            
   DisposeWindow(wp);         /* Delete the window now*/
   wp = NIL;                  /* Reset it now         */
   if (!EqualRect(&curRect,&originalRect)) {/*Changed?*/
        
                              /* Check if got wnd hdl */
    if (wRect = ((Rect **)GetResource(‘WIND’,
                             GetResourceID(windID)))) {
     **wRect = curRect;       /* Save new  location   */
     ChangedResource(wRect);  /* Mark it changed      */
     WriteResource(wRect);    /* Write resource now   */
    }
   }
  }
        
                             /* Get ‘STR#’ resource   */
  if (hdl = GetResource(‘STR#’,GetResourceID(strID)))
   ReleaseResource(hdl);     /* OK, release it now    */
  if (hdl = GetResource(‘STR#’,GetResourceID(errID)))
   ReleaseResource(hdl);     /* OK, release it now    */
            
  InitCursor();              /* Restore arrow cursor  */
  alreadyOpen = FALSE;       /* Reset it              */
 }

DoControl(code,parm)
 short code;                 /* Control command code  */
 short *parm;                /* “csParam” list pointer*/
 {
  switch(code) {             /* Handle request:       */
   case accEvent:            /*      “Event”          */
    DoEvent(*((EventRecord **)parm)); break;
   case accMenu:             /*      “Menu”           */
    DoMenu(*(parm + 1)); break;
   case accRun:              /*      “Run”            */
    DoIdle(); break;
   case accCopy:             /*      “Copy”           */
    DoCopy(); break;
   case accClear:            /*      “Clear”          */
    DoClear(); break;
   case goodBye:             /*      “GoodBye”        */
    DoClose(); break;
   case accDbgPrint:         /*      “DbgPrint”       */
    DoDbgPrint(((long *)(parm))); break;
   case accDbgDump:          /*      “DbgDump”        */
    DoPrintDump(*((long *)(parm)),
                *(((long *)(parm))+1)); break;
  }
 }

DoEvent(e)
 register EventRecord *e;    /* Event Record pointer  */
 {
  switch(e->what) {          /* Handle request:       */
   case updateEvt:           /*      “Update”         */
    DoUpdate(); break;
   case mouseDown:           /*      “Mouse Down”     */
    DoMouse(e->where,e->modifiers); break;
   case activateEvt:         /*      “Activate”       */
    DoActivate((Boolean)(e->modifiers & activeFlag));
    break;
   case keyDown:             /*      “Key Down”       */
   case autoKey:             /*      “Auto-Key Down”  */
                             /* Handle the input key  */
    DoKey((char)(e->message & charCodeMask),
          (char)((e->message & keyCodeMask) >> 8L),
          e->modifiers);
  }
 }

DoUpdate()
 {
  BeginUpdate(wp);           /* Start update processng*/
  ClipRect(&wp->portRect);   /* Reset clipping        */
  EraseRect(&wp->portRect);  /* Erase part of screen  */
  DrawGrowIcon(wp);          /* Draw the grow icon    */
  DrawControls(wp);          /* Draw the controls     */
  if (peHdl) {               /* Check if has edit hdl */
   DoRestoreClippings();     /* Restore clippgings    */
   PEUpdate(peHdl);          /* OK, let’s update it   */
  }
  EndUpdate(wp);             /* Wrapup update         */
}
    
DoMouse(p,modifiers)
 Point   p;                  /* Mouse point position  */
 short   modifiers;          /* Mouse’s modifiers     */
 {
  register long   i;         /* Working index         */
  Rect            wRect;     /* Working window rect   */
  register long   wGrow;     /* Working grow size     */
  ProcPtr         wDef;      /* Working window proc   */
    
                             /* Get window proc def   */
  wDef = (ProcPtr)*((WindowPeek)wp)->windowDefProc;

                             /* Check if in “Content” */
  if (CallPascalL(8,wp,(int)wHit,p,wDef) == wInContent)
   DoContent(p,modifiers);
        
                             /* Check if in “Grow”    */
  else if (CallPascalL(8,wp,(int)wHit,p,wDef) ==
           wInGrow) {
   SetRect(&wRect,100,100,32767,32767);/*Define limits*/
   wGrow = GrowWindow(wp,p,&wRect);/* OK, grow it now */
   if (wGrow) {              /* Check if got new size */
                             /* Reset new size        */
    SizeWindow(wp,LoWord(wGrow),HiWord(wGrow),TRUE);
    DoResizeScrollBar();     /* Resize the scroll bar */
    InvalRect(&wp->portRect);/* Invalidate everything */
    DoAdjustScrollBar();     /* Adjust scroll bar     */
   }   
  }
            
                             /* Check if in “Zoom In” */
  else if (CallPascalL(8,wp,(int)wHit,p,wDef) == 
           wInZoomIn) {
   ZoomWindow(wp,inZoomIn,TRUE);/* Zoom it in         */
   DoResizeScrollBar();      /* Resize the scroll bar */
   DoAdjustScrollBar();      /* Adjust scroll bar     */
  }
                             /* Check if in “Zoom Out”*/
  else if (CallPascalL(8,wp,(int)wHit,p,wDef) ==
           wInZoomOut) {
   ZoomWindow(wp,inZoomOut,TRUE);/* Zoom it out       */
   DoResizeScrollBar();      /* Resize the scroll bar */
   DoAdjustScrollBar();      /* Adjust scroll bar     */
  }
 }
    
DoActivate(activate)
 short   activate;           /* Activate flag         */
 {
  Rect    wRect;             /* Working window rect   */
        
                             /* Set vertical ctrl area*/
  wRect.left = wp->portRect.right - 14;
  wRect.top = wp->portRect.top - 1;
  wRect.right = wp->portRect.right + 1;
  wRect.bottom = wp->portRect.bottom - 16;
        
  ClipRect(&wRect);          /* Reset clippings       */
  if (activate) {            /* Check if activating   */
   dce->dCtlFlags |= dNeedTime;/* Allow periodic runs */
   dce->dCtlDelay = 15;      /* Reset delay timer     */
   if (peHdl) {              /* Check if got the text */
    active = TRUE;           /* Activate text editing */
    PEActivate(peHdl);       /* Activate the text     */
   }
   DoActivateScrollBars();   /* Activate scroll bars  */
   if (menu) {               /* Check if menu is valid*/
    InsertMenu(menu,0);      /* Insert into menu bar  */
    DrawMenuBar();
    dce->dCtlMenu = menuID;  /* Reset menu ID #       */
   }
  }
  
  else {                     /* Nope, deactivating    */
   if (dbgHdl) {             /* Check if it’s valid   */
                             /* Check if there outputs*/ 
    if ((*dbgHdl)->bufTableIdx !=
     (*dbgHdl)->bufNextIdx) {
     dce->dCtlFlags |= dNeedTime;/* Allow periodic run*/
     dce->dCtlDelay = 15;    /* Reset delay timer     */
    }
    else                     /* No, buffer outputs    */
     dce->dCtlFlags &= ~dNeedTime;/* Turn off runs    */
   }
   else                      /* Nope, use defaults    */
    dce->dCtlFlags &= ~dNeedTime;/* Turn off runs     */
   active = FALSE;           /* Deactivate text edit  */
   if (peHdl)                /* Check if got the text */
    PEDeactivate(peHdl);     /* Deactivate the text   */
   DoDeActivateScrollBars(); /* Deactivate scroll bars*/
   InitCursor();             /* Restore arrow cursor  */
   cursorMode = FALSE;       /* Reset cursor mode     */
   if (menu) {               /* Check if menu is valid*/
    DeleteMenu(menuID);      /* Delete from menu bar  */
    DrawMenuBar();
    dce->dCtlMenu = 0;       /* Clear-out menu ID #   */
   }
  }
 }
    
DoActivateScrollBars()
 {
  Rect    wRect;             /* Working rect area     */
        
  ClipRect(&wp->portRect);   /* Set clippings         */
  if (hScrollBar)            /* Check if have horz bar*/
   ShowControl(hScrollBar);  /* Show the scroll bar   */
  if (vScrollBar)            /* Check if have vert bar*/
   ShowControl(vScrollBar);  /* Show the scroll bar   */
                             /* Invalidate drag icon  */
  wRect.top = wp->portRect.bottom - 14;
  wRect.bottom = wp->portRect.bottom;
  wRect.left = wp->portRect.right - 14;
  wRect.right = wp->portRect.right;
  InvalRect(&wRect);
  DoRestoreClippings();      /* Restore clippings     */
}
    
DoDeActivateScrollBars()
 {
  Rect    wRect;             /* Working rect area     */
  ClipRect(&wp->portRect);   /* Set clippings         */
  if (hScrollBar)            /* Check if have horz bar*/
   HideControl(hScrollBar);  /* Hide the scroll bar   */
  if (vScrollBar)            /* Check if have vert bar*/
   HideControl(vScrollBar);  /* Hide the scroll bar   */
                             /* Clear drag icon       */
  wRect.top = wp->portRect.bottom - 14;
  wRect.bottom = wp->portRect.bottom;
  wRect.left = wp->portRect.right - 14;
  wRect.right = wp->portRect.right;
  EraseRect(&wRect);
  DoUpdate();                /* Update the DA window  */
  DoRestoreClippings();      /* Restore clippings     */
 }   

DoIdle()
 {
  register short  id;        /* Working string ID #   */
  register DBGPTR dbgPtr;    /* Working debugger ptr  */
  register char   *s,*f;     /* Working string ptrs   */
  Str255          wStr;      /* Working string        */
  Point           p;         /* Working mouse location*/
    
  if (active) {              /* Check if it activated */
   GetMouse(&p);             /* Get mouse location    */
   if (peHdl)  {             /* Check if got the text */
    PEIdle(peHdl);           /* Do cursor blinking    */
    if (PtInRect(p,&(*peHdl)->viewRect)){/*Within view*/
     if (!cursorMode) {      /* Check if not I-Beam   */
      SetCursor(*GetCursor(iBeamCursor));/* Reset curs*/
      cursorMode = TRUE;     /* Reset cursor mode     */
     }
    }
    else {                   /* Reset to arrow cursor */
     if (cursorMode) {       /* Check if using I-Beam */
      InitCursor();          /* Restore arrow cursor  */
      cursorMode = FALSE;    /* Reset cursor mode     */
     }
    }
   }
  }
  if (dbgHdl) {              /* Check if handle valid */
   if ((*dbgHdl)->bufError) {/* Check for buf overflow*/
    switch((*dbgHdl)->bufError) {/* Get buf err ID #  */
     case bufTableOvrFlw:
      id = dbgTableOvrFlw; break;
     case bufDataOvrFlw:
      id = dbgDataOvrFlw; break;
     case bufBufOvrFlw:
      id = dbgBufOvrFlw;
    }
                             /* Let user know about it*/
    GetIndString(wStr,GetResourceID(strID),id);
    DoPrintLine(“%p\n”,wStr);
    (*dbgHdl)->bufError = dbgNoOvrFlw;/* Reset flag   */
   }
   dbgPtr = *dbgHdl;         /* Set debugger pointer  */
                             /* Check if has changed  */
   if (dbgPtr->bufTableIdx != dbgPtr->bufNextIdx) {
                             /* Bump to next index    */
    dbgPtr->bufTableIdx = (dbgPtr->bufTableIdx + 1L) %
                          dbgPtr->bufTableSize;
    HLock(dbgPtr->bufData);  /*Lock it down for output*/
                             /* Set switch code ptr   */
    s = &(*dbgPtr->bufData)[(*dbgPtr->bufTable)
           [dbgPtr->bufTableIdx]];
    f = s + 2L;              /*Set format string addr */
    switch((unsigned char)(*s)){/* Process input cmd  */
     case accDbgPrint:       /* Do LSC debugging line */
      DoDbgPrintSetUp(f); break;
     case accDbgDump:        /* Do debugging dump     */
      DoPrintDump(((long *)(f + sizeof(long))),
                  *((long *)(f)));
    }
    dbgPtr = *dbgHdl;        /* Reset debugger pointer*/
                             /* Check if it’s finished*/
    if (dbgPtr->bufTableIdx == dbgPtr->bufNextIdx) {
     if (!active)            /* Check if not active   */
      dce->dCtlFlags &= ~dNeedTime;/* Turn it off     */
     else                    /* Restore delay timer   */
      dce->dCtlDelay = 15;
    }
    HUnlock(dbgPtr->bufData);/* OK, let’s unlock it   */
   }
  }
 }
    
DoKey(c,code,modifiers)
 char    c;                  /* Input character       */
 char    code;               /* Input code            */
 short   modifiers;          /* Input modifiers       */
 {
  register short  i,j;       /* Working indexes       */
  register short  adjustIt = TRUE;/* adjust view      */
  register short  item = 0;  /* Working item #        */
  char            cmdChar[2];/* Working command char  */
  register ControlHandle ctrlHdl;/* Working ctrl hdl  */
  static short cnt = 0;       /* Debugging counter    */
        
  if (active) {               /* Check if activated   */
   if (modifiers & cmdKey) {  /* Check if key command */
    switch(c) {               /* Process key command  */
     case ‘c’:                /* “Copy” command       */
     case ‘C’:
      DoCopy(); c = 0; break;
     case ‘k’:                /* “Clear” command      */
     case ‘K’:
      DoClear(); c = 0;
    }
    if (c) {                  /* Check if should cont */
     if (menu) {              /* Check if got menu hdl*/
                              /* Search for item cmd  */
      for(i = 1, j = CountMItems(menu); i <= j; i++) {
       GetItemCmd(menu,i,cmdChar);/* Get item’s cmd   */
       if (cmdChar[1] == ‘?’) /* Check if ‘?’ char    */
        cmdChar[1] = ‘/’;     /* Translate lower case */
                              /* Check if this is it  */
       if (!IUMagIDString(&c,&cmdChar[1],1,1)) {
        item = i;             /* Yup, save item #     */
        i += j;               /* Break-out of loop    */
       }
      }
      if (item) {             /* Check if got our guy */
       HiliteMenu(menuID);    /* OK, let’s highlite it*/
       DoMenu(item);          /* Let’s do it          */
       HiliteMenu(0);         /* Unhighlite the menu  */
      }
      else                    /* Opps, wrong menu     */
       SysBeep(1);            /* Let um know about it */
     }
     else                     /* Opps, no menu handle */
      SysBeep(1);             /* Let um know about it */
    }
   }
   else if (peHdl) {          /* Check if got the text*/
                              /* Check if has ext key */
    if (sysEnv.keyBoardType == envAExtendKbd || 
        sysEnv.keyBoardType == envStandADBKbd) {
     if (modifiers & optionKey)/* Check if want horz  */
      ctrlHdl = hScrollBar;   /* Set horz scroll bar  */
     else                     /* Nope, use vert bar   */
      ctrlHdl = vScrollBar;
     switch(code) {           /* Check if F1-F4 keys  */
      case 0x63:              /* F3 “Copy” key        */
       DoCopy(); break;
      case 0x73:              /* Home key             */
       if (ctrlHdl) {         /* Check if has ctrl hdl*/
        if (i = GetCtlValue(ctrlHdl)) {/* Can scroll ?*/
         ClipRect(&wp->portRect);/* Reset clippings   */
         SetCtlValue(ctrlHdl,0);/* Set new value      */
         DoRestoreClippings();/* Restore clippings    */
         if (ctrlHdl == vScrollBar)/* Check if vert   */
          PEScroll(0,(long)(i),peHdl);/* Scroll vert  */
         else                 /* Nope, horz scroll    */
          PEScroll(i,0L,peHdl);/* Scroll horz dir.    */
        }
       }
       adjustIt = FALSE;      /* Don’t adjust view    */
       break;
      case 0x77:              /* End key              */
       if (ctrlHdl) {         /* Check if has ctrl hdl*/
                              /* Check if can scroll  */
        if ((i = GetCtlValue(ctrlHdl)) !=
            (j = GetCtlMax(ctrlHdl))) {
         ClipRect(&wp->portRect);/* Reset clippings   */
         SetCtlValue(ctrlHdl,j);/* Reset new value    */
         DoRestoreClippings();/* Restore clippings    */
         if (ctrlHdl == vScrollBar)/* Check if vert   */
          PEScroll(0,(long)(i - j),peHdl);
         else                 /* Scroll horz dir.     */
          PEScroll(i - j,0L,peHdl);
        }
       }
       adjustIt = FALSE;      /* Don’t adjust view    */
       break;
      case 0x74:              /* Page up key          */
       if (ctrlHdl) {         /* Check if has ctrl hdl*/
        DoTextScroll(ctrlHdl,inPageUp);/* Scroll up   */
       }
       adjustIt = FALSE;      /* Don’t adjust view    */
       break;
      case 0x79:              /* Page down key        */
       if (ctrlHdl) {         /* Check if has ctrl hdl*/
        DoTextScroll(ctrlHdl,inPageDown);/*Scroll down*/
       }
       adjustIt = FALSE;      /* Don’t adjust view    */
       break;
     }
    }
    if (adjustIt)             /* Should adjust it ?   */
     DoAdjustScrollBar();     /* Adjust the scroll bar*/
   }
  }
 }

DoMenu(item)
 short   item;               /* Item code             */
 {
  switch(item) {             /* Process menu command  */
   case Info:                /* On-line information   */
    DoInfo(); break;
   case StartOutput:         /* Start/Stop output     */
    DoStartStopOutput(); break;
   case Quit:                /* Quit from the DA      */
    DoQuit(); break;
  }
 }
    
DoContent(p,modifiers)
 Point    p;                 /* Mouse down point      */
 short   modifiers;          /* Mouse’s modifiers     */
 {
  long            i;         /* Working index         */
  register short  selectIt = FALSE;/* Selection flag  */
  Point           pt;        /* Working point         */
        
  pt = p;                    /* Convert to local coord*/
  GlobalToLocal(&pt);
        
  if (!DoScrollBar(pt))      /* Check if in scroll bar*/
   DoTextClick(pt,modifiers);/* Do text clicking      */
}
    
DoQuit()
 {
  SysBeep(1);                /* Beep the user now!    */
  CloseDriver(dce->dCtlRefNum);/* OK, let’s close DA  */
 }
    
DoCopy()
 {
  register long   len;       /* Working text length   */
  
  if (active) {              /* Check if it activated */
   if (peHdl) {              /* Check if have edit hdl*/
                             /* Check if any selection*/
    if (len = (*peHdl)->selEnd - (*peHdl)->selStart) {
     ZeroScrap();            /* Reset the scrap file  */
     HLock((*peHdl)->hText); /* Lock the text down    */
                             /* Transfer to clipboard */
     PutScrap(len,’TEXT’,*(*peHdl)->hText + 
                         (*peHdl)->selStart);
     HUnlock((*peHdl)->hText);/* OK, safe to unlock it*/
    }
   }
  }
 }

DoClear()
 {
  register Handle txtHdl;    /* Working text handle   */
  Rect            wRect;     /* Working rect area     */
        
  if (peHdl) {               /* Check if have edit hdl*/
   if (txtHdl = NewHandle(0L)) {/* Check if got hdl   */
    ClipRect(&wp->portRect); /* Reset clipping        */
    if (hScrollBar) {        /* Check if have scroll  */
     (*hScrollBar)->contrlMax = 0;/* Reset values     */
     SetCtlValue(hScrollBar,0);
    }
    if (vScrollBar) {        /* Check if have scroll  */
     (*vScrollBar)->contrlMax = 0;/* Reset values     */
     SetCtlValue(vScrollBar,0);
    }
    DoRestoreClippings();    /* Restore clippings     */
    DisposHandle((*peHdl)->hText);/* Release old text */
    (*peHdl)->hText = NIL;   /* Reset it to zip!      */
    PESetHText(txtHdl,peHdl);/* Set new text handle   */
    wRect = wp->portRect;    /* Clear the display     */
    wRect.right -= 15; wRect.bottom -= 15;
    InvalRect(&wp->portRect);
   }
  }
 }

DoInfo()
 {
  register DialogPtr  dPtr;  /* Working dialog pointer*/
  short               dItem; /* Working dialogue item */
  register short      next = TRUE;/* Working next flag*/
        
  if (dbgHdl) {              /* Check if got ref hdl  */
   (*dbgHdl)->daRefNbr = 0;  /* Clear debugger ref hdl*/
   ChangedResource(dbgHdl);
   WriteResource(dbgHdl);
  }
  DoDeActivateScrollBars();  /* Deactivate scroll bars*/
  DoDlgCenter(‘DLOG’,infoID);/* Center the dialog now */
                             /* Open dialog           */
  dPtr = GetNewDialog(GetResourceID(infoID),NIL,-1L);
  if (dPtr) {                /* Check if open dialog  */
   InitCursor();             /* Restore arrow cursor  */
   cursorMode = FALSE;       /* Reset cursor mode     */
   SetPort(dPtr);            /* Set to my window port */
   while(next) {             /* Process next event    */
    ModalDialog(NIL,&dItem); /* Get modal event       */
    if (dItem == OK)         /* Check if time to quit */
     next = FALSE;           /* Let’s break-out !     */
   }
   SetPort(wp);              /* Restore DA window port*/
   DisposDialog(dPtr);       /* Kill dialogue window  */
  }
  DoActivateScrollBars();    /* Activate scroll bars  */
  if (dbgHdl) {              /* Check if got ref hdl  */
   if (outputEnable) {       /* Check if enabled      */
                             /* Restore ref handle    */
    (*dbgHdl)->daRefNbr = dce->dCtlRefNum;
    ChangedResource(dbgHdl);
    WriteResource(dbgHdl);
   }
  }
 }

DoStartStopOutput()
 {
  Str255      wStr;          /* Working item string   */
        
  if (dbgHdl) {              /* Check if has ref hdl  */
   if (outputEnable) {       /* Check if to turn off  */
    outputEnable = FALSE;    /* Disable output display*/
    (*dbgHdl)->daRefNbr = 0;
    GetIndString(wStr,GetResourceID(strID),
                 itmStartOutput);
   }
   else {                    /* Nope, start-up output */
    outputEnable = TRUE;     /* Enable output display */
    (*dbgHdl)->daRefNbr = dce->dCtlRefNum;
    GetIndString(wStr,GetResourceID(strID),itmStopOutput);
   }
   SetItem(menu,StartOutput,wStr);/* Reset item string*/
  }
 }

DoError(errMsg)
 ERROR   errMsg;             /* Error message         */
 {
  Str255  wStr;              /* Working string        */
        
  if (dbgHdl) {              /* Check if got ref hdl  */
   (*dbgHdl)->daRefNbr = 0;  /* Clear debugger ref hdl*/
   ChangedResource(dbgHdl);
   WriteResource(dbgHdl);
  }
                             /* Get error message     */
  GetIndString(wStr,GetResourceID(errID),errMsg);
  ParamText(wStr,””,””,””);  /* Setup text messages   */
  DoDlgCenter(‘ALRT’,errorID);/* Center alert dialog  */
  DoDeActivateScrollBars();  /* Deactivate scroll bars*/
  CautionAlert(GetResourceID(errorID),NIL);/* Show it */
  DoActivateScrollBars();    /* Activate scroll bars  */
  if (dbgHdl) {              /* Check if got ref hdl  */
   if (outputEnable) {       /* Check if enabled      */
                             /* Restore ref handle    */
    (*dbgHdl)->daRefNbr = dce->dCtlRefNum;
    ChangedResource(dbgHdl);
    WriteResource(dbgHdl);
   }
  }
 }

DoTextClick(pt,modifiers)
 Point   pt;                 /* Mouse down point      */
 short   modifiers;          /* Modifiers selection   */
 {
  register short  extendIt = FALSE;/* Extend selection*/

  if (peHdl) {               /* Check if got the text */
   if ((*peHdl)->peLength > 0) {/* Check if any text  */
    if (modifiers & shiftKey)/*Check if want extend it*/
     extendIt = TRUE;        /* Extend selection then */
    PEClick(pt,extendIt,peHdl);/* Do clicking stuff   */
   }
  }
 }

DoScrollBar(pt)
 Point   pt;                 /* Mouse down point      */
 {
  register short  partCtrl;  /* Working control part  */
  ControlHandle   ctrlHdl;   /* Working control handle*/

                             /* Check if got ctrl part*/
  if (partCtrl = FindControl(pt,wp,&ctrlHdl)) {
   ClipRect(&wp->portRect);  /* Setup clippings       */
   if (partCtrl == inThumb) {/* Check if using thumb  */
                             /* Save cur ctrl’s value */
    SetCRefCon(ctrlHdl,GetCtlValue(ctrlHdl));
    ClipRect(&wp->portRect); /* Reset for a moment    */
    TrackControl(ctrlHdl,pt,NIL);/* Let track by thumb*/
    DoTextScroll(ctrlHdl,inThumb);/* OK, let’s scroll */
    DoRestoreClippings();    /* Restore view clippings*/
   }
   else {                    /* Nope, other types     */
    ClipRect(&wp->portRect); /* Reset for a moment    */
    TrackControl(ctrlHdl,pt,DoTextScroll);/* Scroll it*/
    DoRestoreClippings();    /* Restore text clippings*/
   }
  }
  return(partCtrl);          /* Return part control   */
 }

pascal void DoTextScroll(ctrlHdl,partCtrl)
 ControlHandle   ctrlHdl;    /* Control scroll handle */
 short           partCtrl;   /* Control’s part        */
 {
  register short  delta;     /* Working delta scroll  */
  register short  value;     /* Working current value */
  register short  maxValue;  /* Working maximum value */
  register short  viewLines; /* Working view lines    */
  short           dh = 0;    /* Working delta horz    */
  long            dv = 0;    /* Working delta vertical*/
  PEPtr           pePtr;     /* Working edit pointer  */
        
  SetUpA4();                 /* Setup register A4     */
  delta = GetCtlValue(ctrlHdl);/* Get current value   */
  maxValue = GetCtlMax(ctrlHdl);/* Get maximum value  */
  switch(partCtrl) {         /* Handle request:       */
   case 0:                   /*      “Nothing”        */
    return;
   case inUpButton:
    value = max(0,delta - 1);/* Set new value position*/
    break;
   case inDownButton:
    value = min(maxValue,delta + 1);/* Set new value  */
    break;
   case inPageUp:            /*      “Page Up”        */
   case inPageDown:          /*      “Page Down”      */
    if (ctrlHdl == vScrollBar) {/* Check if vertical  */
     pePtr = *peHdl;         /* Set edit text pointer */
                             /* Set vis lines by half */
     viewLines = (pePtr->viewRect.bottom - 
               pePtr->viewRect.top) / pePtr->lineHeight;
     if (partCtrl == inPageUp)/* Check if page up reg */
      value = max(0,delta - viewLines);
     else                    /* Nope, page down region*/
      value = min(maxValue,delta + viewLines);
    }
    else {                   /* Check if horizontal   */
     if (partCtrl == inPageUp)/* Check if page up reg */
      value = max(0,delta - 10);/* Set new position   */
     else                    /* Nope, page down region*/
      value = min(maxValue,delta + 10);
    }
    break;
   case inThumb:             /*      “Thumb”          */
    delta = GetCRefCon(ctrlHdl);/* Get starting value */
    value = GetCtlValue(ctrlHdl);/* Get new value     */
  }
  SetCtlValue(ctrlHdl,value);/* Reset the value       */
  if (hScrollBar == ctrlHdl) /* Check if horzontal    */
   dh = delta - value;       /* Set horizontal offset */
  else
   dv = delta - value;       /* Set vertical offset   */
  DoRestoreClippings();      /* Restore view clippings*/
  if (dh || dv)              /* Check if should scroll*/
   PEScroll(dh * CharWidth(‘ ‘),dv,peHdl);/* Scroll it*/
  ClipRect(&wp->portRect);   /* Reset clippings       */
  RestoreA4();               /* Restore register A4   */
 }

pascal void DoClickScroll(peHdl)
 register PEHandle    peHdl; /* Edit data handle      */
 {
  register Rect     viewRect;/* Working view rect area*/
  Point             pt;      /* Working mouse point   */
    
  viewRect = (*peHdl)->viewRect;/* Set view rect area */
  GetMouse(&pt);             /* Get current mouse     */
  if (pt.v < viewRect.top)   /* Check if going upward */
   DoTextScroll(vScrollBar,inUpButton);
  else if (pt.v > viewRect.bottom)/* Check if downward*/
   DoTextScroll(vScrollBar,inDownButton);
  else if (pt.h < viewRect.left)/* Check if leftward  */
   DoTextScroll(hScrollBar,inUpButton);
  else if (pt.h > viewRect.right)/* Check if rightward*/
   DoTextScroll(hScrollBar,inDownButton);
 }
   
pascal  void    DoHighLite(hilite,pePtr)
 Rect      *hilite;          /* Highlite rect area    */
 register PEPtr pePtr;       /* Edit text pointer     */
 {
  HiliteMode &= 0x7f;        /* Set highliting bit    */
  InvertRect(hilite);        /* Invert rect area      */
 }

DoNewLineToReturn(s)
 char    *s;                 /* Input string pointer  */
 {
  while(*s) {                /* Cvt NEW-LINE to RETURN*/
   if (*s == ‘\n’)           /* Check if NEW-LINE char*/
    *s = ‘\r’;               /* Convert to RETURN char*/
   s += 1;                   /* Bump to next character*/
  }
 }
    
DoPrintLine(format,args)
 char    *format;            /* Format string pointer */
 va_list args;               /* Argument’s list       */
 {
  vsprintf(PrintOutputBuf,format,&args);/* Format buf */
  DoNewLineToReturn(PrintOutputBuf);/*Convert NEW-LINE*/
                             /* Output string         */
  PEInsert(PrintOutputBuf,DbgStrLen(PrintOutputBuf), peHdl);
  DoAdjustScrollBar();       /* Adjust the scroll bar */
 }
    
DoDbgPrintSetUp(fmt)
 char        *fmt;           /* Input format pointer  */
 {
  register short  fLen;      /* Working format str len*/
  register char   *stack;    /* Working fake stack ptr*/
        
  fLen = DbgStrLen(fmt) + 1; /* Set string length     */
  if (fLen & 0x1)            /* Check if even # chars */
   fLen += 1;                /* Align it to even addr */
  stack = fmt + fLen;        /* Set format string addr*/
  *((long *)(stack)) = ((long)(fmt));
  DoDbgPrint(stack);         /* OK, let’s really do it*/
 }

DoDbgPrint(args)
 long    *args;              /* Input argument’s list */
 {
  DoSetupView();             /* Setup the view display*/
  DoAdjustView();            /* Adjust the view       */
  vsprintf(PrintOutputBuf,*args,args + 1L);/*Format it*/
  DoNewLineToReturn(PrintOutputBuf);/*Convert NEW-LINE*/
                             /* Output string         */
  PEInsert(PrintOutputBuf,DbgStrLen(PrintOutputBuf), peHdl);
  DoAdjustScrollBar();       /* Adjust the scroll bar */
 }
    
DoPrintDump(ptr,size)
 char    *ptr;               /* Print buffer pointer  */
 long    size;               /* Print buffer length   */
 {
  register  long    i,j,k,m,n;/* Working indexes      */
  register  char    *tptr;   /* Working temporary ptr */
  Str255            buffer;  /* Working string buffer */
  Str255            tbuffer; /* Working temp buffer   */
      
  DoSetupView();             /* Setup the view display*/
  DoAdjustView();            /* Adjust the view       */
                             /* Output # of bytes     */
  DoPrintLine(“\nNumber of bytes - %ld\n”,size);
  DoPrintLine(“Cnt  Address  %s %s\n”,
              “Hex Values--------------------------------------------------”,
              “ASCII Values--------”);
  for(i = 0L; i < size; i += 16L) {/*Transfer all data*/
   n = 14L;                  /* Set init buffer index */
   for(j = 0L; j < sizeof(buffer); j++)/* Clr buf str */
    buffer[j] = ‘ ‘;         /* Pad it with spaces    */
   sprintf(buffer,”%04ld %08lx “,i,tptr = ptr);
   j = i; k = m = 0L;        /* Init indexes          */
   while(j < size && m < 16L) {/* Output hex parts    */
    m += 1L;                 /* Bump # of characters  */
    if (k++ == 3L) {         /* Check if time to pad  */
     sprintf(tbuffer,”%04x “,*tptr++);/* Get char hex */
                             /* Add it to output buf  */
     BlockMove(&tbuffer[2],&buffer[n],
               DbgStrLen((char *)(&tbuffer[2])) + 1);
     k = 0L;                 /* Reset index           */
     n += 1L;                /* Bump one extra        */
    }
    else {
     sprintf(tbuffer,”%04x”,*tptr++);/* Get char hex  */
                             /* Add it to output buf  */
     BlockMove(&tbuffer[2],&buffer[n],
               DbgStrLen((char *)(&tbuffer[2])) + 1);
    }
    j += 1L;                 /* Bump to next character*/
    n += 2L;                 /* Bump for two hex chars*/
   }
   buffer[n] = ‘ ‘;          /* Remove end-of-string  */
   n = 50L;                  /* Reset character index */
   j = i; m = 0L;            /* Init indexes          */
   while(j < size && m < 16L) {/* Output hex parts    */
    j += 1L;                 /* Bump to next character*/
    m += 1L;                 /* Bump # of characters  */
    if (isprint(*ptr))       /* Check if printable    */
     sprintf(&buffer[n],”%c”,*ptr++);/* Output char   */
    else {                   /* It’s not printable    */
     BlockMove(“.”,&buffer[n],2L);/* Show period only */
      ptr += 1L;             /* Bump to next character*/
    }
    n += 1L;                 /* Bump for one character*/
   }
                             /* Add RETURN character  */
   BlockMove(“\r”,&buffer[DbgStrLen((char *)(buffer))], 2L);
   DoPrintLine(“%s”,buffer); /* Output the string     */
  }
 }
    
DoRestoreClippings()
 {
  Rect    wRect;             /* Working rect area     */
        
  if (peHdl) {               /* Check if it’s valid   */
   wRect = (*peHdl)->viewRect;/* Restore clipping     */
   ClipRect(&wRect);
  }
 }
    
DoAdjustScrollBar()
 {
  register short  viewHeight;/* Working view height   */
  register short  hiddenLines;/* Working # hidden line*/
  register PEPtr  pePtr;     /* Working edit pointer  */
        
  if (peHdl) {               /* Check if have edit hdl*/
   pePtr = *peHdl;           /* Set edit pointer      */
   if (pePtr->peLength) {    /*Check if there any text*/
    ClipRect(&wp->portRect); /* Reset clippings       */
    if (hScrollBar) {        /* Check if there a horz */
     if (!GetCtlMax(hScrollBar))/* Check if not init  */
      SetCtlMax(hScrollBar,maxColumns);/* Reset to max*/
    }
    if (vScrollBar) {        /* Check if there a vert */
                             /* Set view height       */
     viewHeight = abs(pePtr->viewRect.bottom - 
                      pePtr->viewRect.top);
                             /*Check if need to enable*/
     if (pePtr->nLines*pePtr->lineHeight > viewHeight) {
                             /* Set # of hidden lines */
      hiddenLines = max(0,pePtr->nLines - viewHeight / 
                          pePtr->lineHeight);
                             /*Check if hidden changed*/
      if (GetCtlMax(vScrollBar) != hiddenLines) {
                             /* Update maximum # lines*/
       (*vScrollBar)->contrlMax = hiddenLines - 1;
                             /* Adjust thumb position */
       SetCtlValue(vScrollBar,
                   min((short)pePtr->viewOrgV, hiddenLines - 1));
       DoAdjustView();       /* Adjust the view       */
      }
     }
     else {                  /* Nope, disable scroll  */
                             /* Check if it’s enabled */
      if (GetCtlMax(vScrollBar)) {
       (*vScrollBar)->contrlMax = 0;/* Reset it       */
       SetCtlValue(vScrollBar,0);
      }
     }
    }
   }
   else {                   /* Reset the scroll bars  */
    if (hScrollBar) {       /* Check if there a horz  */
     if (GetCtlMax(hScrollBar)) {/* Check if enabled  */
      (*hScrollBar)->contrlMax = 0;/* Reset it        */
      SetCtlValue(hScrollBar,0);
     }
    }
    if (vScrollBar) {       /* Check if there a vert  */
     if (GetCtlMax(vScrollBar)) {/* Check if enabled  */
      (*vScrollBar)->contrlMax = 0;/* Reset it        */
      SetCtlValue(vScrollBar,0);
     }
    }
   }
   DoRestoreClippings();   /* Restore view clippings  */
  }
 }
    
DoSetupView()
 {
  register PEPtr  pePtr;     /* Working edit data ptr */
    
  if (peHdl) {               /* Check if have edit hdl*/
   pePtr = *peHdl;           /* Set edit pointer      */
                             /* Check if selected text*/
   if (pePtr->selStart != pePtr->selEnd)
    PESetSelect(pePtr->peLength,pePtr->peLength,peHdl);
                             /* Check not end-of-text */
   else if (pePtr->selStart != pePtr->peLength)
    PESetSelect(pePtr->peLength,pePtr->peLength,peHdl);
  }
 }
    

DoAdjustView()
 {
  register PEPtr     pePtr;  /* Working edit data ptr */
  long               delta;  /* Working delta offset  */
  long               currentLine;/* Cur line selection*/
  register long      selectLine;/* Working line sel   */
  register long      viewLines;/* Working view lines  */
  long               hViewLines;/* Half view lines    */
  register long      viewOrgV;/* Origin view offset   */
  long               saveSelStr;/* Save selStart value*/
  long               saveSelEnd;/* Save selEnd value  */
  register long      status = TRUE;/* Adjust view flag*/
  short              adjust = FALSE;/* Vert adjustment*/
    
  if (peHdl) {               /* Check if have edit hdl*/
   DoRestoreClippings();     /* Restore view clippings*/
   pePtr = *peHdl;           /* Set edit text pointer */
   if (optHdl) {             /* Check if hdl valid    */
    if ((*optHdl)->maxTextSize) {/* Check if maxing   */
                             /* Set cur line to chop  */
     currentLine = pePtr->peLength - (*optHdl)->maxTextSize;
     if (currentLine > 0) {  /* Check if time to chop */
      PECloseGap(peHdl);     /* Close the gap first   */
      saveSelStr = pePtr->selStart;/* Save start sel  */
      saveSelEnd = pePtr->selEnd;/* Save end selection*/
                             /* Reset selection       */
      PESetSelect(0L,currentLine = PEEol(currentLine,
                               peHdl) + 1L,peHdl);
      PEDelete(peHdl);       /* OK, let’s delete it   */
                             /* Restore it            */
      PESetSelect(saveSelStr - currentLine,
                  saveSelEnd - currentLine,peHdl);
     }
    }
   }
   pePtr = *peHdl;           /* Set edit text pointer */
   viewOrgV = pePtr->viewOrgV;/*Set view origin offset*/
                             /* Set # of visible lines*/
   viewLines = abs(pePtr->viewRect.bottom -
                   pePtr->viewRect.top) /
               pePtr->lineHeight;
   hViewLines = viewLines / 2;/*Half of the view lines*/
                             /* Set selected line #   */
   selectLine=currentLine=PELineNum(pePtr->selEnd,peHdl);
   pePtr = *peHdl;           /* Reset edit text ptr   */
                             /* Check if within view  */
   if (selectLine >= viewOrgV &&
       selectLine < viewOrgV + viewLines)
    status = FALSE;
   if (status) {             /* Check if should adjust*/
    adjust = TRUE;           /* Set adjust vert offset*/
    selectLine -= viewOrgV;  /* Adjust select line #  */
    if (selectLine == viewLines)/* Check if just off  */
     selectLine -= viewLines - 1;/* Adjust by one line*/
                             /* Check if close bottom */
    else if (delta = (pePtr->nLines - currentLine - 
                              1 - hViewLines) < 0)
     selectLine += delta - viewLines;/*Adjust to bottom*/
    else if (selectLine != -1)/*Check if completely off*/
     selectLine -= hViewLines;/* Center the page      */
    selectLine += viewOrgV;  /*Adjust physical offset */
                             /* Scroll to cursor      */
    PEScrollTo(pePtr->viewOrgH,selectLine,peHdl);
   }
  }
 }

DoResizeScrollBar()
 {
  Rect    wRect;             /* Window rect area     */
        
  if (peHdl) {               /*Check if have edit hdl*/
   wRect.left = wp->portRect.left;
   wRect.top = wp->portRect.top + 5;
   wRect.right = wp->portRect.right - 15;
   wRect.bottom = wp->portRect.bottom - 15;
   (*peHdl)->viewRect = wRect;
  }
  if (hScrollBar) {          /* Check if have scroll  */
                             /* Compute rect area     */
   wRect.left = wp->portRect.left - 1;
   wRect.top = wp->portRect.bottom - 15;
   wRect.right = wp->portRect.right - 14;
   wRect.bottom = wp->portRect.bottom + 1;
   (*hScrollBar)->contrlRect = wRect;/* Set new rect  */
  }
  if (vScrollBar) {          /* Check if have scroll  */
                             /* Compute rect area     */
   wRect.left = wp->portRect.right - 15;
   wRect.top = wp->portRect.top - 1;
   wRect.right = wp->portRect.right + 1;
   wRect.bottom = wp->portRect.bottom - 14;
   (*vScrollBar)->contrlRect = wRect;/* Set new ret   */
  }
 }
    
DialogTHndl DoDlgCenter(type,id)
 long  type;                 /* Resource type id      */
 short id;                   /* Id #                  */
 {
  register DialogTHndl dhdl; /* Working dialog handle */
  register DialogTPtr  dptr; /* Working dialog ptr    */
  WindowPtr            wPtr; /* Working window ptr    */
  register short       swidth;/*Working 1/2 horz width*/
  register short       width;/*Working 1/2 horz width */
      
                             /* Check if got dlg hdl  */
  if (dhdl = ((DialogTHndl)GetResource(type,
                                  GetResourceID(id)))) {  
   GetWMgrPort(&wPtr);       /* Get window mgr ptr    */
   dptr = *dhdl;             /* Set dialog ptr        */
                             /* Set 1/2 screen width  */
   swidth = abs(wPtr->portRect.right -
                wPtr->portRect.left) / 2;
                             /* Set 1/2 dialog width  */
   width = abs(dptr->boundsRect.right -
               dptr->boundsRect.left) / 2;
                             /* Center the dialog     */
   dptr->boundsRect.left = swidth - width;
   dptr->boundsRect.right = swidth + width;
  }
  return(dhdl);              /* Return dialog handle  */
 }

DoItemIdx(item,menu)
 register unsigned char  *item;/* Item string look up */
 register MenuHandle     menu;/* Menu handle          */
 {
  register short  i,j;       /* Working index         */
  register unsigned short len = *item++;/* Item length*/
  Str255          wStr;      /* Working string        */
        
                             /* Look for matching item*/
  for(i = 1, j = CountMItems(menu); i <= j; i++) {
   GetItem(menu,i,&wStr);    /* Working string        */
   if (!IUMagString(item,&wStr[1],len,len))/* Matches?*/
    return(i);               /* Found matching string */
  }
  return(1);                 /* Opps, didn’t find it  */
 }

GetResourceID(n)
 { return(0xC000 + ((~(dce->dCtlRefNum))<<5) + n); }

/*
 *  Source    - Debugger.c
 *  Author    - Alexander S. Colwell,
 *              Copyright (C) 1988, 1989
 *  Purpose   - This is the “Debugger Window” DA
 *              interface routines.
 */

#include “Debugger.h”        /* Debugger defs         */

                             /* Device ctrl entry func*/
#define DbgDCtlEntry(refNbr) (UTableBase[-1*(refNbr+1)])
short   DbgArgCnt();         /* Define forward refs   */

DBGHDL  DbgGetRefHdl()
 {
  register DBGHDL dbgHdl;    /* DA’s reference # hdl  */

  asm {                      /* Debugger’s res name   */
   CLR.L   -(sp)             ;Allocate return handle
   PEA     debuggerType      ;Load resource type
   PEA     @dbgRef           ;Load resource name 
   _GetNamedResource         ;Get resource handle
   MOVE.L  (sp)+,dbgHdl      ;Save resource handle
   BRA.S   @dbgExit          ;Skip around resource name
dbgRef: DC.B 18,’D’,’e’,’b’,’u’,’g’,’g’,’e’,’r’,’ ‘,’R’,’e’,’f’,’e’,’r’,’e’,’n’,’c’,’e’
dbgExit:
  }
  return(dbgHdl);            /* Return resource handle*/
}
    
void    DbgPrint(dbgHdl,args)
 register DBGHDL dbgHdl;     /* Working DA’s ref # hdl*/
 char    *args;              /* Input arguments       */
 {
  register short  refNbr;    /* Working DA’s ref #    */
  register short  daEnable;  /* Working save DA state */
  register DCtlHandle dceHdl;/* Device control entry  */
        
  if (dbgHdl) {              /* Check if got handle   */
   if (refNbr = (*dbgHdl)->daRefNbr) {/*Check if valid*/
                             /* Check if got dev hdl  */
    if (dceHdl = GetDCtlEntry(refNbr)) {
                             /* Save enabled stated   */
     daEnable = (*dceHdl)->dCtlFlags & dCtlEnable;
                             /* Enable DA’s entry     */
     (*dceHdl)->dCtlFlags |= dCtlEnable;
     Control(refNbr,accDbgPrint,&args);/* Write it    */
     if (!daEnable)          /* Check if not enabled  */
      (*dceHdl)->dCtlFlags &= ~dCtlEnable;
    }
   }
  }
 }

void    DbgBufPrint(args)
 long    *args;              /* Input arguments       */
 {
  register DBGHDL dbgHdl;    /* Working DA’s ref # hdl*/
  register DBGPTR dbgPtr;    /* Working DA’s ref hdl  */
  DCtlHandle      dceHdl;    /* Working device ctrl   */
  register char   *fmt;      /* Working format string */
  register char   *buf;      /* Working buffer address*/
  long            *addr;     /* Working stack address */
  register long   fLen;      /* Working format str len*/
  register long   dLen;      /* Working data buf len  */
  register long   argc;      /* Working # of arg bytes*/
  register long   nextIdx;   /* Working next table idx*/
  register long   dataIdx;   /* Working data index    */
        
  dbgHdl = (DBGHDL)(&args[0]);/* Set debugger handle  */
  if (dbgHdl) {              /* Check if got handle   */
   dbgPtr = *dbgHdl;         /* Setup debugger pointer*/
   if (dbgPtr->daRefNbr) {   /* Check if it’s valid   */
                             /* Check if got device   */
    if (dceHdl = DbgDCtlEntry(dbgPtr->daRefNbr)) {
                             /* Check if have buffers */
     if (dbgPtr->bufTable && dbgPtr->bufData) {
                             /* Set next tbl idx entry*/
      nextIdx = (dbgPtr->bufNextIdx + 1L) %
                dbgPtr->bufTableSize;
      if (nextIdx == dbgPtr->bufTableIdx)/* Overflow? */
       dbgPtr->bufError = dbgTableOvrFlw;
      else {                 /* Nope, continue        */
       argc = DbgArgCnt(&args) - 4L;/* Get # of args  */
       if (argc >= 4L) {     /* Check if has fmt str  */
        addr = (long *)(&args);/* Set stack address   */
        fmt = (char *)(addr[1]);/* Get variable arg   */
        fLen = DbgStrLen(fmt) + 1L;/* Get fmt str len */
        if (fLen & 0x1L)     /* Check if even align   */
         fLen += 1L;         /* Align it              */
        dLen = argc + fLen + 2L;/* Total buf length   */
                             /* Check if time buf wrap*/
         if ((dataIdx = dbgPtr->bufDataIdx) + dLen >= 
             dbgPtr->bufDataSize)
          dataIdx = 0L;      /* Reset begin-of-buffer */
         if (dLen > dbgPtr->bufDataSize)/* Buf to big?*/
          dbgPtr->bufError = dbgBufOvrFlw;
                             /* Check if any in buffer*/
         else if (dbgPtr->bufTableIdx != dbgPtr->bufNextIdx) {
                             /* Check if buf overflow */
          if (dataIdx < (*dbgPtr->bufTable)[dbgPtr->bufTableIdx+1L])
           if (dLen + dataIdx >           (*dbgPtr->bufTable)[dbgPtr->bufTableIdx+1L])
            dbgPtr->bufError = dbgDataOvrFlw;
         }
         if (!dbgPtr->bufError) {/* Check no overflow */
          dbgPtr->bufNextIdx = nextIdx;/* Set next lin*/
                             /* Save data buffer index*/
          (*dbgPtr->bufTable)[nextIdx] = dataIdx;
                             /* Set buffer address    */
          buf = &(*dbgPtr->bufData)[dataIdx];
          *buf = accDbgPrint;/* Set code              */
          BlockMove(fmt,buf + 2L,fLen);/* Copy fmt str*/
                             /* Copy the stack        */    
          BlockMove(&addr[1],buf + fLen + 2L,argc);
                             /* Bump to next position */
          dbgPtr->bufDataIdx = dataIdx + dLen;
          (*dceHdl)->dCtlFlags |= dNeedTime;/* Enable */
          (*dceHdl)->dCtlDelay = 1;/* Reset delay time*/
         }
        }
       }
      }
     }
    }
   }
 }
    
void    DbgDump(dbgHdl,buffer,size)
 register DBGHDL dbgHdl;     /* Working DA’s ref # hdl*/
 char    *buffer;            /* Input buffer          */
 long    size;               /* Input buffer size     */
 {
  register short  refNbr;    /* Working DA’s ref #    */
  register short  daEnable;  /* Working save DA state */
  register DCtlHandle dceHdl;/* Working dev ctrl entry*/
  long            csParam[2];/* Working ctrl parm list*/
        
  if (dbgHdl) {              /* Check if got handle   */
   if (refNbr = (*dbgHdl)->daRefNbr) {/*Check if valid*/
                             /*Check if got device hdl*/
    if (dceHdl = GetDCtlEntry(refNbr)) {
                             /* Save enabled stated   */
     daEnable = (*dceHdl)->dCtlFlags & dCtlEnable;
                             /* Enable DA’s entry     */
     (*dceHdl)->dCtlFlags |= dCtlEnable;
     csParam[0] = (long)(buffer);/* Init param list   */
     csParam[1] = size;
                             /* OK, let’s dump it now */
     Control(refNbr,accDbgDump,csParam);
     if (!daEnable)          /* Check if not enabled  */
      (*dceHdl)->dCtlFlags &= ~dCtlEnable;
    }
   }
  }
 }

void    DbgBufDump(dbgHdl,buffer,size)
 register DBGHDL dbgHdl;     /* Working DA’s ref # hdl*/
 char    *buffer;            /* Input buffer          */
 long    size;               /* Input buffer size     */
 {
  register DBGPTR dbgPtr;    /* Working DA’s ref hdl  */
  DCtlHandle      dceHdl;    /* Working dev ctrl entry*/
  register char   *buf;      /* Working buffer address*/
  register long   dLen;      /* Working data buf len  */
  register long   argc;      /* Working # of arg bytes*/
  register long   nextIdx;   /* Working next table idx*/
  register long   dataIdx;   /* Working data index    */
        
  if (dbgHdl) {              /* Check if got handle   */
   dbgPtr = *dbgHdl;         /* Setup debugger pointer*/
   if (dbgPtr->daRefNbr) {   /* Check if it’s valid   */
                             /* Check if got dev hdl  */
    if (dceHdl = DbgDCtlEntry(dbgPtr->daRefNbr)) {
                             /* Check if have buffers */
     if (dbgPtr->bufTable && dbgPtr->bufData) {
                             /* Set next tbl idx entry*/
      nextIdx = (dbgPtr->bufNextIdx + 1L) %
                dbgPtr->bufTableSize;
      if (nextIdx == dbgPtr->bufTableIdx)/* Overflow? */
       dbgPtr->bufError = dbgTableOvrFlw;
      else {                 /* Nope, continue        */
       dLen = size + sizeof(size) + 2L;/*Total buf len*/
       if (dLen & 0x1L)      /* Check if odd size     */
        dLen += 1L;          /* Let’s make it even    */
                             /* Check if time buf wrap*/
       if ((dataIdx = dbgPtr->bufDataIdx) + dLen >= 
           dbgPtr->bufDataSize)
         dataIdx = 0L;       /* Reset begin-of-buffer */
       if (dLen > dbgPtr->bufDataSize)/*Buffer to big?*/
        dbgPtr->bufError = dbgBufOvrFlw;
                             /* Check if any in buffer*/
       else if (dbgPtr->bufTableIdx != dbgPtr->bufNextIdx) {
                             /* Check if buf overflow */
        if (dataIdx <
            (*dbgPtr->bufTable)[dbgPtr->bufTableIdx+1L])
         if (dLen + dataIdx >
             (*dbgPtr->bufTable)[dbgPtr->bufTableIdx+1L])
          dbgPtr->bufError = dbgDataOvrFlw;
       }
       if (!dbgPtr->bufError) {/* Check if no overflow*/
        dbgPtr->bufNextIdx = nextIdx;/* Set next line */
                             /* Save data buffer index*/
        (*dbgPtr->bufTable)[nextIdx] = dataIdx;
                             /* Set buffer address    */
        buf = &(*dbgPtr->bufData)[dataIdx];
        *buf = accDbgDump;   /* Set code              */
                             /* Copy size of buffer   */
        BlockMove(&size,buf + 2L,(long)(sizeof(size)));
                             /* Copy the buffer       */    
        BlockMove(buffer,buf + sizeof(size) + 2L,size);
                             /* Bump to next position */
        dbgPtr->bufDataIdx = dataIdx + dLen;
        (*dceHdl)->dCtlFlags |= dNeedTime;/* Enable it*/
        (*dceHdl)->dCtlDelay = 1;/* Reset delay timer */
       }
      }
     }
    }
   }
  }
 }

short   DbgArgCnt(vararg)
 long vararg;                /* Variable argument list */
 {
  register union {           /* Union of 3 var types   */
   long            addr;     /* Address of the types   */
   long            **args;
  }               varg;      /* Working var arg list   */
  register unsigned long instr;/* Working instruction  */
  register long     arg;     /* Working argument       */
  register long     count = 0L;/* # of arguments       */

  varg.addr = vararg;        /* Init variable arg list */
  varg.addr -= 4;            /* Position to instruction*/
  instr = **varg.args & 0xffff0000;/* Set instr word   */
  if (instr == 0x4fef0000)   /* Check if ADD instr     */
  count = (**varg.args & 0x0000ffff );/* Set # of bytes*/
                             /* Check if ADDI instr    */
  else if ((instr & 0xf1ff0000) == 0x508f0000) {
                             /* Check if 0, then 8 byte*/
   if (!(count = ((instr & 0x0e000000) >> 25)))
   count = 8;                /* Reset 8 bytes on stack */
  }
  return(count);             /* Return count           */
 }
 
long    DbgStrLen(s)
 register char   *s;         /* String pointer        */
 {
  register long   sLen = 0;  /* String length         */
        
  while(*s++)                /* Continue to end-of-str*/
   sLen++;                   /* Bump string length    */
  return(sLen);              /* Return string length  */
 }
    
*
*   Resource - DebuggerDA.R
*   Author   - Alexander S. Colwell,
*              Copyright (C) 1988, 1989
*   Purpose -  This is the resource file for the 
*              “Debugger Window” DA.
*
DebuggerDA.Π.rsrc
rsrcRSED

Type MENU
Debugger Menu,-16000
Debugger
About This Debugger Window.../?
(-
Stop Output/S
Quit/Q

Type STR#
Debugger Misc,-16000 (32)
5
Start Output
Stop Output
ERROR: Table index overflow
ERROR: Data buffer overflow
ERROR: Buffer size overflow

Debugger Errors,-15999 (32)
6
Sorry, fail to open DA. Perhaps running low on memory.
DA’s global memory allocation fail. Running low on memory.
Warning, running low on memory!
Sorry, require 4.1 or higher “System” file version.
Sorry, cannot run under “Lisa” clone Macintosh.
Sorry, cannot run on Mac 128K or 512K computer.

Type WIND
Debugger,-16000 (32)
Debugger Window
227 10 337 502
NoVisible GoAway
8
0

Type DLOG
Debugger Info,-16000 (32)
Info
64 92 105 323 
Visible NoGoAway
1
0
-16000

Type ALRT
Debugger Alert,-15999 (32)
100 100 199 401
-15999
4444

Type DITL
Debugger Info,-16000 (32)
1
StatText Enabled 
5 5 110 278 
  Debugger Window, Version 1.0    Written  by  Alexander S. Colwell

Debugger Alert,-15999 (32)
2
BtnItem Enabled
71 215 91 294 
OK

StatText Enabled
8 60 63 297 
^0

Type Opts = GNRL
Debugger Options,-16000
.I
0
4
9
4
.L
100
2048

Type Dbgr = GNRL
Debugger Reference,-16000 (32)
.I
0
0
.L
0
0
0
0
0
0
0

/*
 *  Source  - Round Window.c
 *  Author  - Alexander S. Colwell,
 *            Copyright (C) 1988, 1989
 *  Purpose - This will display a round window using
 *            “Debugger Window” DA demostration.
 */

#include <Color.h>           /* Color Manager defs    */
#include <math.h>            /* Math defs             */
#include <SetUpA4.h>         /* Desk Accessory defs   */
#include <VRetraceMgr.h>     /* Vertical Retrace defs */
#include “Debugger.h”        /* Debugger defs         */

                             /* Misc definitions      */
#define NIL     (0L)         /* NIL pointer           */
#define abs(a)  (a<0?-a:a)   /* Absolute macro func   */
#define min(a,b) (a<b?a:b)   /* Minumim macro function*/
#define max(a,b) (a<b?b:a)   /* Maximum macro function*/

                             /* Resource ID #’s       */
#define windID          0    /* Window ID #           */

#define helloWorld “\pHello, World”/* String message  */

typedef struct {             /* VBL data structure    */
    VBLTask vblTask;         /* VBL                   */
    DBGHDL  dbgHdl;          /* Debugger handler      */
    short   counter;         /* Tick counter          */
    } VBL;
typedef VBL *VBLPTR;

DCtlPtr         dce;         /* Device control entry  */
WindowPtr       wp = NIL;    /* My window pointer     */
short           alreadyOpen = FALSE;/* DA is opened   */
VBLPTR          vblPtr = NIL;/* VBL data block        */
Handle          vblHdl = NIL;/* VBL code handle       */
DBGHDL          dbgHdl = NIL;/* Debugger reference hdl*/ 

main(p,d,n)
 cntrlParam  *p;             /* Parameter block       */
 DCtlPtr     d;              /* Device control entry  */
 short       n;              /* Entry point selector  */
 {
  WindowPtr   savePort;      /* Save cur window port  */

  if (d->dCtlStorage == 0) { /* Check if got globals  */
   if (n == 0) {             /*Check if request “Open”*/
    SysBeep(1);              /* Beep da user!         */
    CloseDriver(d->dCtlRefNum);/* Close the DA        */
   }
  }
  else {                     /* Got globals then cont */
   GetPort(&savePort);       /* Get cur window port   */
   if (wp)                   /* Check if win ptr valid*/
    SetPort(wp);             /* Set port to my window */
   dce = d;                  /* Save DCE in our global*/
   dce->dCtlFlags &= ~dCtlEnable;/* Set not re-entrant*/
   switch(n) {               /* Handle request:       */
    case 0:                  /*      “Open”           */
     DoOpen(); break;    
    case 2:                  /*      “Control”        */
     DoControl(p->csCode,p->csParam); break; 
    case 4:                  /*      “Close”          */
     DoClose(); break;
   }
   dce->dCtlFlags |= dCtlEnable;/* Enable calls again */
   SetPort(savePort);        /* OK, let’s restore it  */
  }
  return(0);                 /* Return default success*/
 }

DoOpen()
 {
  Handle  wDEFHdl;           /* Working window def hdl*/
        
                             /* Add driver flags      */
  dce->dCtlFlags |= dNeedLock|dNeedGoodBye;
  if (wp)                    /* Check if there a wind */
   SelectWindow(wp);         /* Bring our window front*/
  if (!alreadyOpen) {        /* Check if require inits*/
   wp = GetNewWindow(GetResourceID(windID),NIL,-1L);
   if (wp) {                 /* Check if got window   */
                             /* Check if got our WDEF */
    if (wDEFHdl = GetResource(‘WDEF’,GetResourceID(0)))
     ((WindowPeek)(wp))->windowDefProc = wDEFHdl;
    ShowWindow(wp);          /* Show the window now   */
    SetPort(wp);             /* Set port to our window*/
    alreadyOpen = TRUE;      /* Set open DA indicator */
                             /*Save window association*/
    ((WindowPeek)wp)->windowKind = dce->dCtlRefNum;
    dce->dCtlWindow = wp;    /* Tell device where I am*/
    dbgHdl = DbgGetRefHdl(); /* Get reference handle  */
                             /* Check if got VBL ptr  */
    if (vblPtr = (VBLPTR)(NewPtr((long)sizeof(VBL)))) {
                             /* Check if got VBL code */
     if (vblHdl = GetResource(‘VBLC’,GetResourceID(0))){
      HLock(vblHdl);         /* Lock it for VBL task  */
                             /* Init VBL task         */
      vblPtr->vblTask.vblAddr = (ProcPtr)(*vblHdl);
      vblPtr->vblTask.vblCount = 120;
      vblPtr->vblTask.vblPhase = 0;
      vblPtr->vblTask.qType = vType;
      vblPtr->dbgHdl = dbgHdl;
      vblPtr->counter = 120;
      VInstall(vblPtr);      /* Install the VBL task  */
     }
    }
   }
   else {                   /* Fail to open           */
    SysBeep(1);             /* Beep da user!          */
    CloseDriver(dce->dCtlRefNum);/* OK, let’s close DA*/
   }
  }
 }

DoClose()
 {
  if (wp)                    /* Check if win ptr valid*/
   DisposeWindow(wp);        /* Delete the window now */
  wp = NIL;                  /* Invalidate it now     */
  if (vblPtr && vblHdl)      /* Check if VBL installed*/
   VRemove(vblPtr);
  if (vblPtr)                /* Check if has VBL ptr  */
   DisposPtr(vblPtr);        /* Release it now        */
  vblPtr = NIL;              /* Invalidate it now     */
  if (vblHdl) {              /* Check if has VBL hdl  */
   HUnlock(vblHdl);          /* OK, it safe unlock it */
   ReleaseResource(vblHdl);  /* Release it now        */
  }
  vblHdl = NIL;              /* Invalidate it now     */
  alreadyOpen = FALSE;       /* Reset it              */
 }

DoControl(code,parm)
 short code;                 /* Control command code  */
 short *parm;                /* “csParam” list pointer*/
 {
  switch(code) {             /* Handle request:       */
   case accEvent:            /*      “Event”          */
    DoEvent(*((EventRecord **)parm)); break;
   case goodBye:             /*      “GoodBye”        */
    DoClose(); break;
  }
 }

DoEvent(e)
 register EventRecord *e;    /* Event Record pointer  */
 {
                             /* Output DA’s event type*/
  DbgPrint(dbgHdl,”DA Event: what - %d\n”,e->what);
  switch(e->what) {          /* Handle request:       */
   case updateEvt:           /*      “Update”         */
    DoUpdate(); break;
   case mouseDown:           /*      “Mouse Down”     */
    DoMouse(e->where,e->modifiers); break;
   case keyDown:             /*      “Key Down”       */
   case autoKey:             /*      “Auto-Key Down”  */
                             /* Handle the input key  */
    DoKey((char)(e->message & charCodeMask),
          (char)((e->message & keyCodeMask) >> 8L),
          e->modifiers);
  }
 }

DoUpdate()
 {
  BeginUpdate(wp);           /* Start update process  */
  EraseRect(&wp->portRect);  /* Clear the window      */
  MoveTo(abs(wp->portRect.right - wp->portRect.left)/2 -
         StringWidth(helloWorld) / 2,
         abs(wp->portRect.bottom - wp->portRect.top)/2);
  DrawString(helloWorld);    /* Draw string message   */
  EndUpdate(wp);             /* Wrapup update process */
 }
    
DoMouse(p,modifiers)
 Point   p;                  /* Mouse point position  */
 short   modifiers;          /* Mouse’s modifiers     */
 {
  register long   i;         /* Working index         */
  Rect            wRect;     /* Working window rect   */
  register long   wGrow;     /* Working grow size     */
  ProcPtr         wDef;      /* Working wind proc hdl */
    
                             /* Load it into memory   */
  LoadResource(((WindowPeek)wp)->windowDefProc);
  HLock(((WindowPeek)wp)->windowDefProc);/* Lock it   */
                             /* Get window proc def   */
  wDef = (ProcPtr)*((WindowPeek)wp)->windowDefProc;
                             /* Check if in “Content” */
  if (CallPascalL(8,wp,(int)wHit,p,wDef) == wInContent)
   DoContent(p,modifiers);
  HUnlock(((WindowPeek)wp)->windowDefProc);
 }
    
DoKey(c,code,modifiers)
 char    c;                  /* Input character       */
 char    code;               /* Input code            */
 short   modifiers;          /* Input modifiers       */
 {
  if (modifiers & cmdKey) {  /* Check if key command  */
   if (c == ‘q’)             /* Check if time to quit */
    CloseDriver(dce->dCtlRefNum);/* OK, let’s close DA*/
   else                      /* Opps, invalid command */
    SysBeep(1);              /* Let the user know it  */
  }
 }

DoContent(p,modifiers)
 Point    p;                 /* Mouse down point      */
 short   modifiers;          /* Mouse’s modifiers     */
 {
  Rect            wRect;     /* Working window rect   */
  register long   wGrow;     /* Working grow point    */
  WindowPtr       wPtr;      /* Working window pointer*/
        
                             /* Check if want to resiz*/
  if (modifiers & (shiftKey | optionKey | cmdKey)) {
   SetRect(&wRect,50,50,32767,32767);/* Define limits */
   wGrow = GrowWindow(wp,p,&wRect);/* OK, let grow it */
   if (wGrow) {              /* Check if got new size */
                             /* Reset new size        */
    SizeWindow(wp,LoWord(wGrow),HiWord(wGrow),TRUE);
    InvalRect(&wp->portRect);/* Invalidate everything */
   }
  }
  else {                     /* Nope, just move it    */
   GetWMgrPort(&wPtr);       /* Get window manager ptr*/
   DragWindow(wp,p,&wPtr->portRect);/* Drag the window*/
  }
 }
    
GetResourceID(n)
 { return(0xC000 + ((~(dce->dCtlRefNum))<<5) + n); }

*
*   Resource - Round Window.R
*   Author   - Alexander S. Colwell,
*              Copyright (C) 1988
*   Purpose -  This is resource file for Round Window.
*
Round Window.Π.rsrc
rsrcRSED

Type WIND
Clock,-16000 (32)
Clock
64 64 187 187
NoVisible GoAway
2
0

include RoundWDEF.Π.rsrc
include RoundVBL.Π.rsrc

/*
 *  Source  - RoundVBL.c
 *  Author  - Alexander S. Colwell,
 *            Copyright (C) 1988
 *  Purpose - This is VBL def for “Debugger” DA’s demo.
 */

#include <VRetraceMgr.h>     /* Vertical Retrace defs */
#include <SetupA4.h>         /* Setup Register A4 defs*/
#include “Debugger.h”        /* Debugger defs         */

typedef struct {             /* VBL data structure    */
    VBLTask vblTask;         /* VBL                   */
    DBGHDL  dbgHdl;          /* Debugger handler      */
    short   counter;         /* Tick counter          */
    } VBL;
typedef VBL *VBLPTR;

main()
 {
  register VBLPTR vblPtr;    /* Working VBL data block*/
        
  asm { MOVE.L d0,vblPtr };  /* Move to vblPtr        */
  RememberA0();              /* Remember global ptr   */
  SetUpA4();                 /* Setup register A4     */
                             /* Output entry message  */
  DbgBufPrint(vblPtr->dbgHdl,”VBL: entry\n”);
                             /* Reset timer           */
  vblPtr->vblTask.vblCount = vblPtr->counter; 
  RestoreA4();               /* Restore register A4   */
 }
 /*
 *  Source  - RoundWDEF.c
 *  Author  - Alexander S. Colwell,
 *            Copyright (C) 1988
 *  Purpose - This is WDEF def for “Debugger” DA’s demo.
 */

#include <WindowMgr.h>       /* Window Manager defs   */
#include <SetUpA4.h>         /* Setup Register A4     */
#include “Debugger.h”        /* Debugger defs         */

                             /* Compilation directives*/
#define DEBUG                /* Enable debugging stuff*/

                             /* ‘WDEF’ entry point    */
pascal long main(varCode,theWindow,message,param)
 short       varCode;        /* Variation code        */
 WindowPtr   theWindow;      /* Window pointer        */
 short       message;        /* Message command       */
 long        param;          /* Parameter control     */
 {
  long    status = 0L;       /* Working status flag   */
        
  RememberA0();              /* Remember A0 global ptr*/
  SetUpA4();                 /* Setup register A4     */
        
  #ifdef DEBUG               /* Check if want debug   */
                             /* Output debugging info */
  DbgPrint(DbgGetRefHdl(),”WDEF: message - %d\n”,message);
  #endif
        
  switch(message) {          /* Process message       */
   case wNew:                /* Opening window        */
    break;
   case wDispose:            /* Closing window        */
    break;
   case wDraw:               /* Draw window frame     */
    DoDrawMsg(theWindow,param); break;
   case wHit:                /* Check mouse down hits */
    status = DoHitMsg(theWindow,param); break;
   case wCalcRgns:           /* Calc window regions   */
    DoCalcMsg(theWindow); break;
   case wGrow:               /* Grow window           */
    DoGrowMsg(theWindow,param); break;
   case wDrawGIcon:          /* Draw window Grow Icon */
    break;
  }
  RestoreA4();                /* Restore register A4  */
  return(status);             /* Return status flag   */
 }

DoDrawMsg(theWindow,param)
 WindowPtr   theWindow;      /* Window pointer        */
 long        param;          /* Message parameter     */
 {
  Rect        wRect;         /* Working window rect   */
  long        wPat[2];       /* Working white pattern */
  long        bPat[2];       /* Working black pattern */
        
  if (!param) {              /* Check if want to frame*/
   wPat[0] = wPat[1] = 0L;   /* Init patterns         */
   bPat[0] = bPat[1] = 0xFFFFFFFFL;
                             /* Set window rect area  */
   wRect=(*((WindowPeek)(theWindow))->strucRgn)->rgnBBox;
   PenNormal();              /* Reset pen states      */
   FrameOval(&wRect);        /* Frame outer-most part */
            
   InsetRect(&wRect,1,1);    /* Frame between part    */
   PenPat(wPat);
   FrameOval(&wRect);
            
   InsetRect(&wRect,1,1);    /* Frame middle part     */
   PenSize(3,3);
   PenPat(bPat);
   FrameOval(&wRect);
            
   InsetRect(&wRect,3,3);    /* Frame between part    */
   PenSize(1,1);
   PenPat(wPat);
   FrameOval(&wRect);

   InsetRect(&wRect,1,1);    /* Frame inter-most part */
   PenSize(1,1);
   PenPat(bPat);
   FrameOval(&wRect);
        
   InsetRect(&wRect,1,1);    /* Frame between parts   */
   PenPat(wPat);
   FrameOval(&wRect);
   PenPat(bPat);
  }
 }
    
DoHitMsg(theWindow,pt)
 WindowPtr   theWindow;      /* Window pointer        */
 Point       pt;             /* Mouse-down point      */
 {
  register short  status;    /* Working status flag   */
        
                             /* Check if point inside */
  if (PtInRgn(pt,((WindowPeek)(theWindow))->contRgn))
   status = wInContent;      /* Yup, inside contents  */
  else                       /* Nope, outside contents*/
   status = wNoHit;          /* Set no hit indicator  */
  return(status);            /* Return hit status flag*/
 }
    
DoCalcMsg(theWindow)
 WindowPtr   theWindow;      /* Window pointer        */
 {
  Rect    wRect;             /* Working window rect   */
        
  wRect = theWindow->portRect;/* Set window rect area */

                             /* Normalize window rect */
  OffsetRect(&wRect,-theWindow->portBits.bounds.left,
                    -theWindow->portBits.bounds.top);
                          
                             /* Setup content’s region*/
  SetEmptyRgn(((WindowPeek)(theWindow))->contRgn);
  OpenRgn();
  FrameOval(&wRect);
  CloseRgn(((WindowPeek)(theWindow))->contRgn);
                          
                             /* Setup content’s region*/
  SetEmptyRgn(((WindowPeek)(theWindow))->strucRgn);
  OpenRgn();
  InsetRect(&wRect,-8,-8);
  FrameOval(&wRect);
  CloseRgn(((WindowPeek)(theWindow))->strucRgn);
 }
    
DoGrowMsg(theWindow,theRect)
 WindowPtr   theWindow;      /* Window pointer        */
 Rect        *theRect;       /* Rect area to grow     */
 {
  FrameOval(theRect);        /* Draw the frame area   */
 }
    

 
AAPL
$98.63
Apple Inc.
-0.39
MSFT
$43.92
Microsoft Corpora
-0.05
GOOG
$585.19
Google Inc.
-5.41

MacTech Search:
Community Search:

Software Updates via MacUpdate

OS X Yosemite Wallpaper 1.0 - Desktop im...
OS X Yosemite Wallpaper is the gorgeous new background image for Apple's upcoming OS X 10.10 Yosemite. This wallpaper is available for all screen resolutions with a source file that measures 5,418... Read more
Acorn 4.4 - Bitmap image editor. (Demo)
Acorn is a new image editor built with one goal in mind - simplicity. Fast, easy, and fluid, Acorn provides the options you'll need without any overhead. Acorn feels right, and won't drain your bank... Read more
Bartender 1.2.20 - Organize your menu ba...
Bartender lets you organize your menu bar apps. Features: Lets you tidy your menu bar apps how you want. See your menu bar apps when you want. Hide the apps you need to run, but do not need to... Read more
TotalFinder 1.6.2 - Adds tabs, hotkeys,...
TotalFinder is a universally acclaimed navigational companion for your Mac. Enhance your Mac's Finder with features so smart and convenient, you won't believe you ever lived without them. Tab-based... Read more
Vienna 3.0.0 RC 2 :be5265e: - RSS and At...
Vienna is a freeware and Open-Source RSS/Atom newsreader with article storage and management via a SQLite database, written in Objective-C and Cocoa, for the OS X operating system. It provides... Read more
VLC Media Player 2.1.5 - Popular multime...
VLC Media Player is a highly portable multimedia player for various audio and video formats (MPEG-1, MPEG-2, MPEG-4, DivX, MP3, OGG, ...) as well as DVDs, VCDs, and various streaming protocols. It... Read more
Default Folder X 4.6.7 - Enhances Open a...
Default Folder X attaches a toolbar to the right side of the Open and Save dialogs in any OS X-native application. The toolbar gives you fast access to various folders and commands. You just click... Read more
TinkerTool 5.3 - Expanded preference set...
TinkerTool is an application that gives you access to additional preference settings Apple has built into Mac OS X. This allows to activate hidden features in the operating system and in some of the... Read more
Audio Hijack Pro 2.11.0 - Record and enh...
Audio Hijack Pro drastically changes the way you use audio on your computer, giving you the freedom to listen to audio when you want and how you want. Record and enhance any audio with Audio Hijack... Read more
Intermission 1.1.1 - Pause and rewind li...
Intermission allows you to pause and rewind live audio from any application on your Mac. Intermission will buffer up to 3 hours of audio, allowing users to skip through any assortment of audio... Read more

Latest Forum Discussions

See All

Note Review
Note Review By Jennifer Allen on July 29th, 2014 Our Rating: :: TOO SIMPLEiPhone App - Designed for the iPhone, compatible with the iPad Note is a note taking app that’s a little too short on features to be worth its asking price... | Read more »
Chainsaw Warrior Goes on Sale & Ther...
Chainsaw Warrior Goes on Sale & There’s a Chance to Win a Copy of the Original Board Game Posted by Jennifer Allen on July 29th, 2014 [ permalink | Read more »
It Came From Canada: Tiny Tower Vegas
If you go to a casino, you might make a lot of money. If you run a casino, you’re guaranteed to make a lot of money. The choice seems pretty obvious. So while waiting for your shady real estate deals to move forward, get prepared with Tiny Tower... | Read more »
Z Hunter Review
Z Hunter Review By Lee Hamlet on July 29th, 2014 Our Rating: :: RIGHT ON TARGETUniversal App - Designed for iPhone and iPad While it might not necessarily break new ground, Z Hunter has enough tricks up its sleeve to ensure that... | Read more »
Huge Update Comes To Duet, Adding 48 New...
Huge Update Comes To Duet, Adding 48 New Stages Posted by Jennifer Allen on July 29th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Sharknado: The Video Game Available Now....
Sharknado: The Video Game Available Now. Seriously. Posted by Rob Rich on July 29th, 2014 [ permalink ] Universal App - Designed for iPhone and iPad | Read more »
Frog Orbs 2 Review
Frog Orbs 2 Review By Nadia Oxford on July 29th, 2014 Our Rating: :: THIS MAGIC IS A TAD MONOTONOUS Universal App - Designed for iPhone and iPad Frog Orbs 2 is repetitive, but younger players should enjoy it nonetheless.   | Read more »
Puzzix Review
Puzzix Review By Jennifer Allen on July 29th, 2014 Our Rating: :: NICE IDEAUniversal App - Designed for iPhone and iPad A little like Tetris, Puzzix is all about piecing together blocks and watching them vanish. It could do with... | Read more »
Cannonball eMail is Now Live – Works Wit...
Cannonball eMail is Now Live – Works With Gmail, Yahoo, Outlook, Hotmail, and AOL Posted by Jessica Fisher on July 29th, 2014 [ permalink ] | Read more »
To The End Review
To The End Review By Lee Hamlet on July 29th, 2014 Our Rating: :: A VICIOUS CYCLEUniversal App - Designed for iPhone and iPad To The End will test players’ patience, timing, and dedication as they try to navigate all 13 levels in... | Read more »

Price Scanner via MacPrices.net

Updated MacBook Pro Price Trackers
We’ve updated our MacBook Pro Price Trackers with the latest information on prices, bundles, and availability on the new 2014 models from Apple’s authorized internet/catalog resellers as well as... Read more
Apple updates MacBook Pros with slightly fast...
Apple updated 13″ and 15″ Retina MacBook Pros today with slightly faster Haswell processors. 13″ models now ship with 8GB of RAM standard, while 15″ MacBook Pros ship with 16GB across the board. Most... Read more
Apple drops price on 13″ 2.5GHz MacBook Pro b...
The Apple Store has dropped their price for the 13″ 2.5GHz MacBook Pro by $100 to $1099 including free shipping. Read more
Apple drops prices on refurbished 2013 MacBoo...
The Apple Store has dropped prices on Apple Certified Refurbished 13″ and 15″ 2013 MacBook Pros, with model now available starting at $929. Apple’s one-year warranty is standard, and shipping is free... Read more
iOS 8 and OS X 10.10 To Support DuckDuckGo As...
Writing for Quartz, Dan Frommer reports that Apple’s forthcoming iOS 8 and OS X 10.10 operating systems version updates will allow users to select DuckDuckGo as their default search engine. He notes... Read more
U.K. Hospital Using iPods and iPads To Record...
British news journal GazetteLive’s. Ian McNeal notes that the old “an apple a day keeps the doctor away” proverb is being turned on its head at http://southtees.nhs.uk/hospitals/james-cook/ James... Read more
13-inch 2.5GHz MacBook Pro on sale for $1099,...
Best Buy has the 13″ 2.5GHz MacBook Pro available for $1099.99 on their online store. Choose free shipping or free instant local store pickup (if available). Their price is $100 off MSRP. Price is... Read more
Roundup of Apple refurbished MacBook Pros, th...
The Apple Store has Apple Certified Refurbished 13″ and 15″ MacBook Pros available for up to $400 off the cost of new models. Apple’s one-year warranty is standard, and shipping is free. Their prices... Read more
Record Mac Shipments In Q2/14 Confound Analys...
A Seeking Alpha Trefis commentary notes that Apple’s fiscal Q3 2014 results released July 22, beat market predictions on earnings, although revenues were slightly lower than anticipated. Apple’s Mac’... Read more
Intel To Launch Core M Silicon For Use In Not...
Digitimes’ Monica Chen and Joseph Tsai, report that Intel will launch 14nm-based Core M series processors specifically for use in fanless notebook/tablet 2-in-1 models in Q4 2014, with many models to... Read more

Jobs Board

Sr Software Lead Engineer, *Apple* Online S...
Sr Software Lead Engineer, Apple Online Store Publishing Systems Keywords: Company: Apple Job Code: E3PCAK8MgYYkw Location (City or ZIP): Santa Clara Status: Full Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
Sr. Product Leader, *Apple* Store Apps - Ap...
**Job Summary** Imagine what you could do here. At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
*Apple* Solutions Consultant (ASC) - Apple (...
**Job Summary** The ASC is an Apple employee who serves as an Apple brand ambassador and influencer in a Reseller's store. The ASC's role is to grow Apple Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.