home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 August: Tool Chest / Dev.CD Aug 00 TC Disk 2.toast / pc / sample code / interapplication comm / menuscripter / sources / msscript.c < prev    next >
Encoding:
Text File  |  2000-06-23  |  56.6 KB  |  2,138 lines
  1. // MSScript.c
  2. //
  3. // Original version by Jon Lansdell and Nigel Humphreys.
  4. // 4.0 and 3.1 updates by Greg Sutton.
  5. // Human Interface changes and GX Printing by Don Swatman
  6. // ©Apple Computer Inc 1996, all rights reserved.
  7.  
  8.  
  9. #include <Memory.h>
  10. #include <Resources.h>
  11. #include <TextEdit.h>
  12. #include <Controls.h>
  13. #include <Dialogs.h>
  14. #include <Errors.h>
  15. #include <Files.h>
  16. #include <Folders.h>
  17. #include <Components.h>
  18. #include <AppleEvents.h>
  19. #include <AppleScript.h>
  20. #include <AERegistry.h>
  21. #include <ASRegistry.h>
  22. #include <ASDebugging.h>
  23. #include <Processes.h>
  24.  
  25. #include "MSScript.h"
  26.  
  27. #include "MSUtils.h"
  28. #include "MSAEUtils.h"
  29. #include "MSAETextUtils.h"
  30. #include "MSAEMenuUtils.h"
  31. #include "MSWindow.h"
  32. #include "MSAESetData.h"
  33. #include "MSAEGetData.h"
  34. #include "MSResultWind.h"
  35. #include "MSAEDelete.h"
  36. #include "MSASSubroutines.h"
  37. #include "MSMain.h"
  38. #include "MSAEWindowUtils.h"
  39. #include "MSAERecording.h"
  40.  
  41. /*
  42.     Each menu (or menu item) can have a script associated with it. This
  43.     script has an ID equal to 32 * theMenuID + theItem number. A script
  44.     with an item number of 0 applies to the whole menu unless it is 
  45.     overridden by a particular script for an item in the menu.
  46.     
  47.     Scripts are stored in two resource types
  48.         'scpt' is a compiled script as returned by OSAStore()
  49.         'SCPT' is a raw text script as defined in the resource file
  50.         
  51.     At open application time scripts are built from the 'SCPT' resources 
  52.     if there are not any existing complied scripts of that resource ID.
  53.     These are stored in the preferences file for the application.
  54.     
  55.     One problem with the scripted menu commands is that if the application
  56.     name is changed the target is no longer found. This may be addressed later.
  57. */
  58.  
  59.  
  60.     // Constants
  61. #define kMaxScriptsInApp        100
  62. #define kCompiledScriptType        kOSAScriptResourceType
  63. #define kTextScriptType            'SCPT'
  64.  
  65. const short    kLaunchScriptID            = 128;
  66. const short    kApplicationScriptID    = 200;
  67. const short    kResultsScriptID        = 300;
  68. const short kPleaseWaitStart        = 1006;
  69. const short kPleaseWaitEnd            = 1007;
  70.  
  71. const short kEscapeKey                = 27;
  72. const short kEndOfTextKey            = 3;
  73.  
  74. const short    MenuScriptEditor        = 400;
  75.  
  76. const Str31    kPrefFileName            = "\pMenuScripter Prefs";
  77.  
  78.     // Prototypes
  79. pascal OSErr        MySendProc(const AppleEvent*    theAppleEvent,
  80.                                     AppleEvent*        reply,
  81.                                     AESendMode         sendMode,
  82.                                     AESendPriority     sendPriority,
  83.                                     long            timeOutInTicks,
  84.                                     AEIdleUPP        idleProc,
  85.                                     AEFilterUPP        filterProc,
  86.                                     long            refCon);
  87. pascal OSErr        StdActiveProc( long refCon );
  88.  
  89. static OSAID        GetScriptIDForResID( short lookForID );
  90. OSErr                OpenPreferencesResourceFile(short *theRefNum);
  91. OSErr                ClosePreferencesResourceFile( short theRefNum );
  92. void                AddMenuScript( short theResID, OSAID theScriptID, Boolean fChanged );
  93. OSErr                LoadApplicationScripts( void );
  94. OSErr                StoreApplicationScripts( void );
  95. OSErr                BuildMenuScripts( void );
  96. OSErr                StoreMenuScripts( void );
  97. Boolean                ScriptHasProperties( OSAID theScriptID );
  98. static void            SetUpUniversalProcedures( void );
  99. static DialogPtr    PoseWaitDialog( short theDialogID );
  100. void                DisplayErrorInScript( TEHandle theHTE );
  101.  
  102. pascal void            DrawGrowBoxItem( DialogPtr theDialog, short theItem );
  103. pascal void            DrawStyledTextEditRec( DialogPtr theDialog, short theItem );
  104. pascal void         DrawScrollBar( DialogPtr theDialog, short theItem );
  105. pascal void            ScrollVActionProc( ControlHandle control, short part );
  106. pascal Boolean        MyFilterProc( DialogPtr theDialog, EventRecord *myEvent, short *itemHit );
  107.  
  108. void                 MoveCustTextEditItem( DialogPtr theDialog, short theItem,
  109.                                                     short deltaW, short deltaH );
  110. void                 MoveScrollBarItem( DialogPtr theDialog, short theItem,
  111.                                                     short deltaW, short deltaH );
  112. void                 MoveOneDialogControlItem( DialogPtr theDialog, short theItem,
  113.                                                      short deltaW, short deltaH );
  114. void                 MoveOneDialogItem( DialogPtr theDialog, short theItem,
  115.                                                      short deltaW, short deltaH );
  116.  
  117.  
  118. void                 SetDrawProcForUserItem( DialogPtr theDialog,
  119.                                     short theItem, ControlActionUPP theProc );
  120. void                FlashButton( DialogPtr theDialog, short theItem );
  121. void                TrackTEPosn( ControlHandle theControl, TEHandle theHTE );
  122. void                SetScrollLimit( ControlHandle newScroll, TEHandle theHTE );
  123. Boolean                DoDialogMenu ( long menuResult, TEHandle theTE );
  124.  
  125. OSErr                SetMenuScript( short theResID, OSAID theScriptID );
  126. void                 SetMenuForDialog( void );
  127. void                 ReSetMenuForDialog( void );
  128.  
  129. pascal OSErr        EventPrehandler( AppleEvent *theEvent, AppleEvent *theReply, long theRefcon );
  130. Boolean                CanScriptEvent( AEEventClass theClass, AEEventID theID, AppleEvent* theEvent );
  131. void                AddMissingParameter( AEKeyword theAEKeyword, DescType theType,
  132.                                             Ptr theData, Size theDataSize, AppleEvent* theEvent );
  133. OSErr                DoScriptEvent( AppleEvent            *theEvent, 
  134.                                     AppleEvent            *theReply, 
  135.                                     OSAID                theScriptID );
  136. static OSErr        GetTokenDescScript( AEDesc* theTokenDesc, OSAID* theOSAID );
  137.  
  138.     // Globals
  139. extern short        gRefNum;
  140.  
  141. ComponentInstance    gScriptingComponent;
  142. short                gActiveMenuItem;
  143. OSASendUPP            oldSendProc;
  144. long                refCon;
  145. MenuScriptRecPtr    gMenuScripts;
  146. short                gNumScripts;
  147. short                gPrefsRefFile;
  148. OSAActiveUPP        gOSAActiveUPP;
  149. Boolean                gEditingScript; // Is the script editing dialog up?
  150.  
  151. ControlActionUPP    gScrollScriptVActionUPP;
  152. ControlActionUPP    gDrawStyledTextUPP;
  153. ControlActionUPP    gDrawScrollBarUPP;
  154. ControlActionUPP    gDrawGrowBoxUPP;
  155.  
  156.  
  157. //    These are used in documentation but not defined in the interfaces
  158.  
  159. #ifndef kComponentNotFound
  160.     #define kComponentNotFound    -1
  161. #endif
  162.  
  163.  
  164. pascal OSErr MySendProc(const AppleEvent*    theAppleEvent,
  165.                             AppleEvent*        reply,
  166.                             AESendMode         sendMode,
  167.                             AESendPriority     sendPriority,
  168.                             long            timeOutInTicks,
  169.                             AEIdleUPP        idleProc,
  170.                             AEFilterUPP        filterProc,
  171.                             long            refCon)
  172. { 
  173. #ifdef __MWERKS__
  174.     #pragma unused(refCon)
  175. #endif
  176.  
  177.     DescType     typeCode;
  178.     Size         descSize;
  179.     OSErr        myErr;
  180.     OSErr        ignoreErr;
  181.     OSType       whatEvent;
  182.     AppleEvent   myCopyAEvt;
  183.     
  184.     myErr = AEDuplicateDesc( theAppleEvent, &myCopyAEvt );
  185.  
  186.     myErr = AEGetAttributePtr(&myCopyAEvt, keyEventIDAttr, typeType, &typeCode, 
  187.                                     (Ptr)&whatEvent, sizeof(whatEvent), &descSize );
  188.                                                         
  189.     ignoreErr = AEDisposeDesc( &myCopyAEvt );
  190.     
  191.     if (myErr != noErr) whatEvent = 0x3F3F3F3F;
  192.     
  193.     //    Record the final Set Data that occurs due to a script
  194.     //    'gdte' = id sent to get 'aete' resource from app, dealt with
  195.     //    by system handler.
  196.  
  197.     if ( ( sendMode & kAEDontRecord ) && 
  198.             ( ( whatEvent != kAEGetData ) && ( whatEvent != kGetAETE ) ) )
  199.         sendMode = sendMode - kAEDontRecord;
  200.         
  201.     /* will be this when a5 bug fixed    // =Jon=
  202.     return((*oldSendProc)(theAppleEvent,
  203.                                  reply,
  204.                                  sendMode,
  205.                                  sendPriority,
  206.                                  timeOutInTicks,
  207.                                  idleProc,
  208.                                  filterProc,
  209.                                  refCon));
  210.     */
  211.     
  212.     return( AESend( theAppleEvent, reply, sendMode, sendPriority,
  213.                                 timeOutInTicks, idleProc, filterProc ) );                            
  214. }    // MySendProc
  215.  
  216.  
  217. // Our activeProc is called at various times during script execution and compilation
  218. // we use this to detect when the application is being sent to the background. This can happen
  219. // when a script is targetted to another application, causing this application to be
  220. // brought to the front. Since HiliteMenu(0) is called when the menu command has completed - and
  221. // this will be called when the script has completed, we must ensure that the application is
  222. // in the foreground when HiliteMenu is called. Otherwise the menu bar gets drawn over the frontmost
  223. // application, which is not what we want.
  224.  
  225. pascal OSErr StdActiveProc( long refCon )
  226. {
  227. #ifdef __MWERKS__
  228.     #pragma unused(refCon)
  229. #endif
  230.  
  231.       // Call WaitnextEvent() to get suspend event
  232.     EventRecord myEvent;
  233.  
  234.     if ( ! gEditingScript )
  235.     {
  236.         if ( WaitNextEvent( everyEvent, &myEvent, 0, NULL ) )
  237.         {
  238.             switch ( myEvent.what )
  239.             {
  240.                 case osEvt:
  241.                     HiliteMenu( 0 );// Don't call HiliteMenu in the background 
  242.                                     // so clear it before we switch to the background
  243.                     
  244.                     if ( ( myEvent.message >> 24 ) & suspendResumeMessage )    // suspend or resume
  245.                     {
  246.                         gInBackground = ( ( myEvent.message & resumeFlag ) == 0);
  247.                         DoActivate( FrontWindow( ), ! gInBackground );
  248.                     }
  249.                     break;
  250.             }
  251.         }
  252.     }
  253.  
  254.         // Now call the standard ActiveProc
  255.     return ( CallOSAActiveProc( gOSAActiveUPP,0 ) );
  256. }
  257.  
  258.     
  259. static OSAID    GetScriptIDForResID( short lookForID )
  260. {
  261.     short    index;
  262.     
  263.     for ( index = 0; index < gNumScripts; index++ )
  264.     {
  265.         if ( gMenuScripts[index].theResID == lookForID )
  266.             return gMenuScripts[index].theScriptID;
  267.     }
  268.         
  269.     return kOSANullScript;
  270. }
  271.     
  272. MenuScriptRecPtr    GetMenuScriptRecPtr( short theResID )
  273. {
  274.     short    index;
  275.     
  276.     for ( index = 0; index < gNumScripts; index++ )
  277.     {
  278.         if ( gMenuScripts[index].theResID == theResID )
  279.             return &gMenuScripts[index];
  280.     }
  281.         
  282.     return NULL;
  283. }
  284.     
  285.  
  286. //    Name : OpenPreferencesResourceFile
  287. //    Purpose : Opens the prefs file, in the system prefs folder
  288. //                creating it if it is not found. Sets the current
  289. //                resource file to the prefs file so that resources
  290. //                will be read from there in preference to the app
  291. //                if they have been overridden, and new resources
  292. //                will be created in it.
  293.     
  294. OSErr    OpenPreferencesResourceFile(short *theRefNum)
  295. {
  296.     short  foundVRefNum;
  297.     long   foundDirID;
  298.     OSErr  myErr;
  299.     
  300.     myErr = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  301.                                                      &foundVRefNum, &foundDirID);
  302.                                          
  303.     if (myErr==noErr)
  304.     {
  305.  
  306.         *theRefNum = HOpenResFile(foundVRefNum, foundDirID, kPrefFileName, fsWrPerm);
  307.         myErr = ResError();
  308.         
  309.         if (myErr==fnfErr)
  310.         {
  311.             HCreateResFile(foundVRefNum, foundDirID, kPrefFileName);
  312.             myErr = ResError();
  313.  
  314.             *theRefNum = HOpenResFile(foundVRefNum, foundDirID, kPrefFileName, fsWrPerm);
  315.             myErr = ResError();
  316.         }
  317.     }
  318.  
  319.     return(myErr);
  320. }
  321.     
  322. OSErr    ClosePreferencesResourceFile( short theRefNum )
  323. {
  324.     CloseResFile( theRefNum );
  325.     return( ResError( ) );
  326. }
  327.  
  328.  
  329. //    Name : AddMenuScript
  330. //    Purpose : Adds a compiled script OSAID into the
  331. //              global gMenuScripts array for later access
  332.  
  333. void    AddMenuScript( short theResID, OSAID theScriptID, Boolean fChanged )
  334. {
  335.     if ( gNumScripts < kMaxScriptsInApp )
  336.     {
  337.         gMenuScripts[gNumScripts].theResID = theResID;
  338.         gMenuScripts[gNumScripts].theScriptID = theScriptID;
  339.         gMenuScripts[gNumScripts].fChanged = fChanged;
  340.         gNumScripts++;
  341.         
  342.         (void)CheckForMenuItemName( theResID, theScriptID );
  343.     }
  344. }
  345.  
  346.  
  347. //    Name : BuildMenuScripts
  348. //    Purpose : Reads compiled scripts from the prefs file,
  349. //              Any uncompiled scripts ('SCPT' resources with
  350. //               no 'scpt' of same id are compiled. Any which fail
  351. //               to compile are ignored. Changed scripts are stored
  352. //               in the preferences file on quit.
  353.  
  354. OSErr    BuildMenuScripts( void )
  355. {
  356.     short        aScriptCount,
  357.                 index,
  358.                 anID;
  359.     ResType     aResType;
  360.     Str255        aResName;
  361.     Handle        aScript;
  362.     AEDesc        aScriptDesc = { typeNull, NULL };
  363.     OSAID        aScriptID = kOSANullScript;
  364.     OSErr        anErr;
  365.     
  366.     gNumScripts = 0;
  367.     
  368.     gMenuScripts = (MenuScriptRecord *)NewPtr( sizeof( MenuScriptRecord ) * kMaxScriptsInApp );
  369.     
  370.         // Firstly load all the 'scpt' scripts stored in the preferences file,
  371.         //  these scripts may be customised by the user.
  372.     aScriptCount = Count1Resources( kCompiledScriptType );
  373.     for ( index = 1 ; index <= aScriptCount ; index++ )
  374.     {
  375.         aScript = Get1IndResource( kCompiledScriptType, index );
  376.         GetResInfo( aScript, &anID, &aResType, aResName );
  377.         anErr = ResError( );
  378.         if ( noErr != anErr ) goto done;
  379.         
  380.         HLock( aScript );
  381.         anErr = AECreateDesc( typeOSAGenericStorage, (Ptr)*aScript,
  382.                                     GetHandleSize( aScript ), &aScriptDesc );
  383.         HUnlock( aScript );
  384.         ReleaseResource( aScript );
  385.         if ( noErr != anErr ) goto done;    // This shouldn't happen
  386.         
  387.         aScriptID = kOSANullScript;
  388.         anErr = OSALoad( gScriptingComponent, &aScriptDesc, kOSAModeNull, &aScriptID );
  389.         
  390.         if ( noErr == anErr )
  391.             AddMenuScript( anID, aScriptID, false );
  392.         
  393.         (void)AEDisposeDesc( &aScriptDesc );
  394.     }
  395.         
  396.         // Next load and compile any of the text based scripts, 'SCPT', that 
  397.         //  have no equivalent 'scpt' in the preferences file.
  398.     aScriptCount = CountResources( kTextScriptType );
  399.     for ( index = 1; index <= aScriptCount; index++ )
  400.     {
  401.         aScript = GetIndResource( kTextScriptType, index );
  402.         GetResInfo( aScript, &anID, &aResType, aResName );
  403.         anErr = ResError( );
  404.         if ( noErr != anErr ) goto done;
  405.         
  406.         if ( GetScriptIDForResID( anID ) == kOSANullScript )
  407.         {
  408.                     // Stored as a C string so knock off NULL terninator
  409.             HLock( aScript );
  410.             anErr = AECreateDesc( typeChar, (Ptr)*aScript,
  411.                                     GetHandleSize( aScript ) - 1, &aScriptDesc );
  412.             HUnlock( aScript );
  413.             ReleaseResource( aScript );
  414.             if ( noErr != anErr ) goto done;    // This shouldn't happen
  415.             
  416.             aScriptID = kOSANullScript;
  417.             anErr = OSACompile( gScriptingComponent, &aScriptDesc,
  418.                                     kOSAModeCompileIntoContext, &aScriptID );
  419.                                                 
  420.             if ( noErr == anErr )
  421.                 AddMenuScript( anID, aScriptID, true );    // We need to save this script
  422.                                                         //  so set fChanged to true.
  423.             (void)AEDisposeDesc( &aScriptDesc );
  424.         }
  425.     }
  426.     
  427. done:
  428.     return anErr;
  429. }
  430.  
  431. // This checks to see if a script contains
  432. //  properties. These could change in the script and therefore
  433. //  the script needs to be stored for the next
  434. //  time the application is launched.
  435.  
  436. Boolean    ScriptHasProperties( OSAID theScriptID )
  437. {
  438.     AEDescList    resultingPropertyNames = { typeNull, NULL };
  439.     long        aCount = 0;
  440.     OSErr        anErr;
  441.     Boolean        aResult = true;
  442.  
  443.         // OSAGetPropertyNames() returns typeChar descriptors of
  444.         //  all the properties in a script.
  445.     anErr = OSAGetPropertyNames( gScriptingComponent, kOSAModeNull, 
  446.                         theScriptID, &resultingPropertyNames );
  447.  
  448.     if ( noErr != anErr )
  449.     {
  450.         aResult = false;
  451.         goto done;
  452.     }
  453.     
  454.     anErr = AECountItems( &resultingPropertyNames, &aCount );
  455.     
  456.     if ( noErr != anErr || aCount == 0 )
  457.         aResult = false;
  458.     
  459. done:
  460.     (void)AEDisposeDesc( &resultingPropertyNames );
  461.  
  462.     return aResult;
  463. }
  464.  
  465. OSErr    StoreMenuScripts( void )
  466. {
  467.     short        index;
  468.     OSErr        anErr;
  469.     
  470.     for ( index = 0; index < gNumScripts; index++ )
  471.     {
  472.             // If there are properties or it
  473.             //  has changed then store the script
  474.         if ( gMenuScripts[index].fChanged
  475.                 || ScriptHasProperties( gMenuScripts[index].theScriptID ) )
  476.         {
  477.             anErr = StoreScriptToResFileRef( gPrefsRefFile, gMenuScripts[index].theResID,
  478.                                                         gMenuScripts[index].theScriptID, "\p" );
  479.         }
  480.     }
  481.         
  482.     return anErr;
  483. }
  484.  
  485.  
  486. OSErr    LoadApplicationScripts( void )
  487. {
  488.     OSAID    aScriptID = kOSANullScript,
  489.             aResultID = kOSANullScript;
  490.     DPtr    aDoc;
  491.     OSErr    anErr;
  492.  
  493.     OpenPreferencesResourceFile( &gPrefsRefFile );
  494.     
  495.     gMenuScripts = NULL;
  496.     anErr = BuildMenuScripts( );
  497.     if ( noErr != anErr ) goto done;
  498.     
  499.         // Get the current application scipt from the prefs file.
  500.         //  If there isn't one then the launch script can set one.
  501.     anErr = LoadScriptFromResFileRef( gPrefsRefFile,
  502.                             kApplicationScriptID, &gAppRec.theScriptID );
  503.         
  504.         // Load the results window script too.        
  505.     aDoc = GetResultsDoc( );
  506.     if ( aDoc )
  507.         anErr = LoadScriptFromResFileRef( gPrefsRefFile,
  508.                             kResultsScriptID, &aDoc->theScriptID );
  509.     
  510.         // The application script property is set by executing the 
  511.         //  application script - current script checks to see
  512.         //  if there is already a script - from prefs file.
  513.     anErr = LoadScriptFromResFileRef( gRefNum, kLaunchScriptID, &aScriptID );
  514.     if ( noErr != anErr ) goto done;
  515.     
  516.     anErr = OSAExecute( gScriptingComponent, aScriptID, kOSANullScript,
  517.                                             kOSAModeAlwaysInteract, &aResultID );
  518.     
  519. done:
  520.     (void)OSADispose( gScriptingComponent, aScriptID );
  521.     (void)OSADispose( gScriptingComponent, aResultID );
  522.         
  523.     return anErr;
  524. }
  525.  
  526.  
  527. OSErr    StoreApplicationScripts( void )
  528. {
  529.     DPtr    aDoc;
  530.     OSErr    anErr;
  531.     
  532.     anErr = StoreMenuScripts( );
  533.     if ( noErr != anErr ) goto done;
  534.  
  535.         // Store any changes to the applications script
  536.     anErr = StoreScriptToResFileRef( gPrefsRefFile, kApplicationScriptID,
  537.                                 gAppRec.theScriptID, "\pApplicationScript" );
  538.  
  539.         // Store any changes to the results document script
  540.     aDoc = GetResultsDoc( );
  541.     if ( aDoc )
  542.         anErr = StoreScriptToResFileRef( gPrefsRefFile, kResultsScriptID,
  543.                                 aDoc->theScriptID, "\pResultsScript" );
  544.  
  545.     ClosePreferencesResourceFile( gPrefsRefFile );
  546.  
  547. done:
  548.     return anErr;
  549. }
  550.  
  551.  
  552. static void    SetUpUniversalProcedures( void )
  553. {
  554.     gScrollScriptVActionUPP = NewControlActionProc( ScrollVActionProc );
  555.     gDrawStyledTextUPP = NewControlActionProc( DrawStyledTextEditRec );
  556.     gDrawScrollBarUPP = NewControlActionProc( DrawScrollBar );
  557.     gDrawGrowBoxUPP = NewControlActionProc( DrawGrowBoxItem );
  558. }
  559.  
  560.  
  561. static DialogPtr    PoseWaitDialog( short theDialogID )
  562. {
  563.     DialogPtr progressDialog;
  564.  
  565.         // pose a dialog indicating that we are connecting
  566.         // to the AppleScript component.
  567.     progressDialog = GetNewDialog( theDialogID, NULL, (WindowPtr)-1 );
  568.     SetPort( progressDialog );
  569.     DrawDialog( progressDialog );
  570.     return progressDialog;
  571. }
  572.  
  573. //    Name:   InitEditorScripting
  574. //    Purpose:Connects to the AppleScript component.
  575.  
  576. OSErr    InitEditorScripting( void )
  577. {
  578.     GrafPtr                 oldPort;
  579.     DialogPtr                progressDialog;
  580.     OSAError                 err = 0;
  581.     ComponentDescription     descr;
  582.     Component               aComponent;
  583.     ComponentInstance         aScriptingComponent;
  584.     
  585.     GetPort( &oldPort );
  586.     progressDialog = PoseWaitDialog( kPleaseWaitStart );
  587.     
  588.     SetUpUniversalProcedures( );
  589.     gEditingScript = false;
  590.     
  591.     descr.componentType         = kOSAComponentType;
  592.     descr.componentSubType      = (OSType) 0;
  593.     descr.componentManufacturer = (OSType) 0;
  594.     descr.componentFlags        = kOSASupportsCompiling + 
  595.                                        kOSASupportsGetSource +
  596.                                            kOSASupportsAECoercion + 
  597.                                             kOSASupportsAESending +
  598.                                                 kOSASupportsRecording +
  599.                                                     kOSASupportsConvenience +
  600.                                                         kOSASupportsEventHandling;
  601.     descr.componentFlagsMask    = descr.componentFlags;
  602.     
  603.     aComponent = FindNextComponent( NULL, &descr );
  604.         
  605.     if ( ! aComponent )
  606.     {
  607.         err = kComponentNotFound;
  608.         goto done;
  609.     }
  610.     else
  611.     {
  612.         aScriptingComponent = OpenComponent( aComponent );
  613.                                                                                                 
  614.         if (! aScriptingComponent)
  615.         {
  616.             err = kComponentNotFound;
  617.             goto done;
  618.         }
  619.     }
  620.         
  621.     gScriptingComponent = aScriptingComponent;
  622.  
  623.             
  624.     err = OSAGetSendProc( gScriptingComponent, &oldSendProc, &refCon );
  625.     if ( noErr != err ) goto done;
  626.                                                 
  627.     err = OSASetSendProc( gScriptingComponent, NewOSASendProc( MySendProc ), 0 );
  628.     if ( noErr != err ) goto done;
  629.  
  630.     err = AEInstallSpecialHandler( keyPreDispatch, (UniversalProcPtr)NewAEEventHandlerProc( EventPrehandler ), false );
  631.     if ( noErr != err ) goto done;
  632.     
  633.     err = LoadApplicationScripts( );
  634.  
  635. done:
  636.     DisposeDialog( progressDialog );
  637.     SetPort( oldPort );
  638.  
  639.     return err;
  640. }
  641.  
  642.  
  643. OSErr    SetOSAActiveProcedure(void)
  644. {
  645.     OSErr    err;
  646.     long    theRefCon;
  647.     
  648.         // store the old active proc in order to call this from ours
  649.     err = OSAGetActiveProc( gScriptingComponent, &gOSAActiveUPP, &theRefCon );
  650.     
  651.     return( OSASetActiveProc( gScriptingComponent, NewOSAActiveProc( StdActiveProc ), 0 ) );
  652. }
  653.  
  654.  
  655. //    Name    : CloseEditorScripting
  656. //    Purpose : Shutdown of editor scripting capabilities
  657.  
  658. OSErr    CloseEditorScripting( void )
  659. {
  660.     GrafPtr        oldPort;
  661.     DialogPtr    progressDialog;
  662.     short        index;
  663.     OSErr        err;
  664.     
  665.     GetPort( &oldPort );
  666.     progressDialog = PoseWaitDialog( kPleaseWaitEnd );
  667.  
  668.     StoreApplicationScripts( );
  669.     
  670.     for ( index = 0; index < gNumScripts; index++ )
  671.         err = OSADispose( gScriptingComponent, gMenuScripts[index].theScriptID );
  672.     
  673.     err = CloseComponent( gScriptingComponent );
  674.  
  675.     DisposeDialog( progressDialog );
  676.     SetPort( oldPort );
  677.     
  678.     return err;
  679. }
  680.  
  681.     
  682.  
  683. //    Name:    DisplayErrorInScript
  684. //    Purpose: Put up an alert showing the error text for the last error.
  685. //             Also selects the responsible text in theHTE if one is supplied
  686.  
  687. void    DisplayErrorInScript( TEHandle theHTE )
  688. {
  689.     Str255   errorMessageText;
  690.     AEDesc   errRangeDesc;
  691.     AEDesc   errRecordDesc;
  692.     AEDesc   errTextDesc;
  693.     AEDesc   errNumberDesc;
  694.     DescType typeCode;
  695.     Size     actSize;
  696.     OSErr    myErr;
  697.     OSErr    ignoreErr;
  698.     OSErr    errorNumber;
  699.     short    errorStart;
  700.     short    errorEnd;
  701.     
  702.     SetCursor(&qd.arrow);
  703.     
  704.     myErr = OSAScriptError(gScriptingComponent, kOSAErrorNumber,
  705.                                         typeShortInteger, &errNumberDesc);
  706.     
  707.     myErr = GetIntegerFromDescriptor(&errNumberDesc, &errorNumber);
  708.             
  709.     ignoreErr = AEDisposeDesc(&errNumberDesc);
  710.     
  711.     myErr = OSAScriptError(gScriptingComponent, kOSAErrorMessage,
  712.                                                 typeChar, &errTextDesc);
  713.                                                  
  714.     myErr = GetPStringFromDescriptor( &errTextDesc, errorMessageText );
  715.     
  716.     ignoreErr = AEDisposeDesc(&errTextDesc);
  717.     
  718.     if (theHTE)
  719.     {
  720.         myErr = OSAScriptError(gScriptingComponent, kOSAErrorRange,
  721.                                         typeOSAErrorRange, &errRangeDesc);
  722.                                                      
  723.         myErr = AECoerceDesc(&errRangeDesc, typeAERecord, &errRecordDesc);
  724.         
  725.         ignoreErr = AEDisposeDesc(&errRangeDesc);
  726.         
  727.         myErr = AEGetKeyPtr(&errRecordDesc, keyOSASourceStart, typeShortInteger,
  728.                             &typeCode, (Ptr)&errorStart, sizeof(errorStart), &actSize);
  729.                                                 
  730.         myErr = AEGetKeyPtr(&errRecordDesc, keyOSASourceEnd, typeShortInteger,
  731.                                 &typeCode, (Ptr)&errorEnd, sizeof(errorEnd), &actSize);
  732.                                                 
  733.         ignoreErr = AEDisposeDesc(&errRecordDesc);
  734.         
  735.         TESetSelect(errorStart, errorEnd, theHTE);
  736.     }
  737.     
  738.     ShowError(errorMessageText, errorNumber);
  739. }
  740.  
  741.  
  742. //    Name    : CompileDocument
  743. //    Purpose : Compiles the text of the supplied document - does NOT keep
  744. //              a compiled version - merely checks that it will compile for now
  745.  
  746. OSErr    CompileDocument( DPtr theDoc )
  747. {
  748.     WindowPropToken    aToken;
  749.     AEDesc            aTextDesc = { typeNull, NULL },
  750.                     aCompiledDesc = { typeNull, NULL },
  751.                     aNullDesc = { typeNull, NULL };
  752.     OSAID            aScriptID = kOSANullScript;
  753.     OSErr            anErr;
  754.     
  755.     aToken.tokenWindowToken.tokenWindow = theDoc->theWindow;
  756.     aToken.tokenProperty = pText;        // All of the text in document
  757.     anErr = GetDocumentTokenProperty( &aToken, typeWildCard, &aTextDesc );
  758.     if ( noErr != anErr ) goto done;
  759.         
  760.     anErr = OSACompile( gScriptingComponent, &aTextDesc,
  761.                                             kOSAModeCompileIntoContext, &aScriptID );
  762.     if ( noErr != anErr ) goto done;
  763.         
  764.     anErr = OSAGetSource( gScriptingComponent, aScriptID,
  765.                                         typeStyledText, &aCompiledDesc );
  766.     if ( noErr != anErr ) goto done;
  767.     
  768.     anErr = DisplayDescResult( theDoc->theWindow, &aCompiledDesc, NULL, noErr );
  769.  
  770. done:
  771.     (void)DisplayDescResult( GetResultsWindPtr( ), &aNullDesc, theDoc, anErr );
  772.  
  773.     (void)OSADispose( gScriptingComponent, aScriptID );
  774.     (void)AEDisposeDesc( &aTextDesc );
  775.     (void)AEDisposeDesc( &aCompiledDesc );
  776.  
  777.     return anErr;
  778. }
  779.     
  780.  
  781. //    Name    : ExecuteDocument
  782. //    Purpose : Compiles the text of the supplied document and then executes it
  783. //              - does NOT keep a compiled version after execution
  784.  
  785. OSErr    ExecuteDocument( DPtr theDoc )
  786. {
  787.     WindowPropToken    aToken;
  788.     AEDesc            aTextDesc = { typeNull, NULL },
  789.                     aCompiledDesc = { typeNull, NULL };
  790.     OSAID            aScriptID = kOSANullScript,
  791.                     aResultID = kOSANullScript;
  792.     OSErr            anErr;
  793.     
  794.     aToken.tokenWindowToken.tokenWindow = theDoc->theWindow;
  795.     aToken.tokenProperty = pText;        // All of the text in document
  796.     anErr = GetDocumentTokenProperty( &aToken, typeWildCard, &aTextDesc );
  797.     if ( noErr != anErr ) goto done;
  798.     
  799.     anErr = OSACompile( gScriptingComponent, &aTextDesc, kOSAModeCompileIntoContext, &aScriptID );
  800.     if ( noErr != anErr ) goto done;
  801.                 
  802.             // Set the compiled text first, before executing
  803.     anErr = OSAGetSource( gScriptingComponent, aScriptID,
  804.                                     typeStyledText, &aCompiledDesc );
  805.     if ( noErr != anErr ) goto done;
  806.                                     
  807.     anErr = DisplayDescResult( theDoc->theWindow, &aCompiledDesc, NULL, noErr );
  808.     if ( noErr != anErr ) goto done;
  809.     
  810.     anErr = OSAExecute( gScriptingComponent, aScriptID,
  811.                             kOSANullScript, kOSAModeNull, &aResultID );
  812.  
  813. done:
  814.         // If aResultID is kOSANullScript then clear the window
  815.     (void)DisplayOSAIDResult( GetResultsWindPtr( ), aResultID, theDoc, anErr );
  816.  
  817.     (void)OSADispose( gScriptingComponent, aScriptID );
  818.     (void)OSADispose( gScriptingComponent, aResultID );
  819.     (void)AEDisposeDesc( &aTextDesc );
  820.     (void)AEDisposeDesc( &aCompiledDesc );
  821.  
  822.     return anErr;
  823. }
  824.  
  825.  
  826. //    Name   : ScriptForMenuExists
  827. //    Purpose: Tests for the existance of a valid script for a given menu item             
  828.     
  829. OSErr    ScriptForMenuExists(short theMenu, short theItem, Boolean *exists)
  830. {
  831.     short  resID;
  832.     OSAID  myScriptID;
  833.     OSErr  myErr;
  834.     
  835.     myErr = noErr;
  836.     
  837.     resID = (theMenu<<5) + theItem;
  838.     
  839.     myScriptID = GetScriptIDForResID(resID);
  840.     
  841.     if (myScriptID==kOSANullScript)
  842.     {
  843.         if (theItem!=0)
  844.             myErr = ScriptForMenuExists(theMenu, 0, exists);
  845.         else
  846.             *exists = false;
  847.     }
  848.     else
  849.       *exists = true;
  850.             
  851.     return myErr;        
  852. } // ScriptForMenuExists
  853.     
  854.     
  855. //    Name   : ExecuteScriptForMenu
  856. //    Purpose: Executes a script associated with the menu item.
  857. //             Should be called only after ScriptForMenuExists
  858. //                returns exists.
  859.  
  860. OSErr    ExecuteScriptForMenu( short theMenu, short theItem )
  861. {
  862.     short            resID;
  863.     OSAID            aScriptID,
  864.                     aResultID = kOSANullScript;
  865.     OSErr            err;
  866.  
  867.     resID = ( theMenu << 5 ) + theItem;
  868.     
  869.     aScriptID = GetScriptIDForResID( resID );
  870.             
  871.     if ( aScriptID == kOSANullScript )
  872.     {
  873.         resID = ( theMenu << 5 ); // look for a script for the whole menu - item 0
  874.         aScriptID = GetScriptIDForResID( resID );
  875.     }
  876.     
  877.     if ( aScriptID != kOSANullScript )
  878.     {
  879.         gActiveMenuItem = theItem;
  880.         
  881.         err = OSAExecute( gScriptingComponent, aScriptID,
  882.                                     kOSANullScript, 0, &aResultID );
  883.  
  884.         (void)DisplayOSAIDResult( GetResultsWindPtr( ), aResultID, NULL, err );
  885.  
  886.         gActiveMenuItem = 0;
  887.     }
  888.  
  889. done:
  890.     (void)OSADispose( gScriptingComponent, aResultID );
  891.     
  892.     return err;
  893. }
  894.  
  895.  
  896. //    Name :   GetScriptActiveItem
  897. //    Purpose : Used by SVAppleEvents for the active item property of a menu.
  898. //              Allows a script associated with more than one menu item to
  899. //                find which menu item it was called by.
  900.  
  901. short    GetScriptActiveItem( void )
  902. {
  903.     return gActiveMenuItem;
  904. }
  905.  
  906.  
  907.  
  908. //    Routines used in the StyledTextEdit Dialog Item
  909.  
  910. struct StyleTextInfo
  911. {
  912.     ControlHandle theScrollBar;
  913.     TEHandle      theTEHandle;
  914. };
  915. typedef struct StyleTextInfo StyleTextInfo;
  916. typedef StyleTextInfo *pStyleTextInfo;
  917.  
  918.  
  919. pascal void DrawGrowBoxItem( DialogPtr theDialog, short theItem )
  920. {
  921.     short   theType;
  922.     Handle  theHandle;
  923.     Rect    itemRect;
  924.             
  925.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  926.     PlotIconID (&itemRect, atBottomRight, ttNone, 400);
  927. }
  928.  
  929. pascal void DrawStyledTextEditRec( DialogPtr theDialog, short theItem )
  930. {
  931.     short   theType;
  932.     Handle  theHandle;
  933.     Rect    itemRect;
  934.             
  935.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  936.     FrameRect(&itemRect);
  937.     InsetRect(&itemRect, 5, 5);
  938.     
  939.     TEUpdate(&itemRect, ((pStyleTextInfo) GetWRefCon(theDialog))->theTEHandle);
  940. }
  941.     
  942. pascal void DrawScrollBar( DialogPtr theDialog, short theItem )
  943. {        
  944. #ifdef __MWERKS__
  945.     #pragma unused(theItem)
  946. #endif
  947.  
  948.     Draw1Control(((pStyleTextInfo) GetWRefCon(theDialog))->theScrollBar);
  949. }
  950.  
  951.  
  952. //    Name:    SetDrawProcForUserItem
  953. //    Purpose: Installs a procedure that will be called when theItem needs
  954. //             to be drawn.
  955.  
  956. void SetDrawProcForUserItem( DialogPtr theDialog, short theItem, ControlActionUPP theProc )
  957. {
  958.     short  theType;
  959.     Handle theHandle;
  960.     Rect   itemRect;
  961.     
  962.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  963.     SetDItem(theDialog, theItem, theType, (Handle)theProc, &itemRect);
  964. }
  965.     
  966.  
  967. //    Name:    FlashButton
  968. //    Purpose: Provide visual effect of button having been
  969. //             selected.
  970.  
  971. void    FlashButton( DialogPtr theDialog, short theItem )
  972. {
  973.     short    theType;
  974.     Handle   theHandle;
  975.     Rect     itemRect;
  976.     
  977.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  978.     
  979.     HiliteControl((ControlHandle)theHandle, inButton);
  980.     HiliteControl((ControlHandle)theHandle, 0);
  981. }
  982.     
  983.  
  984. //    Name:    ScrollVActionProc
  985. //    Purpose: Called as scrollbar is tracked in buttons or page up/down.
  986. //             Keeps text in sync with scrollBar
  987.  
  988. pascal void ScrollVActionProc( ControlHandle control, short part )
  989. {
  990.     short  amount;
  991.     short  initialValue;
  992.     
  993.     if ( part )
  994.     {
  995.         switch ( part )
  996.         {
  997.             case inUpButton:
  998.             case inDownButton:
  999.                 amount = 24;
  1000.                 break;
  1001.             case inPageUp:
  1002.             case inPageDown:
  1003.                 amount = (**control).contrlRect.bottom - (**control).contrlRect.top;
  1004.                 break;
  1005.         }
  1006.         
  1007.         if ( part == inUpButton || part == inPageUp )
  1008.             amount = -amount; // reverse direction
  1009.     
  1010.         initialValue = GetCtlValue( control );
  1011.     
  1012.         SetCtlValue( control, initialValue+amount ); // Pinned within Min/Max automatically
  1013.         
  1014.         amount = GetCtlValue( control ) - initialValue;                
  1015.         
  1016.         if (amount)
  1017.             TEScroll(0, -amount,
  1018.                 ((pStyleTextInfo)GetWRefCon((**control).contrlOwner))->theTEHandle);
  1019.     }
  1020. } // ScrollVActionProc
  1021.     
  1022.  
  1023. //    Name:    TrackTEPosn
  1024. //    Purpose: Ensures that the scrollbar value matches the position
  1025. //             of the text edit record.
  1026.  
  1027. void    TrackTEPosn( ControlHandle theControl, TEHandle theHTE )
  1028. {
  1029.     short shouldBe;
  1030.     
  1031.     shouldBe = (**theHTE).viewRect.top - (**theHTE).destRect.top;
  1032.                         
  1033.     if ( GetCtlValue( theControl ) != shouldBe )
  1034.         SetCtlValue( theControl, shouldBe );
  1035. }
  1036.  
  1037.  
  1038. //    Name:    SetScrollLimit
  1039. //    Purpose: Ensures that the maximum value of the scrollbar is sufficient
  1040. //             to allow showing of all text, and no more.
  1041.  
  1042. void    SetScrollLimit( ControlHandle newScroll, TEHandle theHTE )
  1043. {
  1044.     Point     teLimit;
  1045.     short     currentMax;
  1046.     short     currentValue;
  1047.     TextStyle theStyle;
  1048.     short     lineHeight;
  1049.     short     fontAscent;
  1050.     
  1051.     currentMax = GetCtlMax(newScroll);
  1052.     
  1053.     //    Scroll max should be position of bottom of bottom line when unscrolled
  1054.     //    This is equal to
  1055.     //      The position of the bottom line relative to current position +
  1056.     //        The amount currently scrolled -
  1057.     //        The height of the visible part
  1058.             
  1059.     teLimit    = TEGetPoint((**theHTE).teLength, theHTE); // Position of bottom relative to current posn
  1060.     
  1061.     TEGetStyle((**theHTE).teLength, &theStyle, &lineHeight, &fontAscent,theHTE);        
  1062.     teLimit.v += lineHeight-fontAscent; // Add in for descent - TEGetPoint is posn of baseline not bottom of chars
  1063.     
  1064.     teLimit.v += ((**theHTE).viewRect.top -(**theHTE).destRect.top); // Amount already scrolled
  1065.     
  1066.     teLimit.v -= ((**theHTE).viewRect.bottom - (**theHTE).viewRect.top); // Height of page
  1067.     
  1068.     if (teLimit.v<0) // Cannot be negative
  1069.         teLimit.v = 0;
  1070.         
  1071.     if ( currentMax > teLimit.v )
  1072.     {
  1073.         currentValue = GetCtlValue( newScroll );
  1074.  
  1075.         if ( currentValue > teLimit.v )
  1076.         {
  1077.             TEScroll( 0, currentValue - teLimit.v, theHTE );
  1078.             SetCtlValue( newScroll, teLimit.v );
  1079.         }
  1080.  
  1081.         SetCtlMax( newScroll, teLimit.v );
  1082.     }
  1083.         
  1084.     if ( currentMax < teLimit.v )
  1085.         SetCtlMax( newScroll, teLimit.v );
  1086. }
  1087.  
  1088. #define kCompile   3
  1089. #define kTextItem  4
  1090. #define kScrollBar 5
  1091. #define kGrowBox   6
  1092.  
  1093. Boolean DoDialogMenu( long menuResult, TEHandle theTE )
  1094. {
  1095.     short   theItem;
  1096.     short   theMenuID;
  1097.     Boolean hasHandled = false;
  1098.  
  1099.     theItem     = LoWord( menuResult );
  1100.     theMenuID = HiWord( menuResult );
  1101.  
  1102.     switch ( theMenuID )
  1103.     {
  1104.         case editID:
  1105.             switch (theItem)
  1106.             {
  1107.                 case cutCommand:
  1108.                     TECut ( theTE );
  1109.                     hasHandled = true;
  1110.                     break;
  1111.                                              
  1112.                 case copyCommand:
  1113.                     TECopy ( theTE );
  1114.                     hasHandled = true;
  1115.                     break;
  1116.                                              
  1117.                 case pasteCommand:
  1118.                 {
  1119.                     TEStylePaste ( theTE );
  1120.                     hasHandled = true;
  1121.                     break;
  1122.                 }                             
  1123.                 case clearCommand:
  1124.                     TEDelete ( theTE );     
  1125.                     hasHandled = true;
  1126.                     break;
  1127.                                              
  1128.                 case selectAllCommand:
  1129.                     TESetSelect(0, kMaxTELength, theTE);
  1130.                     hasHandled = true;
  1131.                       break;
  1132.             }
  1133.                 
  1134.             break;
  1135.     }
  1136.     return hasHandled;
  1137. }
  1138.  
  1139. void MoveOneDialogItem ( DialogPtr theDialog,
  1140.                          short     theItem,
  1141.                          short     deltaW,
  1142.                          short     deltaH )
  1143. {
  1144.     short  theType;
  1145.     Handle theHandle;
  1146.     Rect   itemRect;
  1147.     
  1148.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  1149.     OffsetRect ( &itemRect, deltaW, deltaH);
  1150.     SetDItem(theDialog, theItem, theType, theHandle, &itemRect);
  1151. }
  1152.  
  1153. void MoveOneDialogControlItem( DialogPtr theDialog,
  1154.                                  short     theItem,
  1155.                                  short     deltaW,
  1156.                                  short     deltaH )
  1157. {
  1158.     short  theType;
  1159.     Handle theHandle;
  1160.     Rect   itemRect;
  1161.     
  1162.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  1163.     OffsetRect ( &itemRect, deltaW, deltaH);
  1164.     SetDItem(theDialog, theItem, theType, theHandle, &itemRect);
  1165.  
  1166.     MoveControl ( (ControlHandle)theHandle,
  1167.                     (**(ControlHandle)theHandle).contrlRect.left + deltaW,
  1168.                     (**(ControlHandle)theHandle).contrlRect.top  + deltaH);
  1169. }
  1170.  
  1171. void MoveScrollBarItem( DialogPtr theDialog,
  1172.                         short     theItem,
  1173.                         short     deltaW,
  1174.                         short     deltaH )
  1175. {
  1176.     short  theType;
  1177.     Handle theHandle;
  1178.     Rect   itemRect;
  1179.     Rect   controlRect;
  1180.     ControlHandle hTheControl;
  1181.     
  1182.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  1183.     
  1184.     itemRect.left  = itemRect.left + deltaW;
  1185.     itemRect.right = itemRect.right + deltaW;
  1186.     itemRect.bottom = itemRect.bottom + deltaH;
  1187.  
  1188.     SetDItem(theDialog, theItem, theType, theHandle, &itemRect);
  1189.  
  1190.     hTheControl = ((pStyleTextInfo) GetWRefCon(theDialog))->theScrollBar;
  1191.     controlRect = (**hTheControl).contrlRect;
  1192.     HideControl ( hTheControl );
  1193.     SizeControl ( hTheControl,
  1194.                     controlRect.right - controlRect.left,
  1195.                     deltaH + controlRect.bottom - controlRect.top );
  1196.     MoveControl ( hTheControl,
  1197.                     controlRect.left + deltaW,
  1198.                     controlRect.top );
  1199.     ShowControl ( hTheControl );
  1200. }
  1201.  
  1202. void MoveCustTextEditItem( DialogPtr theDialog,
  1203.                             short     theItem,
  1204.                             short     deltaW,
  1205.                             short     deltaH )
  1206. {
  1207.     short    theType;
  1208.     Handle   theHandle;
  1209.     Rect     itemRect;
  1210.     TEHandle theTEHandle;
  1211.     
  1212.     GetDItem(theDialog, theItem, &theType, &theHandle, &itemRect);
  1213.     
  1214.     itemRect.right = itemRect.right + deltaW;
  1215.     itemRect.bottom = itemRect.bottom + deltaH;
  1216.     SetDItem(theDialog, theItem, theType, theHandle, &itemRect);
  1217.  
  1218.     theTEHandle = ((pStyleTextInfo) GetWRefCon(theDialog))->theTEHandle;
  1219.     (**theTEHandle).destRect.right  = (**theTEHandle).destRect.right  + deltaW;
  1220.     (**theTEHandle).destRect.bottom = (**theTEHandle).destRect.bottom + deltaH;
  1221.     (**theTEHandle).viewRect.right  = (**theTEHandle).viewRect.right  + deltaW;
  1222.     (**theTEHandle).viewRect.bottom = (**theTEHandle).viewRect.bottom + deltaH;
  1223. }
  1224.  
  1225.  
  1226. pascal Boolean    MyFilterProc( DialogPtr theDialog, EventRecord *myEvent, short *itemHit )
  1227. {
  1228.     short            myPart;
  1229.     WindowPtr        whichWindow;
  1230.     TEHandle        newTE;
  1231.     Boolean            extend;
  1232.     GrafPtr            oldPort;
  1233.     Point            mousePt;
  1234.     char            myKey;
  1235.     Boolean            returnVal;
  1236.     long            menuResult;
  1237.     Rect            teItemRect;
  1238.     Rect            scrollItemRect;
  1239.     Rect            growItemRect;
  1240.     ControlHandle    newScroll;
  1241.     ControlHandle    theControl;
  1242.     short            part;
  1243.     short            value;
  1244.     short            cntlCode;
  1245.     Rect             growBounds;
  1246.     long             newRectSize;
  1247.     short             deltaW;
  1248.     short             deltaH;
  1249.     SFTypeList      myTypes = {'TEXT'};
  1250. #ifdef THINK_C
  1251.     ModalFilterUPP    standardProc;
  1252. #endif
  1253.     
  1254.     GetPort(&oldPort);
  1255.     
  1256.     returnVal = false;
  1257.     
  1258.     newTE     = ((pStyleTextInfo)GetWRefCon(theDialog))->theTEHandle;
  1259.     newScroll = ((pStyleTextInfo)GetWRefCon(theDialog))->theScrollBar;
  1260.     
  1261.     TEIdle(newTE);
  1262.     
  1263.     // Maintain the cursor
  1264.     
  1265.     SetPort(theDialog);
  1266.     GetMouse(&mousePt);
  1267.     
  1268.     GetRectOfDialogItem(theDialog, kTextItem,  &teItemRect);
  1269.     GetRectOfDialogItem(theDialog, kScrollBar, &scrollItemRect);
  1270.     GetRectOfDialogItem(theDialog, kGrowBox, &growItemRect);
  1271.     
  1272.     if (PtInRect(mousePt, &teItemRect))
  1273.     SetCursor(&editCursor);
  1274.     else
  1275.     SetCursor(&qd.arrow);
  1276.     
  1277.     switch (myEvent->what)
  1278.     {
  1279.         case mouseDown:
  1280.             myPart = FindWindow(myEvent->where, &whichWindow);
  1281.             
  1282.             if ( ( whichWindow != theDialog ) && ( myPart != inMenuBar ) )
  1283.                 break;
  1284.  
  1285.             switch (myPart)
  1286.             {
  1287.                 case inContent:
  1288.                 case inGrow:
  1289.                     SetPort(whichWindow);
  1290.                     mousePt = myEvent->where;
  1291.                     GlobalToLocal(&mousePt);
  1292.             
  1293.                     extend = ((myEvent->modifiers & shiftKey) != 0);
  1294.                     if ( PtInRect( mousePt, &(*(newTE))->viewRect ) )
  1295.                     {
  1296.                         TEClick(mousePt, extend, newTE);
  1297.                         TrackTEPosn(newScroll, newTE);
  1298.                     }
  1299.                     else
  1300.                     {
  1301.                         if (PtInRect(mousePt, &scrollItemRect))
  1302.                         {
  1303.                             cntlCode = FindControl(mousePt, theDialog, &theControl);
  1304.                             if (theControl)
  1305.                                 if (cntlCode == inThumb)
  1306.                                 {
  1307.                                     value = GetCtlValue(theControl);
  1308.                                     part  = TrackControl(theControl, mousePt, nil);
  1309.                                     if (part)
  1310.                                     {
  1311.                                         value -= GetCtlValue(theControl);
  1312.                                         if (value)
  1313.                                             TEScroll(0, value, newTE);
  1314.                                     }
  1315.                                 }
  1316.                                 else if ( cntlCode != 0 )
  1317.                                     part = TrackControl(theControl, mousePt, gScrollScriptVActionUPP);
  1318.                         }    // See if click is in grow box
  1319.                         else if ( PtInRect(mousePt, &growItemRect ))
  1320.                         {
  1321.         // Let the user drag out the new window size
  1322.                              SetRect(&growBounds, 300, 115,
  1323.                                                  qd.screenBits.bounds.right,
  1324.                                                  qd.screenBits.bounds.bottom);
  1325.                             newRectSize = GrowWindow ( whichWindow, myEvent->where,
  1326.                                                         &growBounds);
  1327.                             if (newRectSize)
  1328.                             {
  1329.         // Calculate the change in size of the window
  1330.                                 SetPort(theDialog);
  1331.                                 deltaW = LoWord(newRectSize) + whichWindow->portRect.left
  1332.                                             - whichWindow->portRect.right;
  1333.                                 deltaH = HiWord(newRectSize) + whichWindow->portRect.top
  1334.                                             - whichWindow->portRect.bottom;
  1335.                                 
  1336.         // Move all the items arround as appropriate
  1337.                                 MoveOneDialogControlItem( theDialog, ok,         deltaW, deltaH );
  1338.                                 MoveOneDialogControlItem( theDialog, cancel,     deltaW, deltaH );
  1339.                                 MoveOneDialogControlItem( theDialog, kCompile,   deltaW, deltaH );
  1340.                                 MoveOneDialogItem( theDialog, kGrowBox, deltaW, deltaH );
  1341.  
  1342.         // Move the scroll bar and Text edit around. Change the scroll bar's maximum
  1343.         //   and current value as necessary
  1344.                                 MoveScrollBarItem( theDialog, kScrollBar, deltaW, deltaH );
  1345.                                 MoveCustTextEditItem( theDialog, kTextItem, deltaW, deltaH );
  1346.                                 SetScrollLimit( newScroll, newTE);
  1347.  
  1348.         // Resize the window, don't bother about the update because we're going it
  1349.         //     invalidate it all later
  1350.                                 SizeWindow ( whichWindow,
  1351.                                              LoWord(newRectSize), HiWord(newRectSize),
  1352.                                              false );
  1353.  
  1354.         // Invalidate the window for update : Note that you have to add an erase rect
  1355.         //     to make sure that the window is cleared. This seems to be because the
  1356.         //     Dialog manager doesn't do one.
  1357.                 
  1358.                                 EraseRect( &whichWindow->portRect );
  1359.                                 InvalRect( &whichWindow->portRect );
  1360.                             }
  1361.                             returnVal = true;
  1362.                         }
  1363.                     }
  1364.                     break;
  1365.             
  1366.                 case inDrag:
  1367.                     DragWindow(whichWindow, myEvent->where, &qd.screenBits.bounds);
  1368.                     returnVal = true; // Stops modal dialog beeping
  1369.                     break;
  1370.             
  1371.                 case inMenuBar:
  1372.                     menuResult = MenuSelect(myEvent->where);
  1373.                     DoDialogMenu( menuResult, newTE );
  1374.                     HiliteMenu( 0 );
  1375.                     returnVal = true;   // Always return handled to stop beeping
  1376.                     break;                                                                                        
  1377.             }
  1378.             break;
  1379.  
  1380.         case keyDown:
  1381.         case autoKey: // Need hooks here for command keys if menus enabled
  1382.             myKey = myEvent->message & charCodeMask;
  1383.             
  1384.             if ((myEvent->modifiers & cmdKey) == cmdKey)
  1385.             {
  1386.                 menuResult = MenuKey(myKey);
  1387.                 returnVal = DoDialogMenu( menuResult, newTE );
  1388.                 HiliteMenu(0);
  1389.             }
  1390.             else if ( myKey != kEscapeKey ) // Escape Key
  1391.                 if ( myKey == kEndOfTextKey )
  1392.                 {
  1393.                     *itemHit = kCompile;
  1394.                     FlashButton(theDialog, kCompile);
  1395.                     returnVal = true;
  1396.                 }
  1397.                 else
  1398.                 {
  1399.                     TEKey(myKey, newTE);
  1400.                     SetScrollLimit(newScroll, newTE);
  1401.                     TrackTEPosn(newScroll, newTE);
  1402.                     returnVal = true;
  1403.                 }
  1404.             break;
  1405.                                 
  1406.         case activateEvt:
  1407.             if (((myEvent->modifiers & activeFlag) != 0))
  1408.             {
  1409.                 if ((WindowPtr)myEvent->message == theDialog)
  1410.                     TEActivate(newTE);
  1411.                 else
  1412.                     DoActivate((WindowPtr)myEvent->message, true); // Should not get here!
  1413.             }
  1414.             else if ((WindowPtr)myEvent->message == theDialog)
  1415.                 TEDeactivate(newTE);
  1416.             else
  1417.                 DoActivate((WindowPtr)myEvent->message, false);
  1418.             break;
  1419.                                         
  1420.         case updateEvt:
  1421.             if (Ours((WindowPtr)myEvent->message))
  1422.                 DoUpdate( (WindowPtr)myEvent->message );
  1423.             break;
  1424.     }
  1425.  
  1426.     if ( ! returnVal )
  1427.     {
  1428.         #ifdef THINK_C    // Can't use StdFilterProc() get and
  1429.                         //  call the standard filter ourselves
  1430.             if ( noErr == GetStdFilterProc( &standardProc ) ) 
  1431.                 returnVal= ((ModalFilterUPP)standardProc)( theDialog, myEvent, itemHit );
  1432.         #else
  1433.             returnVal = StdFilterProc( theDialog, myEvent, itemHit );
  1434.         #endif
  1435.     }
  1436.     
  1437.     MaintainEditItems( newTE, 1, myTypes );
  1438.     SetPort( oldPort );
  1439.     
  1440.     return returnVal;
  1441. }
  1442.  
  1443.  
  1444. // Given a resource ID for a menu, along with a OSAID for a script
  1445. //  to be associated with it. This routine sets the menu or menu item
  1446. //  script property. This in turn sets that the script has changed
  1447. //  so that it will get saved when the application is quit.
  1448.  
  1449. OSErr    SetMenuScript( short theResID, OSAID theScriptID )
  1450. {
  1451.     MenuPropToken        aMenuPropToken;
  1452.     MenuItemPropToken    aMenuItemPropToken;
  1453.     AEDesc                aDesc = { typeNull, NULL };
  1454.     OSErr                anErr;
  1455.               
  1456.     anErr = GetScriptDesc( theScriptID, typeWildCard, &aDesc );
  1457.  
  1458.     if ( theResID % 32 )    // Then the script is for an item
  1459.     {
  1460.         MenuItemTokenFromResID( theResID, &aMenuItemPropToken.token );
  1461.         aMenuItemPropToken.tokenProperty = pScript;
  1462.  
  1463.         anErr = SetMenuItemTokenProperty( &aMenuItemPropToken, &aDesc );
  1464.     }
  1465.     else                    // The script is for the whole menu
  1466.     {
  1467.         MenuTokenFromResID( theResID, &aMenuPropToken.token );
  1468.         aMenuPropToken.tokenProperty = pScript;
  1469.  
  1470.         anErr = SetMenuTokenProperty( &aMenuPropToken, &aDesc );
  1471.     }
  1472.     
  1473. done:
  1474.     (void)AEDisposeDesc( &aDesc );
  1475.  
  1476.     return anErr;
  1477. }
  1478.  
  1479. void SetMenuForDialog ( void )
  1480. {
  1481.     Boolean redrawMenuBar = false;
  1482.     
  1483. // Unhilite the menu bar
  1484.     HiliteMenu( 0 );
  1485.  
  1486. // Gray out apple menu (This will allow us to get at the edit menu)
  1487.     redrawMenuBar |= SetMenuItemState ( false, myMenus[appleM], kMenuTitle);
  1488.  
  1489. // Now Gray out everything apart from the edit menu
  1490.     redrawMenuBar |= SetMenuItemState ( false,  myMenus[fileM], kMenuTitle);
  1491.     if ( CountDocuments( ) > 0 )
  1492.     {
  1493.         redrawMenuBar |= SetMenuItemState ( false, myMenus[fontM], kMenuTitle);
  1494.         redrawMenuBar |= SetMenuItemState ( false, myMenus[sizeM], kMenuTitle);
  1495.         redrawMenuBar |= SetMenuItemState ( false, myMenus[styleM], kMenuTitle);
  1496.         redrawMenuBar |= SetMenuItemState ( false, myMenus[scriptM], kMenuTitle);
  1497.         redrawMenuBar |= SetMenuItemState ( false, myMenus[subroutineM], kMenuTitle);
  1498.     }
  1499.  
  1500. // Enable the edit menu
  1501.     redrawMenuBar |= SetMenuItemState ( true, myMenus[editM], kMenuTitle);
  1502.     SetMenuItemState ( true, myMenus[editM], cutCommand);
  1503.     SetMenuItemState ( true, myMenus[editM], copyCommand);
  1504.     SetMenuItemState ( true, myMenus[editM], pasteCommand);
  1505.     SetMenuItemState ( true, myMenus[editM], clearCommand);
  1506.     SetMenuItemState ( true, myMenus[editM], selectAllCommand);
  1507.  
  1508.     if (redrawMenuBar)
  1509.         DrawMenuBar();
  1510. }
  1511.  
  1512. void ReSetMenuForDialog ( void )
  1513. {
  1514.     Boolean redrawMenuBar = false;
  1515.     
  1516.         // Reset the menus
  1517.     redrawMenuBar |= SetMenuItemState ( true, myMenus[appleM], kMenuTitle);
  1518.     redrawMenuBar |= SetMenuItemState ( true, myMenus[fileM], kMenuTitle);
  1519.     if ( CountDocuments( ) > 0 )
  1520.     {
  1521.         redrawMenuBar |= SetMenuItemState ( true, myMenus[fontM], kMenuTitle);
  1522.         redrawMenuBar |= SetMenuItemState ( true, myMenus[sizeM], kMenuTitle);
  1523.         redrawMenuBar |= SetMenuItemState ( true, myMenus[styleM], kMenuTitle);
  1524.         redrawMenuBar |= SetMenuItemState ( true, myMenus[scriptM], kMenuTitle);
  1525.         redrawMenuBar |= SetMenuItemState ( true, myMenus[subroutineM], kMenuTitle);
  1526.     }
  1527.     MaintainMenus( &redrawMenuBar);
  1528. }
  1529.  
  1530.  
  1531. OSErr    EditMenuScript(short theMenu, short theItem)
  1532. {
  1533.     short         resID;
  1534.     OSAID         myScriptID;
  1535.     OSErr         myErr;
  1536.     OSErr         ignoreErr;
  1537.     AEDesc        scriptTextDesc;
  1538.     DialogPtr     scriptEditDlog;
  1539.     short         itemHit;
  1540.     TEHandle      newTE;
  1541.     GrafPtr       oldPort;
  1542.     Rect          itemRect;
  1543.     OSAID         myCompiledID;
  1544.     Boolean       wholeMenu;
  1545.     ControlHandle myScrollBar;
  1546.     StyleTextInfo theStyleTextInfo;
  1547.     ModalFilterUPP modalFilterDescriptor;
  1548.  
  1549.     SetMenuForDialog( );
  1550.  
  1551.     gEditingScript = true;
  1552.  
  1553.     GetPort(&oldPort);
  1554.     
  1555.     //    Look for a script associated with theItem first,
  1556.     //    and if not found look for one associated with 
  1557.     //    the whole menu
  1558.     
  1559.     wholeMenu = false;
  1560.     
  1561.     resID = ( theMenu << 5 ) + theItem;
  1562.     
  1563.     myScriptID = GetScriptIDForResID( resID );
  1564.     
  1565.     if ( myScriptID == kOSANullScript )
  1566.     {
  1567.         resID = (theMenu<<5);
  1568.         myScriptID = GetScriptIDForResID(resID);
  1569.         wholeMenu = true;
  1570.     }
  1571.             
  1572.     scriptEditDlog = GetNewDialog( MenuScriptEditor, NULL, (WindowPtr)-1 );                     
  1573.     SetPort( scriptEditDlog );
  1574.  
  1575.     //    Create a styled text edit record for the userItem
  1576.     //    and install it
  1577.  
  1578.     GetRectOfDialogItem( scriptEditDlog, kTextItem,  &itemRect );
  1579.     
  1580.     InsetRect(&itemRect, 5, 5);
  1581.     
  1582.     newTE = TEStylNew(&itemRect, &itemRect);
  1583.     
  1584.     TEAutoView(true, newTE);
  1585.     
  1586.     SetDrawProcForUserItem(scriptEditDlog, kTextItem, gDrawStyledTextUPP);
  1587.     
  1588.     //    Now create a scrollbar and install it
  1589.     
  1590.     GetRectOfDialogItem(scriptEditDlog, kScrollBar, &itemRect);
  1591.     
  1592.     myScrollBar = NewControl(scriptEditDlog, &itemRect, (unsigned char *)"",
  1593.                                 true, 0, 0, kMaxTELength, // Will be fixed up later - by SetScrollLimit()
  1594.                                  scrollBarProc, 0);
  1595.                                                      
  1596.     SetDrawProcForUserItem(scriptEditDlog, kScrollBar, gDrawScrollBarUPP);
  1597.  
  1598.     //    Now create grow box draw proc
  1599.     SetDrawProcForUserItem(scriptEditDlog, kGrowBox, gDrawGrowBoxUPP);
  1600.     
  1601.     //    Use the dialog window refcon to allow access to the 
  1602.     //    TEHandle and scrollHandle avoiding the use
  1603.     //    of globals
  1604.     
  1605.     theStyleTextInfo.theTEHandle  = newTE;
  1606.     theStyleTextInfo.theScrollBar = myScrollBar;
  1607.     
  1608.     SetWRefCon(scriptEditDlog, (long) &theStyleTextInfo);
  1609.  
  1610.     //    Put the source of the script into the 
  1611.     //    text edit record
  1612.     
  1613.     myErr = OSAGetSource(gScriptingComponent, myScriptID,
  1614.                                     typeStyledText, &scriptTextDesc);
  1615.  
  1616.     PutStyledTextFromDescIntoTEHandle(&scriptTextDesc, newTE);
  1617.     
  1618.     ignoreErr = AEDisposeDesc(&scriptTextDesc);
  1619.     
  1620.     SetScrollLimit(myScrollBar, newTE);
  1621.     TrackTEPosn(myScrollBar, newTE);
  1622.  
  1623.     // Set item 1 - <OK> to have a default box around it
  1624.     SetDialogDefaultItem(scriptEditDlog,ok);
  1625.     SetDialogCancelItem(scriptEditDlog,cancel);
  1626.     
  1627.     //    Added during PowerPC port:
  1628.     
  1629.     modalFilterDescriptor = NewModalFilterProc( MyFilterProc );
  1630.     
  1631.     do
  1632.     {
  1633.         ModalDialog(modalFilterDescriptor, &itemHit);
  1634.         switch ( itemHit )
  1635.         {
  1636.             case ok:
  1637.             case kCompile:
  1638.                 SetCursor(&waitCursor);
  1639.                 HLock((Handle)(**newTE).hText);
  1640.                 myErr = AECreateDesc(typeChar, (Ptr)*((**newTE).hText),
  1641.                                         (**newTE).teLength, &scriptTextDesc);
  1642.                 HUnlock((Handle)(**newTE).hText);
  1643.                                                 
  1644.                 myCompiledID = kOSANullScript;
  1645.                 myErr = OSACompile(gScriptingComponent, &scriptTextDesc,
  1646.                                             kOSAModeCompileIntoContext, &myCompiledID);
  1647.                                                                                      
  1648.                 ignoreErr = AEDisposeDesc(&scriptTextDesc);
  1649.                                                 
  1650.                 scriptTextDesc.dataHandle = nil;
  1651.                                                 
  1652.                 if (myErr==noErr)
  1653.                 {
  1654.                     myErr = OSAGetSource(gScriptingComponent, myCompiledID,
  1655.                                                     typeStyledText, &scriptTextDesc);
  1656.                                                              
  1657.                         // Zap current contents and replace with returned source
  1658.                          
  1659.                     TESetSelect(0, kMaxTELength, newTE);
  1660.                     TEDelete(newTE);
  1661.  
  1662.                          // We deleted all the text so it won't be scrolled anymore
  1663.                     SetCtlValue(myScrollBar, 0);
  1664.                     
  1665.                     PutStyledTextFromDescIntoTEHandle(&scriptTextDesc, newTE);
  1666.                     
  1667.                     DrawStyledTextEditRec(scriptEditDlog, kTextItem);
  1668.                                                          
  1669.                     ignoreErr = AEDisposeDesc(&scriptTextDesc);
  1670.                 }
  1671.                 else if ( errOSAScriptError == myErr )
  1672.                 {
  1673.                     DisplayErrorInScript( newTE );
  1674.                     itemHit  = 0; // Stop dialog going away
  1675.                 }
  1676.                     
  1677.                 SetScrollLimit(myScrollBar, newTE);
  1678.                 TrackTEPosn(myScrollBar, newTE);
  1679.             
  1680.                 SetCursor(&qd.arrow);
  1681.                     
  1682.                 if ( ok == itemHit )
  1683.                 {        // Swap this script for the old one even if whole menu 
  1684.                     if ( noErr == myErr )
  1685.                         SetMenuScript( resID, myCompiledID );
  1686.                     else
  1687.                         itemHit = -1;
  1688.                 }
  1689.                                                         
  1690.                 (void)OSADispose(gScriptingComponent, myCompiledID);
  1691.                 break;
  1692.                                                 
  1693.             case cancel: 
  1694.             case kTextItem: 
  1695.             case kScrollBar:
  1696.                 break;
  1697.         }
  1698.     } while ( itemHit != ok && itemHit != cancel );
  1699.             
  1700.     DisposeRoutineDescriptor( modalFilterDescriptor );
  1701.             
  1702.     DisposeDialog( scriptEditDlog );
  1703.     
  1704.     SetPort(oldPort);
  1705.  
  1706.     gEditingScript = false;
  1707.  
  1708.     ReSetMenuForDialog( );
  1709.     
  1710.     return noErr;
  1711. }
  1712.  
  1713.  
  1714. OSAError    LoadDocumentScript( DPtr theDoc, short theFileRef )
  1715. {
  1716.     OSAError    err;
  1717.  
  1718.     theDoc->theScriptID = kOSANullScript;
  1719.     
  1720.     err = LoadScriptFromResFileRef( theFileRef,
  1721.                     kDefaultDocumentScript, &theDoc->theScriptID );
  1722.                     
  1723.     return err;
  1724. }
  1725.  
  1726.  
  1727. OSAError    StoreDocumentScript( DPtr theDoc, short theFileRef )
  1728. {
  1729.     OSAError    err;
  1730.     
  1731.     if ( kOSANullScript == theDoc->theScriptID )
  1732.         return noErr;
  1733.     
  1734.     err = StoreScriptToResFileRef( theFileRef, kDefaultDocumentScript,
  1735.                                 theDoc->theScriptID, "\pDocument Script" );
  1736.                     
  1737.     return err;
  1738. }
  1739.  
  1740.  
  1741. OSAError    GetScriptProperty( OSAID contextID, const AEDesc* propertyName, AEDesc* result )
  1742. {
  1743.     OSAID        aScriptValueID = kOSANullScript;
  1744.     OSAError    err;
  1745.     
  1746.     if ( kOSANullScript == contextID )
  1747.         return errAEEventNotHandled;
  1748.     
  1749.                         // Get the property as a script ID
  1750.     err = OSAGetProperty( gScriptingComponent, kOSAModeNull, contextID,
  1751.                                         propertyName, &aScriptValueID );
  1752.     if (noErr != err) goto done;
  1753.                         // Convert the script data located by the script ID to an AEDesc
  1754.     err = OSACoerceToDesc( gScriptingComponent, aScriptValueID,
  1755.                                     typeWildCard, kOSAModeNull, result );
  1756.  
  1757. done:
  1758.     (void)OSADispose( gScriptingComponent, aScriptValueID );
  1759.  
  1760.     return(err);
  1761. }
  1762.  
  1763.  
  1764. // Set a script property using a descriptor.
  1765.  
  1766. OSAError    SetScriptProperty( OSAID contextID, const AEDesc* propertyName, const AEDesc* value )
  1767. {
  1768.     OSAID        aScriptValueID = kOSANullScript;
  1769.     OSAError    err;
  1770.                         // Convert from a descriptor to a script ID
  1771.     err = OSACoerceFromDesc( gScriptingComponent, value,
  1772.                                        kOSAModeNull, &aScriptValueID );
  1773.     if (noErr != err) goto done;
  1774.                         // Set the property using the script ID
  1775.     err = OSASetProperty( gScriptingComponent, kOSAModeNull,
  1776.                                 contextID, propertyName, aScriptValueID );
  1777.  
  1778. done:
  1779.     (void)OSADispose( gScriptingComponent, aScriptValueID );
  1780.  
  1781.     return(err);
  1782. }
  1783.  
  1784.  
  1785. OSErr    GetScriptDesc( OSAID theScriptID, DescType theWantType, AEDesc* theResult )
  1786. {
  1787.     OSErr    err;
  1788.  
  1789.     if ( theWantType == typeChar || theWantType == typeIntlText )
  1790.     {    // If caller wants text, we need to de-compile the script
  1791.         err = (OSErr)OSAGetSource( gScriptingComponent, theScriptID, 
  1792.                                                         theWantType, theResult );
  1793.     }
  1794.     else
  1795.     {
  1796.         if ( theWantType == typeWildCard )
  1797.             theWantType = typeOSAGenericStorage;
  1798.             
  1799.         err = (OSErr)OSAStore( gScriptingComponent, theScriptID, 
  1800.                                 theWantType, kOSAModeDontStoreParent, theResult );
  1801.     }
  1802.     
  1803.     return err;
  1804. }
  1805.  
  1806.  
  1807. OSErr    SetScriptDesc( const AEDesc* theData, OSAID* theResult )
  1808. {
  1809.     OSAID         aScriptID = kOSANullScript;
  1810.     OSAError    err;
  1811.  
  1812.     switch ( theData->descriptorType )
  1813.     {
  1814.         case typeChar:
  1815.         case typeIntlText:
  1816.             err = OSACompile( gScriptingComponent, theData, 
  1817.                                      kOSAModeCompileIntoContext, &aScriptID );
  1818.             if ( errOSAScriptError == err )
  1819.                 DisplayOSAScriptError( NULL );
  1820.             break;
  1821.         
  1822.         default:
  1823.             err = OSALoad( gScriptingComponent, theData, 
  1824.                                     kOSAModeNull, &aScriptID );
  1825.     }
  1826.     
  1827.     if ( noErr == err )
  1828.     {
  1829.         (void)OSADispose( gScriptingComponent, *theResult );
  1830.         *theResult = aScriptID;
  1831.     }
  1832.  
  1833.     return (OSErr)err;
  1834. }
  1835.  
  1836. void    AddMissingParameter( AEKeyword theAEKeyword, DescType theType,
  1837.                                     Ptr theData, Size theDataSize, AppleEvent* theEvent )
  1838. {
  1839.     AEDesc    aDesc = { typeNull, NULL };
  1840.     OSErr    anErr;
  1841.     
  1842.         // See if the parameter is there first
  1843.     anErr = AEGetParamDesc( theEvent, theAEKeyword, typeWildCard, &aDesc );
  1844.     if ( noErr == anErr ) goto done;
  1845.     
  1846.     switch ( theType )
  1847.     {
  1848.         case typeAEList:
  1849.         case typeAERecord:
  1850.             anErr = AECreateList( NULL, 0, ( typeAERecord == theType ), &aDesc );
  1851.             if ( noErr != anErr ) goto done;
  1852.         
  1853.             anErr = AEPutParamDesc( theEvent, theAEKeyword, &aDesc );
  1854.             break;
  1855.             
  1856.         default:
  1857.             anErr = AECreateDesc( theType, theData, theDataSize, &aDesc );
  1858.             if ( noErr != anErr ) goto done;
  1859.         
  1860.             anErr = AEPutParamDesc( theEvent, theAEKeyword, &aDesc );
  1861.     }
  1862.  
  1863. done:    
  1864.     (void)AEDisposeDesc( &aDesc );
  1865. }
  1866.  
  1867.  
  1868. Boolean    CanScriptEvent( AEEventClass theClass, AEEventID theID, AppleEvent* theEvent )
  1869. {
  1870.     DescType    aType;
  1871.     FSSpec        aSpec;
  1872.     Boolean        result;
  1873.     
  1874.     switch ( theClass )
  1875.     {
  1876.         case kCoreEventClass:
  1877.             switch ( theID )
  1878.             {
  1879.                 case kAEOpenApplication:
  1880.                     result = false;
  1881.                     break;
  1882.                     
  1883.                 default:
  1884.                     result = true;
  1885.             }
  1886.             break;
  1887.             
  1888.         case kAECoreSuite:
  1889.             switch ( theID )
  1890.             {
  1891.                 case kAESetData:
  1892.                 case kAEGetData:
  1893.                 case kAEDoObjectsExist:
  1894.                     result = false;
  1895.                     break;
  1896.                     
  1897.                 case kAECreateElement:
  1898.                     aType = typeNull;     // Null to show nothing
  1899.                     AddMissingParameter( keyAEInsertHere, typeType,
  1900.                                             (Ptr)&aType, sizeof( aType ), theEvent );
  1901.                     AddMissingParameter( keyAEData, typeAERecord, NULL, 0, theEvent );
  1902.                     AddMissingParameter( keyAEPropData, typeAERecord, NULL, 0, theEvent );
  1903.                     result = true;
  1904.                     break;
  1905.                     
  1906.                 case kAEClose:
  1907.                     aType = kAEAsk;     // Default for no parameter
  1908.                     AddMissingParameter( keyAESaveOptions, typeEnumeration,
  1909.                                             (Ptr)&aType, sizeof( aType ), theEvent );
  1910.                     result = true;
  1911.                     break;
  1912.                     
  1913.                 case kAESave:
  1914.                     aSpec.vRefNum = 0;    // Send a blank FSSpec
  1915.                     aSpec.parID = 0;
  1916.                     aSpec.name[0] = 0;
  1917.                     AddMissingParameter( keyAEFile, typeFSS,
  1918.                                             (Ptr)&aSpec, sizeof( aSpec ), theEvent );
  1919.                     result = true;
  1920.                     break;
  1921.                     
  1922.                 default:
  1923.                     result = true;
  1924.             }
  1925.             break;
  1926.  
  1927.         case kAEMiscStandards:    // e.g. kAERevert
  1928.             switch ( theID )
  1929.             {
  1930.                 default:
  1931.                     result = true;
  1932.             }
  1933.             break;
  1934.  
  1935.         case kASAppleScriptSuite:
  1936.             switch ( theID )
  1937.             {
  1938.                 case kASSubroutineEvent:
  1939.                     result = true;
  1940.                     break;
  1941.                     
  1942.                 default:
  1943.                     result = false;
  1944.             }
  1945.             break;
  1946.             
  1947.         default:
  1948.             result = false;
  1949.     }
  1950.     
  1951.     return result;
  1952. }
  1953.  
  1954.  
  1955. // Debugging routine
  1956.  
  1957. OSAError    GetAHandler( AEDesc* theName, OSAID theOSAID );
  1958. OSAError    GetAHandler( AEDesc* theName, OSAID theOSAID )
  1959. {
  1960.     AEDesc        aDesc = { typeNull, NULL };
  1961.     OSAID        aResultID;
  1962.     OSAError    anErr;
  1963.  
  1964.     (void)DisplayDescResult( GetResultsWindPtr( ), theName, NULL, noErr );
  1965.     
  1966.     anErr = OSAGetHandler( gScriptingComponent, kOSAModeNull, theOSAID, theName, &aResultID );
  1967.     if ( noErr != anErr ) goto done;
  1968.     
  1969.     anErr = OSAGetSource( gScriptingComponent, aResultID, typeStyledText, &aDesc );
  1970.     if ( noErr != anErr ) goto done;
  1971.  
  1972. done:
  1973.     (void)DisplayDescResult( GetResultsWindPtr( ), &aDesc, NULL, anErr );
  1974.     (void)AEDisposeDesc( &aDesc );
  1975.  
  1976.     return anErr;
  1977. }
  1978.  
  1979. // Debugging routine
  1980.  
  1981. OSErr    LookAtHandlers( OSAID theOSAID );
  1982. OSErr    LookAtHandlers( OSAID theOSAID )
  1983. {
  1984.     AEDesc        aList = { typeNull, NULL },
  1985.                 aDesc = { typeNull, NULL };
  1986.     long        aCount,
  1987.                 anIndex;
  1988.     AEKeyword    anAEKeyword;
  1989.     OSAError    anErr;
  1990.  
  1991.     anErr = OSAGetHandlerNames( gScriptingComponent, kOSAModeNull, theOSAID, &aList );
  1992.     if ( noErr != anErr ) goto done;
  1993.     
  1994.     anErr = AECountItems( &aList, &aCount );
  1995.     if ( noErr != anErr ) goto done;
  1996.  
  1997.     for ( anIndex = 1; anIndex <= aCount; anIndex++ )
  1998.     {
  1999.         anErr = AEGetNthDesc( &aList, anIndex, typeWildCard, &anAEKeyword, &aDesc );
  2000.         if ( noErr != anErr ) continue;
  2001.         
  2002.         anErr = GetAHandler( &aDesc, theOSAID );
  2003.     }
  2004.  
  2005. done:
  2006.     (void)DisplayDescResult( GetResultsWindPtr( ) , &aDesc, NULL, anErr );
  2007.     (void)AEDisposeDesc( &aList );
  2008.     (void)AEDisposeDesc( &aDesc );
  2009.  
  2010.     return anErr;
  2011. }
  2012.  
  2013.  
  2014. static OSErr    GetTokenDescScript( AEDesc* theTokenDesc, OSAID* theOSAID )
  2015. {
  2016.     WindowToken        aWindowToken;
  2017.     Size            aSize;
  2018.     DPtr            aDoc;
  2019.     OSErr            err = noErr;
  2020.     
  2021.     *theOSAID = kOSANullScript;        // Null to begin with
  2022.  
  2023.     switch ( theTokenDesc->descriptorType )
  2024.     {
  2025.         case typeMyDocument:
  2026.             GetRawDataFromDescriptor( theTokenDesc, (Ptr)&aWindowToken,
  2027.                                                 sizeof( aWindowToken ), &aSize );
  2028.             aDoc = DPtrFromWindowPtr( aWindowToken.tokenWindow );
  2029.             *theOSAID = aDoc->theScriptID;
  2030.             
  2031. //            LookAtHandlers( *theOSAID );
  2032.             break;
  2033.             
  2034.         case typeMyAppl:
  2035.             *theOSAID = gAppRec.theScriptID;
  2036.  
  2037. //            LookAtHandlers( *theOSAID );
  2038.             break;
  2039.             
  2040.         default:
  2041.             err = errAEEventNotHandled;
  2042.     }
  2043.  
  2044.     return err;
  2045. }
  2046.  
  2047.  
  2048. OSErr    DoScriptEvent( AppleEvent            *theEvent, 
  2049.                         AppleEvent            *theReply, 
  2050.                         OSAID                theScriptID )
  2051. {
  2052.     OSAError            err = errAEEventNotHandled;
  2053.     AEEventHandlerUPP    oldResumeProc;
  2054.     long                oldRefcon;
  2055.     
  2056.     if ( kOSANullScript == theScriptID )
  2057.         return err;
  2058.     
  2059.     OSAGetResumeDispatchProc( gScriptingComponent, &oldResumeProc, &oldRefcon );
  2060.     
  2061.     err = OSASetResumeDispatchProc( gScriptingComponent,
  2062.                     (AEEventHandlerUPP)kOSAUseStandardDispatch, kOSADontUsePhac );
  2063.     if ( noErr == err )
  2064.     {
  2065.         err = OSADoEvent( gScriptingComponent, theEvent, theScriptID, 
  2066.                                                  kOSAModeAlwaysInteract, theReply );
  2067.         if ( errOSAScriptError == err )
  2068.             (void)DisplayOSAScriptError( NULL );
  2069.     }
  2070.  
  2071.     OSASetResumeDispatchProc( gScriptingComponent, oldResumeProc, oldRefcon ) ;
  2072.     
  2073.     return    (OSErr)err;
  2074. }
  2075.  
  2076.  
  2077. pascal OSErr    EventPrehandler( AppleEvent *theEvent, AppleEvent *theReply, long theRefcon )
  2078. {
  2079. #ifdef __MWERKS__
  2080.     #pragma unused( theRefcon )
  2081. #endif
  2082.  
  2083.     AEEventClass         aClass;
  2084.     AEEventID             anID;
  2085.     DescType            aType;
  2086.     Size                aSize;
  2087.     AEDesc                anObject = { typeNull, NULL },
  2088.                         aTokenDesc = { typeNull, NULL };
  2089.     OSAID                 aScriptID = kOSANullScript;
  2090.     OSAError             err;
  2091.  
  2092.     // Extract the class and ID of the event from the AppleEvent
  2093.     err = AEGetAttributePtr( theEvent, keyEventClassAttr, typeType,
  2094.                                     &aType, (Ptr)&aClass, sizeof( aClass ), &aSize ); 
  2095.     if ( noErr != err ) goto done;
  2096.  
  2097.     err = AEGetAttributePtr( theEvent, keyEventIDAttr, typeType,
  2098.                                     &aType, (Ptr)&anID, sizeof( anID ), &aSize );
  2099.     if ( noErr != err ) goto done;
  2100.     
  2101.     if ( CanScriptEvent( aClass, anID, theEvent ) )
  2102.     {        // Above test is to make sure we handle all the scriptable events 
  2103.             //  and that we skip the ones we don't want to be scriptable.
  2104.         err = AEGetParamDesc( theEvent, keyDirectObject, typeWildCard, &anObject );
  2105.  
  2106.             // If there is no object specifier for the direct object
  2107.             //  then well have a go with the application script.
  2108.         if ( noErr != err || typeObjectSpecifier != anObject.descriptorType )
  2109.             aTokenDesc.descriptorType = typeMyAppl;
  2110.         else
  2111.         {    // Resolve to an internal token
  2112.             err = AEResolve( &anObject, kAEIDoMinimum, &aTokenDesc );
  2113.             if ( noErr != err ) goto done;
  2114.         }
  2115.     
  2116.         err = GetTokenDescScript( &aTokenDesc, &aScriptID );
  2117.         if ( noErr != err ) goto done;
  2118.         
  2119.             // If there's no script then we want the application
  2120.             //  to handle it in the normal way.
  2121.         if ( kOSANullScript == aScriptID )
  2122.         {
  2123.             err = errAEEventNotHandled;
  2124.             goto done;
  2125.         }
  2126.         
  2127.         err = DoScriptEvent( theEvent, theReply, aScriptID );
  2128.     }
  2129.     else
  2130.         err = errAEEventNotHandled;
  2131.  
  2132. done:
  2133.     (void)AEDisposeDesc( &anObject );
  2134.     (void)AEDisposeDesc( &aTokenDesc );
  2135.         
  2136.     return (OSErr)err;
  2137. }
  2138.