Demonstration Program

// ��������������������������������������������������������������������������������������
// Miscellany.h
// ��������������������������������������������������������������������������������������
// 
// This program demonstrates:
//
// �  The use of the Notification Manager to allow an application running in the 
//    background to communicate with the foreground application.
//
// �  The use of the determinate progress indicator control to show progress during a
//    time-consuming operation, together with scanning the event queue for Command-period
//    key-down events for the purpose of terminating the lengthy operation before it 
//    concludes of its own accord.
//
// �  Image drawing optimisation and window zooming in a multi-monitors environment. 
//
// �  The use of the Color Picker to solicit a choice of colour from the user.
//
// �  Slot-based VBL tasks.

// �  The use of stubs in 68K code segments, together with a function which uses those 
//    stubs  to unlock code segments and make them purgeable. 
//
// The program utilises the following resources:
//
// �  An 'MBAR' resource, and 'MENU' resources for Apple, File, Edit and Demonstration
//    menus (preload, non-purgeable).
//
// �  A 'WIND' resource (purgeable) (initially visible) for a window in which graphics
//    and information relevant to the demonstrations is displayed.
//
// �  A 'DLOG' resource (purgeable), and associated 'DITL', 'dlgx', and 'dftb' resources
//    (purgeable), for a dialog box in which the progress indicator is displayed.
//
// �  'CNTL' resources (purgeable) for the progress indicator dialog.
//
// �  'icn#', 'ics4', and 'ics8' resources (non-purgeable) which contain the application
//    icon shown in the Application menu during the Notification Manager demonstration.
//
// �  A 'snd ' resource (non-purgeable) used in the Notification Manager demonstration.
//
// �  A 'STR ' resource (non-purgeable) containing the text displayed in the alert box
//    invoked by the Notification Manager.
//
// �  A 'STR#' resource (purgeable) containing the label and narrative strings for the
//    notification-related alert displayed by Miscellany.
//
// �  A 'PICT' resource (non-purgeable) used in the slot-based VBL task demonstration. 
//
// �  A 'SIZE' resource with the acceptSuspendResumeEvents, doesActivateOnFGSwitch,
//    canBackgound, and is32BitCompatible flags set.
//
// Miscellany source code is contained in six files.  In the 68K project, each source 
// code file is assigned to a different segment.  (Note that this small program does not
// really require such segmentation.  The code is segmented only to facilitate the
// demonstration of the Segment Loader aspects, which apply only to the 68K version.)
//
// ��������������������������������������������������������������������������������������

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

#include <Appearance.h>
#include <ColorPicker.h>
#include <ControlDefinitions.h>
#include <Devices.h>
#include <LowMem.h>
#include <Retrace.h>
#include <SegLoad.h>
#include <Sound.h>
#include <ToolUtils.h>

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

#define mApple              128
#define  iAbout             1
#define mFile               129
#define  iQuit              11
#define mDemonstration      131
#define  iNotification      1
#define  iProgress          2
#define  iColourPicker      3
#define  iMultiMonitors     4
#define  iSlotVertBlank     5
#define rMenubar            128
#define rWindow             128
#define rAlert              128
#define rDialog             128
#define  iProgressIndicator 1
#define rIconFamily         128
#define rBarkSound          8192
#define rString             128
#define rAlertStrings       128
#define  indexLabel         1
#define  indexNarrative     2
#define rPicture            128
#define topLeft(r)          (((Point *) &(r))[0])
#define botRight(r)         (((Point *) &(r))[1])

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

typedef struct
{
  VBLTask   vblTaskStruc;
  SInt32    thisApplicationsA5;
  Boolean   inVBlankPeriod;
} VBLStructure, *VBLStructurePtr;

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

void        main                            (void);
void        doInitManagers                  (void);
void        doEvents                        (EventRecord *);
void        doMenuChoice                    (SInt32 menuChoice);
void        unloadSegments                  (void);

void        notificationSegment             (void);
void        doSetUpNotification             (void);
void        doPrepareNotificationStructure  (void);
void        doIdle                          (void);
void        doOSEvent                       (EventRecord *);
void        doDisplayMessageToUser          (void);

void        progressBarSegment              (void);
void        doProgressIndicator             (void);
Boolean     doCheckForCancel                (DialogPtr);

void        multiMonitorSegment             (void);
pascal void doDeviceLoopDraw                (SInt16,SInt16,GDHandle,SInt32);
void        doZoomWindowMultiMonitors       (WindowPtr,SInt16);
void        doRedoWindowContent             (WindowPtr);

void        colourPickerSegment             (void);
void        doColourPicker                  (void);
void        doDrawColourPickerChoice        (void);
char        *doDecimalToHexadecimal         (UInt16 n);

void        doStopSystemVBLTask             (void);
void        doSlotVBLTask                   (void);
OSErr        doInstallSlotVBLTask           (void);
#if TARGET_CPU_68K
void        theSlotVBLTask                  (void);
#else
void        theSlotVBLTask                  (VBLStructurePtr);
#endif
void        doStopSlotVBLTask               (void);

// ........................................................... in-line glue for GetVBLRec

#if TARGET_CPU_68K
pascal SInt32  GetVBLRec (void) = 0x2E88;
#endif

// ��������������������������������������������������������������������������������������
// Miscellany.c
// ��������������������������������������������������������������������������������������

#include "Miscellany.h"

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

DeviceLoopDrawingUPP  doDeviceLoopDrawUPP;
Boolean               gDone;
WindowPtr             gWindowPtr;
ProcessSerialNumber   gProcessSerNum;
Rect                  gMultiMonDragBounds, gMultiMonGrowBounds;
Boolean               gMultiMonitorsDrawDemo = false;
Boolean               gColourPickerDemo  = false;
RGBColor              gWhiteColour = { 0xFFFF, 0xFFFF, 0xFFFF };
RGBColor              gBlueColour  = { 0x4444, 0x4444, 0x9999 };

// ��������������������������������������������������������������������������������� main

