/*

 * This is a viewer application shell

 *

 * Nick Thompson, nickt@apple.com

 * send bug reports to devsupport@apple.com

 *

 * ©1995-7 Apple Computer Inc., All Rights Reserved.

 *

 * This is a sample app that was originally written for an article in Develop

 * issue 29, but please note that it is really extended from the example 

 * presented in that article.  

 *

 * I've extended it to be the "reference" app for supporting plug-in 

 * renderers.  Along the way it became apparent that just sticking all the renderers

 * into a popup menu, simply did not cut the mustard.  Here's why.  There is a 

 * distinction between interactive (for example the apple interactive renderer)

 * and non interactive renderers (such as the lightwork renderer).  Bear in mind

 * that the interactivity of a renderer is often a tradeoff against speed.  In particular, 

 * it makes no sense whatsoever to support interactivity with a non interactive

 * renderer.

 *

 * This led me to the big change in the application.  I decided that if the 

 * renderer was non-interactive, then it should draw into a new window, which

 * the user could save as a pict, print, or whatever.  Bear in mind that this is

 * not the only way to do this.  Another simpler way would be to let the user

 * chose a non interactive renderer, and just render one into the window, then

 * switch back to the non interactive renderer.  I saw a couple of problems with

 * this approach for this particular application, in particular that if the 

 * window received an update event (out of the users control) then the window 

 * or worse - part of the window - would get redrawn with the "wrong" renderer.

 *

 * This remains a work in progress.  As sample code it is useful as an 

 * illustration of how to use the viewer, and an illustration of how to use

 * plug-in renderers.

 *

 * As usual this is a work in progress, which means use the code at your own risk!!  

 *

 * If you fix a bug, or add some functionality feel free to send me the change and

 * I'll roll it in.

 *

 * 

 *

 * TO DO: drag and drop support for pict windows

 *        saving and restoring print records to files.

 *

 * 2/4/99 nick updated to universal headers 3.2 and CW4.

 */

/*------------------------------------------------------------ */

#include <AppleEvents.h>

#include <CodeFragments.h>

#include <ColorPicker.h>

#include <Devices.h>

#include <Dialogs.h>

#include <Diskinit.h>

#include <Events.h>

#include <Errors.h>

#include <Fonts.h>

#include <Gestalt.h>

#include <LowMem.h>

#include <Printing.h>

#include <QDOffscreen.h>

#include <QuickDraw.h>

#include <Menus.h>

#include <Scrap.h>

#include <SegLoad.h>

#include <StandardFile.h>

#include <TextUtils.h>

#include <Strings.h>

#include <Sound.h>

#include <Windows.h>

// is alpha macros etc...

#include <ctype.h>

/* always include this before anything else when using the QuickDraw 3D library  */

#include "QD3D.h"

/* viewer support  */

#include "QD3DViewer.h"

/* this has the routines for renderer objects  */

#include "QD3DRenderer.h"

/* this has the routines for view objects  */

#include "QD3DView.h"

/*------------------------------------------------------------ */

/* convenience macros to peek at event records  */

#define     HiWrd(aLong)            (((aLong) >> 16) & 0xFFFF)

#define     LoWrd(aLong)            ((aLong) & 0xFFFF)

#define     kMaxRendererCount       30

#define     RETURN_KEY              0x0D

#define     ENTER_KEY               0x03

#define     ESCAPE                  0x1B

#define     kProgressBarDlogID      1028

#define     kProgressBarPBItemID    2

/*------------------------------------------------------------ */

/* constants  */

const   short               kWindHeight = 350 ;         /* default theWindow height  */

const   short               kWindWidth = 300 ;          /* default theWindow width  */

const   short               kMaxHeight = 400 ;          /* max theWindow height  */

const   short               kMaxWidth = 560 ;           /* max theWindow width  */

const   SFTypeList          kTypeList = { '3DMF' } ;    /* file type we can open  */

const   short               kNumTypes = 1 ;             /* num of file types we can recognise  */

const   short               kAppMenuBarID = 128 ;       /* resource ID for the application's menu bar  */

const   short               kFatalAlert = 128 ;         /* res ID for error alert before we bail  */

const   short               kErrorAlertStrings = 128 ;  /* res ID for alert strs  */

const   short               kAboutDialogID = 129;       /* ID for the about box dialog  */

const   short               kFinalRenderDialogID = 130; /* ID for the final quality render dialog  */

const   short               kInsetPixelsConst = 30 ;    /* num of pixels to inset view by  */

/* error codes  */

enum {

    kNoMenuBar = 1,

    kNoQD3DViewerLib,

    kNoAEVTSupport

} ;

/* menu resource IDs  */

enum {

    mInteractiveRendererMenu = 1,   /* hierarchical, stored in the view menu  */

    mNonInteractiveRendererMenu ,   /* hierarchical, stored in final dialog  */

    mAppleMenu = 128,

    mFileMenu,

    mEditMenu,

    mViewMenu

} ;

/* item numbers - Apple menu  */

enum {

    iAppleAboutItem = 1

} ;

/* item numbers - File menu  */

enum {

    iFileNewItem = 1,

    iFileOpenItem,

    iFileCloseItem = 4,

    iFileSaveItem,

    iFileSaveAsItem,

    iFileRevertItem,

    iFilePageSetupItem = 9,

    iFilePrintItem,

    iFileQuitItem = 12

} ;

/* item numbers - Edit menu  */

enum {

    iEditUndoItem = 1,

    iEditCutItem = 3,

    iEditCopyItem,

    iEditPasteItem,

    iEditClearItem = 7,

    iEditRendererPrefsItem = 9

} ;

/* item numbers - View menu  */

enum {

    iViewRendererItem = 1,

    iViewFinalRendererItem,

    iViewBadgeItem = 4,

    iViewCameraButtonItem = 6,

    iViewTruckButtonItem,

    iViewOrbitButtonItem,

    iViewZoomButtonItem,

    iViewDollyButtonItem,

    iViewInsetNFrameItem = 12,

    iViewSetBackgroundColorItem

} ;

/* items in the final quality render menu */

enum {

    kFinalRendrOK = 1,

    kFinalRendrCancel,

    kFinalRendrIcon,

    kFinalRendrTitle,

    kFinalRendrText,

    kFinalRendrSep1,

    kFinalRendrSep2,

    kFinalRendrSep3,

    kFinalRendrPopup,

    kFinalRendrConfigure,

    kFinalRendrWinSzTxt,

    kFinalRendrHtTxt,

    kFinalRendrWiTxt,

    kFinalRendrHeight,

    kFinalRendrWidth

} ;

/* res ID's for small picts used in the progress bar dialog */

enum {

    kResIDStartCap = 1028,

    kResIDEndCap,

    kResIDDropShadow

} ;

/*------------------------------------------------------------ */

/*

 * type definitions - these magic numbers are the first field of the struct

 * that we stuff in the window's refcon field

 */

/*

 * as this app grow's I'm in the process of factoring it, here's a list

 * of functions that can be stuffed in the document record 

 */

typedef void        (*AdjustMenusProc)( WindowPtr  theWindow )  ;

typedef Boolean     (*HandleEventProc)( WindowPtr theWindow, const EventRecord *theEventRecord) ;

typedef void        (*UpdateContentProc)( WindowPtr  theWindow ) ;

typedef WindowPtr   (*NewProc)( unsigned char *windowTitle ) ;

typedef OSErr       (*SaveAsProc)( WindowPtr theWindow ) ;

typedef OSErr       (*SaveProc)( WindowPtr theWindow ) ;

typedef OSErr       (*RevertProc)( WindowPtr theWindow ) ;

typedef WindowPtr   (*OpenProc)( FSSpec *theFSSpec ) ;

typedef OSErr       (*CloseProc)( WindowPtr theWindow ) ;

typedef short       (*CountPagesProc)( WindowPtr theWindow, Rect *pageRect ) ;

typedef void        (*PrintPageProc)( WindowPtr theWindow, Rect *pageRect, GrafPtr imagingPort, short pageNum ) ;

typedef void        (*PrePrintProc)( WindowPtr  theWindow ) ;

typedef void        (*PostPrintProc)( WindowPtr  theWindow )    ;

typedef OSErr       (*CutProc)( WindowPtr   theWindow ) ;

typedef OSErr       (*CopyProc)( WindowPtr  theWindow ) ;

typedef OSErr       (*PasteProc)( WindowPtr theWindow ) ;

typedef OSErr       (*ClearProc)( WindowPtr theWindow ) ;

typedef OSErr       (*UndoProc)( WindowPtr  theWindow ) ;

