home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 4 / ETO Development Tools 4.iso / Tools - Objects / MacApp / MacApp 3.0a2 / Libraries / UEvtHandler.cp < prev    next >
Encoding:
Text File  |  1991-05-01  |  20.1 KB  |  776 lines  |  [TEXT/MPS ]
  1. // UEvtHandler.cp 
  2. // Copyright © 1984-1991 by Apple Computer Inc.    All rights reserved.
  3.  
  4.  
  5. #ifndef __UEVTHANDLER__
  6. #include <UEvtHandler.h>
  7. #endif
  8.  
  9. #ifndef __STDIO__
  10. #include <StdIo.h>
  11. #endif
  12.  
  13. #ifndef __UGEOMETRY__
  14. #include <UGeometry.h>
  15. #endif
  16.  
  17. #ifndef __UBEHAVIOR__
  18. #include <UBehavior.h>
  19. #endif
  20.  
  21. #ifndef __RESOURCES__
  22. #include <Resources.h>
  23. #endif
  24.  
  25. #ifndef __STDLIB__
  26. #include <StdLib.h>
  27. #endif
  28.  
  29. #ifndef __UAPPLICATION__
  30. #include <UApplication.h>
  31. #endif
  32.  
  33. #ifndef __UVIEW__
  34. #include <UView.h>
  35. #endif
  36.  
  37. #ifndef __UMACAPPUTILITIES__
  38. #include <UMacAppUtilities.h>
  39. #endif
  40.  
  41. #ifndef __UERRORMGR__
  42. #include <UErrorMgr.h>
  43. #endif
  44.  
  45. #ifndef __UMACAPPGLOBALS__
  46. #include <UMacAppGlobals.h>
  47. #endif
  48.  
  49. //--------------------------------------------------------------------------------------------------
  50. Point gStdHysteresis;
  51.  
  52. //--------------------------------------------------------------------------------------------------
  53. #pragma segment MAEvtHandlerRes
  54.  
  55. Boolean CHandlerIterator::More()
  56. {
  57.     return (fCurrentHandler != NULL);
  58. }
  59.  
  60. //--------------------------------------------------------------------------------------------------
  61. #pragma segment MAEvtHandlerRes
  62.  
  63. void CHandlerIterator::Reset()
  64. {
  65.     fCurrentHandler = fFirstHandler;
  66. }
  67.  
  68. //--------------------------------------------------------------------------------------------------
  69. #pragma segment MAEvtHandlerRes
  70.  
  71. void CHandlerIterator::Advance()
  72. {
  73.     fCurrentHandler = fNextHandler;
  74.     if (fCurrentHandler)
  75.         fNextHandler = fCurrentHandler->GetNextHandler();
  76. }
  77.  
  78. //--------------------------------------------------------------------------------------------------
  79. #pragma segment MAEvtHandlerRes
  80.  
  81. pascal void TEvtHandler::Initialize(void)        // override 
  82. {
  83.     inherited::Initialize();
  84.  
  85.     fNextHandler = NULL;
  86.     fIdleFreq = kMaxIdleTime;                    // Assume it never wants idle time 
  87.     fLastIdle = 0;
  88.     fEnabled = TRUE;                            // Default to taking events 
  89.     fBehavior = NULL;
  90.     fIdentifier = kNoIdentifier;
  91. }
  92.  
  93. //--------------------------------------------------------------------------------------------------
  94. #pragma segment MAEvtHandlerRes
  95.  
  96. pascal void TEvtHandler::IEvtHandler(TEvtHandler* itsNextHandler)
  97. {
  98.     this->IObject();
  99.     fNextHandler = itsNextHandler;
  100. }
  101.  
  102. //--------------------------------------------------------------------------------------------------
  103. #pragma segment MAEvtHandlerRes
  104.  
  105. pascal void TEvtHandler::BecameWindowTarget(void)
  106. {
  107.     this->HandleEvent(mBecameWindowTarget,this,NULL);
  108. }
  109.  
  110. //--------------------------------------------------------------------------------------------------
  111. #pragma segment MAEvtHandlerRes
  112.  
  113. pascal void TEvtHandler::BecameApplicationTarget(void)
  114. {
  115.     this->HandleEvent(mBecameApplicationTarget,this,NULL);
  116. }
  117.  
  118. //--------------------------------------------------------------------------------------------------
  119. #pragma segment MAEvtHandlerRes
  120.  
  121. pascal Boolean TEvtHandler::IsEnabled(void)
  122. {
  123.     return fEnabled;
  124. }
  125.  
  126. //--------------------------------------------------------------------------------------------------
  127. #pragma segment MAEvtHandlerRes
  128.  
  129. pascal void TEvtHandler::SetEnable(Boolean state)
  130. {
  131.     fEnabled = state;
  132. }
  133.  
  134. //--------------------------------------------------------------------------------------------------
  135. #pragma segment MAClose
  136.  
  137. pascal void TEvtHandler::Free(void)                // override 
  138. {
  139.     TEvtHandler * nextHandler;
  140.  
  141.     if (gApplication->GetTarget() == this)
  142.     {
  143.         nextHandler = this->GetNextHandler();
  144.         if (nextHandler == NULL)
  145.             gApplication->SetTarget(gApplication);
  146.         else
  147.             gApplication->SetTarget(nextHandler);
  148.     }
  149.     fNextHandler = NULL;
  150.     
  151.     fBehavior = (TBehavior*)FreeIfObject(fBehavior);
  152.     
  153.     inherited::Free();
  154. }
  155.  
  156. //--------------------------------------------------------------------------------------------------
  157. #pragma segment MANonRes
  158.  
  159. pascal TEvtHandler* TEvtHandler::AddHandler(TEvtHandler* headOfChain)
  160. {
  161.     // add headOfChain to the end of the chain 
  162.     if (fNextHandler != NULL)
  163.         fNextHandler->AddHandler(headOfChain);
  164.     else
  165.         fNextHandler = headOfChain;
  166.     return this;                                // new head of chain 
  167. }
  168.  
  169. //--------------------------------------------------------------------------------------------------
  170. #pragma segment MANonRes
  171.  
  172. pascal TEvtHandler* TEvtHandler::RemoveHandler(TEvtHandler* headOfChain)
  173. {
  174.     TEvtHandler * prevCohandler;
  175.     TEvtHandler * currCohandler;
  176.     TEvtHandler * newHeadOfChain;
  177.  
  178.     prevCohandler = NULL;
  179.     currCohandler = headOfChain;
  180.     newHeadOfChain = headOfChain;
  181.     while (currCohandler != NULL)
  182.     {
  183.         if (currCohandler == this)                // found it 
  184.         {
  185.             if (prevCohandler == NULL)            /* I was the head of the chain, so there will
  186.                                                   be a new head of chain */
  187.                 newHeadOfChain = fNextHandler;
  188.             else
  189.                 prevCohandler->fNextHandler = fNextHandler;// take me out of the link 
  190.             fNextHandler = NULL;                /* remember that i'm not in the chain anymore
  191.                                                 */
  192.             currCohandler = NULL;                // So loop will end 
  193.         }
  194.         else
  195.         {
  196.             prevCohandler = currCohandler;
  197.             currCohandler = currCohandler->fNextHandler;
  198.         }
  199.     }
  200.     return newHeadOfChain;
  201. }
  202.  
  203. //--------------------------------------------------------------------------------------------------
  204. #pragma segment MAFields
  205.  
  206. pascal void TEvtHandler::Fields(TObject* obj)
  207. {
  208.     obj->DoToField("TEvtHandler", NULL, bClass);
  209.     obj->DoToField("fNextHandler", &fNextHandler, bObject);
  210.     obj->DoToField("fBehavior", &fBehavior, bObject);
  211.     obj->DoToField("fIdleFreq", &fIdleFreq, bLongInt);
  212.     obj->DoToField("fLastIdle", &fLastIdle, bLongInt);
  213.     obj->DoToField("fEnabled", &fEnabled, bBoolean);
  214.     obj->DoToField("fIdentifier", &fIdentifier, bIDType);
  215.  
  216.     inherited::Fields(obj);
  217. }
  218.  
  219. //--------------------------------------------------------------------------------------------------
  220. #pragma segment MAEvtHandlerRes
  221.  
  222. pascal void TEvtHandler::DoAppleCommand(CmdNumber aCmdNumber,
  223.                                         const AppleEvent& message,
  224.                                         const AppleEvent& reply)
  225. {
  226.     TEvtHandler * nextHandler;
  227.  
  228.     nextHandler = this->GetNextHandler();
  229.     
  230.     if ( nextHandler != NULL)
  231.         nextHandler->HandleAppleCommand(aCmdNumber, message, reply);
  232.     else
  233.     {
  234.         // Nobody handled the event.  Let the AppleEvent Manager search through
  235.         // the system handlers.  gApplication->DispatchAppleEvent will catch the
  236.         // failure and report it back to the AppleEvent Manager.
  237.         FailOSErr(errAEEventNotHandled);
  238. #if qDebugMsg
  239.         fprintf(stderr, "No one handled the AppleEvent %1d", aCmdNumber);
  240. #endif
  241.     }
  242. }
  243.  
  244. //--------------------------------------------------------------------------------------------------
  245. #pragma segment MAEvtHandlerRes
  246.  
  247. pascal void TEvtHandler::HandleAppleCommand(CmdNumber aCmdNumber,
  248.                                         const AppleEvent& message,
  249.                                         const AppleEvent& reply)
  250. {
  251.     TBehavior* aBehavior;
  252.     
  253.     aBehavior = this->GetFirstBehavior();    
  254.     if ( aBehavior )
  255.         aBehavior->DoAppleCommand ( aCmdNumber, message, reply );
  256.     else
  257.         this->DoAppleCommand ( aCmdNumber, message, reply );
  258.     
  259. }
  260.  
  261. //--------------------------------------------------------------------------------------------------
  262. #pragma segment MAEvtHandlerRes
  263.  
  264. pascal void TEvtHandler::DoCommandKey(TToolboxEvent* event)
  265. {
  266.     TEvtHandler * nextHandler;
  267.  
  268.     nextHandler = this->GetNextHandler();
  269.     if (nextHandler)
  270.         nextHandler->HandleCommandKey(event);
  271.         
  272. }
  273.  
  274. //--------------------------------------------------------------------------------------------------
  275. #pragma segment MAEvtHandlerRes
  276.  
  277. pascal void TEvtHandler::HandleCommandKey(TToolboxEvent* event)
  278. {
  279.     TBehavior* aBehavior;
  280.  
  281.     aBehavior = this->GetFirstBehavior();    
  282.     if ( aBehavior )
  283.         aBehavior->DoCommandKey ( event );
  284.     else
  285.         this->DoCommandKey ( event );
  286.     
  287. }
  288.  
  289. //--------------------------------------------------------------------------------------------------
  290. #pragma segment MAEvtHandlerRes
  291.  
  292. pascal Boolean TEvtHandler::DoCoHandlerEvent(TEvent*)
  293. {
  294.     return FALSE;
  295. }
  296.  
  297. //--------------------------------------------------------------------------------------------------
  298. #pragma segment MAHelp
  299.  
  300. pascal void TEvtHandler::DoHelp(TToolboxEvent* event,
  301.                                 long& message)
  302. {
  303.     TEvtHandler * nextHandler;
  304.  
  305.     nextHandler = this->GetNextHandler();
  306.     
  307.     if (nextHandler != NULL)
  308.         nextHandler->DoHelp(event, message);
  309. }
  310.  
  311. //--------------------------------------------------------------------------------------------------
  312. #pragma segment MAEvtHandlerRes
  313.  
  314. pascal long TEvtHandler::NextIdle(void)
  315. {
  316.     if ((fIdleFreq != kMaxIdleTime) && (this->IsEnabled()))// Does it idle at all? 
  317.     {
  318.         if (fLastIdle == 0)                        // if never idled then it needs idling now 
  319.             return TickCount();
  320.         else
  321.             return (fLastIdle + fIdleFreq);
  322.     }
  323.     else
  324.         return kMaxIdleTime;
  325. }
  326.  
  327. //--------------------------------------------------------------------------------------------------
  328. #pragma segment MAEvtHandlerRes
  329.  
  330. pascal void TEvtHandler::HandleIdle(IdlePhase phase)
  331. {
  332.     if ((fIdleFreq != kMaxIdleTime) && (this->IsEnabled()))// Does it idle at all? 
  333.     {
  334.         /* idleBegin and idleEnd don't respect fIdleFreq because they are
  335.           notifications that the application is beginning/ending idle.
  336.           idleContinues, however, are parceled out at the fIdleFreq. */
  337.         if ((phase != idleContinue) || (TickCount() - fLastIdle >= fIdleFreq))
  338.         {
  339.             /* don't store the fLastIdle if the I FREE'd myself or
  340.               the idlePhase is not idleContinue */
  341.             if (!(this->DoIdle(phase)) && (phase == idleContinue))
  342.                 fLastIdle = TickCount();
  343.         }
  344.     }
  345. }
  346.  
  347. //--------------------------------------------------------------------------------------------------
  348. #pragma segment MAEvtHandlerRes
  349.  
  350. pascal Boolean TEvtHandler::DoIdle(IdlePhase)
  351. {
  352.     return FALSE;                                // Did not free myself 
  353. }
  354.  
  355. //--------------------------------------------------------------------------------------------------
  356. #pragma segment MAEvtHandlerRes
  357.  
  358. pascal void TEvtHandler::DoKeyCommand(TToolboxEvent* event)
  359. {
  360.     TEvtHandler * nextHandler;
  361.  
  362.     nextHandler = this->GetNextHandler();
  363.     if (nextHandler)
  364.         nextHandler->HandleKeyCommand(event);
  365.         
  366. }
  367.  
  368. //--------------------------------------------------------------------------------------------------
  369. #pragma segment MAEvtHandlerRes
  370.  
  371. pascal void TEvtHandler::HandleKeyCommand(TToolboxEvent* event)
  372. {
  373.     TBehavior* aBehavior;
  374.  
  375.     aBehavior = this->GetFirstBehavior();    
  376.     if ( aBehavior )
  377.         aBehavior->DoKeyCommand ( event );
  378.     else
  379.         this->DoKeyCommand ( event );
  380.     
  381. }
  382.  
  383. //--------------------------------------------------------------------------------------------------
  384. #pragma segment MASelCommand
  385.  
  386. pascal void TEvtHandler::DoMenuCommand(CmdNumber aCmdNumber)
  387. {
  388.     TEvtHandler * nextHandler;
  389.  
  390.     nextHandler = this->GetNextHandler();    
  391.     if ( nextHandler )
  392.         nextHandler->HandleMenuCommand(aCmdNumber);
  393.     else
  394.     {
  395. #if qDebugMsg
  396.         fprintf(stderr, "No one handled the command %1d", aCmdNumber);
  397. #endif
  398.     }
  399.     
  400. }
  401.  
  402. //--------------------------------------------------------------------------------------------------
  403. #pragma segment MAEvtHandlerRes
  404.  
  405. pascal void TEvtHandler::HandleMenuCommand(CmdNumber aCmdNumber)
  406. {
  407.     TBehavior* aBehavior;
  408.  
  409.     aBehavior = this->GetFirstBehavior();    
  410.     if ( aBehavior )
  411.         aBehavior->DoMenuCommand ( aCmdNumber );
  412.     else
  413.         this->DoMenuCommand ( aCmdNumber );
  414.     
  415. }
  416.  
  417. //--------------------------------------------------------------------------------------------------
  418. #pragma segment MAEvtHandlerRes
  419.  
  420. pascal Boolean TEvtHandler::DoMultiClick(Point lastDownPt,
  421.                                          Point newDownPt)
  422. {
  423.     TEvtHandler * nextHandler;
  424.  
  425.     nextHandler = this->GetNextHandler();
  426.     if (nextHandler != NULL)
  427.         return (nextHandler->DoMultiClick(lastDownPt, newDownPt));
  428.     else
  429.         return ((abs(lastDownPt.h - newDownPt.h) <= (gStdHysteresis.h)) && (abs(lastDownPt.v - newDownPt.v) <= (gStdHysteresis.v)));
  430. }
  431.  
  432. //--------------------------------------------------------------------------------------------------
  433. #pragma segment MAEvtHandlerRes
  434.  
  435. pascal void TEvtHandler::DoSetupMenus(void)
  436. {
  437.     TEvtHandler * nextHandler;
  438.  
  439.     nextHandler = this->GetNextHandler();
  440.     if (nextHandler)
  441.         nextHandler->HandleSetupMenus();
  442. }
  443.  
  444. //--------------------------------------------------------------------------------------------------
  445. #pragma segment MAEvtHandlerRes
  446.  
  447. pascal void TEvtHandler::HandleSetupMenus(void)
  448. {
  449.     TBehavior* aBehavior;
  450.  
  451.     aBehavior = this->GetFirstBehavior();    
  452.     if ( aBehavior )
  453.         aBehavior->DoSetupMenus();
  454.     else
  455.         this->DoSetupMenus();
  456.     
  457. }
  458.  
  459. //--------------------------------------------------------------------------------------------------
  460. #pragma segment MAEvtHandlerRes
  461.  
  462. pascal void TEvtHandler::EachHandler(pascal void(* DoToEvtHandler)(TEvtHandler* anEvtHandler,
  463.                                                                    void* staticLink),
  464.                                      void* staticLink)
  465. {
  466.     CHandlerIterator iter(this);
  467.     
  468.     for (TEvtHandler* aHandler = iter.FirstHandler(); iter.More(); aHandler = iter.NextHandler())
  469.         DoToEvtHandler(aHandler, staticLink);
  470. }
  471.  
  472. //--------------------------------------------------------------------------------------------------
  473. #pragma segment MAEvtHandlerRes
  474.  
  475. pascal TEvtHandler* TEvtHandler::FirstHandlerThat(pascal Boolean(* TestEvtHandler)(TEvtHandler* anEvtHandler,
  476.                                                                                    void* staticLink),
  477.                                                   void* staticLink)
  478. {
  479.     CHandlerIterator iter(this);
  480.     
  481.     for (TEvtHandler* aHandler = iter.FirstHandler(); iter.More(); aHandler = iter.NextHandler())
  482.         if (TestEvtHandler(aHandler, staticLink))
  483.             return aHandler;
  484.     return NULL;
  485. }
  486.  
  487. //--------------------------------------------------------------------------------------------------
  488. #pragma segment MAEvtHandlerRes
  489.  
  490. pascal TEvtHandler* TEvtHandler::GetNextHandler(void)
  491. {
  492.     return fNextHandler;
  493. }
  494.  
  495. //--------------------------------------------------------------------------------------------------
  496. #pragma segment MADebug
  497.  
  498. pascal long TEvtHandler::LookupSymbol(Str255& sym)
  499. {
  500.     TEvtHandler * nextHandler;
  501.  
  502.     nextHandler = this->GetNextHandler();
  503.     if (nextHandler != NULL)
  504.         return (nextHandler->LookupSymbol(sym));
  505.     else
  506.         return (-1);
  507. }
  508.  
  509. //--------------------------------------------------------------------------------------------------
  510. #pragma segment MAEvtHandlerRes
  511.  
  512. pascal void TEvtHandler::CommitLastCommand(void)
  513. {
  514.     TEvtHandler * nextHandler;
  515.  
  516.     nextHandler = this->GetNextHandler();
  517.     if (nextHandler != NULL)
  518.         nextHandler->CommitLastCommand();
  519. }
  520.  
  521. //--------------------------------------------------------------------------------------------------
  522. #pragma segment MAEvtHandlerRes
  523.  
  524. pascal TEvent* TEvtHandler::RetrieveAnEvent(void)    // Override
  525. {
  526.     TEvtHandler * nextHandler;
  527.  
  528.     nextHandler = this->GetNextHandler();
  529.     if (nextHandler != NULL)
  530.         return nextHandler->RetrieveAnEvent();
  531.     else
  532.         return NULL;
  533. }
  534.  
  535. //--------------------------------------------------------------------------------------------------
  536. #pragma segment MAEvtHandlerRes
  537.  
  538. pascal TCommand* TEvtHandler::GetLastCommand(void)
  539. {
  540.     TEvtHandler * nextHandler;
  541.  
  542.     nextHandler = this->GetNextHandler();
  543.     if (nextHandler != NULL)
  544.         return (nextHandler->GetLastCommand());
  545.     else
  546.         return NULL;
  547. }
  548.  
  549. //--------------------------------------------------------------------------------------------------
  550. #pragma segment MAEvtHandlerRes
  551.  
  552. pascal void TEvtHandler::PerformCommand(TCommand* command)
  553. {
  554.     TEvtHandler * nextHandler;
  555.  
  556.     nextHandler = this->GetNextHandler();
  557.     if (nextHandler != NULL)
  558.         nextHandler->PerformCommand(command);
  559.     else
  560.     {
  561. #if qDebug
  562.         WrLblHexLongint("No one performed the command ", (long)(command));
  563. #endif
  564.  
  565.         if (command->ShouldFreeOnCompletion())
  566.             command = (TCommand *)(FreeIfObject(command));
  567.     }
  568. }
  569.  
  570. //--------------------------------------------------------------------------------------------------
  571. #pragma segment MAEvtHandlerRes
  572.  
  573. pascal void TEvtHandler::SetIdleFreq(long newIdleFreq)
  574. {
  575.     fIdleFreq = newIdleFreq;
  576. }
  577.  
  578. //--------------------------------------------------------------------------------------------------
  579. #pragma segment MAEvtHandlerRes
  580.  
  581. pascal void TEvtHandler::RemoveBehavior (TBehavior* theBehavior)
  582. {
  583.     if (theBehavior == fBehavior)
  584.         fBehavior = fBehavior->GetNextBehavior();
  585.     else
  586.         fBehavior->Remove(theBehavior);
  587. }
  588.  
  589. //--------------------------------------------------------------------------------------------------
  590. #pragma segment MAEvtHandlerRes
  591.  
  592. pascal void TEvtHandler::AddBehavior (TBehavior* theBehavior)
  593. {
  594.     theBehavior->SetOwner(this);                     // make this object its owner
  595.  
  596.     if (fBehavior)        
  597.         fBehavior->SetNextBehavior (theBehavior);
  598.     else
  599.         fBehavior = theBehavior;
  600. }
  601.  
  602. //--------------------------------------------------------------------------------------------------
  603. #pragma segment MAEvtHandlerRes
  604.  
  605. pascal TBehavior* TEvtHandler::GetFirstBehavior ( void )
  606. {
  607.     return fBehavior;
  608. }
  609.  
  610. //--------------------------------------------------------------------------------------------------
  611. #pragma segment MAEvtHandlerRes
  612.  
  613. pascal void TEvtHandler::PostAnEvent(TEvent* event)
  614. {
  615.     TEvtHandler * nextHandler;
  616.  
  617.     nextHandler = this->GetNextHandler();
  618.     if (nextHandler != NULL)
  619.         nextHandler->PostAnEvent(event);
  620.     else
  621.     {
  622. #if qDebug
  623.         WrLblHexLongint("No one posted the event ", (long)(event));
  624. #endif
  625.  
  626.         if (event->ShouldFreeOnCompletion())
  627.             event = (TEvent *)(FreeIfObject(event));
  628.     }
  629. }
  630.  
  631. //--------------------------------------------------------------------------------------------------
  632. #pragma segment MAEvtHandlerRes
  633.  
  634. pascal void TEvtHandler::PostCommand(TCommand* command)
  635.  
  636. {
  637. //!!! Left in for compatibility.
  638.     TEvtHandler * nextHandler;
  639.  
  640.     nextHandler = this->GetNextHandler();
  641.     if (nextHandler != NULL)
  642.         nextHandler->PostCommand(command);
  643.     else
  644.     {
  645. #if qDebug
  646.         WrLblHexLongint("No one posted the command ", (long)(command));
  647. #endif
  648.  
  649.         if (command->ShouldFreeOnCompletion())
  650.             command = (TCommand*)(FreeIfObject(command));
  651.     }
  652. }
  653.  
  654. //--------------------------------------------------------------------------------------------------
  655. #pragma segment MAEvtHandlerRes
  656.  
  657. pascal void TEvtHandler::ResignedWindowTarget(void)
  658.  
  659. {
  660.     this->HandleEvent(mResignedWindowTarget,this,NULL);
  661. }
  662.  
  663. //--------------------------------------------------------------------------------------------------
  664. #pragma segment MAEvtHandlerRes
  665.  
  666. pascal void TEvtHandler::ResignedApplicationTarget(void)
  667.  
  668. {
  669.     this->HandleEvent(mResignedApplicationTarget,this,NULL);
  670. }
  671.  
  672. //--------------------------------------------------------------------------------------------------
  673. #pragma segment MATerminate
  674.  
  675. pascal void TEvtHandler::Terminate(void)
  676.  
  677. {
  678. }
  679.  
  680. //--------------------------------------------------------------------------------------------------
  681. #pragma segment MAEvtHandlerRes
  682.  
  683. pascal Boolean TEvtHandler::WantToBecomeTarget(void)
  684.  
  685. {
  686.     return FALSE;
  687. }
  688.  
  689. //--------------------------------------------------------------------------------------------------
  690. #pragma segment MAEvtHandlerRes
  691.  
  692. pascal long TEvtHandler::WillingToResignTarget(void)
  693.  
  694. {
  695.     return 0;                                    // kValidValue 
  696. }
  697.  
  698. //--------------------------------------------------------------------------------------------------
  699. #pragma segment MAEvtHandlerRes
  700.  
  701. pascal void TEvtHandler::KeyEventToComponents(TToolboxEvent* event)
  702.  
  703. {
  704.     TEvtHandler * nextHandler = this->GetNextHandler();
  705.     if (nextHandler)
  706.         nextHandler->KeyEventToComponents(event);
  707.     else
  708.     {
  709.         if ((event->fEventRecord.what == keyDown) || (event->fEventRecord.what == autoKey))
  710.         {
  711.             // Default extractions 
  712.             event->fCharacter = (char)(event->fEventRecord.message & charCodeMask);
  713.             event->fKeyCode = (unsigned short)(event->fEventRecord.message & keyCodeMask) >> 8;
  714.         }
  715.     }
  716. }
  717.  
  718. //--------------------------------------------------------------------------------------------------
  719. #pragma segment MAEvtHandlerRes
  720.  
  721. pascal void TEvtHandler::TargetValidationSucceeded()
  722.  
  723. {
  724. }
  725.  
  726. //--------------------------------------------------------------------------------------------------
  727. #pragma segment MAEvtHandlerRes
  728.  
  729. pascal void TEvtHandler::TargetValidationFailed(long reason)
  730.  
  731. {
  732. }
  733.  
  734.  
  735. //--------------------------------------------------------------------------------------------------
  736. #pragma segment MAEvtHandlerRes
  737.  
  738. pascal void TEvtHandler::DoEvent(EvtNumber eventNumber,
  739.                                      TEvtHandler* source,
  740.                                      TEvent* event)
  741. {
  742.     TEvtHandler * nextHandler;
  743.  
  744.     nextHandler = this->GetNextHandler();    
  745.     if (nextHandler)
  746.         nextHandler->HandleEvent(eventNumber, source, event);
  747.     else if (gIntenseDebugging)
  748.     {
  749.         fprintf(stderr, "in TEvtHandler.DoHandleEvent: no one handled the event: %1d", eventNumber);
  750.         WrLblHexLongint(" From source: ", (long)(source));
  751.         fprintf(stderr, "\n");
  752.         WrLblHexLongint(" Event object: ", (long)(event));
  753.         fprintf(stderr, "\n");
  754.     }
  755. }
  756.  
  757. //--------------------------------------------------------------------------------------------------
  758. #pragma segment MAEvtHandlerRes
  759.  
  760. pascal void TEvtHandler::HandleEvent(    EvtNumber eventNumber,
  761.                                         TEvtHandler* source,
  762.                                         TEvent* event)
  763. {
  764.     TBehavior* aBehavior;
  765.     
  766.     aBehavior = this->GetFirstBehavior();    
  767.     if ( aBehavior )
  768.         aBehavior->DoEvent ( eventNumber, source, event );
  769.     else
  770.         this->DoEvent ( eventNumber, source, event );
  771.     
  772. }
  773.  
  774.  
  775.  
  776.