void  main(void)
{
  Handle        menubarHdl;
  MenuHandle    menuHdl;
  RgnHandle     grayRgnHdl;
  EventRecord   eventStructure;

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

  doInitManagers();

  // .......................................................... create routine descriptor

  doDeviceLoopDrawUPP = NewDeviceLoopDrawingProc((ProcPtr) doDeviceLoopDraw);
  
  // .......................................................... 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 

  if(!(gWindowPtr = GetNewCWindow(rWindow,NULL,(WindowPtr)-1)))
    ExitToShell();

  SetPort(gWindowPtr);
  TextSize(10);

  // .......................................... get process serial number of this process

  GetCurrentProcess(&gProcessSerNum);  

  // ............................ get window drag and sizing limits for multiple monitors 

  grayRgnHdl = LMGetGrayRgn();
  gMultiMonDragBounds = (*grayRgnHdl)->rgnBBox;
  SetRect(&gMultiMonGrowBounds,445,302,
          ((gMultiMonDragBounds.right) - (gMultiMonDragBounds.left)),
          ((gMultiMonDragBounds.bottom) - (gMultiMonDragBounds.top)));

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

  gDone = false;

  while(!gDone)
  {
    if(WaitNextEvent(everyEvent,&eventStructure,0,NULL))
      doEvents(&eventStructure);
    else
      doIdle();

    unloadSegments();
  }
}

// ����������������������������������������������������������������������� doInitManagers

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

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

  InitCursor();
  FlushEvents(everyEvent,0);
  
  RegisterAppearanceClient();
}

// ����������������������������������������������������������������������������� doEvents

void  doEvents(EventRecord *eventStrucPtr)
{
  SInt16    partCode;
  WindowPtr windowPtr;
  SInt8     charCode;
  SInt32    newSize, userData;

  switch(eventStrucPtr->what)
  {
    case mouseDown:
      partCode = FindWindow(eventStrucPtr->where,&windowPtr);

      switch(partCode)
      {
        case inMenuBar:
          doMenuChoice(MenuSelect(eventStrucPtr->where));
          break;

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

        case inDrag:
          DragWindow(windowPtr,eventStrucPtr->where,&gMultiMonDragBounds);
          break;
    
        case inGrow:
          newSize = GrowWindow(windowPtr,eventStrucPtr->where,&gMultiMonGrowBounds);
          if(newSize != 0)
            SizeWindow(windowPtr,LoWord(newSize),HiWord(newSize),true);
          InvalRect(&windowPtr->portRect);
          break;

        case inZoomIn:
        case inZoomOut:
          if(TrackBox(windowPtr,eventStrucPtr->where,partCode))
            doZoomWindowMultiMonitors(windowPtr,partCode);
          break;
      }
      break;

    case keyDown:
    case autoKey:
      charCode = eventStrucPtr->message & charCodeMask;
      if((eventStrucPtr->modifiers & cmdKey) != 0)
        doMenuChoice(MenuEvent(eventStrucPtr));
      break;

    case updateEvt:
      windowPtr = (WindowPtr) eventStrucPtr->message;

      BeginUpdate(windowPtr);
      
      if(gMultiMonitorsDrawDemo)
      {
        RGBBackColor(&gWhiteColour);
        userData = (SInt32) windowPtr;
        DeviceLoop(windowPtr->visRgn,doDeviceLoopDrawUPP,userData,0);
      }
      else if(gColourPickerDemo )
      {
        RGBBackColor(&gBlueColour);
        EraseRect(&windowPtr->portRect);
        doDrawColourPickerChoice();
      }
      else
      {
        RGBBackColor(&gBlueColour);
        EraseRect(&windowPtr->portRect);
      }
  
      EndUpdate(windowPtr);
      break;

    case osEvt:
      doOSEvent(eventStrucPtr);
      HiliteMenu(0);
      break;
  }
}

// ������������������������������������������������������������������������� 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)
        ExitToShell();
      break;

    case mDemonstration:
  
      gMultiMonitorsDrawDemo = gColourPickerDemo = false;
      
      switch(menuItem)
      {
        case iNotification:
          RGBBackColor(&gBlueColour);
          EraseRect(&gWindowPtr->portRect);
          doSetUpNotification();
          break;
          
        case iProgress:
          RGBBackColor(&gBlueColour);
          EraseRect(&gWindowPtr->portRect);
          doProgressIndicator();
          break;

        case iColourPicker:
          gColourPickerDemo  = true;
          doColourPicker();
          break;
          
        case iMultiMonitors:
          gMultiMonitorsDrawDemo = true;
          InvalRect(&gWindowPtr->portRect);
          break;

        case iSlotVertBlank:
          RGBBackColor(&gBlueColour);
          EraseRect(&gWindowPtr->portRect);
          doSlotVBLTask();
          break;

      }
      
      break;
  }

  HiliteMenu(0);
}

// ����������������������������������������������������������������������� unloadSegments

void  unloadSegments(void)
{
  UnloadSeg(notificationSegment);
  UnloadSeg(progressBarSegment);
  UnloadSeg(multiMonitorSegment);
  UnloadSeg(colourPickerSegment);
}

// ��������������������������������������������������������������������������������������
// Notification.c
// ��������������������������������������������������������������������������������������

#include "Miscellany.h"

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

NMRec                       gNotificationStructure;
long                        gStartingTickCount;
Boolean                     gNotificationDemoInvoked;
Boolean                     gNotificationInQueue;
Boolean                     gInBackground;
extern WindowPtr            gWindowPtr;
extern ProcessSerialNumber  gProcessSerNum;
extern RGBColor             gWhiteColour;
extern RGBColor             gBlueColour;

// ������������������������������������������������������������������ notificationSegment

void  notificationSegment(void) {}

// ������������������������������������������������������������������ doSetUpNotification

void  doSetUpNotification(void)
{
  doPrepareNotificationStructure();
  gNotificationDemoInvoked = true;

  gStartingTickCount = TickCount();

  RGBForeColor(&gWhiteColour);
  MoveTo(10,279);
  DrawString("\pPlease click on the desktop now to make the Finder ");
  DrawString("\pthe frontmost application.");
  MoveTo(10,292);
  DrawString("\p(This application will post a notification 10 seconds from now.)");
}

// ������������������������������������������������������� doPrepareNotificationStructure