/*

 * This struct is used to store related items for a progress bar,

 * these cached items can then be used when updating the PB

 */

typedef struct {

    DialogPtr       thePBDialog ;       /* the dialog containing a 14 pixel high user item  *

                                         * within which the PB is drawn                     */

    short           thePBItemNumber ;   /* item number in the DITL for the PB user item */

    Rect            thePBRect ;         /* it's rect, local coodinates in the dialog */

    GWorldPtr       thePBGWorld ;       /* a GWorld that is used to draw the pb, it's then blitted to the dialog */

    long            thePBMaxValue ;     /* the maximum value the PB can be */

    long            thePBCurrValue ;    /* the current value for the progress bar */

} ProgressBarDlogInfoData, **ProgressBarDlogInfoHdl ;

/*

 * this is a struct that contains the fp's associated with a document class

 * later we'll use this to set up menus.  If a fp is null then the menu is 

 * disabled, this will really reduce the size of the adjust menus proc.

 *

 * Each document record will have this as the second field.

 */

typedef struct Procs {

    AdjustMenusProc     adjustMenusP ;      /* fix up window specific menus */

    UpdateContentProc   updateWindowP ;     /* redraw the window */

    HandleEventProc     handleEventP ;      /* handle events for the window */

    NewProc             newP ;              /* do window specific stuff post create (unused at the moment) */

    SaveAsProc          saveAsP ;           /* save the window contens ask for a file */

    SaveProc            saveP ;             /* save the window contents to the original file */

    RevertProc          revertP ;           /* revert to the last saved copy of the windows file */

    OpenProc            openP ;             /* read in some document data */

    CloseProc           closeP ;            /* close and destroy */

    CountPagesProc      countPagesP ;       /* count the number of pages for a print job */

    PrintPageProc       printPageP ;        /* print one page */

    PrePrintProc        prePrintP ;         /* stuff to do before printing */

    PostPrintProc       postPrintP ;        /* stuff to do after printing */

    CutProc             cutProc ;           /* handle clipboard cut, same as copy followed by clear */

    CopyProc            copyProc ;          /* handle clipboard copy */

    PasteProc           pasteProc ;         /* paste compatible scrap type from the scrap */

    ClearProc           clearProc ;         /* clear the document contents without a save to the scrap */

    UndoProc            undoProc ;          /* undo the last action - if supported */

} Procs ;

/*

 * eventually to make a new doc, we'll just define the structure of the private 

 * field for each class.  Right now they are kind of copies which can be cast around.

 *

 * Make sure that the fields are in the same order, again this is something I'm 

 * planning to fix.

 */

typedef struct {

    unsigned long       fDocumentMagic ;    /* use this to describe the contents of the fPrivate field */

    Procs               *procs ;            /* a pointer to a set of function pointers for this window type */

    THPrint             fPrintRec ;         /* print record so we can print the doc contents */

    void                *fPrivate ;         /* the private data associated with this class */

} Document, *DocumentPtr, **DocumentHdl ;

/* these structures get stuffed in the private field of a generic document record */

typedef struct {

    TQ3ViewerObject     fViewer ;       /* stores reference to the viewer object  */

    GWorldPtr           fGWorld ;       /* used temporarily during printing */

    FSSpec              fFSSpec ;       /* reference to the file for the document  */

} ViewerData, *ViewerDataPtr, **ViewerDataHdl ;

typedef struct {

    GWorldPtr           fGWorld ;       /* a buffer that stores the picture */

} PictData, *PictDataPtr, **PictDataHdl ;

/*

 * Structure for the private data for a popup control.

 * This structure is documented on page 5-77 

 * Inside Macintosh: Macintosh Toolbox Essentials

*/

typedef struct popupPrivateData {

    MenuHandle  mHandle;     /* the popup menu handle */

    short       mID;         /* the popup menu ID */

    /*

     * after these two public fields is the mPrivate private data, 

     * which may be any old size and should not be messed with 

     */

}   popupPrivateData;

/*------------------------------------------------------------ */

/* function prototypes for the application  */

void            SetUpRendererMenu( void ) ;

void            TearDownRendererMenu( void ) ;

void            LoadApplicationDialogs( void ) ;

void            LoadMenuBarForApplication( short myMenuBarID ) ;

void            FatalAlert( short theErrorMessage ) ;

void            InitializeToolBox( void ) ;

Boolean         HasQuickDraw3DViewer( void ) ;

Boolean         SupportsAEVT( void ) ;

void            RegisterRequiredAppleEventHandlers( void ) ;

/* routines to handle the renderer progress bar */

ProgressBarDlogInfoHdl PB_New( 

                DialogPtr   thePBDialog,

                short       thePBItemNumber,

                long        maxValue,

                long        currValue ) ;

void            PB_Update(ProgressBarDlogInfoHdl theInfo ) ;

void            PB_Delete(ProgressBarDlogInfoHdl theInfo ) ;

pascal OSErr    HandleCoreAppleEventOfTypeOAPP( AppleEvent *theAppleEvent, 

                                AppleEvent *theAppleEventReply, 

                                long userDefinedReferenceConstant) ;

pascal OSErr    HandleCoreAppleEventOfTypeODOC( AppleEvent *theAppleEvent, 

                                AppleEvent *theAppleEventReply, 

                                long userDefinedReferenceConstant) ;

pascal OSErr    HandleCoreAppleEventOfTypePDOC( AppleEvent *theAppleEvent, 

                                AppleEvent *theAppleEventReply,

                                long userDefinedReferenceConstant) ;

pascal OSErr    HandleCoreAppleEventOfTypeQUIT( AppleEvent *theAppleEvent, 

                                AppleEvent *theAppleEventReply,

                                long userDefinedReferenceConstant) ; 

void            MainEventLoop( void ) ; 

TQ3Boolean      HandleEvent( const EventRecord *theEventRecord ) ;

void            HandleKeyPress(const EventRecord *theEventRecord) ;

void            HandleMenuCommand(long menuResult) ;

void            HandleAppleMenu( short menuItem ) ;

void            HandleFileMenu( short menuItem ) ;

OSErr           HandleFilePageSetupItem( WindowPtr theWindow ) ;

OSErr           HandleFilePrintItem( WindowPtr theWindow ) ;

OSErr           HandleFileQuitItem( void ) ;

void            HandleEditMenu( short menuItem ) ;

pascal Boolean  OurFilter(DialogPtr dlg, EventRecord *event, short *itemHit) ;

void            HandleViewFinalRendererOption( void ) ;

void            HandleInteractiveRendererMenu( short menuItem ) ;

void            HandleViewMenu( short menuItem ) ;

OSErr           GetViewerVersion( unsigned long *major, unsigned long *minor ) ;

Boolean         BackgroundColor(RGBColor *theRGBColor, unsigned char *thePrompt ) ;

void            AdjustMenus( void ) ;

void            DoDrawGrowIcon(WindowPtr theWindow) ;

WindowPtr       DoCreateNewViewerWindow( unsigned char *windowName ) ;

void            ViewerWindow_Update( WindowPtr  theWindow ) ;

void            ViewerWindow_AdjustMenus( WindowPtr  theWindow ) ;

Boolean         ViewerWindow_HandleEvent( WindowPtr theWindow, const EventRecord *theEventRecord) ;

WindowPtr       ViewerWindow_New( unsigned char *windowTitle ) ;

OSErr           ViewerWindow_SaveAs( WindowPtr theWindow ) ;

OSErr           ViewerWindow_Save( WindowPtr theWindow ) ;

OSErr           ViewerWindow_Revert( WindowPtr theWindow ) ;

WindowPtr       ViewerWindow_Open( FSSpec *theFSSpec ) ;

OSErr           ViewerWindow_Close( WindowPtr theWindow ) ;

short           ViewerWindow_CountPages( WindowPtr theWindow, Rect *pageRect ) ;

void            ViewerWindow_PrintPage( WindowPtr theWindow, Rect *pageRect, GrafPtr imagingPort, short pageNum ) ;

void            ViewerWindow_PrePrint( WindowPtr theWindow ) ;

void            ViewerWindow_PostPrint( WindowPtr theWindow ) ;

OSErr           ViewerWindow_Cut( WindowPtr theWindow ) ;

OSErr           ViewerWindow_Copy( WindowPtr    theWindow ) ;

OSErr           ViewerWindow_Paste( WindowPtr   theWindow ) ;

OSErr           ViewerWindow_Clear( WindowPtr   theWindow ) ;

OSErr           ViewerWindow_Undo( WindowPtr    theWindow ) ;

WindowPtr       DoCreateNewPictWindow( unsigned char *windowName, long windWidth, long windHeight ) ;

