home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / WASTE 1.2a4 / WASTE Demo / WEDemoEvents.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-05  |  10.4 KB  |  558 lines  |  [TEXT/CWIE]
  1. /*
  2.     WASTE Demo Project:
  3.     Events Handling
  4.         
  5.     Copyright © 1993-1995 Marco Piovanelli
  6.     All Rights Reserved
  7.  
  8.     C port by John C. Daub
  9. */
  10.  
  11. #ifndef __APPLEEVENTS__
  12. #include <AppleEvents.h>
  13. #endif
  14.  
  15. #ifndef __AEREGISTRY__
  16. #include <AERegistry.h>
  17. #endif
  18.  
  19. #ifndef __DISKINIT__
  20. #include <DiskInit.h>
  21. #endif
  22.  
  23. #ifndef __TEXTSERVICES__
  24. #include <TextServices.h>
  25. #endif
  26.  
  27.  
  28. #ifndef __WEDEMOAPP__
  29. #include "WEDemoIntf.h"
  30. #endif
  31.  
  32. //    some global definitions...
  33.  
  34. unsigned long        gSleepTime;            // sleep time for WaitNextEvent()
  35. RgnHandle            gMouseRgn;            // mouse region for WaitNextEvent()
  36.  
  37.  
  38.  
  39. void    AdjustCursor( Point mouseLoc, RgnHandle mouseRgn )
  40. {
  41.     WindowRef        window;
  42.     
  43.     // by default, set mouseRgn to the whole QuickDraw coordinate plane,
  44.     // so that we never get mouse moved events
  45.     
  46.     SetRectRgn( mouseRgn, -SHRT_MAX, -SHRT_MAX, SHRT_MAX, SHRT_MAX );
  47.     
  48.     // give text services a chance to set the cursor shape
  49.     
  50.     if ( gHasTextServices )
  51.     {
  52.         if ( SetTSMCursor( mouseLoc ) )
  53.             return;
  54.     }
  55.     
  56.     // if there is a window open, give WEAdjustCursor an opportunity to set the cursor
  57.     // WEAdjustCursor intersects mouseRgn (if supplied) with a region within which
  58.     // the cursor is to retain its shape
  59.     // (if the cursor is outside the view region, this is subtracted from mouseRgn )
  60.     
  61.     window = FrontWindow();
  62.     
  63.     if ( window != NULL )
  64.         if ( WEAdjustCursor( mouseLoc, mouseRgn, GetWindowWE(window) ) )
  65.             return;
  66.     
  67.     // set the cursor to the arrow cursor
  68.     
  69.     SetCursor( &qd.arrow );
  70.     
  71.     return;
  72. }
  73.  
  74.  
  75. void    DoMouseDown( const EventRecord *event )
  76. {
  77.     WindowRef    window;
  78.     short        partCode;
  79.     
  80.     // find out where this click when down in
  81.     
  82.     partCode = FindWindow( event->where, &window );
  83.     
  84.     // dispatch on partCode
  85.     
  86.     switch ( partCode )
  87.     {
  88.         case inMenuBar:
  89.             PrepareMenus();
  90.             DoMenuChoice( MenuSelect( event->where ) );
  91.         break;
  92.         
  93.         case inSysWindow:
  94.             // ??? shouldn't SystemClick be defined as
  95.             //     SystemClick(const EventRecord *, WindowRef) ???
  96.             SystemClick( event, (WindowPtr) window );
  97.         break;
  98.         
  99.         case inContent:
  100.             if ( DoContent( event->where, event, window ) )
  101.                 SelectWindow( window );
  102.         break;
  103.         
  104.         case inDrag:
  105.             DoDrag( event->where, window );
  106.         break;
  107.         
  108.         case inGrow:
  109.             DoGrow( event->where, window );
  110.         break;
  111.         
  112.         case inGoAway:
  113.             if ( TrackGoAway( window, event->where ) )
  114.                 if ( DoClose( closingWindow, savingAsk, window ) != noErr )
  115.                     ; // insert error handling
  116.         break;
  117.         
  118.         case inZoomIn:
  119.         case inZoomOut:
  120.             if ( TrackBox( window, event->where, partCode ) )
  121.                 DoZoom( partCode, window );
  122.         break;
  123.         
  124.         default:    // unnecessary, but to keep with the original code.
  125.             ;        // do nothing
  126.         
  127.     } // end:  switch (partCode)
  128.     
  129.     
  130.     return;
  131. }
  132.  
  133.  
  134. void    DoKeyDown( const EventRecord *event )
  135. {
  136.     char        key;
  137.     Boolean        isCmdKey;
  138.     
  139.     // extract character code from event message
  140.     
  141.     key = BAND( event->message, charCodeMask );
  142.     
  143.     // is this a command+key combo?
  144.     
  145.     isCmdKey = ( BAND( event->modifiers, cmdKey ) != 0 );
  146.     
  147.     // map function keys to the equivalent command+key combos
  148.     // note that all fuction keys generate the same code, i.e. 0x10
  149.     
  150.     if ( key == 0x10 )
  151.     {
  152.         isCmdKey = true;
  153.             
  154.         switch( BSR( BAND( event->message, keyCodeMask ), 8 ) )
  155.         {
  156.             case keyF1:
  157.                 key = 'z';
  158.             break;
  159.             
  160.             case keyF2:
  161.                 key = 'x';
  162.             break;
  163.             
  164.             case keyF3:
  165.                 key = 'c';
  166.             break;
  167.             
  168.             case keyF4:
  169.                 key = 'v';
  170.             break;
  171.             
  172.             default:
  173.                 key = 0;
  174.         
  175.         }// end switch BSR( BAND( event->message, keyCodeMask), 8 ) 
  176.     
  177.     } // end if ( key == 0x10 )
  178.     
  179.     // command + printable character combos are routed to MenuKey()
  180.     
  181.     if ( isCmdKey && (key >= 0x32 ) )
  182.     {
  183.         PrepareMenus();
  184.         DoMenuChoice( MenuKey(key) );
  185.     }
  186.     else
  187.     {
  188.         DoKey( key, event );
  189.     }
  190.     
  191.     return;
  192. }
  193.  
  194.  
  195. void    DoDiskEvent( const EventRecord *event )
  196. {
  197.     Point        dialogCorner;
  198.     OSErr        err;
  199.     
  200.     if ( BSR( event->message, 16) != noErr )
  201.     {
  202.         SetPt( &dialogCorner, 112, 80 );
  203.         err = DIBadMount( dialogCorner, event->message );
  204.     }
  205.     
  206.     return;
  207. }
  208.  
  209.  
  210. void    DoOSEvent( const EventRecord *event )
  211. {
  212.     short        osMessage;
  213.     WindowRef    window;
  214.     
  215.     // extract the OS message field from the event record
  216.     
  217.     osMessage = BSR( BAND( event->message, osEvtMessageMask), 24 );
  218.     
  219.     // dispatch on osMessage
  220.     
  221.     switch( osMessage )
  222.     {
  223.         case suspendResumeMessage:
  224.         {
  225.             window = FrontWindow();
  226.             
  227.             if ( window != NULL )
  228.                 DoActivate( BAND(event->message, resumeFlag) != 0, window );
  229.         }
  230.         break;
  231.         
  232.         case mouseMovedMessage:
  233.             ; // nothing
  234.         break;
  235.     }
  236.     
  237.     return;
  238. }
  239.  
  240.  
  241. void    DoHighLevelEvent( const EventRecord *event )
  242. {
  243.     if ( AEProcessAppleEvent( event ) != noErr )
  244.         ; // error handling
  245.     
  246.     return;
  247. }
  248.  
  249.  
  250. void    DoNullEvent( const EventRecord *event )
  251. {
  252. #pragma unused (event)
  253.  
  254.     WindowRef        window;
  255.     
  256.     window = FrontWindow();
  257.     
  258.     if ( window != NULL )
  259.         WEIdle( &gSleepTime, GetWindowWE(window) );
  260.     else
  261.         gSleepTime = LONG_MAX;
  262.         
  263.     return;
  264. }
  265.  
  266.  
  267. void    DoWindowEvent( const EventRecord *event )
  268. {
  269.     WindowRef        window;
  270.     
  271.     // the message field of the event record contains the window reference
  272.     
  273.     window = (WindowRef) event->message;
  274.     
  275.     // make sure this window is an application window; check the windowKind field
  276.  
  277.     if ( GetWindowKind( window ) != userKind )
  278.         return;
  279.     
  280.     switch ( event->what )
  281.     {
  282.         case updateEvt:
  283.             DoUpdate( window );
  284.         break;
  285.         
  286.         case activateEvt:
  287.             DoActivate( BAND( event->modifiers, activeFlag) != 0, window );
  288.         break;
  289.     }
  290.     
  291.     return;
  292. }
  293.  
  294.  
  295. void    ProcessEvent( void )
  296. {
  297.     EventRecord        event;
  298.     Boolean            gotEvent;
  299.     
  300.     gotEvent = WaitNextEvent( everyEvent, &event, gSleepTime, gMouseRgn );
  301.     
  302.     // give text services a chance to intercept this event
  303.     
  304.     if ( gHasTextServices )
  305.         if ( TSMEvent( &event ) )
  306.             ;
  307.     
  308.     // adjust cursor shape and set mouse region
  309.     // (we assume event.where is the current mouse position in global coordinates
  310.     // if event.what <= osEvt; high-level events store the event ID there)
  311.     
  312.     if ( event.what <= osEvt )
  313.         AdjustCursor( event.where, gMouseRgn );
  314.     
  315.     // dispatch on event.what
  316.     
  317.     switch( event.what )
  318.     {
  319.         case nullEvent:
  320.             DoNullEvent( &event );
  321.         break;
  322.         
  323.         case mouseDown:
  324.             DoMouseDown( &event);
  325.         break;
  326.         
  327.         case keyDown:
  328.         case autoKey:
  329.             DoKeyDown( &event );
  330.         break;
  331.         
  332.         case updateEvt:
  333.         case activateEvt:
  334.             DoWindowEvent( &event );
  335.         break;
  336.         
  337.         case diskEvt:
  338.             DoDiskEvent( &event );
  339.         break;
  340.         
  341.         case osEvt:
  342.             DoOSEvent( &event );
  343.         break;
  344.         
  345.         case kHighLevelEvent:
  346.             DoHighLevelEvent( &event );
  347.         break;
  348.         
  349.         default:
  350.             ;    // ignore other events
  351.     }
  352.     
  353.     if ( gotEvent )
  354.         gSleepTime = 0;  // force early idle after non-idle event
  355.     
  356.     return;
  357. }
  358.  
  359.  
  360. OSErr     GotRequiredParams( const AppleEvent *ae )
  361. {
  362.     OSErr        err;
  363.     DescType    returnedType;
  364.     Size        actualSize;
  365.     
  366.     err = AEGetAttributePtr( ae, keyMissedKeywordAttr, typeWildCard, &returnedType, NULL, 0, &actualSize );
  367.     
  368.     if ( err == errAEDescNotFound)
  369.         return( noErr );
  370.     
  371.     if ( err == noErr )
  372.         return( errAEParamMissed );
  373.     
  374.     return( err );
  375. }
  376.  
  377.  
  378. static pascal OSErr    HandleOpenDocument( const AppleEvent *ae, AppleEvent *reply, long refCon )
  379. {
  380. #pragma unused ( reply, refCon )
  381.     AEDescList        docList;
  382.     AEKeyword        keyWord;
  383.     DescType        returnedType;
  384.     Size            actualSize;
  385.     long            numberOfDocuments, i;
  386.     FSSpec            fileSpec;
  387.     OSErr            err;
  388.     
  389.     
  390.     err = noErr;
  391.     
  392.     // extract direct parameter from the AppleEVent
  393.     
  394.     err = AEGetParamDesc( ae, keyDirectObject, typeAEList, &docList );
  395.     if ( err != noErr )
  396.     {
  397.         AEDisposeDesc( &docList );
  398.         return err;
  399.     }
  400.  
  401.     // perform the recommended check for additional required parameters
  402.     
  403.     err = GotRequiredParams( ae );
  404.     if ( err != noErr )
  405.     {
  406.         AEDisposeDesc( &docList );
  407.         return err;
  408.     }
  409.  
  410.     // count the items in the list of aliases
  411.     
  412.     err = AECountItems( &docList, &numberOfDocuments );
  413.     if ( err != noErr )
  414.     {
  415.         AEDisposeDesc( &docList );
  416.         return err;
  417.     }
  418.  
  419.     for ( i = 1; i <= numberOfDocuments; i++ )
  420.     {
  421.         // coerce the nth alias to a file system specification record
  422.         
  423.         err = AEGetNthPtr( &docList, i, typeFSS, &keyWord, &returnedType, (Ptr)&fileSpec, sizeof( fileSpec ), &actualSize );
  424.     
  425.         if ( err != noErr )
  426.         {
  427.             AEDisposeDesc( &docList );
  428.             return err;
  429.         }
  430.  
  431.         // open the specified file
  432.         
  433.         err = CreateWindow( &fileSpec );
  434.         if ( err != noErr )
  435.         {
  436.             AEDisposeDesc( &docList );
  437.             return err;
  438.         }
  439.     }
  440.     
  441.     // dispose of the alias list
  442.     
  443.     err = AEDisposeDesc( &docList );
  444.     if ( err != noErr )
  445.     {
  446.         AEDisposeDesc( &docList );
  447.         return err;
  448.     }
  449.  
  450.     return err;
  451. }
  452.  
  453.  
  454. static pascal OSErr    HandleOpenApplication( const AppleEvent *ae, AppleEvent *reply, long refCon )
  455. {
  456. #pragma unused ( reply, refCon )
  457.     OSErr        err;
  458.     
  459.     // perform the recommended check for additional required parameters
  460.     
  461.     err = GotRequiredParams( ae );
  462.     if ( err != noErr )
  463.         return err;
  464.     
  465.     // create a new window from scratch
  466.     
  467.     err = CreateWindow( NULL );
  468.     
  469.     return err;
  470. }
  471.  
  472. static pascal OSErr    HandleQuitApplication( const AppleEvent *ae, AppleEvent *reply, long refCon )
  473. {
  474. #pragma unused (reply, refCon)
  475.  
  476.     AEKeyword        optKey;
  477.     DescType        actualType;
  478.     Size            actualSize;
  479.     SavingOption    saving;
  480.     OSErr            err;
  481.     
  482.     // default saving option is savingAsk;
  483.     
  484.     saving = savingAsk;
  485.     
  486.     // extract optional save options
  487.     
  488.     err = AEGetParamPtr( ae, keyAESaveOptions, typeEnumerated, &actualType, &optKey, sizeof( optKey ), &actualSize );
  489.     if ( err == noErr )
  490.     {
  491.         if ( optKey == kAEYes )
  492.             saving = savingYes;
  493.         else if (optKey == kAENo )
  494.             saving = savingNo;
  495.         else if ( optKey != kAEAsk )
  496.         {
  497.             err = paramErr;    // for want of a better code
  498.             return err;
  499.         }
  500.     }
  501.     
  502.     // perform the recommended check for additional required parameters
  503.     
  504.     err = GotRequiredParams( ae );
  505.     
  506.     if ( err != noErr )
  507.         return err;
  508.     
  509.     // actually do the quit stuff
  510.     
  511.     err = DoQuit( saving );
  512.     
  513.     return err;
  514. }
  515.  
  516.  
  517. OSErr    InitializeEvents( void )
  518. {
  519.     OSErr    err;
  520.     
  521.     err = noErr;
  522.     
  523.     // allocate space for the mouse region
  524.     
  525.     gMouseRgn = NewRgn();
  526.     
  527.     // install AppleEvent handlers for the Required Suite
  528.     
  529.     err = AEInstallEventHandler( kCoreEventClass, kAEOpenApplication, NewAEEventHandlerProc( HandleOpenApplication ), 0, false );
  530.     if ( err != noErr )
  531.         return err;
  532.     
  533.     err = AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerProc( HandleOpenDocument ), kDoOpen, false );
  534.     if ( err != noErr )
  535.         return err;
  536.     
  537.     err = AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments, NewAEEventHandlerProc( HandleOpenDocument ), kDoPrint, false );
  538.     if ( err != noErr )
  539.         return err;
  540.     
  541.     err = AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, NewAEEventHandlerProc( HandleQuitApplication ), 0, false );
  542.     if ( err != noErr )
  543.         return err;
  544.     
  545.     // install Apple event handlers for a subset of the Core suite
  546.     
  547.     err = InstallCoreHandlers();
  548.     if ( err != noErr )
  549.         return err;
  550.     
  551.     // install Apple event handlers for inline input
  552.     
  553.     err = WEInstallTSMHandlers();
  554.     if ( err != noErr )
  555.         return err;
  556.     
  557.     return err;
  558. }