void  doPrepareNotificationStructure(void)
{
  Handle        iconSuiteHdl;
  Handle        soundHdl;
  StringHandle  stringHdl;

  GetIconSuite(&iconSuiteHdl,rIconFamily,kSelectorAllSmallData);
  soundHdl = GetResource('snd ',rBarkSound);
  stringHdl = GetString(rString);

  gNotificationStructure.qType    = nmType;
  gNotificationStructure.nmMark    = 1;
  gNotificationStructure.nmIcon    = iconSuiteHdl;
  gNotificationStructure.nmSound  = soundHdl;
  gNotificationStructure.nmStr    = *stringHdl;
  gNotificationStructure.nmResp    = NULL;
  gNotificationStructure.nmRefCon  = 0;
}

// ������������������������������������������������������������������������������� doIdle

void  doIdle(void)
{
  ProcessSerialNumber  frontProcessSerNum;
  Boolean              isSameProcess;

  if(gNotificationDemoInvoked)
  {
    if(TickCount() > gStartingTickCount + 600)
    {
      GetFrontProcess(&frontProcessSerNum);
      SameProcess(&frontProcessSerNum,&gProcessSerNum,&isSameProcess);
  
      if(!isSameProcess)
      {
        NMInstall(&gNotificationStructure);
        gNotificationDemoInvoked = false;
        gNotificationInQueue = true;
      }
      else
      {
        doDisplayMessageToUser();
        gNotificationDemoInvoked = false;
      }

      EraseRect(&gWindowPtr->portRect);
    }
  }
}

// ���������������������������������������������������������������������������� doOSEvent

void  doOSEvent(EventRecord *eventStrucPtr)
{
  switch((eventStrucPtr->message >> 24) & 0x000000FF)
  {
    case suspendResumeMessage:
      gInBackground = (eventStrucPtr->message & resumeFlag) == 0;
      if((!gInBackground) && gNotificationInQueue)
        doDisplayMessageToUser();
      break;
  }
}

// ��������������������������������������������������������������� doDisplayMessageToUser

void  doDisplayMessageToUser(void)
{
  AlertStdAlertParamRec paramRec;
  Str255                labelText;
  Str255                narrativeText;
  SInt16                itemHit;

  if(gNotificationInQueue)
  {
    NMRemove(&gNotificationStructure);
    gNotificationInQueue = false;
  }

  EraseRect(&gWindowPtr->portRect);
  
  paramRec.movable        = true;
  paramRec.helpButton     = false;
  paramRec.filterProc     = NULL;
  paramRec.defaultText    = (StringPtr) kAlertDefaultOKText;
  paramRec.cancelText     = NULL;
  paramRec.otherText      = NULL;
  paramRec.defaultButton  = kAlertStdAlertOKButton;
  paramRec.cancelButton   = 0;
  paramRec.position       = kWindowDefaultPosition;

  GetIndString(labelText,rAlertStrings,indexLabel);
  GetIndString(narrativeText,rAlertStrings,indexNarrative);

  StandardAlert(kAlertNoteAlert,labelText,narrativeText,¶mRec,&itemHit);

  DisposeIconSuite(gNotificationStructure.nmIcon,false);
  ReleaseResource(gNotificationStructure.nmSound);
  ReleaseResource((Handle) gNotificationStructure.nmStr);
}

// ��������������������������������������������������������������������������������������
// ProgressIndicator.c
// ��������������������������������������������������������������������������������������


#include "Miscellany.h"

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

extern WindowPtr  gWindowPtr;
extern RGBColor   gWhiteColour;

// ������������������������������������������������������������������� progressBarSegment

void  progressBarSegment(void) {}

// ������������������������������������������������������������������������ doProgressBar

void  doProgressIndicator(void)
{
  DialogPtr     dialogPtr;
  ControlHandle progressBarHdl;
  SInt16        statusMax, statusCurrent;
  SInt16        a, b, c;
  Handle        soundHdl;
  Rect          theRect;
  RGBColor      redColour = { 0xFFFF, 0x0000, 0x0000 };
  
  if(!(dialogPtr = GetNewDialog(rDialog,NULL,(WindowPtr) -1)))
    ExitToShell();

  SetPort(dialogPtr);
  UpdateControls(dialogPtr,((GrafPtr) dialogPtr)->visRgn);
  SetPort(gWindowPtr);

  GetDialogItemAsControl(dialogPtr,iProgressIndicator,&progressBarHdl);

  statusMax = 3456;
  statusCurrent = 0;
  SetControlMaximum(progressBarHdl,statusMax);

  for(a=0;a<9;a++)
  {
    for(b=8;b<423;b+=18)
    {
      for(c=8;c<286;c+=18)
      {
        if(doCheckForCancel(dialogPtr))
        {
          soundHdl = GetResource('snd ',rBarkSound);
          SndPlay(NULL,(SndListHandle) soundHdl,false);
          ReleaseResource(soundHdl);
          DisposeDialog(dialogPtr);

          EraseRect(&gWindowPtr->portRect);
          MoveTo(10,292);
          RGBForeColor(&gWhiteColour);
          DrawString("\pOperation cancelled at user request");

          return;
        }
        
        SetRect(&theRect,b+a,c+a,b+17-a,c+17-a);
        if(a < 3)                RGBForeColor(&gWhiteColour);
        else if(a > 2 && a < 6)  RGBForeColor(&redColour);
        else if(a > 5)           RGBForeColor(&gWhiteColour);
        FrameRect(&theRect);

        SetControlValue(progressBarHdl,statusCurrent++);
      }
    }
  }

  DisposeDialog(dialogPtr);  
  EraseRect(&gWindowPtr->portRect);
  MoveTo(10,292);
  RGBForeColor(&gWhiteColour);
  DrawString("\pOperation completed");
}


// ��������������������������������������������������������������������� doCheckForCancel