void            PictWindow_Update( WindowPtr  theWindow ) ;

void            PictWindow_AdjustMenus( WindowPtr  theWindow ) ;

Boolean         PictWindow_HandleEvent( WindowPtr theWindow, const EventRecord *theEventRecord) ;

WindowPtr       PictWindow_New( unsigned char *windowTitle ) ;

OSErr           PictWindow_SaveAs( WindowPtr theWindow ) ;

OSErr           PictWindow_Save( WindowPtr theWindow ) ;

OSErr           PictWindow_Revert( WindowPtr theWindow ) ;

WindowPtr       PictWindow_Open( FSSpec *theFSSpec ) ;

OSErr           PictWindow_Close( WindowPtr theWindow ) ;

short           PictWindow_CountPages( WindowPtr theWindow, Rect *pageRect ) ;

void            PictWindow_PrintPage( WindowPtr theWindow, Rect *pageRect, GrafPtr imagingPort, short pageNum ) ;

void            PictWindow_PrePrint( WindowPtr theWindow ) ;

void            PictWindow_PostPrint( WindowPtr theWindow ) ;

OSErr           PictWindow_Copy( WindowPtr theWindow ) ;

//

OSErr SetupPrintHdl(THPrint *hPrint) ;

void DoCreatePrintRecord( DocumentHdl theDocument ) ;

OSErr DoStyleDlog(THPrint hPrint) ;

OSErr DoJobDlog(THPrint hPrint) ;

OSErr CommandPeriod() ;

pascal void IdleProc() ;

short GeneralCountPages( GWorldPtr theGWorld, Rect *pageRect ) ;

void GeneralPrintPage( GWorldPtr theGWorld, Rect *pageRect, GrafPtr imagingPort, short pageNum ) ;

OSErr DoPrintLoop( WindowPtr theWindow ) ;

TQ3ViewerObject GetViewerFromViewerWindow( WindowPtr theWindow ) ;

GWorldPtr GetGWorldFromPictWindow( WindowPtr  theWindow ) ;

TQ3RendererObject   GetRendererByType(TQ3ObjectType theRendererType) ;

TQ3Status   ViewerSetRenderer( TQ3ObjectType theRendererType, TQ3ViewerObject theViewer ) ;

TQ3Status MyViewIdleProgressMethod( 

    TQ3ViewObject       view,

    const void          *idlerData,     /* contains the dialog ref */

    unsigned long       current,

    unsigned long       completed) ;

OSErr GetOutputPictFileRef(short    *dstPictFRef ) ;

/*------------------------------------------------------------ */

/* global variables  */

DialogPtr           gFinalRenderDialog = NULL ; /* the non interactive renderer dial0g */

DialogPtr           gProgressModelessDialog = NULL ;

Boolean             gQuitFlag = false ; /* set to true to quit application  */

AEAddressDesc       gSelfAddress;       /* A self-addressed address descriptor record  */

/* these are used for the menus */

static TQ3ObjectType        pInteractiveTypes[ kMaxRendererCount ] ; /* renderer types installed - includes plug-ins */

static TQ3ObjectType        pNonInteractiveTypes[ kMaxRendererCount ] ; /* renderer types installed - includes plug-ins */

static long                 pNonInteractiveRendererCount = 0;   /* the number of non-interactive renderers installed on this system */

static long                 pInteractiveRendererCount = 0;      /* the number of interactive renderers installed on this system */

static Boolean              pHasFinalQualityRenderer = false ;  /* set true if one or more non interactive renderers are installed */

/* 

 * this is a list of the installed renderers that we can use to switch easily. 

 * By this point you are probably muttering that this app has way to many globals,

 * and you might be right, however keeping a list of renderer objects makes sense.

 * The most obvious reason to build a list of the available renderers, together

 * with an instance of each mish be efficiency considerations, but the real reason

 * is somewhat more subtle.  We want renderer prefs to be "sticky".  In other words

 * if I set prefs for a renderer I want those prefs to be the same for multiple

 * uses of the renderer.  Just setting the renderer is not enough, since each time 

 * a renderer object is created it is created with the default set of prefs which

 * may not be what I selected last time I bought the prefs dialog up.

 *

 * The way this structure is used is to build a list of renderer types and an 

 * instance of each when the application is launched, then this list is used

 * whenever renderer prefs need to be set or when a new renderer is selected.

 * This way the prefs will stay with the renderer for the life time of the program.

 *

 * This list contains both interactive and non interactive renderers, it has no

 * real order (first come first served) and is seached linearly by renderer type.

 *

 * In the future, it might be good to build a list of renderer prefs for each 

 * document and save these along with the document, or to have a global list of

 * prefs for the application..

 */

static struct {

    TQ3ObjectType       fRendererType ;     /* the object type for this renderer */

    TQ3RendererObject   fRendererObject ;   /* an instance of the renderer type */  

} pRendererList[ 2 * kMaxRendererCount ] ;

static short        pRendererCount = 0 ;        /* indexes the pRendererList array */

ModalFilterUPP      gModalFilterProcUPP ; 

/********************************************************************************

 * Colors used to draw the progress bar 

 */

/* 

I got these by dumping a scroll bar from the MacOS 8 finder and poking around in photoshop.

Color table, byte value (e.g. from photoshop) on LHS

8bit    16bit       16bit (Hex)

0,      0,          0x0000

51,     13107,      0x3333

102,    26214,      0x6666

136,    34952,      0x8888

153,    39321,      0x9999

170,    43690,      0xaaaa

187,    48059,      0xbbbb

204,    52428,      0xcccc

221,    56797,      0xdddd

255,    65535,      0xffff

*/

const RGBColor      RGBBlack    = { 0x0000, 0x0000, 0x0000 } ;

const RGBColor      RGBDkGrey   = { 0x8888, 0x8888, 0x8888 } ;

const RGBColor      RGBMedGrey  = { 0xaaaa, 0xaaaa, 0xaaaa } ;

const RGBColor      RGBGrey     = { 0xbbbb, 0xbbbb, 0xbbbb } ;

const RGBColor      RGBLtGrey   = { 0xdddd, 0xdddd, 0xdddd } ;

const RGBColor      RGBWhite    = { 0xffff, 0xffff, 0xffff } ;

/* blue shades used */

const RGBColor      RGBDkBlue   = { 0x3333, 0x3333, 0x6666 } ;

const RGBColor      RGBMedBlue  = { 0x6666, 0x6666, 0x9999 } ;

const RGBColor      RGBBlue     = { 0x9999, 0x9999, 0xcccc } ;

const RGBColor      RGBLtBlue   = { 0xcccc, 0xcccc, 0xffff } ;

static  GWorldPtr   theStartCap     = NULL;

static  GWorldPtr   theEndCap       = NULL ;

static  GWorldPtr   theDropShadow   = NULL ;

const unsigned long kViewerMagic    =   0xBADB00CA ;    /* viewer windows */

const unsigned long kPICTMagic      =   0xBADABADA ;    /* picture windows */

/* these MUST be in the same order as above or bad things happen.

 * function procs for the regular viewer window.  Setting these up

 * this way is a little dangerous, if the fields get jumbled up

 * unexpected results can happen, it might make more sense to use

 * a metahandler approach to install the methods - like QD3D

 * extensions...

 */

Procs viewerProcs = { 

    ViewerWindow_AdjustMenus, 

    ViewerWindow_Update, 

    ViewerWindow_HandleEvent,

    ViewerWindow_New, 

    ViewerWindow_SaveAs, 

    ViewerWindow_Save, 

    ViewerWindow_Revert, 

    ViewerWindow_Open, 

    ViewerWindow_Close,

    ViewerWindow_CountPages,

    ViewerWindow_PrintPage,

    ViewerWindow_PrePrint,

    ViewerWindow_PostPrint,

    ViewerWindow_Cut,

    ViewerWindow_Copy,

    ViewerWindow_Paste,

    ViewerWindow_Clear,

    ViewerWindow_Undo

};

/* function procs for the pict window */

Procs pictProcs = { 

    PictWindow_AdjustMenus, 

    PictWindow_Update, 

    PictWindow_HandleEvent,

    PictWindow_New, 

    PictWindow_SaveAs, 

    PictWindow_Save, 

    PictWindow_Revert, 

    PictWindow_Open, 

    PictWindow_Close,

    PictWindow_CountPages,

    PictWindow_PrintPage,

    NULL,                       /* pre print method is not supported */

    NULL,                       /* post print method is not supported */

    NULL,                       /* cut method is not supported */

    PictWindow_Copy,

    NULL,                       /* paste method is not supported */

    NULL,                       /* clear method is not supported */

    NULL                        /* undo method is not supported */

};

