Demonstration Program 2

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
// Text2.c
// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
//
// This program demonstrates:
//
// ¥  The use of edit text field controls and TextEdit to enter data into the various 
//    fields of a database record.
//
// ¥  The formatting and display of dates, times and numbers.
//
// The program opens a document window in which four edit text fields are displayed.  The
// first field requires text to be entered, the second an integer value, the third a 
// floating point value (that is, a currency value), and the fourth a date.  The user may
// select a field for data entry using the mouse or by cycling between fields using the 
// Tab key.
//
// TENew could have been used to create the four edit text fields; however, edit text
// field controls have been used so as to simplify the appearance aspects of window
// activation and deactivation and the setting and erasing of the keyboard focus frame.
// That said, TextEdit functions are widely used to deal directly with the controls' edit
// text structures.  Amongst other things, this allows the program to limit the number of
// characters that may be entered in each field and to cause the forward-delete key to be
// used to forward-delete characters.  (The forward-delete key is not supported by the 
// edit text field control CDEF.)
//
// The current date and the current time are displayed at the top of the window.
//
// The program utilises the following resources:
//
// ¥  An 'MBAR' resource, and 'MENU' resources for Apple, File, and Edit menus (preload,
//    non-purgeable).
//
// ¥  'CNTL' resources (purgeable) for edit text field controls and primary and secondary
//    group boxes (text title variant).  
//
// ¥  A 'WIND' resource (purgeable) (initially not visible).
//
// ¥  'hrct' and 'hwin' resources (purgeable) for balloon help. 
//
// ¥  A 'SIZE' resource with the acceptSuspendResumeEvents, doesActivateOnFGSwitch, 
//    canBackground and  is32BitCompatible flags set.    
//
// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

// ............................................................................. includes

#include <Appearance.h>
#include <ControlDefinitions.h>
#include <Devices.h>
#include <fp.h>
#include <Sound.h>
#include <ToolUtils.h>

// .............................................................................. defines

#define rMenubar               128
#define mApple                 128
#define  iAbout                1
#define mFile                  129
#define  iQuit                 12
#define mEdit                  130    
#define  iCut                  3
#define  iCopy                 4
#define  iPaste                5
#define  iClear                6
#define  iSelectAll            7
#define rWindow                128
#define cDateAndTimeGroupBox   128
#define cDataEntryGroupBox     129
#define cItemTitleEditText     130
#define cQuantityEditText      131
#define cUnitValueEditText     132
#define cDateEditText          133
#define cLastRecordGroupBox    134
#define cBalloonGroupBox       135
#define kTab                   0x09
#define kDel                   0x7F
#define kReturn                0x0D
#define kMaxCharasItem         20
#define kMaxCharasQuant        9
#define kMaxCharasValue        9
#define kMaxCharasDate         16
#define topLeft(r)             (((Point *) &(r))[0])
#define botRight(r)            (((Point *) &(r))[1])

// ............................................................................. typedefs

typedef struct
{
  ControlHandle  itemControlHdl;
  ControlHandle  quantControlHdl;
  ControlHandle  valueControlHdl;
  ControlHandle  dateControlHdl;
} docStruc, **docStrucHandle;

// ..................................................................... global variables

Boolean    gIsColourDevice;
Boolean    gPixelDepth;
Boolean    gDone;
Boolean    gInBackground;
RgnHandle  gCursorRegion;
TEHandle   gCurrentEditStrucHdl;
SInt16     gMaxCharasThisField;
Rect       gItemRect    = { 89 ,91,102, 231 };
Rect       gQuantRect  = { 112 ,91,125,233 };
Rect       gValueRect  = { 135,91,148,233 };
Rect       gDateRect    = { 158,91,171,233 };
Str255     gLastRecordItem;
Str255     gLastRecordQuantity;
Str255     gLastRecordUnitValue;
Str255     gLastRecordTotalValue;
Str255     gLastRecordReviewDate;

// .................................................................. function prototypes

void      main                     (void);
void      doInitManagers           (void);
void      doGetControls            (WindowPtr);
void      eventLoop                (void);
void      doIdle                   (void);
void      doEvents                 (EventRecord *);
void      doUpdate                 (EventRecord *);
void      doActivate               (EventRecord *);
void      doActivateWindow         (WindowPtr,Boolean);
void      doMenuChoice             (SInt32);
void      doAdjustMenus            (void);
void      doKeyEvent               (SInt8,docStrucHandle);
void      doHandleTabKey           (void);
void      doHandleDelKey           (void);
void      doInContent              (EventRecord *);
void      doChangeCurrentEditRec   (ControlHandle,Boolean,Point,SInt16);
void      doTodaysDate             (void);
void      doAcceptNewRecord        (void);
void      doAcceptValueField       (TEHandle,TEHandle);
void      doAcceptDateField        (TEHandle);
TEHandle  doGetEditTextHandle      (ControlHandle);
void      doDrawWindow             (void);
void      doAdjustCursor           (WindowPtr);
void      doCopyPString            (Str255,Str255);
void      doGetDepthAndDevice      (void);
  
// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× main