Boolean  doCheckForCancel(DialogPtr dialogPtr) 
{
  GrafPtr    oldPort;
  Boolean    foundCommandPeriod;
  QHdrPtr    eventQHdrPtr;
  EvQElPtr  eventQElPtr;
  SInt32    charCode;
  SInt32    commandKeyDown;

  GetPort(&oldPort);
  SetPort(dialogPtr);

  foundCommandPeriod = false;

  eventQHdrPtr = LMGetEventQueue();
  eventQElPtr = (EvQElPtr) eventQHdrPtr->qHead;

  while(eventQElPtr && !foundCommandPeriod)
  {
    if(eventQElPtr->evtQWhat == keyDown)
    {
      charCode = eventQElPtr->evtQMessage & charCodeMask;
      commandKeyDown = eventQElPtr->evtQModifiers & cmdKey;

      if(commandKeyDown)
        if(charCode == 0x2e)
          foundCommandPeriod = true;
    }

    if(!foundCommandPeriod)
      eventQElPtr = (EvQElPtr) eventQElPtr->qLink;
  }

  SetPort(oldPort);
  
  return(foundCommandPeriod);
}

// ��������������������������������������������������������������������������������������

// ��������������������������������������������������������������������������������������
// ColourPicker.c
// ��������������������������������������������������������������������������������������

#include "Miscellany.h"

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

RGBColor          gInColour = { 0xCCCC, 0x0000, 0x0000 };
RGBColor          gOutColour;
Boolean           gColorPickerButton;
extern WindowPtr  gWindowPtr;
extern RGBColor   gWhiteColour;
extern RGBColor   gBlueColour;

// ������������������������������������������������������������������ colourPickerSegment

void  colourPickerSegment(void) {}

// ����������������������������������������������������������������������� doColourPicker

void  doColourPicker(void)
{
  Rect      theRect;
  Point     where;
  Str255    prompt = "\pChoose a rectangle colour:";

  theRect = gWindowPtr->portRect;
  RGBBackColor(&gBlueColour);
  EraseRect(&theRect);
  InsetRect(&theRect,55,55);
  RGBForeColor(&gInColour);
  PaintRect(&theRect);

  where.v = where.h = 0;

  gColorPickerButton = GetColor(where,prompt,&gInColour,&gOutColour);
  
  InvalRect(&gWindowPtr->portRect);
}

// �������������������������������������������������������������� doDrawColorPickerChoice

void  doDrawColourPickerChoice(void)
{
  Rect  theRect;
  char  *cString;  

  theRect = gWindowPtr->portRect;
  InsetRect(&theRect,55,55);

  if(gColorPickerButton)
  {
    RGBForeColor(&gOutColour);
    PaintRect(&theRect);
  
    RGBForeColor(&gWhiteColour);

    MoveTo(55,22);
    DrawString("\pRequested Red Value: ");
    cString = doDecimalToHexadecimal(gOutColour.red);
    MoveTo(170,22);
    DrawText(cString,0,6);

    MoveTo(55,35);
    DrawString("\pRequested Green Value: ");
    cString = doDecimalToHexadecimal(gOutColour.green);
    MoveTo(170,35);
    DrawText(cString,0,6);

    MoveTo(55,48);
    DrawString("\pRequested Blue Value: ");
    cString = doDecimalToHexadecimal(gOutColour.blue);
    MoveTo(170,48);
    DrawText(cString,0,6);
  }
  else
  {
    RGBForeColor(&gInColour);
    PaintRect(&theRect);
  
    RGBForeColor(&gWhiteColour);
    MoveTo(55,48);
    DrawString("\pCancel button was clicked.");
  }
}

// ��������������������������������������������������������������� doDecimalToHexadecimal

char  *doDecimalToHexadecimal(UInt16 decimalNumber)
{
  static char cString[] = "0xXXXX";
  char        *hexCharas = "0123456789ABCDEF";
  SInt16      a;

  for (a=0;a<4;decimalNumber >>= 4,++a)
    cString[5 - a] = hexCharas[decimalNumber & 0xF];

  return cString;
}

// ��������������������������������������������������������������������������������������
// MultiMonitor.c
// ��������������������������������������������������������������������������������������

#include "Miscellany.h"

// ������������������������������������������������������������������ multiMonitorSegment

void  multiMonitorSegment(void) {}

// ��������������������������������������������������������������������� doDeviceLoopDraw

pascal void  doDeviceLoopDraw(SInt16 depth,SInt16 deviceFlags,GDHandle targetDeviceHdl,
                              SInt32 userData)
{
  RGBColor  oldForeColour;
  WindowPtr windowPtr;
  Rect      theRect;
  RGBColor  greenColour  = { 0x0000, 0xAAAA, 0x1111 };
  RGBColor  redColour    = { 0xAAAA, 0x4444, 0x3333 };
  RGBColor  blueColour   = { 0x5555, 0x4444, 0xFFFF };
  RGBColor  ltGrayColour = { 0xDDDD, 0xDDDD, 0xDDDD };
  RGBColor  grayColour   = { 0x9999, 0x9999, 0x9999 };
  RGBColor  dkGrayColour = { 0x4444, 0x4444, 0x4444 };
  
  GetForeColor(&oldForeColour);

  windowPtr = (WindowPtr) userData;
  theRect = windowPtr->portRect;
  EraseRect(&windowPtr->portRect);
  
  if(BitTst(&deviceFlags,15 - gdDevType))
  {
    InsetRect(&theRect,50,50);
    RGBForeColor(&greenColour);
    PaintRect(&theRect);
    InsetRect(&theRect,40,40);
    RGBForeColor(&redColour);
    PaintRect(&theRect);
    InsetRect(&theRect,40,40);
    RGBForeColor(&blueColour);
    PaintRect(&theRect);
  }
  else
  {
    InsetRect(&theRect,50,50);
    RGBForeColor(<GrayColour);
    PaintRect(&theRect);
    InsetRect(&theRect,40,40);
    RGBForeColor(&grayColour);
    PaintRect(&theRect);
    InsetRect(&theRect,40,40);
    RGBForeColor(&dkGrayColour);
    PaintRect(&theRect);
  }

  RGBForeColor(&oldForeColour);
}

// ������������������������������������������������������������������������� doZoomWindow