/*------------------------------------------------------------ */

/* REMOVE THIS */

#include <Types.h>

#include <Memory.h>

#include <Quickdraw.h>

#include <Gestalt.h>

#include <Fonts.h>

#include <Events.h>

#include <Menus.h>

#include <Windows.h>

#include <TextEdit.h>

#include <Dialogs.h>

#include <OSUtils.h>

#include <ToolUtils.h>

#include <SegLoad.h>

#include <Notification.h>

#include <OSUtils.h>

/* Prototypes */

Boolean IsVMCurrentlyOn(void) ;

void notify(void) ;

static Str255       VMIsCurrentlyOnStr      = "\pVirtual memory is currently on" ;

static Str255       VMIsCurrentlyOffStr     = "\pVirtual memory is currently off" ;

static  NMRec       myNotification ;

void notify(void)

{

    OSErr theErr ;

    myNotification.qType = nmType ;

    myNotification.nmIcon = NULL ;

    myNotification.nmSound = NULL ;

    myNotification.nmResp = NULL ;

    myNotification.nmRefCon = 0L ;

    /* check Gestalt to see if VM is on */

    if( IsVMCurrentlyOn() )

    {

        myNotification.nmStr = VMIsCurrentlyOnStr ;

    }

    else

    {

        myNotification.nmStr = VMIsCurrentlyOffStr ;

    }

    theErr = NMInstall( &myNotification ) ;

}

/*

 * returns true if the VM is on

 */

Boolean IsVMCurrentlyOn(void)

{

    OSErr theError;

    long response;

    theError = Gestalt(gestaltVMAttr, &response);

    if (theError!=noErr)

        return false;

    return (response && (response << gestaltVMPresent));

}

/* END REMOVE THIS */

void main(void)

{

    InitializeToolBox() ;

    gModalFilterProcUPP = NewModalFilterProc( OurFilter ) ;

    LoadApplicationDialogs() ;

    LoadMenuBarForApplication( kAppMenuBarID ) ;

    /*

     * check that we have AppleEvents, and if so install the

     * AppleEvent handlers for the required AppleEvents

     */

    if( SupportsAEVT() ) 

    {

        RegisterRequiredAppleEventHandlers() ;

        /*

         * Check that the viewer is installed

         */

        if( HasQuickDraw3DViewer() )

        {

            Q3Initialize() ;

            SetUpRendererMenu() ;

            MainEventLoop() ;

            TearDownRendererMenu() ;

            Q3Exit() ;

        }

    }

    ExitToShell();  

}

/*------------------------------------------------------------ */

/*

 * Load the final quality renderer dialog.  We do this here so

 * that we can set up the menu properly.  Don't display it just 

 * yet though.

 */

void    LoadApplicationDialogs(void)

{

    /* 

     * load the dialog but don't show it.  As a side note since the 

     * dialog is going to be around for a while, the items in the dialog 

     * should not be purgable.

     */

    gFinalRenderDialog = GetNewDialog( kFinalRenderDialogID, NULL, (WindowPtr)-1) ;

    gProgressModelessDialog = GetNewDialog( kProgressBarDlogID, nil, (WindowPtr)-1) ;

    /* the popup menu for the renderers is item 9 */

}

/*------------------------------------------------------------ */

/*

 * Load the menu bar specified.

 */

void LoadMenuBarForApplication( short myMenuBarID )

{

    Handle      menuBar = NULL;

    /* 

     *Read menus into menu bar specified by the resource 

     * id passed into this routine by myMenuBarID 

     */

    menuBar = GetNewMBar(myMenuBarID);  

    if ( menuBar == NULL )

         ExitToShell();

    /* Install the menus we just read in  */             

    SetMenuBar(menuBar);

    /* it is now safe to dispose the menu handle  */

    DisposeHandle(menuBar);

    /* 

     * this next routine adds the names of desk accessories 

     * to the specified menu, in this case the apple menu

     */

    AppendResMenu( GetMenuHandle( mAppleMenu ), 'DRVR' );

    /*

     * now add the two hierarchical menus

     */

    InsertMenu(GetMenu( mInteractiveRendererMenu ), -1);

    /* call our routine to grey out menus as appropriate  */

    AdjustMenus() ;

    /* finally ensure the new menubar gets drawn  */

    DrawMenuBar();

}

/*------------------------------------------------------------ */

/*

 * dispose of the global rtenderer list

 */

void TearDownRendererMenu( void )

{

    long        theIndex ;

    for( theIndex = 0; theIndex < pRendererCount ; theIndex++ ) 

        Q3Object_Dispose( pRendererList[ theIndex ].fRendererObject ) ;

}

/*------------------------------------------------------------ */

/*

 * set up the interactive renderer menu and the non interactive 

 * renderer popup menu for the "final render" dialog.  Build up

 * a list of renderer objects in the pRendererList struct to make 

 * switching between renderers easier

 */

void SetUpRendererMenu( void ) 

{

    MenuHandle                  theMenu, interactiveRendererMenu, nonInteractiveRendererMenu ;

    TQ3SubClassData             subClassData;

    TQ3ObjectType               *classPointer;

    short                       i;

    TQ3ObjectClassNameString    objectClassName;

    TQ3RendererObject           tempRendererObject ;

    unsigned char               nameBuffer[256] ;

    unsigned long               actualLength ;

    TQ3ObjectClassNameString    objectClassString ;

    Boolean                     isInteractive ;

    popupPrivateData            **myPopupPrivateDataPtr ;

    /* some variables for accessing the fields of the dialog */

    short               iKind;

    Handle              iHandle;

    Rect                iRect;

    interactiveRendererMenu = GetMenuHandle(mInteractiveRendererMenu);

    /*

     * Set up the dialog renderer popup.  We know the item number for the popup

     * we need to get the menuhandle associated with the control, it is in the private

     * control data field, as documented in Inside Macintosh: Toolbox page 5-77

     */

    /* get the control handle for the popup from the dialog */  

    GetDialogItem ( gFinalRenderDialog, kFinalRendrPopup, &iKind, &iHandle, &iRect) ;

    /* extract from the control the menuhandle */

    myPopupPrivateDataPtr = (popupPrivateData **)(**(ControlHandle)iHandle).contrlData ; 

    nonInteractiveRendererMenu = (**myPopupPrivateDataPtr).mHandle ;

    HLock((Handle)nonInteractiveRendererMenu) ;

    /* the popup control has a problem under 7.5 and 7.6, since it expects the 

     * menu to alredy be constructed otherwise the default value for the control 

     * is 0, which means nothing is selected after the menu items have been added, 

     * so i put a dummy item in the menu, we need to delete this before adding 

     * any new items

     */

    DeleteMenuItem ( nonInteractiveRendererMenu, 1 ) ;

    Q3ObjectHierarchy_GetSubClassData(kQ3SharedTypeRenderer, &subClassData);

    classPointer = subClassData.classTypes;

    i = subClassData.numClasses;

    while( i-- > 0 && pInteractiveRendererCount <= kMaxRendererCount) {

        /* 

         * the "generic" renderer is used internally, it can't draw, 

         * so don't display it in any user interface item

         */

        if( *classPointer != kQ3RendererTypeGeneric )

        {

            /*

             * Q3RendererClass_GetNickNameString is only available on 1.5.1, so 

             * check for the existance of this trap before calling.  If the call 

             * is not installed just set the string to nil, we'll use the class name

             * instead and everthing will be hunky dory.

             */

            if( Q3RendererClass_GetNickNameString != (void *)kUnresolvedCFragSymbolAddress ) 

                Q3RendererClass_GetNickNameString(*classPointer, objectClassString );

            else

                objectClassString[0] = '\0' ;

            /*

             * Create an instance of a renderer object and then call 

             * Q3Renderer_IsInteractive to determine if the renderer is 

             * an interactive renderer (this is something the renderer 

             * tells QuickDraw 3D).  Stash the renderer and the type in

             * the pRendererList structure array.

             */

            tempRendererObject = Q3Renderer_NewFromType( *classPointer ) ;

            isInteractive = Q3Renderer_IsInteractive( tempRendererObject ) ;

            /* cache the renderer and type */

            pRendererList[ pRendererCount ].fRendererType = *classPointer ;

            pRendererList[ pRendererCount ].fRendererObject = tempRendererObject;

            pRendererCount++ ;      /* bump the count of elements in the array */

            if( isInteractive )

            {

                theMenu = interactiveRendererMenu ;

                pInteractiveTypes[pInteractiveRendererCount++] = *classPointer ;

            }

            else

            {

                theMenu = nonInteractiveRendererMenu ;

                pHasFinalQualityRenderer = true ;

                pNonInteractiveTypes[pNonInteractiveRendererCount++] = *classPointer ;

            }

            /*

             * check to see if we got a string back, if not use the renderer class name

             */

            if( objectClassString[0] == '\0' )

            {

                /* the renderer did not provide the name, just use the class name */

                Q3ObjectHierarchy_GetStringFromType(*classPointer, objectClassName);

                AppendMenu(theMenu,c2pstr((char *)objectClassName));

            }

            else

            {

                AppendMenu(theMenu,c2pstr(objectClassString));

            }

        }

        classPointer++ ;        

    }

    HLock((Handle)nonInteractiveRendererMenu) ;

    /* null terminate the arrays */

    pInteractiveTypes[pInteractiveRendererCount] = NULL ;

    pNonInteractiveTypes[pInteractiveRendererCount] = NULL ;

    pRendererList[ pRendererCount ].fRendererType = 0L ;

    pRendererList[ pRendererCount ].fRendererObject = NULL;

    Q3ObjectHierarchy_EmptySubClassData( &subClassData ) ;

}