void  main(void)
{
  Handle          menubarHdl;
  MenuHandle      menuHdl;
  WindowPtr       windowPtr;
  docStrucHandle  docStrucHdl;

  // .................................................................initialise managers

  doInitManagers();

  // .......................................................... set up menu bar and menus

  menubarHdl = GetNewMBar(rMenubar);
  if(menubarHdl == NULL)
    ExitToShell();
  SetMenuBar(menubarHdl);
  DrawMenuBar();

  menuHdl = GetMenuHandle(mApple);
  if(menuHdl == NULL)
    ExitToShell();
  else
    AppendResMenu(menuHdl,'DRVR');

  // .................... open window, set Appearance-compliant colour/pattern for window
  
  if(!(windowPtr = GetNewCWindow(rWindow,NULL,(WindowPtr) -1)))
    ExitToShell();

  SetPort(windowPtr);
  TextSize(10);
  
  SetThemeWindowBackground(windowPtr,kThemeBrushDialogBackgroundActive,true);

  // ...... get block for document structure, assign handle to window record refCon field

  if(!(docStrucHdl = (docStrucHandle) NewHandle(sizeof(docStruc))))
    ExitToShell();
  SetWRefCon(windowPtr,(SInt32) docStrucHdl);

  // ...................... get controls, show window, save background colour and pattern

  doGetControls(windowPtr);

  ShowWindow(windowPtr);

  // ......... get pixel depth and whether colour device for certain Appearance functions
  
  doGetDepthAndDevice();

  // .................................................................... enter eventLoop

  eventLoop();
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doInitManagers

void  doInitManagers(void)
{
  MaxApplZone();
  MoreMasters();

  InitGraf(&qd.thePort);
  InitFonts();
  InitWindows();
  InitMenus();
  TEInit();
  InitDialogs(NULL);
  InitCursor();

  FlushEvents(everyEvent,0);

  RegisterAppearanceClient();
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doGetControls

void  doGetControls(WindowPtr windowPtr)
{
  ControlHandle        controlHdl,lastRecordControlHdl;
  docStrucHandle       docStrucHdl;
  Boolean              booleanData = true;
  ControlFontStyleRec  controlFontStyleStruc;

  CreateRootControl(windowPtr,&controlHdl);

  docStrucHdl = (docStrucHandle) (GetWRefCon(windowPtr));

  if(!(controlHdl  = GetNewControl(cDateAndTimeGroupBox,windowPtr)))
    ExitToShell();
  if(!(controlHdl = GetNewControl(cDataEntryGroupBox,windowPtr)))
    ExitToShell();
  if(!((*docStrucHdl)->itemControlHdl = GetNewControl(cItemTitleEditText,windowPtr)))
    ExitToShell();
  if(!((*docStrucHdl)->quantControlHdl = GetNewControl(cQuantityEditText,windowPtr)))
    ExitToShell();
  if(!((*docStrucHdl)->valueControlHdl = GetNewControl(cUnitValueEditText,windowPtr)))
    ExitToShell();
  if(!((*docStrucHdl)->dateControlHdl = GetNewControl(cDateEditText,windowPtr)))
    ExitToShell();
  if(!(lastRecordControlHdl  = GetNewControl(cLastRecordGroupBox,windowPtr)))
    ExitToShell();
  if(!(controlHdl  = GetNewControl(cBalloonGroupBox,windowPtr)))
    ExitToShell();

  controlFontStyleStruc.flags = kControlUseFontMask;
  controlFontStyleStruc.font = kControlFontSmallSystemFont;
  SetControlFontStyle((*docStrucHdl)->itemControlHdl,&controlFontStyleStruc);
  SetControlFontStyle((*docStrucHdl)->quantControlHdl,&controlFontStyleStruc);
  SetControlFontStyle((*docStrucHdl)->valueControlHdl,&controlFontStyleStruc);
  SetControlFontStyle((*docStrucHdl)->dateControlHdl,&controlFontStyleStruc);
  controlFontStyleStruc.font = kControlFontSmallBoldSystemFont;
  SetControlFontStyle(lastRecordControlHdl,&controlFontStyleStruc);

  SetKeyboardFocus(windowPtr,(*docStrucHdl)->itemControlHdl,kControlEditTextPart);
  gCurrentEditStrucHdl = doGetEditTextHandle((*docStrucHdl)->itemControlHdl);
  gMaxCharasThisField = kMaxCharasItem;
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× eventLoop

void  eventLoop(void)
{
  EventRecord  eventStructure;
  Boolean      gotEvent;
  SInt32       sleepTime;

  gDone = false;
  gCursorRegion = NewRgn();
  sleepTime = LMGetCaretTime();

  while(!gDone)
  {
    gotEvent = WaitNextEvent(everyEvent,&eventStructure,sleepTime,gCursorRegion);

    if(gotEvent)
      doEvents(&eventStructure);
    else
      doIdle();
  }
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doIdle

void  doIdle(void)
{
  static UInt32    oldRawSeconds;
  UInt32           rawSeconds;
  Str255           timeString;
  Rect             eraseRect;

  IdleControls(FrontWindow());

  GetDateTime(&rawSeconds);

  if(rawSeconds > oldRawSeconds) 
  {
    TimeString(rawSeconds,true,timeString,NULL);
    MoveTo(268,39);
    SetRect(&eraseRect,268,29,323,39);
    EraseRect(&eraseRect);
    DrawString(timeString);
    oldRawSeconds = rawSeconds;
  }
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doEvent

void  doEvents(EventRecord *eventStrucPtr)
{
  WindowPtr        windowPtr;
  docStrucHandle   docStrucHdl;
  SInt16           partCode;
  SInt8            charCode;

  windowPtr = FrontWindow();
  docStrucHdl = (docStrucHandle) GetWRefCon(windowPtr);

  switch(eventStrucPtr->what)
  {
    case mouseDown:
      partCode = FindWindow(eventStrucPtr->where,&windowPtr);
  
      switch(partCode)
      {
        case inMenuBar:
          doAdjustMenus();
          doMenuChoice(MenuSelect(eventStrucPtr->where));
          break;

        case inContent:
          if(windowPtr != FrontWindow())
            SelectWindow(windowPtr);
          else
            doInContent(eventStrucPtr);
          break;

        case inDrag:
          DragWindow(windowPtr,eventStrucPtr->where,&qd.screenBits.bounds);
          doAdjustCursor(windowPtr);
          break;

        case inGoAway:
          if(TrackGoAway(windowPtr,eventStrucPtr->where))
            gDone = true;
          break;
      }
      break;

    case keyDown:
    case autoKey:
      charCode = eventStrucPtr->message & charCodeMask;
      if((eventStrucPtr->modifiers & cmdKey) != 0)
      {
        doAdjustMenus();
        doMenuChoice(MenuEvent(eventStrucPtr));
      }
      else
        doKeyEvent(charCode,docStrucHdl);
      break;

    case updateEvt:
      doUpdate(eventStrucPtr);
      break;

    case activateEvt:
      doActivate(eventStrucPtr);
      break;

    case osEvt:
      switch((eventStrucPtr->message >> 24) & 0x000000FF)
      {
        case suspendResumeMessage:
          gInBackground = (eventStrucPtr->message & resumeFlag) == 0;
          if(!gInBackground)
            SetCursor(&qd.arrow);
          doActivateWindow(FrontWindow(),!gInBackground);
          break;
          
        case mouseMovedMessage:
          doAdjustCursor(FrontWindow());
          break;
      }
      break;
  }
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doUpdate

void  doUpdate(EventRecord *eventStrucPtr)
{
  WindowPtr       windowPtr;
  docStrucHandle  docStrucHdl;
  GrafPtr         oldPort;

  windowPtr = (WindowPtr) eventStrucPtr->message;
  docStrucHdl = (docStrucHandle) GetWRefCon(windowPtr);

  GetPort(&oldPort);
  SetPort(windowPtr);

  BeginUpdate((WindowPtr) eventStrucPtr->message);
  UpdateControls(windowPtr,windowPtr->visRgn);
  doDrawWindow();
  EndUpdate((WindowPtr) eventStrucPtr->message);

  SetPort(oldPort);
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doActivate

void  doActivate(EventRecord *eventStrucPtr)
{
  WindowPtr  windowPtr;
  Boolean    becomingActive;

  windowPtr = (WindowPtr) eventStrucPtr->message;
  becomingActive = ((eventStrucPtr->modifiers & activeFlag) == activeFlag);
  doActivateWindow(windowPtr,becomingActive);
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doActivateWindow

void  doActivateWindow(WindowPtr windowPtr,Boolean becomingActive)
{
  ControlHandle controlHdl;

  GetRootControl(windowPtr,&controlHdl);

  if(becomingActive)
  {
    ActivateControl(controlHdl);
    doDrawWindow();
  }
  else
  {
    DeactivateControl(controlHdl);
    doDrawWindow();
  }
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doMenuChoice

void  doMenuChoice(SInt32 menuChoice)
{
  SInt16  menuID, menuItem;
  Str255  itemName;
  SInt16  daDriverRefNum;

  menuID   = HiWord(menuChoice);
  menuItem = LoWord(menuChoice);

  if(menuID == 0)
    return;

  switch(menuID)
  {
    case mApple:
      if(menuItem == iAbout)
        SysBeep(10);
      else
      {
        GetMenuItemText(GetMenuHandle(mApple),menuItem,itemName);
        daDriverRefNum = OpenDeskAcc(itemName);
      }
      break;

    case mFile:
      if(menuItem == iQuit)
        gDone = true;
      break;
      
    case mEdit:
      switch(menuItem)
      {
        case iCut:
          TECut(gCurrentEditStrucHdl);
          break;

        case iCopy:
          TECopy(gCurrentEditStrucHdl);
          break;

        case iPaste:
          TEPaste(gCurrentEditStrucHdl);
          break;

        case iClear:
          TEDelete(gCurrentEditStrucHdl);
          break;

        case iSelectAll:
          TESetSelect(0,(*gCurrentEditStrucHdl)->teLength,gCurrentEditStrucHdl);
          break;
      }
      break;
  }

  HiliteMenu(0);
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doAdjustMenus

void  doAdjustMenus(void)
{
  MenuHandle  fileMenuHdl, editMenuHdl;
  
  fileMenuHdl = GetMenuHandle(mFile);
  editMenuHdl = GetMenuHandle(mEdit);

  if((*gCurrentEditStrucHdl)->selStart < (*gCurrentEditStrucHdl)->selEnd)
  {
    EnableItem(editMenuHdl,iCut);
    EnableItem(editMenuHdl,iCopy);
    EnableItem(editMenuHdl,iClear);
  }
  else
  {
    DisableItem(editMenuHdl,iCut);
    DisableItem(editMenuHdl,iCopy);
    DisableItem(editMenuHdl,iClear);
  }

  if(TEGetScrapLength() > 0)
    EnableItem(editMenuHdl,iPaste);
  else
    DisableItem(editMenuHdl,iPaste);

  if((*gCurrentEditStrucHdl)->teLength > 0)
    EnableItem(editMenuHdl,iSelectAll);
  else
    DisableItem(editMenuHdl,iSelectAll);

  DrawMenuBar();
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doKeyEvent

void  doKeyEvent(SInt8 charCode,docStrucHandle docStrucHdl)
{
  if(charCode == kTab)
    doHandleTabKey();
  else if(charCode == kDel)
    doHandleDelKey();
  else if(charCode == kReturn)
    doAcceptNewRecord();  
  else
  {
    if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->quantControlHdl) ||
       gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->valueControlHdl))
    {
      if(!((charCode >= '0' && charCode <= '9') || charCode == '.' || 
            charCode == '-' ||(charCode < 0x20)))
      {
        SysBeep(10);
        return;
      }
    }

    if(((*gCurrentEditStrucHdl)->teLength < gMaxCharasThisField) || (charCode < 0x20))
      TEKey(charCode,gCurrentEditStrucHdl);
    else
      SysBeep(10);
  }
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doHandleTabKey

void  doHandleTabKey(void)
{
  WindowPtr        windowPtr;
  docStrucHandle   docStrucHdl;
  ControlHandle    oldControlHdl;
  Point            dummy;
  
  windowPtr = FrontWindow();
  docStrucHdl = (docStrucHandle) (GetWRefCon(windowPtr));

  GetKeyboardFocus(windowPtr,&oldControlHdl);  

  if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->itemControlHdl))
    doChangeCurrentEditRec((*docStrucHdl)->quantControlHdl,false,dummy,kMaxCharasQuant);
  else if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->quantControlHdl))
    doChangeCurrentEditRec((*docStrucHdl)->valueControlHdl,false,dummy,kMaxCharasValue);
  else if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->valueControlHdl))
    doChangeCurrentEditRec((*docStrucHdl)->dateControlHdl,false,dummy,kMaxCharasDate);
  else if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->dateControlHdl))
    doChangeCurrentEditRec((*docStrucHdl)->itemControlHdl,false,dummy,kMaxCharasItem);

  Draw1Control(oldControlHdl);

  doAdjustCursor(windowPtr);
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doHandleDelKey

void  doHandleDelKey(void)
{
  SInt16  selectionLength;

  selectionLength = (*gCurrentEditStrucHdl)->selEnd - (*gCurrentEditStrucHdl)->selStart;
  if(selectionLength == 0)
    (*gCurrentEditStrucHdl)->selEnd += 1;
  TEDelete(gCurrentEditStrucHdl);
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doInContent

void  doInContent(EventRecord *eventStrucPtr)
{
  WindowPtr        windowPtr;
  docStrucHandle   docStrucHdl;
  Boolean          shiftKeyPosition;
  ControlHandle    oldControlHdl, controlHdl;

  windowPtr = FrontWindow();
  docStrucHdl = (docStrucHandle) GetWRefCon(windowPtr);
  GetKeyboardFocus(windowPtr,&oldControlHdl);  
  shiftKeyPosition = (eventStrucPtr->modifiers & shiftKey) != 0;

  SetPort(windowPtr);
  GlobalToLocal(&eventStrucPtr->where);

  if(FindControl(eventStrucPtr->where,windowPtr,&controlHdl))
  {
    if(controlHdl == (*docStrucHdl)->itemControlHdl)
    {
      if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->itemControlHdl))
        TEClick(eventStrucPtr->where,shiftKeyPosition,
                doGetEditTextHandle((*docStrucHdl)->itemControlHdl));
      else
      {
        doChangeCurrentEditRec((*docStrucHdl)->itemControlHdl,true,
                                eventStrucPtr->where,kMaxCharasItem);
      }
    }
    else if(controlHdl == (*docStrucHdl)->quantControlHdl)
    {
      if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->quantControlHdl))
        TEClick(eventStrucPtr->where,shiftKeyPosition,
                doGetEditTextHandle((*docStrucHdl)->quantControlHdl));
      else
        doChangeCurrentEditRec((*docStrucHdl)->quantControlHdl,true,eventStrucPtr->where,
                               kMaxCharasQuant);
    }
    else if(controlHdl == (*docStrucHdl)->valueControlHdl)
    {
      if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->valueControlHdl))
        TEClick(eventStrucPtr->where,shiftKeyPosition,
                doGetEditTextHandle((*docStrucHdl)->valueControlHdl));
      else
        doChangeCurrentEditRec((*docStrucHdl)->valueControlHdl,true,eventStrucPtr->where,
                               kMaxCharasValue);
    }
    else if(controlHdl == (*docStrucHdl)->dateControlHdl)
    {
      if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->dateControlHdl))
        TEClick(eventStrucPtr->where,shiftKeyPosition,
                doGetEditTextHandle((*docStrucHdl)->dateControlHdl));
      else
        doChangeCurrentEditRec((*docStrucHdl)->dateControlHdl,true,eventStrucPtr->where,
                               kMaxCharasDate);
    }
  }

  Draw1Control(oldControlHdl);
  doAdjustCursor(windowPtr);
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doChangeCurrentEditRec