void doZoomWindowMultiMonitors(WindowPtr windowPtr,SInt16 zoomInOrOut)
{
  GrafPtr     oldPort;
  Rect        windRect, intersectRect, zoomRect;
  SInt16      titleBarHeight, windowFrameWidth;
  WStateData  *winStateDataPtr;
  GDHandle    deviceHdl, zoomDeviceHdl;
  SInt32      intersectArea, greatestArea;

  GetPort(&oldPort);
  SetPort(windowPtr);

  EraseRect(&windowPtr->portRect);

  if(zoomInOrOut == inZoomOut)
  {
    windRect = windowPtr->portRect;
    LocalToGlobal(&topLeft(windRect));
    LocalToGlobal(&botRight(windRect));
    titleBarHeight = windRect.top - 
                     (*((WindowPeek) windowPtr)->strucRgn)->rgnBBox.top - 1;

    windRect.top = windRect.top - titleBarHeight;

    deviceHdl = LMGetDeviceList();
    greatestArea = 0;

    while(deviceHdl != NULL)
    {
      if(TestDeviceAttribute(deviceHdl,screenDevice) && 
         TestDeviceAttribute(deviceHdl,screenActive))
      {   
        SectRect(&windRect,&(*deviceHdl)->gdRect,&intersectRect);

        intersectArea = (long) (intersectRect.right - intersectRect.left) * 
                               (intersectRect.bottom - intersectRect.top);
        if(intersectArea > greatestArea)
        {
          greatestArea = intersectArea;
          zoomDeviceHdl = deviceHdl;
        }
            
        deviceHdl = GetNextDevice(deviceHdl);
      }
    }
      
    if(zoomDeviceHdl == LMGetMainDevice())
      titleBarHeight = titleBarHeight + LMGetMBarHeight();
      
    windowFrameWidth = (*(((WindowPeek) windowPtr)->strucRgn))->rgnBBox.right -
                       (*(((WindowPeek) windowPtr)->contRgn))->rgnBBox.right;

    SetRect(&zoomRect,(*zoomDeviceHdl)->gdRect.left + 3 + windowFrameWidth,
                      (*zoomDeviceHdl)->gdRect.top + titleBarHeight + 3,
                      (*zoomDeviceHdl)->gdRect.right - 3 - windowFrameWidth,
                      (*zoomDeviceHdl)->gdRect.bottom - 3 - windowFrameWidth);
      
    winStateDataPtr = (WStateData *) *((WindowPeek) windowPtr)->dataHandle;
    winStateDataPtr->stdState = zoomRect;
  }

  ZoomWindow(windowPtr,zoomInOrOut,windowPtr == FrontWindow());
  doRedoWindowContent(windowPtr);
  SetPort(oldPort);
}

// ������������������������������������������������������������������ doRedoWindowContent

void doRedoWindowContent(WindowPtr windowPtr)
{
  // Do scroll bar and TextEdit, etc, adjustments here as appropriate.

  InvalRect(&windowPtr->portRect);
}

// ��������������������������������������������������������������������������������������
// VerticalBlank.c
// ��������������������������������������������������������������������������������������

#include "Miscellany.h"

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

VBLUPP          gSlotVBLTaskUPP;
VBLStructure    gSlotVBLStructure;
SInt16          gMainSlotNumber;

extern RGBColor   gWhiteColour;

// ������������������������������������������������������������������������ doSlotVBLTask

void  doSlotVBLTask(void)
{
  GDHandle    mainDeviceHdl;
  SInt16      mainDeviceRefNum;
  DCtlHandle  deviceCtlEntryHdl;
  OSErr       osErr;
  PicHandle   pictureHdl;
  Rect        theRect;
  SInt16      h = 1, v = 1, hh = 0, vv = 0, index = 0;

  gSlotVBLTaskUPP = NewVBLProc((ProcPtr) theSlotVBLTask);

  mainDeviceHdl     = LMGetMainDevice();
  mainDeviceRefNum   = (*mainDeviceHdl)->gdRefNum;
  deviceCtlEntryHdl = GetDCtlEntry(mainDeviceRefNum);
  gMainSlotNumber   = (SInt16) (*((AuxDCEHandle) deviceCtlEntryHdl))->dCtlSlot;

  RGBForeColor(&gWhiteColour);

  osErr = doInstallSlotVBLTask();
  if(osErr != noErr)
  {
    MoveTo(10,292);
    DrawString("\pCould not install slot-based VBL task.");
    DisposeRoutineDescriptor(gSlotVBLTaskUPP);
    return;
  }
    
  MoveTo(10,292);
  DrawString("\pClick mouse to remove slot-based VBL task");
  pictureHdl = GetPicture(rPicture);
  theRect = (*pictureHdl)->picFrame;

  while(!Button())
  {
    while(!gSlotVBLStructure.inVBlankPeriod)
      ;
      
    OffsetRect(&theRect,h,v);
    DrawPicture(pictureHdl,&theRect);

    gSlotVBLStructure.inVBlankPeriod = false;

    hh = hh + h;
    if(hh == 0 || hh == 350)
      h = -h;
    vv = vv + v;
    if(vv == - 18 || vv == 165)
      v = -v;
  }
  
  doStopSlotVBLTask();
}

// ����������������������������������������������������������������� doInstallSlotVBLTask

OSErr doInstallSlotVBLTask(void)
{
  OSErr  osErr;

  gSlotVBLStructure.vblTaskStruc.qType    = vType;
  gSlotVBLStructure.vblTaskStruc.vblAddr  = gSlotVBLTaskUPP;
  gSlotVBLStructure.vblTaskStruc.vblCount  = 1;
  gSlotVBLStructure.vblTaskStruc.vblPhase  = 0;
  gSlotVBLStructure.inVBlankPeriod = false;

  osErr = SlotVInstall((QElemPtr) &gSlotVBLStructure.vblTaskStruc,gMainSlotNumber);

  return osErr;
}

// ����������������������������������������������������������������������� theSlotVBLTask

#if TARGET_CPU_68K
void  theSlotVBLTask(void)
#else
void  theSlotVBLTask(VBLStructurePtr vblStructurePtr)
#endif
{
#if TARGET_CPU_68K
  VBLStructurePtr  vblStructurePtr;

  vblStructurePtr = (VBLStructurePtr) GetVBLRec();
#endif

  vblStructurePtr->inVBlankPeriod = true;
  vblStructurePtr->vblTaskStruc.vblCount = 1;
}

// �������������������������������������������������������������������� doStopSlotVBLTask

void  doStopSlotVBLTask(void)
{
  SlotVRemove((QElemPtr) &gSlotVBLStructure.vblTaskStruc,gMainSlotNumber);

  DisposeRoutineDescriptor(gSlotVBLTaskUPP);
}