/*------------------------------------------------------------ */

/*

 * Display an alert and quit.

 */

void FatalAlert( short theErrorMessage )

{

    unsigned char   *thePString, theErrorStr[256] ;

    thePString = theErrorStr ;

    GetIndString( thePString, kErrorAlertStrings, theErrorMessage ) ;

    ParamText( thePString, "\p", "\p", "\p" ) ;

    StopAlert( kFatalAlert, NULL ) ;

    ExitToShell() ;

}

/*------------------------------------------------------------ */

/*

 * Initialize all the needed managers.

 */

void    InitializeToolBox( void )

{

    /*

     * Initialize the toolbox managers

     */

    InitGraf((Ptr)&qd.thePort);

    InitFonts();

    InitWindows();

    InitMenus();

    TEInit();

    InitDialogs((long)NULL);

    InitCursor();

    /*

     * must call this so that the heap is expanded to maximum

     * size before calling any viewer routines

     */

    MaxApplZone() ;

}

/*------------------------------------------------------------ */

/*

 * return true if the viewer is installed

 */

Boolean     HasQuickDraw3DViewer( void )

{

    return((long) Q3ViewerNew != kUnresolvedCFragSymbolAddress) ;

}

/*------------------------------------------------------------ */

/*

 * returns true if the platform supports appleevents - we won't run

 * if it doesn't

 */

Boolean SupportsAEVT(void)

{

    OSErr theError;

    long response;

    theError = Gestalt(gestaltAppleEventsAttr,&response);

    if (theError!=noErr)

        return false;

    return (response && (response << gestaltAppleEventsPresent));

}

/********************************************************************************

 * LoadPictIntoGWorld - read pict from the current resource chain, create a 32 bit

 * GWorld the size of the pict, image the pict into the GWorld, dispose of the 

 * pict.  Return a reference to the gworld.

 */

static GWorldPtr LoadPictIntoGWorld( short resID )

{

    Rect        pictRect ;

    GWorldPtr   theGWorld = NULL;

    QDErr       theErr ;

    PicHandle   aPicH = GetPicture(resID);

    if( aPicH != NULL ) 

    {

        /* create a GWorld the size of the pict */

        pictRect.top = (**aPicH).picFrame.top ;

        pictRect.left = (**aPicH).picFrame.left ;

        pictRect.bottom = (**aPicH).picFrame.bottom ;

        pictRect.right = (**aPicH).picFrame.right ;

        OffsetRect(&pictRect, -pictRect.left, -pictRect.top);

        theErr = NewGWorld(&theGWorld, 32, &pictRect, NULL, NULL, 0L) ;

        if( theErr != noErr )

            theGWorld = NULL ;

        else

        {

            CGrafPtr        savedPort ;

            GDHandle        gdh ;

            GetGWorld( &savedPort, &gdh);

            SetGWorld( (CGrafPtr)theGWorld, NULL ) ;

            DrawPicture( aPicH, &theGWorld->portRect ) ;

            SetGWorld( savedPort, gdh);

        }

    }

    return theGWorld ;

}

/*------------------------------------------------------------ */

/*

 * PBNew set up for a new progress bar in a dialog, get all of the info we'll

 * need in order to draw it and allocate a GWorld to composite the Scroll bar.

 */

ProgressBarDlogInfoHdl  PB_New( 

    DialogPtr   thePBDialog, 

    short       thePBItemNumber,

    long        maxValue,

    long        currValue )

{

    ProgressBarDlogInfoHdl  theInfo ;

    /* first make sure we have the requisite pict's loaded */

    if(theStartCap == NULL )

        theStartCap = LoadPictIntoGWorld( kResIDStartCap ) ;

    if(theEndCap == NULL )

        theEndCap = LoadPictIntoGWorld( kResIDEndCap ) ;

    if(theDropShadow == NULL )

        theDropShadow = LoadPictIntoGWorld( kResIDDropShadow ) ;

    theInfo = (ProgressBarDlogInfoHdl)NewHandle(sizeof(ProgressBarDlogInfoData)) ;

    if( theInfo != NULL ) 

    {

        short       itemType ;

        Handle      item ;

        Rect        box ;

        QDErr       theErr ;

        GWorldPtr   theOffscreen ;

        /* stash the other values passed in */

        (**theInfo).thePBDialog = thePBDialog ;         /* reference to the dialog containing the progressbar */

        (**theInfo).thePBItemNumber = thePBItemNumber ; /* the item number in the dialog that is the progress bar */

        (**theInfo).thePBMaxValue = maxValue ;          /* the max value that the progress bar can be */

        (**theInfo).thePBCurrValue = currValue ;        /* current value of the progress bar (usually 0 ) */

        /* get the rect of the given item number in local co-ordinates */

        GetDialogItem(thePBDialog, thePBItemNumber, &itemType, &item, &box) ;

        /* save the box information, we'll use this to draw into */

        (**theInfo).thePBRect.top       = box.top ;

        (**theInfo).thePBRect.left      = box.left ;

        (**theInfo).thePBRect.bottom    = box.bottom ;

        (**theInfo).thePBRect.right     = box.right ;

        OffsetRect( &box, -box.left, -box.top ) ;

        /* make a new GWorld for the progress bar, we composite the PB in here and copy to the screen */

        theErr = NewGWorld( &theOffscreen, 32, &box, NULL, NULL, 0L);

        if( theErr != noErr || theOffscreen == NULL )

        {

            /* we couldn't create the offscree, zero the info rec. */

            DisposeHandle((Handle)theInfo) ;

            theInfo = NULL ;

        }

        else

        {

            (**theInfo).thePBGWorld = theOffscreen ;

        }

    }

    return theInfo ;

}

/*------------------------------------------------------------ */

/*

 * Redraw the progress bar, assumes the caller has just updated the 

 * value in current.

 */

void    PB_Update( ProgressBarDlogInfoHdl theInfo )