void  doChangeCurrentEditRec(ControlHandle newControlHdl,Boolean teClickFlag,
                             Point mouseXY,SInt16 maxCharas)
{
  ClearKeyboardFocus(FrontWindow());
  SetKeyboardFocus(FrontWindow(),newControlHdl,kControlEditTextPart);

  gCurrentEditStrucHdl = doGetEditTextHandle(newControlHdl);

  if(teClickFlag)
    TEClick(mouseXY,false,doGetEditTextHandle(newControlHdl));

  TESetSelect(0,32767,gCurrentEditStrucHdl);

  gMaxCharasThisField = maxCharas;
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doTodaysDate

void  doTodaysDate(void)
{
  UInt32  rawSeconds;
  Str255  dateString;

  GetDateTime(&rawSeconds);
  DateString(rawSeconds,longDate,dateString,NULL);
  MoveTo(59,39);
  DrawString(dateString);
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doAcceptNewRecord

void  doAcceptNewRecord(void)
{
  WindowPtr       windowPtr;
  docStrucHandle  docStrucHdl;
  TEHandle        itemEditHdl, quantEditHdl, valueEditHdl, dateEditHdl;
  Rect            theRect;
  Point           dummy;

  windowPtr = FrontWindow();
  docStrucHdl = (docStrucHandle) GetWRefCon(windowPtr);

  itemEditHdl    = doGetEditTextHandle((*docStrucHdl)->itemControlHdl);
  quantEditHdl  = doGetEditTextHandle((*docStrucHdl)->quantControlHdl);
  valueEditHdl  = doGetEditTextHandle((*docStrucHdl)->valueControlHdl);
  dateEditHdl    = doGetEditTextHandle((*docStrucHdl)->dateControlHdl);

  if((*itemEditHdl)->teLength   == 0 || (*quantEditHdl)->teLength == 0 ||
     (*valueEditHdl)->teLength == 0  || (*dateEditHdl)->teLength   == 0)
  {
    SysBeep(10);
    return;
  }

  GetDialogItemText((*itemEditHdl)->hText,gLastRecordItem);
  GetDialogItemText((*quantEditHdl)->hText,gLastRecordQuantity);
  doAcceptValueField(valueEditHdl,quantEditHdl);
  doAcceptDateField(dateEditHdl);

  SetRect(&theRect,144,198,310,300);
  InvalRect(&theRect);

  TESetSelect(0,32767,itemEditHdl);
  TEDelete(itemEditHdl);

  TESetSelect(0,32767,quantEditHdl);
  TEDelete(quantEditHdl);

  TESetSelect(0,32767,valueEditHdl);
  TEDelete(valueEditHdl);

  TESetSelect(0,32767,dateEditHdl);
  TEDelete(dateEditHdl);

  gCurrentEditStrucHdl = itemEditHdl;
  doChangeCurrentEditRec((*docStrucHdl)->itemControlHdl,false,dummy,kMaxCharasItem);
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doAcceptValueField

void  doAcceptValueField(TEHandle valueEditHdl,TEHandle quantEditHdl)
{
  Handle            itl4ResourceHdl;
  SInt32            numpartsOffset;
  SInt32            numpartsLength;
  NumberParts       *numpartsTablePtr;
  Str255            formatString = "\p'$'###,###,###.00;'Valueless';'Valueless'";
  NumFormatString   formatStringRec;
  Str255            inputNumString;
  Str255            formattedNumString;
  extended80        value80Bit;
  Str255            quantityString;
  SInt32            quantity;
  FormatResultType  result;
#if TARGET_CPU_PPC
  double            valueDouble;
#endif

  GetIntlResourceTable(smSystemScript,iuNumberPartsTable,&itl4ResourceHdl,&numpartsOffset,
                       &numpartsLength);
  numpartsTablePtr = (NumberPartsPtr) ((SInt32) *itl4ResourceHdl + numpartsOffset);

  StringToFormatRec(formatString,numpartsTablePtr,&formatStringRec);

  GetDialogItemText((*valueEditHdl)->hText,inputNumString);

  StringToExtended(inputNumString,&formatStringRec,numpartsTablePtr,&value80Bit);
  ExtendedToString(&value80Bit,&formatStringRec,numpartsTablePtr,formattedNumString);

  doCopyPString(formattedNumString,gLastRecordUnitValue);

  GetDialogItemText((*quantEditHdl)->hText,quantityString);
  StringToNum(quantityString,&quantity);

#if TARGET_CPU_68K
value80Bit = value80Bit * quantity;
#endif
#if TARGET_CPU_PPC
  valueDouble = x80tod(&value80Bit);
  valueDouble = valueDouble * quantity;
  dtox80(&valueDouble,&value80Bit);
#endif

  result = ExtendedToString(&value80Bit,&formatStringRec,numpartsTablePtr,
                            formattedNumString);

  if(result == fFormatOverflow)
    doCopyPString("\p(Too large to display)",gLastRecordTotalValue);
  else
    doCopyPString(formattedNumString,gLastRecordTotalValue);
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doAcceptDateField

void  doAcceptDateField(TEHandle dateEditHdl)
{
  DateCacheRecord  dateCacheRec;
  Ptr              textPtr;
  SInt32           textLength, lengthUsed;
  LongDateRec      longDateTimeRec;
  LongDateTime     longDateTimeValue;
  Str255           dateString;

  InitDateCache(&dateCacheRec);
  textPtr = (*(*dateEditHdl)->hText);
  textLength = (*dateEditHdl)->teLength;

  HLock((*dateEditHdl)->hText);
  StringToDate(textPtr,textLength,&dateCacheRec,&lengthUsed,&longDateTimeRec);
  HUnlock((*dateEditHdl)->hText);
  
  LongDateToSeconds(&longDateTimeRec,&longDateTimeValue);
  longDateTimeValue += 15724800;
  LongDateString(&longDateTimeValue,longDate,dateString,NULL);
  doCopyPString(dateString,gLastRecordReviewDate);
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doGetEditTextHandle

TEHandle  doGetEditTextHandle(ControlHandle controlHdl)
{
  TEHandle  textEditHdl;

  GetControlData(controlHdl,kControlNoPart,kControlEditTextTEHandleTag,
                 sizeof(textEditHdl),(Ptr) &textEditHdl,NULL);

  return textEditHdl;
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doDrawWindow

void  doDrawWindow(void)
{
  Rect  theRect;
  
  SetRect(&theRect,144,198,310,300);
  EraseRect(&theRect);
  
  if(!gInBackground)
    SetThemeTextColor(kThemeTextColorModelessDialogActive,gPixelDepth,gIsColourDevice);
  else
    SetThemeTextColor(kThemeTextColorModelessDialogInactive,gPixelDepth,gIsColourDevice);

  doTodaysDate();

  MoveTo(32,39);
  DrawString("\pDate:");
  MoveTo(239,39);
  DrawString("\pTime:");

  MoveTo(34,99);
  DrawString("\pItem Title:");
  MoveTo(41,122);
  DrawString("\pQuantity:");
  MoveTo(32,145);
  DrawString("\pUnit Value:");
  MoveTo(61,168);
  DrawString("\pDate:");

  MoveTo(240,99);
  DrawString("\pEg: Barometers");
  MoveTo(240,122);
  DrawString("\pEg: 34");
  MoveTo(240,145);
  DrawString("\pEg: 135.58");
  MoveTo(240,168);
  DrawString("\pEg: 24 Jul 95");

  MoveTo(92,214);
  DrawString("\pItem Title:");
  MoveTo(99,234);
  DrawString("\pQuantity:");
  MoveTo(90,254);
  DrawString("\pUnit Value:");
  MoveTo(87,274);
  DrawString("\pTotal Value:");
  MoveTo(81,294);
  DrawString("\pReview Date:");

  MoveTo(112,349);
  DrawString("\pBalloon help is available");

  MoveTo(147,214);
  DrawString(gLastRecordItem);
  MoveTo(147,234);
  DrawString(gLastRecordQuantity);
  MoveTo(147,254);
  DrawString(gLastRecordUnitValue);
  MoveTo(147,274);
  DrawString(gLastRecordTotalValue);
  MoveTo(147,294);
  DrawString(gLastRecordReviewDate);
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doAdjustCursor

void  doAdjustCursor(WindowPtr windowPtr)
{
  GrafPtr          oldPort;
  docStrucHandle   docStrucHdl;
  RgnHandle        arrowRegion,iBeamRegion;
  Rect             iBeamRect;
  Point            mouseXY;

  GetPort(&oldPort);
  SetPort(windowPtr);
    
  docStrucHdl = (docStrucHandle) GetWRefCon(windowPtr);

  arrowRegion = NewRgn();
  iBeamRegion = NewRgn();
    
  SetRectRgn(arrowRegion,-32768,-32768,32766,32766);
  
  if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->itemControlHdl))
    iBeamRect = gItemRect;
  else if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->quantControlHdl))
    iBeamRect = gQuantRect;
  else if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->valueControlHdl))
    iBeamRect = gValueRect;
  else if(gCurrentEditStrucHdl == doGetEditTextHandle((*docStrucHdl)->dateControlHdl))
    iBeamRect = gDateRect;

  LocalToGlobal(&topLeft(iBeamRect));
  LocalToGlobal(&botRight(iBeamRect));  

  RectRgn(iBeamRegion,&iBeamRect);
  DiffRgn(arrowRegion,iBeamRegion,arrowRegion);
  
  GetMouse(&mouseXY);
  LocalToGlobal(&mouseXY);

  if(PtInRgn(mouseXY,iBeamRegion))
  {
    SetCursor(*(GetCursor(iBeamCursor)));
    CopyRgn(iBeamRegion,gCursorRegion);
  }
  else
  {
    SetCursor(&qd.arrow);
    CopyRgn(arrowRegion,gCursorRegion);
  }

  DisposeRgn(arrowRegion);
  DisposeRgn(iBeamRegion);

  SetPort(oldPort);
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doCopyPString

void  doCopyPString(Str255 sourceString,Str255 destinationString)
{
  SInt16  stringLength;

  stringLength = sourceString[0];
  BlockMove(sourceString + 1,destinationString + 1,stringLength);
  destinationString[0] = stringLength;
}

// ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doGetDepthAndDevice

void doGetDepthAndDevice(void)
{
  GDHandle  deviceHdl;

  deviceHdl = LMGetMainDevice();
  gPixelDepth = (*(*deviceHdl)->gdPMap)->pixelSize;
  if(BitTst(&(*deviceHdl)->gdFlags,gdDevType))
    gIsColourDevice = true;
}

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

When this program is run, the user should enter data in the four edit text fields, using
the tab key or mouse clicks to select the required field and pressing the Return key when
data has been entered in all fields.

In order to observe number formatting effects, the user should occasionally enter very
large numbers and negative numbers in the Value field.  In order to observe the effects
of date string parsing and formatting, the user should enter dates in a variety of
formats, for example: "2 Mar 95", "2/3/95", "March 2 1995", "2 3 95", etc.

The constants beginning with c represent resource IDs for group box and edit text field
controls.  kTab, kDel, and kReturn represent the character codes generated by the tab,
forward-delete, and return keys.  The following four constants are used to limit the
number of characters that can be entered in a particular edit text field.

The DocStruc data type will be used for a document structure, which will be attached 
to the single window opened by the program.  The four fields of this structure will be 
assigned handles to separate edit structures.


Global Variables

gIsColourDevice and gPixelDepth will be used by the Appearance Manager function 
SetThemeTextColor.  gCursorRegion relates to the cursorRgn parameter of the WaitNextEvent 
function.

gCurrentEditStrucHdl will be assigned the handle to the edit structure for the currently
active edit text field.  gMaxCharasThisField will be assigned a value representing the
maximum number of characters allowed to be entered in the currently active edit text
field.  The four Rect variables will be used by the cursor shape changing function to
establish the I-Beam cursor region for the currently active edit text field.  The four
Str255 variables will be assigned the strings to be drawn in the "last Record Entered"
group box when the Return key is pressed.


main

SetThemeWindowBackground sets an Appearance-compliant colour/pattern for the window's
content area.  This means that the content area will be automatically repainted with that
colour/pattern when required with no further assistance from the application.

doGetControls creates the controls for the window, following which the window is
displayed and the background colour and pattern are saved.


doGetControls

doGetControls creates the window's controls.

Firstly, a root control is created for the window.  The edit text field and group box
controls are then created, their handles being assigned to the relevant field of the
window's document structure.

At the next block, SetControlFontStyle is used to set the font for the edit text field
controls to the small system font and the font for the "Last Record Entered" group box to
the small emphasized system font.

At the last block, SetKeyboardFocus is called to set the keyboard focus to the first edit
text field control, the associated edit structure is made the current edit structure, and
the global variable which will limit the number of characters that may be entered in this
edit text field is assigned the appropriate value.


eventLoop

When a NULL event is received, the application-defined function doIdle is called. 
Because IdleControls will be called in the idle function to blink the insertion point
caret, WaitNextEvent's sleep parameter is assigned the value returned by a call to
LMGetCaretTime


doIdle

doIdle is called when WaitNextEvent returns a null event.  doIdle blinks the insertion
point caret and draws the current time in the top right of the window.

IdleControls is called to ensure that the caret blinks regularly in the edit text field
control with keyboard focus.

GetDateTime retrieves the "raw" seconds value, as known to the system.  (This is the
number of seconds since 1 Jan 1904.)  If that value is greater than the value retrieved
the last time doIdle was called, TimeString converts the raw seconds value to a string
containing the time formatted according to flags in the numeric format ('itl0') resource. 
(Since NULL is specified in the resource handle parameter, the appropriate 'itl0'
resource for the current script system is used.)  This string is then drawn in the window
and the retrieved raw seconds value is assigned to the static variable oldRawSeconds for
use next time doIdle is called.


doEvents

doEvents handles initial event processing.  

In the case of a mouse-down event in the content region of the window (when it is the
front window), the application-defined function doInContent is called.

In the case of a non-Command key equivalent key-down event, the application-defined
function doKeyEvent is called.


doUpdate and doActivateWindow

doUpdate handles update events.  Between the usual calls to BeginUpdate and EndUpdate,
the contents of the window are re-drawn.

doActivateWindow activates or deactivates the window's contents.  GetRootControl gets a
handle to the window's root control.  This is used in the following lines to either
activate or deactivate all of the controls in the window.  In addition, the
application-defined function doDrawWindow is called to draw all the non-control text in
the window in either the normal or dimmed state, as appropriate.


doMenuChoice

doMenuChoice handles Apple, File, and Edit menu choices.  In the case of choices from the
Edit menu, the appropriate TextEdit function is called.


doAdjustMenus

doAdjustMenus adjusts the menus.

If there is a selection range in the current edit structure, the Cut, Copy, and Clear
items are enabled, otherwise they are disabled.  If there is any text in the TextEdit
private scrap (the call to TEGetScrapLength), the Paste item is enabled, otherwise it is
disabled.  If there is any text in the currently activate edit text field, Select All is
enabled, otherwise it is disabled.


doKeyEvent

doKeyEvent handles key-down and auto-key events which are not Command key equivalents.

If the character code is that generated by the tab key or the del key, handling is passed
to other application-defined functions.  If the Return key was pressed, control is passed
to an application-defined function which accepts, formats, and displays the entered data
and deletes all text from the edit text fields.

The following occurs if the character code makes it to the else block.  Firstly, if the
active edit text field is the Quantity or Unit Value field, and if the character code is
not a numeric character, the minus character, or the period character, the system alert
sound is played and the function returns.  TEKey is called provided that the maximum
number of characters allowable in the currently active edit text field will not be
exceeded or the character is one of the non-printing characters.  If the number of
characters entered is at the limit and a printing character key was pressed, the
character is not accepted and the system alert sound is played.  This arrangement ensures
that, if the number of characters in the edit structure is at the maximum allowed, the
arrow and delete keys, unlike the printing character keys, will not be ignored and will
have their usual effect.


doHandleTabKey

doHandleTabKey handles the tab key.  Its purpose is to cycle around the edit text fields
in response to tab key presses, defeating keyboard focus on the currently active edit
text field and setting keyboard focus on the next edit text field in the sequence.

The first two lines retrieve a handle to the document structure for the window.  The call
to GetKeyboardFocus gets a handle to the control with keyboard focus.  This will be used
in the call to Draw1Control at the bottom of the function.

The central block determines which is the current edit structure (and thus the current
edit text field) and calls the application-defined function that changes the active edit
text field.  This call passes the handle to the next edit text field control in the
sequence, together with the maximum number of characters allowed in that field.

The call to Draw1Control on the "old" edit text field control ensures that the insertion
point caret will be erased in that field.  The call to doAdjustCursor is required in
order to change the rectangle within which the cursor changes to the I-beam shape.


doHandleDelKey

doHandleDelKey handles the forward-delete key, which is not supported by TextEdit.  The
first line gets the current selection length.  If the selection length is zero (that is,
an insertion point caret is being displayed), the selection is set to include the
character to the right of the insertion point.  TEDelete deletes the current selection
range from the text.


doInContent

doInContent handles mouse-down events in the content region of the window.

The second and third lines get a handle to the window's document structure. .  The call
to GetKeyboardFocus gets a handle to the control with keyboard focus.  (This will be used
in the call to Draw1Control at the bottom of the function.)  The next line gets the
position of shift key at the time of the mouse-down.  (TEClick's behaviour depends on the
position of the shift key.)

GlobalToLocal converts the global coordinates of the mouse-down to the local coordinates
required by FindControl and TEClick.

If FindControl reports an enabled item under the mouse, and if that item is the Item
Title edit text field control, and if that control has the keyboard focus, TEClick is
called to take control until the mouse button is released.  (Note that the shift key
position is passed in the second parameter.)  If the Item Title edit text field control
does not have the keyboard focus, the application-defined function doChangeCurrentEditRec
is called to change the keyboard focus to that control.  The same basic procedure is
followed in the case of mouse-downs within the other three edit text field controls.

The call to Draw1Control on the "old" edit text field control ensures that the insertion
point caret will be erased in that field.  The call to doAdjustCursor is required in
order to change the rectangle within which the cursor changes to the I-beam shape.


doChangeCurrentEditRec

doChangeCurrentEditRec is called by both doHandleTabKey and doInContent to change 
the edit text field control with keyboard focus (and thus the currently active edit 
structure).

SetKeyboardFocus sets the keyboard focus to the specified edit text field control.  The 
next line makes the edit structure associated with that control the current edit 
structure.

If this function was called by doInContent (teClick = true), TEClick is called to tell
TextEdit that the mouse-down has occurred in the newly-activated edit structure.  Note
that the extend parameter is set to false, telling TextEdit, regardless of the position
of the shift key, that the user is not extending a selection.

TESetSelect ensures that, if there are any characters in the edit structure, they will be
initially highlighted.  The last line assigns the appropriate value to the global
variable which controls the maximum allowable number of characters in the active edit
text field.


doTodaysDate

doTodaysDate draws the date at the top of the window.

GetDateTime gets the raw seconds value, as known to the system.  DateString converts the
raw seconds value to a string containing a date formatted in long date format according
to flags in the numeric format ('itl0') resource.  (Since NULL is specified in the
resource handle parameter, the appropriate 'itl0' resource for the current script system
is used.)  This string is then drawn in the window.


doAcceptNewRecord

doAcceptNewRecord is called when the Return key is pressed.  Assuming each edit text
field contains at least one character of text, it calls other application-defined
functions to format (where necessary) and display strings in the "Last Record Entered"
group box area, and prepares the edit text fields to accept new data.

The first two lines get a handle to the window's document structure.  The next block
copies the handles to the four edit structures to four local variables.

At the next block, if any one of the edit text fields does not contain any text, the
system alert sound is played and the function returns.

The two calls to GetDialogItemText get the text in the "Item Title" and "Quantity" edit
text fields into two global variables.  (GetDialogItemText is usually used to get the
text from an editable edit text item in a dialog box.  It works here because the first
parameter required by GetDialogItemText is a handle to the hText field of an edit
structure.)  No special formatting of these two strings is required.

The call to InvalRect causes an update event to be generated.  As will be seen, this
causes the strings created by the preceding block to be drwan in the "Last Record
Entered" group box area.

The next two lines call two application defined functions to format and display strings
derived from the information in the "Unit Value" and "Date" edit text fields.

The next 10 lines delete the text from all edit text fields.  The last three lines change
the keyboard focus back to the "Item Title" edit text field.


doAcceptValueField

doAcceptValueField is called by doAcceptNewRecord to get the string from the "Value" edit
structure, convert it to floating point number, convert that number to a formatted number
string, draw that string, get the string in the "Quantity" edit structure, convert that
string to an integer, multiply the floating point number by the integer to arrive at the
"Total Value" value, convert the result to a formatted number string, and draw that
string .

A pointer to a number parts table is required by the functions that convert between
floating point numbers and strings.  Accordingly, the first three lines get the required
pointer.

StringToFormatRec converts the number format specification string into the internal
numeric representation required by the functions that convert between floating point
numbers and strings.

With that preparation attended to, GetDialogItemText gets the "Value" edit text field
text into a Pascal string.  StringToExtended converts that string into a floating point
number of type extended (80 bits).  ExtendedToString converts that number back to a
string, formatted according to the internal numeric representation of the number format
specification string.  doCopyPString copies that string to a global variable for
subsequent drawing in the window.

The intention now is to multiply the quantity by the unit value to arrive at a total
value.  However, conditional compilation is required here to account for the fact that
the PowerPC Floating Point Unit does not support Motorola's 80-bit extended type.

If the program is being compiled as 680x0 code, the value in the extended80 variable
(unit value) is multiplied by the quantity and the result (total value) is stored in the
extended80 variable.  If the program is being compiled as PowerPC code, the extended80
value is converted to a value  of type double before the multiplication occurs.  The
result of the multiplication is assigned to the variable of type double.  This is then
converted to an extended80.

The extended80 value is then passed in the first parameter of ExtendedToString for
conversion to a formatted string.  If ExtendedToString does not return fFormatOverflow,
the formatted string is copied to a global variable for subsequent drawing in the window.


doAcceptDateField

doAcceptDateField is called by doAcceptNewRecord to create a long date-time structure
from the string in the "Date" edit structure, add six months to the date, format the date
as a string (long date format), and draw that string in the structure panel.

The function which creates the long date-time structure takes an initialised date cache
structure as a parameter.  Accordingly, the first step is to initialise the specified
date cache structure.

The next two lines get a pointer to the text in the "Date" edit structure and the length
of that text.  These are passed as parameters in the StringToDate call, which parses the
input string and fills in the relevant fields of the long date-time structure.

LongDateToSeconds converts the long date-time structure to a long date-time value.  The
next line adds six months worth of seconds to the long date-time value.  The modified
long date-time value is then passed as a parameter to LongDateString.  LongDateString
converts the long date-time value to a long format date string formatted according to the
specified international resource.  (In this case, NULL is passed as the international
resource parameter, meaning that the appropriate 'itl1' resource for the current script
system is used.)

The formatted date string is copied to a global variable for subsequent drawing in the
window.


doGetEditTextHandle

doGetEditTextHandle returns the handle to the edit structure associated with the
specified edit text control.
doDrawWindow

doDrawWindow draws the non-control text content of the window.  The text will be drawn
normal or dimmed depending on whether the application is in the foreground or background.


doAdjustCursor

doAdjustCursor is the cursor adjustment function.  It is similar to the cursor adjustment
functions in previous demonstration programs except that the rectangle in which the
cursor is required to change to the I-beam cursor shape is changed to accord with that of
the edit text field with keyboard focus.





Prior to the version issued with Mac OS 8.5 and later, the text backgound colour in 
the edit text control would often corrupt after cut and paste operations using the 
Edit menu (though not when using the Command-key equivalents).  If you experience 
this problem when running the demonstration under a version of the Mac OS earlier 
than mac OS 8.5, proceed as follows:

Add this data type:

  typedef struct
  {
    RGBColor      backColour;
    PixPatHandle  backPixelPattern;
    Pattern       backBitPattern;
    } backColourPattern;

Add this global variable:

  backColourPattern gBackColourPattern;

Add these function prototypes:

  void doSaveBackground     (backColourPattern *);
  void doRestoreBackground  (backColourPattern *);
  void doSetBackgroundWhite (void);

Add these functions:

  // ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doSaveBackground

  void  doSaveBackground(backColourPattern *gBackColourPattern)
  {
    GrafPtr  currentPort;

    GetPort(¤tPort);

    GetBackColor(&gBackColourPattern->backColour);
    gBackColourPattern->backPixelPattern  = NULL;

    if((**((CGrafPtr) currentPort)->bkPixPat).patType != 0)
      gBackColourPattern->backPixelPattern = ((CGrafPtr) currentPort)->bkPixPat;
    else
      gBackColourPattern->backBitPattern = 
                       *(PatPtr) (*(**((CGrafPtr) currentPort)->bkPixPat).patData);
  }

  // ×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doRestoreBackground

  void  doRestoreBackground(backColourPattern *gBackColourPattern)
  {
    RGBBackColor(&gBackColourPattern->backColour);

    if(gBackColourPattern->backPixelPattern)
    BackPixPat(gBackColourPattern->backPixelPattern);
    else
      BackPat(&gBackColourPattern->backBitPattern);
  }

  // ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××× doSetBackgroundWhite

  void  doSetBackgroundWhite(void)
  {
    RGBColor  whiteColour = { 0xFFFF, 0xFFFF, 0xFFFF };
  
    RGBBackColor(&whiteColour);
    BackPat(&qd.white);
  }

// ××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××

Add this call:

  doSaveBackground(&gBackColourPattern);

in the main function, after the call to ShowWindow.

Add this call:

  doRestoreBackground(&gBackColourPattern);

in doIdle, after call to IdleControls,
in doMenuChoice, just before the last break statement,
in doKeyEvent, just before the last closing brace,
in doIncontent, just before the last closing brace, and
in doChangeCurrentEditRec, as the first line.

Add this line:

  doSetBackgroundWhite();

in doMenuChoice, immediately before switch(menuItem),
in doKeyEvent, as the first line, and
in doInContent, as the first line.