// ��������������������������������������������������������������������������������������

When this program is run, the user should make choices from the Demonstration menu,
taking the following actions and making the following observations:

*  Choose the Notification item and, observing the instructions in the window, click 
   the desktop immediately to make the Finder the foreground application.  A 
   notification will be posted by Miscellany about 10 seconds after the Notification 
   item choice is made.  Note that, when about 10 seconds have elapsed, the 
   Notification Manager invokes an alert box (Mac OS 8.6 and earlier) or floating 
   window (Mac OS 9.x) and alternates the Finder and Miscellany icons in the 
   Application menu title.  Observing the instructions in the alert box/floating 
   window, dismiss the alert (Mac OS 8.6 and earlier only) and then choose the 
   Miscellany item in the Application menu, noting the � mark to the left of the item
   name. When Miscellany comes to the foreground, note that the icon alternation 
   concludes and that an alert (invoked by Miscellany) appears.  Dismiss this second 
   alert box.

*   Choose the Notification item again and, this time, leave Miscellany in the
    foreground.  Note that only the alert box invoked by Miscellany appears on this 
    occasion.

*   Choose the Notification item again and, this time, click on the desktop and then
    in the Miscellany window before 10 seconds elapse.  Note again that only the alert
    box invoked by Miscellany appears.

*   Choose the Determinate Progress Indicator item, noting that the progress indicator
    dialog box is automatically disposed of when the (simulated) time-consuming task
    concludes.

*   Choose the Determinate Progress Indicator item again, and this time press the
    Command-period key combination before the (simulated) time-consuming task
    concludes.  Note that the progress indicator dialog box is disposed of when the 
    Command-period key combination is pressed.

*   Choose the Colour Picker item and make colour choices using the various available
    modes.  Note that, when the Colour Picker is dismissed by clicking the OK button,
    the requested RGB colour values for the chosen colour are displayed in hexadecimal,
    together with a rectangle in that colour, in the Miscellany window.

*   Choose the Multiple Monitors Draw item, noting that the drawing of the simple
    demonstration image is optimised as follows:

    *   On a monitor set to display 256 or more colours, the image is drawn in three
        distinct colours.  The luminance of the three colours is identical, meaning
        that, if these colours are drawn on a grayscale screen, they will all appear
        in the same shade of gray.

    *   On a monitor set to display 256 shades of gray, the image is drawn in three
        distinct shades of gray.

*   Choose the Slot-Based VBL Task item, bearing in mind that the successive re-drawing
    of the picture is delayed until the monitor is in the vertical blank period.

In addition, if the user's system has more than one monitor, the user should zoom the
window in and out when the window is on the main monitor, when it has been dragged to the
second monitor, and when it has been dragged to a position where it is partially
displayed on both monitors, noting the standard state, and the monitor zoomed to, in each
case.

The VBLStructure data type, which can be regarded as an expanded VBL task structure,
will be used by the slot-based VBL task.  The first field is a VBL task structure.  The 
second field will be used to save the A5 register (680x0 code only).

doDeviceLoopDrawUPP will be assigned a universal procedure pointer to the
application-defined image-optimising drawing function called by DeviceLoop. 
gProcessSerNum will be assigned the process serial number of the Miscellany application. 
gMultiMonDragBounds will be passed in the bounds parameter of the DragWindow function. 
gMultiMonGrowBounds will be passed in the bBox parameter of the GrowWindow
function.

The call to NewDeviceLoopDrawingProc creates a routine descriptor for the
image-optimising drawing function doDeviceLoopDraw.

GetCurrentProcess gets the process serial number of this process.

The next block defines two rectangles. gMultiMonDragBounds is set to equate to the
current desktop region, which potentially crosses multiple devices and consists of
everything below the menu bar.  This establishes the limits within which the user will be
able to drag the window.  gMultiMonGrowBounds establishes the minimum and maximum heights
and widths to apply to window resizing.

Within the event loop, note that:

*   The call to doIdle is relevant to the notification demonstration only.

*   The application-defined function unloadSegments is called at the bottom of the event
    loop after the event received by WaitNextEvent has been handled to completion.

Note that, within the mouseDown case, gMultiMonDragBounds is be passed in the bounds
parameter of DragWindow, gMultiMonGrowBounds is passed in the bBox parameter of
GrowWindow, and the application-defined window-zooming function doZoomWindowMultiMonitors
is called at the inZoomIn/inZoomOut case.

Within the updateEvt case, if the Multiple Monitors Draw item in the Demonstration menu
has been chosen (gMultiMonitorsDrawDemo is true), a call is made to DeviceLoop and the
universal procedure pointer to the application-defined drawing function doDeviceLoopDraw
is passed as the second parameter.

When the Multiple Monitors Draw item in the Demonstration menu is chosen, the 
window's port rectangle is invalidated so as to force an update event and consequential 
call to DeviceLoop.

unloadSegments unlocks, and marks as purgeable, the specified 68K code segments,
that is, the segment in which a stub ("do nothing" function) resides.  Note that a stub
has not been included in the segment containing the VBL task demonstration code, and that
that segment is preloaded and locked.  This is because a VBL task's code must be locked
into physical memory if virtual memory is in operation.

Recall that there is no need to include conditional compilation directives in source code
containing segmentation directives before that code is compiled for the PowerPC. 
Compilers which produce PowerPC code ignore segmentation directives, and any calls to the
Segment Manager's UnloadSeg function are simply ignored.

notificationSegment is the stub, or "do nothing" function, called by unloadSegments
at the bottom of the main event loop.

doSetUpNotification is called when the user chooses Notification from the
Demonstration menu.

The first line calls an application-defined function which fills in the relevant fields
of a notification structure.  The next line assigns true to a global variable which
records that the Notification item has been chosen by the user.

The next line saves the system tick count at the time that the user chose the
Notification item.  This value is used later to determine when 10 seconds have elapsed
following the execution of this line.

doPrepareNotificationStructure fills in the relevant fields of the notification
structure.