{

    CGrafPtr    savedPort ;

    GDHandle    gdh ;

    Rect        theFrame ;

    short       numPixels ;

    Rect        tmpRect ;

    Rect        destRect ;

    HLock((Handle)theInfo) ;

    GetGWorld( &savedPort, &gdh);

    SetGWorld( (CGrafPtr)(**theInfo).thePBGWorld, NULL ) ;

    /* fill the entire rect with the default grey */

    RGBForeColor(&RGBGrey) ;

    PaintRect(&(**theInfo).thePBGWorld->portRect) ;

    /* frame the outline of the progress bar */

    /* copy the rect to the frame rect */

    theFrame.top    = (**theInfo).thePBGWorld->portRect.top ;

    theFrame.left   = (**theInfo).thePBGWorld->portRect.left ;

    theFrame.bottom = (**theInfo).thePBGWorld->portRect.bottom ;

    theFrame.right  = (**theInfo).thePBGWorld->portRect.right ;

    /* how long is the progress part of the progress bar in pixels */

    numPixels = ((float)(**theInfo).thePBCurrValue / (**theInfo).thePBMaxValue ) 

                    * ((**theInfo).thePBGWorld->portRect.right - (**theInfo).thePBGWorld->portRect.left - 2) ;

    /* and inset for the frame */

    InsetRect( &theFrame, 1, 1 ) ;

    RGBForeColor( &RGBBlack ) ;

    FrameRect( &theFrame ) ;

    /* apply highlight to top and left edges (outermost) */

    MoveTo( (**theInfo).thePBGWorld->portRect.left, 

            (**theInfo).thePBGWorld->portRect.bottom - 1) ;

    RGBForeColor( &RGBLtGrey ) ;

    MoveTo( (**theInfo).thePBGWorld->portRect.left, 

            (**theInfo).thePBGWorld->portRect.bottom - 2 ) ;

    RGBForeColor( &RGBMedGrey ) ;

    LineTo( (**theInfo).thePBGWorld->portRect.left, 

            (**theInfo).thePBGWorld->portRect.top );        

    LineTo( (**theInfo).thePBGWorld->portRect.right - 1, 

            (**theInfo).thePBGWorld->portRect.top );

    /* hit the pixel at the top left */     

    RGBForeColor( &RGBLtGrey ) ;

    LineTo( (**theInfo).thePBGWorld->portRect.right, 

            (**theInfo).thePBGWorld->portRect.top );

    /* right and bottom edges */

    RGBForeColor( &RGBWhite ) ;

    MoveTo( (**theInfo).thePBGWorld->portRect.right - 1, 

            (**theInfo).thePBGWorld->portRect.top + 1 ) ;

    LineTo( (**theInfo).thePBGWorld->portRect.right - 1, 

            (**theInfo).thePBGWorld->portRect.bottom - 1);

    LineTo( (**theInfo).thePBGWorld->portRect.left + 1, 

            (**theInfo).thePBGWorld->portRect.bottom - 1);

    /* apply highlight to top and left edges (innermost) */

    MoveTo( (**theInfo).thePBGWorld->portRect.left + 2, 

            (**theInfo).thePBGWorld->portRect.bottom - 3) ;

    RGBForeColor( &RGBDkGrey ) ;

    LineTo( (**theInfo).thePBGWorld->portRect.left + 2, 

            (**theInfo).thePBGWorld->portRect.top + 2 ) ;       

    LineTo( (**theInfo).thePBGWorld->portRect.right - 4, 

            (**theInfo).thePBGWorld->portRect.top + 2) ;

    /* hit the single pixel in the inside corner */

    RGBForeColor( &RGBGrey ) ;

    LineTo( (**theInfo).thePBGWorld->portRect.right - 3, 

            (**theInfo).thePBGWorld->portRect.top + 2) ;

    /* right and bottom */

    RGBForeColor( &RGBLtGrey ) ;

    LineTo( (**theInfo).thePBGWorld->portRect.right - 3, 

            (**theInfo).thePBGWorld->portRect.bottom - 3) ;

    LineTo( (**theInfo).thePBGWorld->portRect.left + 3, 

            (**theInfo).thePBGWorld->portRect.bottom - 3) ;

    RGBForeColor( &RGBBlack ) ;

    /* set up the rect for the progress part of the PB */

    tmpRect.top = theFrame.top ;

    tmpRect.left = theFrame.left  ;

    tmpRect.bottom = theFrame.bottom ;

    tmpRect.right = theFrame.right ;

    InsetRect( & tmpRect, 1, 1 ) ;

    tmpRect.right = theFrame.left + numPixels ;

    /* lock the compositing GWorld for updates */

    LockPixels(GetGWorldPixMap((**theInfo).thePBGWorld)) ;

    /* what do we want to draw today */

    if( numPixels <= 8 )

    {

        /* we don't start doing the 3d effect until we have enough pixels for the

         * start and end caps, so before that just draw a blue rect.

         */

        RGBForeColor( &RGBBlue ) ;

        PaintRect(&tmpRect) ;

        RGBForeColor( &RGBBlack ) ;

    }   

    else

    {

        short startLine = tmpRect.top ;

        /* draw the line gradation */

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBDkBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBMedBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBLtBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBWhite ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBLtBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBMedBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBDkBlue ) ;

        LineTo( tmpRect.right, startLine++) ;

        MoveTo( tmpRect.left, startLine ) ;

        RGBForeColor( &RGBBlack ) ;

        LineTo( tmpRect.right, startLine++) ;

        if( theStartCap != NULL )

        {

            destRect.top = theStartCap->portRect.top ;

            destRect.left = theStartCap->portRect.left ;

            destRect.bottom = theStartCap->portRect.bottom ;

            destRect.right = theStartCap->portRect.right ;

            OffsetRect(&destRect, 2, 2) ;

            LockPixels(GetGWorldPixMap(theStartCap)) ;      

            CopyBits(   (BitMapPtr) &theStartCap->portPixMap, 

                        (BitMapPtr) &(**theInfo).thePBGWorld->portPixMap, 

                        & theStartCap->portRect, 

                        & destRect, 

                        srcCopy, 

                        0L ) ;

            UnlockPixels(GetGWorldPixMap(theStartCap)) ;        

        }

        if( theEndCap != NULL )

        {

            destRect.top = theEndCap->portRect.top ;

            destRect.left = theEndCap->portRect.left ;

            destRect.bottom = theEndCap->portRect.bottom ;

            destRect.right = theEndCap->portRect.right ;

            OffsetRect(&destRect, numPixels + 2 - 6 , 2) ;

            LockPixels(GetGWorldPixMap(theEndCap)) ;        

            CopyBits(   (BitMapPtr) &theEndCap->portPixMap, 

                        (BitMapPtr) &(**theInfo).thePBGWorld->portPixMap, 

                        & theEndCap->portRect, 

                        & destRect, 

                        srcCopy, 

                        0L ) ;

            UnlockPixels(GetGWorldPixMap(theEndCap)) ;      

        }

    }   

    /* handle the drop shadow */

    if( numPixels > 3 && theDropShadow != NULL )

    {

        destRect.top = theDropShadow->portRect.top ;

        destRect.left = theDropShadow->portRect.left ;

        destRect.bottom = theDropShadow->portRect.bottom ;

        destRect.right = theDropShadow->portRect.right ;

        OffsetRect(&destRect, numPixels + 2 - 3, 2) ;

        LockPixels(GetGWorldPixMap(theDropShadow)) ;        

        CopyBits(   (BitMapPtr) &theDropShadow->portPixMap, 

                    (BitMapPtr) &((**theInfo).thePBGWorld->portPixMap), 

                    & theDropShadow->portRect, 

                    & destRect, 

                    srcCopy, 

                    0L ) ;

        UnlockPixels(GetGWorldPixMap(theDropShadow)) ;      

    }

    SetGWorld( savedPort, gdh ) ;

    CopyBits(   (BitMapPtr) &(**theInfo).thePBGWorld->portPixMap, 

                &(**theInfo).thePBDialog->portBits, 

                &(**theInfo).thePBGWorld->portRect, 

                &(**theInfo).thePBRect, 

                srcCopy, 

                0L ) ;

    UnlockPixels(GetGWorldPixMap((**theInfo).thePBGWorld)) ;

    HUnlock((Handle)theInfo) ;

}

/*------------------------------------------------------------ */

/*

 * free up a progress bar info record

 */

void    PB_Delete( ProgressBarDlogInfoHdl theInfo ) 

{

    GWorldPtr   theGWorld ;

    /* dispose of the GWorld associated with the info record */

    if((theGWorld = (**theInfo).thePBGWorld ) != NULL )

        DisposeGWorld( theGWorld ) ;

    /* 

     * dispose of the memory allocated for the picts used to 

     * build the progress bar first make sure we have the 

     * requisite pict's loaded 

     */

    if(theStartCap == NULL )

        DisposeGWorld( theStartCap ) ;

    if(theEndCap == NULL )

        DisposeGWorld( theEndCap ) ;

    if(theDropShadow == NULL )

        DisposeGWorld( theDropShadow ) ;

    /* last of all blow away the info record */

    DisposeHandle((Handle)theInfo) ;

}

/* printing support */

/*---------------------------------------------------------------------*/

/*

 * SetupPrintHdl - This routine returns a default print handle for the 

 * current printer driver.

 *

 * The printer driver is expected to be closed upon entry, and is 

 * therefore opened and closed in this routine.

 */

OSErr SetupPrintHdl(THPrint *hPrint)

{

    OSErr err;

    /*

     * Create a handle, open the printer driver, set the

     * default values for the handle, and close the driver.

     * Be on the lookout for errors.

     */

    *hPrint = (THPrint) NewHandle(sizeof(TPrint));

    if ( *hPrint != nil )

    {

        PrOpen() ;

        err = PrError() ;

        if (err == noErr) 

        {

            PrintDefault( *hPrint ) ;

            err = PrError() ;

        }

        PrClose() ;

    }

    else

        err = MemError() ;

    return err;

}

void DoCreatePrintRecord( DocumentHdl theDocument )