First, however, GetIconSuite creates an icon family based on the specified resource ID
and the third parameter, which limits the family to 'ics#', 'ics4' and 'ics8' icons.  The
GetIconSuite call returns the handle to the suite in its first parameter.  The call to
GetResource loads the specified 'snd ' resource.  GetString loads the specified 'STR '
resource.

The first line of the main block specifies the type of operating system queue.  The next
line specifies that the � mark is to appear next to the application's name in the
Application menu.  The next three lines assign the icon suite, sound and string handles
previously obtained.  The next line specifies that no response function is required to be
executed when the notification is posted.

doIdle is called from the main event loop when a null event is received.  Recall
that the canBackground flag is set in the application's 'SIZE' resource, meaning that the
application will receive null events when it is in the background.

If the user has not just chosen the Notification item in the Demonstration menu
(gNotificationDemoInvoked is false), doIdle simply returns immediately.

If, however, that item has just been chosen, and if 10 seconds (600 ticks) have elapsed
since that choice was made, the following occurs:

*   The calls to GetFrontProcess and SameProcess determine whether the current
    foreground process is Miscellany.  If it is not, the notification request is
    installed in the notification queue by NMInstall and a global variable is set to
    indicate that a request has been placed in the queue by Miscellany.  Also,
    gNotificationDemoInvoked is set to false so as to ensure that the main if block
    only executes once after the Notification item is chosen.

*   If, however, the current foreground process is Miscellany, the application-defined
    function doDisplayMessageToUser is called to present the required message to the
    user, via an alert box, in the normal way.  Once again gNotificationDemoInvoked is
    reset to false so as to ensure that the main if block only executes once after the
    Notification item is chosen.

doOSEvent handles operating system events.

If the event is a resume event (that is, Miscellany is coming to the foreground) and if
the notification request is still in the notification queue (gNotificationInQueue is
true), the application-defined function doDisplayMessageToUser is called to remove the
notification request from the queue and have Miscellany convey the required message to
the user via an alert box.

doDisplayMessageToUser is called by doOSEvent and doIdle in the circumstances
previously described.

If a Miscellany notification request is in the queue, NMRemove removes it from the queue
and gNotificationInQueue is set to false to reflect this condition.  (Recall that, if the
nmResp field of the notification structure is not assigned -1, the application itself
must remove the queue element from the queue.)

Regardless of whether there was a notification in the queue or not, Miscellany then
presents its alert.  When the alert is dismissed, the notification's icon suite, sound
and string resources are released/disposed of.

doProgressIndicator is called when the user chooses Determinate Progress Indicator
from the Demonstration menu.

GetNewDialog creates a modal dialog box.  The call to UpdateControls draws the dialog
box's controls.  The call to GetDialogItemAsControl retrieves the handle to the dialog's
progress indicator control.  SetControlMaximum sets the control's maximum value to equate
to the number of steps in a simulated time-consuming task.

The main for loop performs the simulated time-consuming task, represented to the user by
the drawing of a large number of coloured rectangles in the window.  The task involves
3456 calls to FrameRect.

Within the outer for loop, the application-defined function doCheckForCancel is called to
check whether the user has pressed the Command-period key combination or clicked the
dialog's Stop button.  If so, a 'snd ' resource is loaded, played, and released, the
dialog is disposed of, an advisory message in drawn in the window, and the function
returns.

Within the inner for loop, the rectangles are drawn.  Each time round this inner loop, a
progress indicator control's value is incremented.

When the outer loop exits (that is, when the Command-period key combination is not
pressed before the simulated time-consuming task completes), the dialog is disposed of.

doCheckForCancel scans the event queue for Command-period keyboard events.

The first line sets a variable so as to begin by assuming that such an event is not in 
the queue.

LMGetEventQueue gets a pointer to the event queue header.  The next line gets a pointer 
to first queue element.  The while loop scans the whole of the event queue, exiting only 
when a Command-period key event is found in the queue or the entire queue has been
scanned.

Inside the loop, if a key-down event is found, the first two lines in the else if 
block get the character code and the third line checks whether the Command key was down.
If the Command key was down, and if the character code is the code for the period 
character (charCode 0x2e), the variable foundCommandPeriod is set to true, causing the 
loop to exit and doCheckForCancel to return true.  

If a Command-period keyboard event was not found, the last two lines in the while loop
call up the next queue for examination.

The last line returns the result of the search.

doColourPicker is called when the user chooses Colour Picker from the Demonstration
menu.

The first block erases the window's content area and paints a rectangle in the colour
which will be passed in GetColor's inColor parameter. 

The next line assigns 0 to the fields of the Point variable to be passed in GetColor's
where parameter.  ((0,0) will cause the Colour Picker dialog box to be centred on the
main screen.)

The call to GetColor displays the Colour Picker's dialog box.  GetColor retains control
until the user clicks either the OK button or the Cancel button, at which time the port
rectangle is invalidated, causing the function doDrawColourPickerChoice to be
called.

If the user clicked the OK button, a filled rectangle is painted in the window in
the colour returned in GetColor's outColor parameter, and the values representing the
red, green, and blue components of this colour are displayed at the top of the window in
hexadecimal.  Note that the application-defined function doDecimalToHexadecimal is called
to convert the decimal (UInt32) values in the fields of the RGBColor variable outColor to
hexadecimal.

If the user clicks the Cancel button, a filled rectangle is painted in the window in the
colour passed in GetColor's inColor parameter.

doDecimalToHexadecimal converts a UInt16 value to a hexadecimal string.
MultiMonitor.c

doDeviceLoopDraw is the image-optimising drawing function the universal procedure
pointer to which is passed in the second parameter in the DeviceLoop call in the function
doEvents.  (Recall that the DeviceLoop call is made whenever the Multiple Monitors Draw
item in the Demonstration menu has been selected and an update event is received.) 
DeviceLoop scans all active video devices, calling doDeviceLoopDraw whenever it
encounters a device which intersects the drawing region, and passing certain information
to doDeviceLoopDraw.

The second line casts the SInt32 value received in the userData parameter to a WindowPtr. 
The window's content area is then erased.

If an examination of the device's attributes, as received in the deviceFlags formal
parameter, reveals that the device is a colour device, three rectangles are painted in
the window in three different colours.  (The luminance value of these colours is the
same, meaning that the rectangles would all be the same shade of gray if they were drawn
on a monochrome (grayscale) device.) 