{

    Boolean         changed = false ;

    char            theState = 0 ;

    short           theResRef ;

    FSSpec          theFile ;

    /*  create a new print record */

    theState = HGetState( (Handle)theDocument ) ;

    MoveHHi( (Handle)theDocument ) ;

    HLock( (Handle)theDocument ) ;

    if(SetupPrintHdl( &(**theDocument).fPrintRec ) == noErr) 

    {       

        /*  check we have a "good" print record */

        changed = PrValidate( (**theDocument).fPrintRec ) ;

    }

    HSetState( (Handle)theDocument, theState ) ;

}

/* ---------------------------------------------------------------------------------- */

OSErr DoStyleDlog(THPrint hPrint)

{

    OSErr   err = noErr ;

    Boolean changed = false ;

    PrOpen() ;

    if((err = PrError()) == noErr ) {

        changed = PrStlDialog(hPrint);

        err = PrError();

        if (!err && !changed) err = iPrAbort;

    }

    PrClose();

    return err;

}

/* ---------------------------------------------------------------------------------- */

OSErr DoJobDlog(THPrint hPrint)

{

    OSErr   err = noErr ;

    Boolean changed = false ;

    PrOpen() ;

    if((err = PrError()) == noErr ) {

        changed = PrJobDialog(hPrint);

        err = PrError();

        if (!err && !changed) err = iPrAbort;

    }

    PrClose();

    return err;

}

/* ---------------------------------------------------------------------------------- */

/*   CommandPeriod - This routine checks to see if the user has */

/*   pressed command-period.  The Printing Manager does this */

/*   for us, but a routine like this is helpful to allow users */

/*   to cancel in the middle of a rendering routine, rather */

/*   than only Printing Manager operations. */

/*    */

/*   If there's a command-period in the event queue, the */

/*   routine returns iPrAbort just like the Printing Manager. */

/*   Otherwise, it returns noErr. */

OSErr CommandPeriod()

{

    Boolean     cancel = false;

    EventRecord evtRec;

    while (!cancel && (WaitNextEvent(keyDownMask | autoKeyMask, &evtRec, 0, nil)))

        cancel = (evtRec.modifiers & cmdKey) &&

                 ((evtRec.message & charCodeMask) == '.');

    return ((cancel)? iPrAbort: noErr);

}

/* ---------------------------------------------------------------------------------- */

/*  IdleProc - This routine is a PrIdleProcPtr that spins our */

/*   cursor and looks for command-period presses during */

/*   printing. */

pascal void IdleProc()

{

    OSErr       err;

//  BumpCursor();

    if (err = CommandPeriod()) 

        PrSetError(err);

}

/* ---------------------------------------------------------------------------------- */

short   GeneralCountPages( 

    GWorldPtr   theGWorld, 

    Rect        *pageRect ) 

{

    Rect            pictRect ;

    short           horizOffset, 

                    vertOffset,

                    pagesWide = 0,  /*  the number of pages wide the image is */

                    pagesHigh = 0,  /*  the number pages high for this image */

                    pageWidth,      /*  the width of one page */

                    pageHeight ;    /*  the height of one page */

    DocumentHdl     theDocumentHdl ;

    PictDataHdl     thePictDataHdl ;

    OSErr           theErr ;

    pictRect = theGWorld->portRect ;

    horizOffset = -(pictRect.left) ;

    vertOffset = -(pictRect.top) ;

    OffsetRect( &pictRect, horizOffset, vertOffset ) ;  /*  this should make the origin of the rect (0,0) */

    pageWidth = pageRect->right - pageRect->left ;

    pageHeight = pageRect->bottom - pageRect->top ;

    pagesWide = (1.0 + pictRect.right / pageWidth ) ;   /*  round up the number of pages to the nearest */

    pagesHigh = (1.0 + pictRect.top  / pageHeight ) ;   /*  whole page in each direction. */

    return pagesWide * pagesHigh ;

}

/* ---------------------------------------------------------------------------------- */

void    GeneralPrintPage( 

    GWorldPtr       theGWorld, 

    Rect            *pageRect, 

    GrafPtr         imagingPort, 

    short           pageNum ) 

{

    GWorldPtr       docGWorld;

    Rect            pictRect, rectToPrint,srcRect,dstRect;

    short           pagesWide,      /*  the number of pages wide the image is */

                    pagesHigh,      /*  the number pages high for this image */

                    horozTile,      /*  used in the loop to denote the H tile to print from the image */

                    vertTile ;      /*  used in the loop to denote the V tile to print from the image */

    short           thisPage = 1;   /*  used to find the page they want us to print */

    short           pictHOff,

                    pictVOff,

                    pictWidth,      /*  the width of the doc's GWorld */

                    pictHeight ;    /*  the height of the doc's GWorld */

    short           pageWidth,      /*  the width of one page */

                    pageHeight ;    /*  the height of one page */

    DocumentHdl     theDocumentHdl ;

    PictDataHdl     thePictDataHdl ;

    OSErr           theErr ;

    PixMapHandle    offPixMap ;

    pictRect = theGWorld->portRect ;

    SetPort( imagingPort ) ;

    pictHOff   = -(pictRect.left) ;

    pictVOff   = -(pictRect.top) ;

    pictWidth  = pictRect.right - pictRect.left ;

    pictHeight = pictRect.bottom - pictRect.top ;

    pageWidth = pageRect->right - pageRect->left ;

    pageHeight = pageRect->bottom - pageRect->top ;

    pagesWide = (1.0 + pictWidth  / pageWidth  ) ;  /*  round up the number of pages to the nearest */

    pagesHigh = (1.0 + pictHeight / pageHeight ) ;  /*  whole page in each direction. */

    thisPage = 1;

    for (vertTile=0; vertTile<pagesHigh; vertTile++)

    {

        for (horozTile=0; horozTile<pagesWide; horozTile++)

        {

            /*  check this is the page we were called to print */

            if( thisPage == pageNum )

            {

                srcRect = *pageRect;

                OffsetRect( &srcRect,

                            pictRect.left - srcRect.left,

                            pictRect.top  - srcRect.top );

                OffsetRect( &srcRect,

                            horozTile * pageWidth,

                            vertTile * pageHeight );

                SectRect( &srcRect, &pictRect, &srcRect);

                /*  finess the rect to print, we'll assume the the top left is always correct. */

                /*  this helps with areas of the pict that don't fit entirely on one sheet of */

                /*  paper */

                dstRect = srcRect;

                OffsetRect( &dstRect,

                            pageRect->left - srcRect.left,

                            pageRect->top  - srcRect.top );

                ClipRect( &dstRect ) ;

                /* get the gworld pixmap and lock it down */

                offPixMap = GetGWorldPixMap( theGWorld ) ;

                (void) LockPixels( offPixMap ) ;

                /* copy from the gWorld Image to the window's port */

                CopyBits( (BitMap *) *offPixMap,

                          &imagingPort->portBits,

                          &srcRect,                         

                          &dstRect,

                          srcCopy,

                          nil ) ;

                /* unlock the pixmap */

                (void) UnlockPixels( offPixMap ) ;

            }

            /*  bump the page number */

            thisPage++ ;

        }

    }

}

/* ---------------------------------------------------------------------------------- */

OSErr DoPrintLoop( WindowPtr    theWindow ) 