If the examination of the device's attributes reveals that the device is a monochrome
device, the rectangles are painted in three distinct shades of gray.

doZoomWindowMultiMonitors is called when the user clicks in the window's zoom box.

The first two lines save and set the current graphics port.  The third line erases the
window's port rectangle prior to the zoom so as to avoid flicker.  

The main if block executes only if the direction of the zoom is "out" to the standard
state.  The purpose of this block of code is to determine the standard state rectangle
and, in a multi-monitors environment, the monitor on which the zoomed window is to be
displayed.

The first block inside the if block converts the window's port rectangle to global
coordinates and gets the height of the window's title bar.  The next line establishes a
rectangle equal to the window's port rectangle, plus the window's title bar, in global
coordinates.  

LMGetDeviceList gets a handle to the first gDevice structure in the device list and the
variable greatestArea is assigned 0.  

The while loop then walks the device list.  For each active video device, the associated
gDevice structure's gdRect field is compared to the window's rectangle by a call to
SectRect.  If the two rectangles intersect, the coordinates of the intersection are
assigned to the intersectRect variable, otherwise an empty rectangle ((0,0)(0,0)) is
assigned to intersectRect.  The area of the intersection rectangle is calculated and
stored in the variable intersectArea.  If the new value in intersectArea is greater than
that calculated during any previous pass through the loop, the variable zoomDeviceHdl is
assigned the GDHandle of the device currently being examined.

GetNextDevice gets the handle to the next device in the device list.  The while loop
exits when this call returns NULL.  When the loop exits, the contents of the variable
zoomDeviceHdl represents the video device on which the window should be zoomed to the
standard state, that is, the device on which the largest area of the window currently
appears.

If the call to LMGetMainDevice reveals that this device is the main device, the height of
the menu bar is added to the value in the variable which holds the window's title bar
height.

The next two lines determine the width of the window frame and the following four lines
establish the standard state rectangle.  This latter is three pixels inside the rectangle
contained in the gdRect field of the device's gDevice structure, but with the top
adjusted to account for the height of the title bar (and the menu bar if the device is
the main device) and the sides and bottom adjusted for the width of the window frame. 
The last two lines in the main if block then assign this rectangle to the stdState field
of the window's state data structure.

Below the main if block, ZoomWindow is called to zoom the window in the appropriate
direction, following which an application-defined function is called to redraw the window
contents as appropriate.  Finally, the saved graphics port is restored.

doRedoWindowContent is called by doZoomWindowMultiMonitors to redraw the content
region of a newly-zoomed window.  In this demonstration the window's content area is
simply invalidated, forcing an update event.

doSlotVBLTask is called when the user chooses Slot-Based VBL Task from the
Demonstration menu. In this demonstration, the slot-based VBL task is used to delay the
drawing of a picture at a new location until the monitor enters the vertical blank
period.

The first line creates a routine descriptor for the slot-based VBL task.

The next block gets the slot number of the main graphics device.  This process involves
getting a handle to the startup gDevice structure, extracting from that structure the
device driver's reference number, getting a handle to the DCtlEntry structure, and then
getting the slot number.

doInstallSlotVBLTask is then called to install the slot-based VBL task.  If this call is
not successful, the function returns.

The call to GetPicture loads the specified 'PICT' resource, following which the picFrame
field in the resource is copied to a local variable.  Within the outer while loop, this
rectangle is continually offset between successive calls to DrawPicture, causing the
picture to appear to move around the window.  The inner (empty) while loop continues to
cycle until the inBlankPeriod field of the expanded VBL task structure is set to true by
the VBL task, at which time the Picture is drawn and the inBlankPeriod field is set back
to false.

When the user clicks the mouse, the outer while loop exits and doStopSlotVBLTask is
called to remove the slot-based VBL task.

doInstallSlotVBLTask installs the slot-based VBL task.

The first four lines fill in the appropriate fields of the VBL task record.  Note that
the vblCount field is set to 1 so that the VBL task will execute at the first interrupt.

The fifth line sets a field in the expanded VBL task structure to false.  This field will
be set to true by the slot-based VBL task.  Note that there is no need to save the
application's A5 in this case because the slot-based VBL task does not need to access an
application global variable.

SlotVInstall attempts to install the task in the slot-based queue.  The success, or
otherwise, of the attempted installation is returned to the calling function.

theSlotVBLTask is the slot-based VBL task itself.  It is similar to theSystemVBLTask
except that no measures are required to facilitate access to the application's global
variables.

When the task executes, it sets to true the flag in the expanded VBL task structure which
indicates that the vertical blanking period has just been entered.  When the task
executes, the value in the vblCount field of the VBL task record will be 0.  So that the
task will execute again at the next interrupt, the last line  sets the vblCount field of
the VBL task record back to 1.

doStopSlotVBLTask is called when the user clicks the mouse button.  It removes the
slot-based VBL task from the relevant queue and disposes of the routine descriptor.

Recall that, at the Demonstration Program Controls2 Comments section at
Chapter7 - Introduction to Controls, mention was made of horizontal "tearing"
of the picture in the lower section of the window when it was being scrolled
using the scroll arrows, and that this would be addressed in the Demonstration
Program Comments section of this chapter.

This "tearing" can be eliminated by delaying the drawing of the picture
until the vertical blanking period is entered, using the same approach as is
used in the slot-based VBL task demonstration, above.  Simply install a 
slot-based VBL task using the relevant source code in the Miscellany 
demonstration and change the bottom of the actionFuncLive function in 
Controls2.c to the following:

    doMoveScrollBox(controlHdl,scrollDistance);
  }
  
  SetOrigin(GetControlValue((*docStrucHdl)->scrollbarLiveHdl),0);

  if(!gVBLInstallFail)  // Set this flag to true if VBL task is not 
                        // successfully installed.
  {
    while(!gSlotVBLStructure.inVBlankPeriod) // Wait for vert blanking period.
      ;
    DrawPicture(gPictHandleLive,&gPictRectLive);
    gSlotVBLStructure.inVBlankPeriod = false;
  }
  else
    DrawPicture(gPictHandleLive,&gPictRectLive);

  SetOrigin(0,0);
}