{

    short               savedResFile = CurResFile() ;

    GrafPtr             savedPort ;

    TPPrPort            printingPort ;

    OSErr               theErr = noErr ;

    THPrint             thePrintRec  ;

    PrIdleUPP           myIdleProc = NewPrIdleProc(IdleProc) ;

    DocumentHdl         theDocumentHdl ;

    CountPagesProc      countPagesP ;

    PrintPageProc       printPageP ;

    theDocumentHdl = (DocumentHdl)GetWRefCon(theWindow) ;

    if(theDocumentHdl != NULL)

    {

        thePrintRec = (**theDocumentHdl).fPrintRec ; 

        GetPort( &savedPort ) ;

        PrOpen() ;

        if( (theErr = PrError()) == noErr ) {

            short   numCopies = (**thePrintRec).prJob.iCopies ;

            short   firstPage = (**thePrintRec).prJob.iFstPage ;    /*  save the first page */

            short   lastPage = (**thePrintRec).prJob.iLstPage;      /*  save the last page */

            short   copies, pageNum ;

            (**thePrintRec).prJob.iFstPage = 1 ;            /*  reset to 1 */

            (**thePrintRec).prJob.iLstPage = iPrPgMax ; /*  reset to maximum */

            /*  we don't assign this directly because NewPrIdleProc may move memory, */

            /*  so assign to an intermediate - myIdleProc */

            (**thePrintRec).prJob.pIdleProc =  myIdleProc; /*  install the cursor spinning idle proc */

            /*

             * since the count pages function is dereferenced by a pointer we have two choices,

             * either lock the handle, or copy the function pointer.

             */

            countPagesP = (**theDocumentHdl).procs->countPagesP ;

            /* if there is one, call the save handling proc with this window */

            if( countPagesP )

                lastPage = (*countPagesP)( theWindow, &(**thePrintRec).prInfo.rPage ) ;

            for( copies = 1; copies <= numCopies ; copies++ ) {

                printingPort = PrOpenDoc( thePrintRec, nil, nil ) ;

                SetPort( (GrafPtr)printingPort ) ;

                if((theErr = PrError()) == noErr ) {

                    for( pageNum = firstPage; pageNum <= lastPage; pageNum++ ) {

                        PrOpenPage( printingPort, nil ) ;

                        if((theErr = PrError()) == noErr ) {

                            /*

                             * since the print page function is dereferenced by a pointer 

                             * we have two choices, either lock the handle, or copy the 

                             * function pointer.

                             */

                            printPageP = (**theDocumentHdl).procs->printPageP ;

                            /*  image the page */

                            if( printPageP )

                                (*printPageP)( theWindow,  &(**thePrintRec).prInfo.rPage, (GrafPtr)printingPort, pageNum  ) ;

                            PrClosePage(printingPort) ;

                        }

                    }

                    if( (theErr = PrError()) == noErr ) {

                        TPrStatus       theStatus ;

                        PrCloseDoc(printingPort) ;

                        theErr = PrError() ;

                        /*  if we're printing to our good friend the ImageWriter, or similar, despool */

                        if( theErr == noErr && ((**thePrintRec).prJob.bJDocLoop == bSpoolLoop))

                            PrPicFile( thePrintRec, nil, nil, nil, &theStatus ) ; 

                    }

                }

            }

        }

        PrClose() ;

        DisposeRoutineDescriptor((UniversalProcPtr)myIdleProc) ;

        SetPort( savedPort ) ;

    }

    return theErr ;

}

/*------------------------------------------------------------ */

/*

 * called to register our AppleEvent handlers.

 *

 * Should really have some error handling in here.

 */

void RegisterRequiredAppleEventHandlers(void)

{

    OSErr               theError;

    ProcessSerialNumber myApplicationPSN;           /* This application's psn  */

    /* Set up a self-addressed descriptor record.  */

    myApplicationPSN.highLongOfPSN = 0;

    myApplicationPSN.lowLongOfPSN = kCurrentProcess ;

    theError = AECreateDesc(typeProcessSerialNumber,

                            (Ptr)&myApplicationPSN,

                            sizeof(ProcessSerialNumber),

                            &gSelfAddress);

    if (theError!=noErr)

        return;

    theError = AEInstallEventHandler(   kCoreEventClass,

                                        kAEOpenApplication,

                                        NewAEEventHandlerProc(HandleCoreAppleEventOfTypeOAPP),

                                        0L,

                                        false);

    if (theError!=noErr)

        return;

    theError = AEInstallEventHandler(   kCoreEventClass,

                                        kAEOpenDocuments,

                                        NewAEEventHandlerProc(HandleCoreAppleEventOfTypeODOC),

                                        0L,

                                        false);

    if (theError!=noErr)

        return;

    theError = AEInstallEventHandler(   kCoreEventClass,

                                        kAEPrintDocuments,

                                        NewAEEventHandlerProc(HandleCoreAppleEventOfTypePDOC),

                                        0L,

                                        false);

    if (theError!=noErr)

        return;

    theError = AEInstallEventHandler(   kCoreEventClass,

                                        kAEQuitApplication,

                                        NewAEEventHandlerProc(HandleCoreAppleEventOfTypeQUIT),

                                        0L,

                                        false);

    if (theError!=noErr)

        return;

}

/*------------------------------------------------------------ */

/*

 * open application theEventRecord handler for the core theEventRecord suite, 

 * by default we just want a blank new document

 */

pascal OSErr HandleCoreAppleEventOfTypeOAPP( AppleEvent *theAppleEvent, AppleEvent *theAppleEventReply, long userDefinedReferenceConstant)

{

    /*

     * we don't actually do anything on open - you could,

     * for example you might want to open a blank untitled 

     * theWindow

     */

    OSErr theError = noErr ;

    return theError;

}

/*------------------------------------------------------------ */

/*

 * handler for the open document AppleEvent handler

 */

pascal OSErr HandleCoreAppleEventOfTypeODOC(AppleEvent *theAppleEvent, AppleEvent *theAppleEventReply, long userDefinedReferenceConstant)

{

    FSSpec      theFileSpec;

    AEDescList  theDocumentList;

    OSErr       theError,

                theIgnoredError;

    long        myTempIndex,

                numberOfItemsInList;

    Size        actualSize;

    AEKeyword   theAEKeyword;

    DescType    theDescriptorType;

    theError = AEGetParamDesc(theAppleEvent,keyDirectObject,typeAEList,&theDocumentList);

    if (theError == noErr) {

        /*

         * see how many descriptor items are in the list

         * this is the number of documents we want to open

         */

        theError = AECountItems(&theDocumentList,&numberOfItemsInList);

        /*

         * now get each descriptor record from the list

         * coerce the returned data to an FSSpec record, and

         * open the asoociated file

         */

        for (myTempIndex=1; myTempIndex <= numberOfItemsInList && theError == noErr; myTempIndex++) {

            theError = AEGetNthPtr( &theDocumentList, 

                                    myTempIndex,

                                    typeFSS,

                                    &theAEKeyword,

                                    &theDescriptorType,

                                    (Ptr)&theFileSpec,

                                    sizeof(theFileSpec),

                                    &actualSize);

            if (theError == noErr)  {

                FInfo       fndrInfo ;

                /*

                 * we now have a valid FSSpec to reference the file, we need to know 

                 * what type the file is to determine which file open function to call

                 * we can determine this from the finder info for the file

                 */

                theError = FSpGetFInfo( &theFileSpec, &fndrInfo );  

                /*

                 * if we got that ok, then we switch on the file  

                 * type (we don't care about the creator type)  

                 */

                if (theError == noErr)  {

                    switch( fndrInfo.fdType ) {

                        case 'TEXT':    /* your app should NOT really open text files since

                                         * they may not be of type 3DMF, this is here for 

                                         * debugging, note that the standard file dlog will

                                         * not allow you to open TEXT files.

                                         */

                        case '3DMF':

                            ViewerWindow_Open( &theFileSpec );

                            break ;

                    }

                }

            }

        }

        theIgnoredError = AEDisposeDesc(&theDocumentList);

    }

    return theError ;

}

/*------------------------------------------------------------ */

/*

 * handler for the print document theEventRecord handler

 */

pascal OSErr HandleCoreAppleEventOfTypePDOC(AppleEvent *theAppleEvent,AppleEvent *theAppleEventReply,long userDefinedReferenceConstant)

{

    FSSpec      theFileSpec;

    AEDescList  theDocumentList;

    OSErr       theError;

    long        myTempIndex,

                numberOfItemsInList;

    Size        actualSize;

    AEKeyword   theAEKeyword;

    DescType    theDescriptorType;

    theError = AEGetParamDesc(theAppleEvent,keyDirectObject,typeAEList,&theDocumentList);

    if (theError == noErr) {    

        /*

         * see how many descriptor items are in the list

         * this is the number of documents we want to print

         */

        theError = AECountItems(&theDocumentList,&numberOfItemsInList);

        /*

         * now get each descriptor record from the list

         * coerce the returned data to an FSSpec record, and

         * print the asoociated file

         */

        for (myTempIndex=1; myTempIndex <= numberOfItemsInList && theError == noErr; myTempIndex++) {

            theError = AEGetNthPtr( &theDocumentList, 

                                myTempIndex,

                                typeFSS,

                                &theAEKeyword,

                                &theDescriptorType,

                                (Ptr)&theFileSpec,

                                sizeof(theFileSpec),

                                &actualSize);

            if (theError == noErr)  {   

                /*

                 * if the app handles printing then you could do 

                 * something like: theError = HandlePrintDoc( &theFileSpec );

                 */

                theError = errAEEventNotHandled ;

            }

        }

        theError = AEDisposeDesc(&theDocumentList);

    }

    return theError ;

}

/*------------------------------------------------------------ */

/*

 * Quit AppleEvent handler

 */

pascal OSErr HandleCoreAppleEventOfTypeQUIT(AppleEvent *theAppleEvent,AppleEvent *theAppleEventReply,long userDefinedReferenceConstant)

{

    OSErr           theError = noErr ;      /* this is used as the return value  */

    theError = HandleFileQuitItem() ;

    return theError ;

}