home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc Development Framework / ODFDev / ODF / Framewrk / FWEvents / FWEventH.cpp < prev    next >
Encoding:
Text File  |  1996-09-17  |  28.9 KB  |  830 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FWEventH.cpp
  4. //    Release Version:    $ ODF 2 $
  5. //
  6. //    Copyright:    (c) 1993 - 1996 by Apple Computer, Inc., all rights reserved.
  7. //
  8. //========================================================================================
  9.  
  10. #include "FWFrameW.hpp"
  11.  
  12. #ifndef FWEVENT_H
  13. #include "FWEvent.h"
  14. #endif
  15.  
  16. #ifndef FWEVENTH_H
  17. #include "FWEventH.h"
  18. #endif
  19.  
  20. #ifndef FWFRAME_H
  21. #include "FWFrame.h"
  22. #endif
  23.  
  24. #ifndef FWMNUBAR_H
  25. #include "FWMnuBar.h"
  26. #endif
  27.  
  28. #ifndef FWORDCOL_H
  29. #include "FWOrdCol.h"
  30. #endif
  31.  
  32. #ifndef FWCURSOR_H
  33. #include "FWCursor.h"
  34. #endif
  35.  
  36. #ifndef SOM_ODFrame_xh
  37. #include <Frame.xh>
  38. #endif
  39.  
  40. #ifndef SOM_ODFacet_xh
  41. #include <Facet.xh>
  42. #endif
  43.  
  44. #ifndef FWSOMENV_H
  45. #include "FWSOMEnv.h"
  46. #endif
  47.  
  48. #pragma segment fwevents
  49.  
  50. //========================================================================================
  51. //    Template Instantiations
  52. //========================================================================================
  53.  
  54. FW_DEFINE_AUTO_TEMPLATE(FW_TOrderedCollectionIterator, FW_MEventHandler)
  55. FW_DEFINE_AUTO_TEMPLATE(FW_TOrderedCollection, FW_MEventHandler)
  56.  
  57. #ifdef FW_USE_TEMPLATE_PRAGMAS
  58.  
  59. #pragma template_access public
  60. #pragma template FW_TOrderedCollection<FW_MEventHandler>
  61. #pragma template FW_TOrderedCollectionIterator<FW_MEventHandler>
  62.  
  63. #endif
  64.  
  65. //========================================================================================
  66. // class FW_MEventHandler
  67. //========================================================================================
  68.  
  69. FW_DEFINE_CLASS_M0(FW_MEventHandler)
  70.  
  71. //----------------------------------------------------------------------------------------
  72. // FW_MEventHandler::FW_MEventHandler
  73. //----------------------------------------------------------------------------------------
  74.  
  75. FW_MEventHandler::FW_MEventHandler()
  76.   : fNextEventHandler(NULL),
  77.     fEnabled(true),
  78.     fPriority(FW_kNoPriority),
  79.     fEventHandlers(NULL)
  80. {
  81. }
  82.  
  83. //----------------------------------------------------------------------------------------
  84. // FW_MEventHandler::FW_MEventHandler
  85. //----------------------------------------------------------------------------------------
  86.  
  87. FW_MEventHandler::FW_MEventHandler(Environment* ev, FW_MEventHandler* nextEventHandler, FW_Priority thePriority)
  88.   : fNextEventHandler(nextEventHandler),
  89.     fEnabled(true),
  90.     fPriority(thePriority),
  91.     fEventHandlers(NULL)
  92. {
  93. FW_UNUSED(ev);
  94. }
  95.  
  96. //----------------------------------------------------------------------------------------
  97. //    FW_MEventHandler::~FW_MEventHandler
  98. //----------------------------------------------------------------------------------------
  99.  
  100. FW_MEventHandler::~FW_MEventHandler()
  101. {
  102.     if (fEventHandlers)
  103.     {
  104.         FW_MEventHandler* eventHandler;
  105.         while ((eventHandler = fEventHandlers->First()) != NULL)
  106.         {
  107.             fEventHandlers->Remove(eventHandler);
  108.             delete eventHandler;  // adopted eventHandler belongs to this event handler
  109.         }        
  110.  
  111.         delete fEventHandlers;
  112.     }
  113. }
  114.  
  115. //----------------------------------------------------------------------------------------
  116. // FW_MEventHandler::GetPriority
  117. //----------------------------------------------------------------------------------------
  118.  
  119. FW_Priority FW_MEventHandler::GetPriority(Environment* ev) const
  120. {
  121. FW_UNUSED(ev);
  122.     return fPriority;
  123. }
  124.  
  125. //----------------------------------------------------------------------------------------
  126. // FW_MEventHandler::SetPriority
  127. //----------------------------------------------------------------------------------------
  128.  
  129. void FW_MEventHandler::SetPriority(Environment* ev, FW_Priority thePriority)
  130. {
  131. FW_UNUSED(ev);
  132.     fPriority = thePriority;
  133.     // [B1 Conversion] Changing the priority should change its position ????
  134. }
  135.  
  136. //----------------------------------------------------------------------------------------
  137. // FW_MEventHandler::Insert
  138. //----------------------------------------------------------------------------------------
  139.  
  140. void FW_MEventHandler::PrivInsert(Environment* ev, FW_MEventHandler* eventHandler)
  141. {
  142.     FW_MEventHandler* before = NULL;
  143.     
  144.     FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  145.     for (FW_MEventHandler* handler = ite.First(); ite.IsNotComplete(); handler = ite.Next())
  146.     {
  147.         if (handler == eventHandler) {
  148.             FW_DEBUG_MESSAGE("in FW_MEventHandler::PrivInsert, handler already inserted");
  149.             return;
  150.         }
  151.         if (handler->GetPriority(ev) > eventHandler->GetPriority(ev))
  152.         {
  153.             before = handler;
  154.         }
  155.     }
  156.     
  157.     if (before)
  158.         fEventHandlers->AddBefore(before, eventHandler);
  159.     else
  160.         fEventHandlers->AddLast(eventHandler);
  161. }
  162.  
  163. //----------------------------------------------------------------------------------------
  164. // FW_MEventHandler::AdoptEventHandler
  165. //----------------------------------------------------------------------------------------
  166.  
  167. void FW_MEventHandler::AdoptEventHandler(Environment* ev, FW_MEventHandler* eventHandler)
  168. {
  169.     if (fEventHandlers == NULL)
  170.     {
  171.         FW_TOrderedCollection<FW_MEventHandler>* eventHandlers = FW_NEW(FW_TOrderedCollection<FW_MEventHandler>, ());
  172.         fEventHandlers = eventHandlers;
  173.     }
  174.  
  175.     PrivInsert(ev, eventHandler);
  176. }
  177.  
  178. //----------------------------------------------------------------------------------------
  179. // FW_MEventHandler::RemoveEventHandler
  180. //----------------------------------------------------------------------------------------
  181.  
  182. FW_MEventHandler* FW_MEventHandler::RemoveEventHandler(Environment* ev, FW_MEventHandler* eventHandler)
  183. {
  184. FW_UNUSED(ev);
  185.     FW_MEventHandler* theEventHandler = NULL;
  186.     if (fEventHandlers)
  187.     {
  188.         fEventHandlers->Remove(eventHandler);
  189.         theEventHandler = eventHandler;
  190.         // [HLX] should we dispose fEventHandlers if empty???
  191.     }
  192.     
  193.     return theEventHandler;
  194. }
  195.  
  196. //----------------------------------------------------------------------------------------
  197. // FW_MEventHandler::Enable
  198. //----------------------------------------------------------------------------------------
  199.  
  200. void FW_MEventHandler::Enable(Environment* ev)
  201. {
  202. FW_UNUSED(ev);
  203.     fEnabled = TRUE;
  204. }
  205.  
  206. //----------------------------------------------------------------------------------------
  207. // FW_MEventHandler::Disable
  208. //----------------------------------------------------------------------------------------
  209.  
  210. void FW_MEventHandler::Disable(Environment* ev)
  211. {
  212. FW_UNUSED(ev);
  213. //    FW_ASSERT(fSuperView != NULL);    // a CFrame cannot be disabled
  214.     fEnabled = FALSE;
  215. }
  216.  
  217. //----------------------------------------------------------------------------------------
  218. // FW_MEventHandler::GetFrame
  219. //----------------------------------------------------------------------------------------
  220.  
  221. FW_CFrame* FW_MEventHandler::GetFrame(Environment* ev) const
  222. {
  223. FW_UNUSED(ev);
  224.         // Event handlers are not automtically associated with a frame.
  225.         // Views, which derive from 
  226.     FW_DEBUG_MESSAGE("FW_MEventHandler::GetFrame: subclass responsibility");
  227.     return NULL;
  228. }
  229.  
  230. //----------------------------------------------------------------------------------------
  231. //     FW_MEventHandler::IsTarget
  232. //----------------------------------------------------------------------------------------
  233.  
  234. FW_Boolean FW_MEventHandler::IsTarget(Environment* ev) const
  235. {
  236.     FW_CFrame* frame = GetFrame(ev);
  237.     return (frame ? frame->GetTarget(ev) == this : false);
  238. }
  239.  
  240. //----------------------------------------------------------------------------------------
  241. //     FW_MEventHandler::IsActiveTarget
  242. //----------------------------------------------------------------------------------------
  243.  
  244. FW_Boolean FW_MEventHandler::IsActiveTarget(Environment* ev) const
  245. {
  246.     FW_CFrame* frame = GetFrame(ev);
  247.     return (frame ? (frame->GetTarget(ev) == this) && (frame->HasSelectionFocus(ev)) : false);
  248. }
  249.  
  250. //----------------------------------------------------------------------------------------
  251. //     FW_MEventHandler::IsSuspendedTarget
  252. //----------------------------------------------------------------------------------------
  253.  
  254. FW_Boolean FW_MEventHandler::IsSuspendedTarget(Environment* ev) const
  255. {
  256.     FW_CFrame* frame = GetFrame(ev);
  257.     return (frame ? (frame->GetTarget(ev) == this) && (!frame->HasSelectionFocus(ev)) : false);
  258. }
  259.  
  260. //----------------------------------------------------------------------------------------
  261. //     FW_MEventHandler::BecomeTarget
  262. //----------------------------------------------------------------------------------------
  263.  
  264. FW_Boolean FW_MEventHandler::BecomeTarget(Environment* ev, FW_Boolean tabSelection)
  265. {
  266.     FW_CFrame* frame = GetFrame(ev);
  267.  
  268.     FW_ASSERT(IsEnabled(ev));    // can't make a disabled view the target
  269.     FW_ASSERT(frame);            // can't become the target without a frame
  270.     
  271.     FW_MEventHandler* currentTarget = frame->GetTarget(ev);
  272.     if (this != currentTarget)
  273.     {
  274.         if (currentTarget->ResignTarget(ev))
  275.         {
  276.             frame->SetTarget(ev, this, tabSelection);
  277.             return true;
  278.         }
  279.         else
  280.             return false;
  281.     }
  282.     return true;
  283. }
  284.  
  285. //----------------------------------------------------------------------------------------
  286. //     FW_MEventHandler::ResignTarget
  287. //----------------------------------------------------------------------------------------
  288.  
  289. FW_Boolean FW_MEventHandler::ResignTarget(Environment* ev)
  290. {
  291.     FW_CFrame* frame = GetFrame(ev);
  292.     FW_ASSERT(frame);
  293.     
  294.     if (this == frame->GetTarget(ev))
  295.     {
  296.         if (WillingToResignTarget(ev) == 0)
  297.         {
  298.             frame->SetTarget(ev, frame);
  299.             return true;
  300.         }
  301.         else
  302.             return false;
  303.     }
  304.     else
  305.         return true;
  306. }
  307.  
  308. //----------------------------------------------------------------------------------------
  309. //     FW_MEventHandler::WantsToBeTarget
  310. //----------------------------------------------------------------------------------------
  311.  
  312. FW_Boolean FW_MEventHandler::WantsToBeTarget(Environment* ev)
  313. {
  314. FW_UNUSED(ev);
  315.     return false;
  316. }
  317.  
  318. //----------------------------------------------------------------------------------------
  319. //     FW_MEventHandler::WillingToResignTarget
  320. //----------------------------------------------------------------------------------------
  321.  
  322. long FW_MEventHandler::WillingToResignTarget(Environment* ev)
  323. {
  324. FW_UNUSED(ev);
  325.     return 0;
  326. }
  327.  
  328. //----------------------------------------------------------------------------------------
  329. //     FW_MEventHandler::ActivateTarget
  330. //----------------------------------------------------------------------------------------
  331.  
  332. void FW_MEventHandler::ActivateTarget(Environment* ev, FW_Boolean tabSelection)
  333. {
  334. FW_UNUSED(ev);
  335. FW_UNUSED(tabSelection);
  336. }
  337.  
  338. //----------------------------------------------------------------------------------------
  339. //     FW_MEventHandler::DeactivateTarget
  340. //----------------------------------------------------------------------------------------
  341.  
  342. void FW_MEventHandler::DeactivateTarget(Environment* ev)
  343. {
  344. FW_UNUSED(ev);
  345. }
  346.  
  347. //----------------------------------------------------------------------------------------
  348. // FW_MEventHandler::PrivDispatchIdle
  349. //----------------------------------------------------------------------------------------
  350.  
  351. FW_Handled FW_MEventHandler::PrivDispatchIdle(Environment* ev, const FW_CNullEvent& theNullEvent)
  352. {
  353.     if (fEventHandlers)
  354.     {
  355.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);        
  356.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  357.         {
  358.             if (eventHandler->PrivDispatchIdle(ev, theNullEvent) == FW_kHandled)
  359.                 return FW_kHandled;
  360.         }
  361.     }
  362.     
  363.     return IsEnabled(ev) ? HandleIdle(ev, theNullEvent) : FW_kNotHandled;
  364. }
  365.  
  366. //----------------------------------------------------------------------------------------
  367. // FW_MEventHandler::HandleIdle
  368. //----------------------------------------------------------------------------------------
  369.  
  370. FW_Handled FW_MEventHandler::HandleIdle(Environment* ev, const FW_CNullEvent& theNullEvent)
  371. {    
  372.     return DoIdle(ev, theNullEvent);    
  373. }
  374.  
  375. //----------------------------------------------------------------------------------------
  376. // FW_MEventHandler::DoIdle
  377. //----------------------------------------------------------------------------------------
  378.  
  379. FW_Handled FW_MEventHandler::DoIdle(Environment* ev, const FW_CNullEvent& theNullEvent)
  380. {
  381. FW_UNUSED(ev);
  382. FW_UNUSED(theNullEvent);
  383.     return FW_kNotHandled;
  384. }
  385.  
  386. //----------------------------------------------------------------------------------------
  387. // FW_MEventHandler::PrivDispatchMouseDown
  388. //----------------------------------------------------------------------------------------
  389.  
  390. FW_Handled FW_MEventHandler::PrivDispatchMouseDown(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  391. {
  392.     if (fEventHandlers)
  393.     {
  394.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  395.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  396.         {
  397.             if (eventHandler->PrivDispatchMouseDown(ev, theMouseEvent) == FW_kHandled)
  398.                 return FW_kHandled;
  399.         }
  400.     }
  401.     
  402.     return HandleMouseDown(ev, theMouseEvent);
  403. }
  404.  
  405. //----------------------------------------------------------------------------------------
  406. // FW_MEventHandler::HandleMouseDown
  407. //----------------------------------------------------------------------------------------
  408.  
  409. FW_Handled FW_MEventHandler::HandleMouseDown(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  410. {    
  411.     return IsEnabled(ev) ? DoMouseDown(ev, theMouseEvent) : FW_kNotHandled;
  412. }
  413.  
  414. //----------------------------------------------------------------------------------------
  415. // FW_MEventHandler::DoMouseDown
  416. //----------------------------------------------------------------------------------------
  417.  
  418. FW_Handled FW_MEventHandler::DoMouseDown(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  419. {
  420. FW_UNUSED(ev);
  421. FW_UNUSED(theMouseEvent);
  422.     return FW_kNotHandled;
  423. }
  424.  
  425. //----------------------------------------------------------------------------------------
  426. // FW_MEventHandler::PrivDispatchBGMouseDown
  427. //----------------------------------------------------------------------------------------
  428.  
  429. FW_Handled FW_MEventHandler::PrivDispatchBGMouseDown(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  430. {
  431.     if (fEventHandlers)
  432.     {
  433.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  434.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  435.         {
  436.             if (eventHandler->PrivDispatchBGMouseDown(ev, theMouseEvent) == FW_kHandled)
  437.                 return FW_kHandled;
  438.         }
  439.     }
  440.     
  441.     return HandleBGMouseDown(ev, theMouseEvent);
  442. }
  443.  
  444. //----------------------------------------------------------------------------------------
  445. // FW_MEventHandler::HandleBGMouseDown
  446. //----------------------------------------------------------------------------------------
  447.  
  448. FW_Handled FW_MEventHandler::HandleBGMouseDown(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  449. {
  450.     return IsEnabled(ev) ? DoBGMouseDown(ev, theMouseEvent) : FW_kNotHandled;
  451. }
  452.  
  453. //----------------------------------------------------------------------------------------
  454. // FW_MEventHandler::DoBGMouseDown
  455. //----------------------------------------------------------------------------------------
  456.  
  457. FW_Handled FW_MEventHandler::DoBGMouseDown(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  458. {
  459. FW_UNUSED(ev);
  460. FW_UNUSED(theMouseEvent);
  461.     return FW_kNotHandled;
  462. }
  463.  
  464. //----------------------------------------------------------------------------------------
  465. // FW_MEventHandler::PrivDispatchMouseUp
  466. //----------------------------------------------------------------------------------------
  467.  
  468. FW_Handled FW_MEventHandler::PrivDispatchMouseUp(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  469. {
  470.     if (fEventHandlers)
  471.     {
  472.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  473.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  474.         {
  475.             if (eventHandler->PrivDispatchMouseUp(ev, theMouseEvent) == FW_kHandled)
  476.                 return FW_kHandled;
  477.         }
  478.     }
  479.     
  480.     return HandleMouseUp(ev, theMouseEvent);
  481. }
  482.  
  483. //----------------------------------------------------------------------------------------
  484. // FW_MEventHandler::HandleMouseUp
  485. //----------------------------------------------------------------------------------------
  486.  
  487. FW_Handled FW_MEventHandler::HandleMouseUp(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  488. {
  489. FW_UNUSED(ev);
  490.     return IsEnabled(ev) ? DoMouseUp(ev, theMouseEvent) : FW_kNotHandled;
  491. }
  492.  
  493. //----------------------------------------------------------------------------------------
  494. // FW_MEventHandler::DoMouseUp
  495. //----------------------------------------------------------------------------------------
  496.  
  497. FW_Handled FW_MEventHandler::DoMouseUp(Environment* ev, const FW_CMouseEvent& theMouseEvent)
  498. {
  499. FW_UNUSED(ev);
  500. FW_UNUSED(theMouseEvent);
  501.     return FW_kNotHandled;
  502. }
  503.  
  504. //----------------------------------------------------------------------------------------
  505. // FW_MEventHandler::PrivDispatchMouseDownInEmbeddedFrame
  506. //----------------------------------------------------------------------------------------
  507.  
  508. FW_Handled FW_MEventHandler::PrivDispatchMouseDownInEmbeddedFrame(Environment* ev, 
  509.                                                             const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  510. {
  511.     if (fEventHandlers)
  512.     {
  513.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  514.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  515.         {
  516.             if (eventHandler->PrivDispatchMouseDownInEmbeddedFrame(ev, theEmbeddedMouseEvent) == FW_kHandled)
  517.                 return FW_kHandled;
  518.         }
  519.     }
  520.             
  521.     return IsEnabled(ev) ? HandleMouseDownInEmbeddedFrame(ev, theEmbeddedMouseEvent) : FW_kNotHandled;
  522. }
  523.  
  524. //----------------------------------------------------------------------------------------
  525. // FW_MEventHandler::HandleMouseDownInEmbeddedFrame
  526. //----------------------------------------------------------------------------------------
  527.  
  528. FW_Handled FW_MEventHandler::HandleMouseDownInEmbeddedFrame(Environment* ev, 
  529.                                                             const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  530. {
  531.     return DoMouseDownInEmbeddedFrame(ev, theEmbeddedMouseEvent);
  532. }
  533.  
  534. //----------------------------------------------------------------------------------------
  535. // FW_MEventHandler::DoMouseDownInEmbeddedFrame
  536. //----------------------------------------------------------------------------------------
  537. //    By default just call DoMouseDown
  538.  
  539. FW_Handled FW_MEventHandler::DoMouseDownInEmbeddedFrame(Environment* ev, const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  540. {
  541.     return DoMouseDown(ev, theEmbeddedMouseEvent);
  542. }
  543.  
  544. //----------------------------------------------------------------------------------------
  545. // FW_MEventHandler::PrivDispatchBGMouseDownInEmbeddedFrame
  546. //----------------------------------------------------------------------------------------
  547.  
  548. FW_Handled FW_MEventHandler::PrivDispatchBGMouseDownInEmbeddedFrame(Environment* ev, 
  549.                                                             const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  550. {
  551.     if (fEventHandlers)
  552.     {
  553.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  554.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  555.         {
  556.             if (eventHandler->PrivDispatchBGMouseDownInEmbeddedFrame(ev, theEmbeddedMouseEvent) == FW_kHandled)
  557.                 return FW_kHandled;
  558.         }
  559.     }
  560.             
  561.     return IsEnabled(ev) ? HandleBGMouseDownInEmbeddedFrame(ev, theEmbeddedMouseEvent) : FW_kNotHandled;
  562. }
  563.  
  564. //----------------------------------------------------------------------------------------
  565. // FW_MEventHandler::HandleBGMouseDownInEmbeddedFrame
  566. //----------------------------------------------------------------------------------------
  567.  
  568. FW_Handled FW_MEventHandler::HandleBGMouseDownInEmbeddedFrame(Environment* ev, 
  569.                                                             const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  570. {
  571.     return DoBGMouseDownInEmbeddedFrame(ev, theEmbeddedMouseEvent);
  572. }
  573.  
  574. //----------------------------------------------------------------------------------------
  575. // FW_MEventHandler::DoBGMouseDownInEmbeddedFrame
  576. //----------------------------------------------------------------------------------------
  577. //    By default just call DoBGMouseDown
  578.  
  579. FW_Handled FW_MEventHandler::DoBGMouseDownInEmbeddedFrame(Environment* ev, const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  580. {
  581.     return DoBGMouseDown(ev, theEmbeddedMouseEvent);
  582. }
  583.  
  584. //----------------------------------------------------------------------------------------
  585. // FW_MEventHandler::PrivDispatchMouseUpInEmbeddedFrame
  586. //----------------------------------------------------------------------------------------
  587.  
  588. FW_Handled FW_MEventHandler::PrivDispatchMouseUpInEmbeddedFrame(Environment* ev, const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  589. {
  590.     if (fEventHandlers)
  591.     {
  592.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  593.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  594.         {
  595.             if (eventHandler->PrivDispatchMouseUpInEmbeddedFrame(ev, theEmbeddedMouseEvent) == FW_kHandled)
  596.                 return FW_kHandled;
  597.         }
  598.     }
  599.     
  600.     return IsEnabled(ev) ? HandleMouseUpInEmbeddedFrame(ev, theEmbeddedMouseEvent) : FW_kNotHandled;
  601. }
  602.  
  603. //----------------------------------------------------------------------------------------
  604. // FW_MEventHandler::HandleMouseUpInEmbeddedFrame
  605. //----------------------------------------------------------------------------------------
  606.  
  607. FW_Handled FW_MEventHandler::HandleMouseUpInEmbeddedFrame(Environment* ev, const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  608. {
  609.     return DoMouseUpInEmbeddedFrame(ev, theEmbeddedMouseEvent);
  610. }
  611.  
  612. //----------------------------------------------------------------------------------------
  613. // FW_MEventHandler::DoMouseUpInEmbeddedFrame
  614. //----------------------------------------------------------------------------------------
  615. // By Default just call DoMouseUp
  616.  
  617. FW_Handled FW_MEventHandler::DoMouseUpInEmbeddedFrame(Environment* ev, const FW_CEmbeddedMouseEvent& theEmbeddedMouseEvent)
  618. {
  619.     return DoMouseUp(ev, theEmbeddedMouseEvent);
  620. }
  621.  
  622. //----------------------------------------------------------------------------------------
  623. // FW_MEventHandler::PrivDispatchMouseDownInEmbeddedFrameBorder
  624. //----------------------------------------------------------------------------------------
  625.  
  626. FW_Handled FW_MEventHandler::PrivDispatchMouseDownInEmbeddedFrameBorder(Environment* ev, const FW_CBorderMouseEvent& theBorderMouseEvent)
  627. {
  628.     if (fEventHandlers)
  629.     {
  630.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  631.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  632.         {
  633.             if (eventHandler->PrivDispatchMouseDownInEmbeddedFrameBorder(ev, theBorderMouseEvent) == FW_kHandled)
  634.                 return FW_kHandled;
  635.         }
  636.     }
  637.     
  638.     return IsEnabled(ev) ? HandleMouseDownInEmbeddedFrameBorder(ev, theBorderMouseEvent) : FW_kNotHandled;
  639. }
  640.  
  641. //----------------------------------------------------------------------------------------
  642. // FW_MEventHandler::HandleMouseDownInEmbeddedFrameBorder
  643. //----------------------------------------------------------------------------------------
  644.  
  645. FW_Handled FW_MEventHandler::HandleMouseDownInEmbeddedFrameBorder(Environment* ev, const FW_CBorderMouseEvent& theBorderMouseEvent)
  646. {
  647. FW_UNUSED(ev);
  648.     return DoMouseDownInEmbeddedFrameBorder(ev, theBorderMouseEvent);
  649. }
  650.  
  651. //----------------------------------------------------------------------------------------
  652. // FW_MEventHandler::DoMouseDownInEmbeddedFrameBorder
  653. //----------------------------------------------------------------------------------------
  654.  
  655. FW_Handled FW_MEventHandler::DoMouseDownInEmbeddedFrameBorder(Environment* ev, const FW_CBorderMouseEvent& theBorderMouseEvent)
  656. {
  657. FW_UNUSED(ev);
  658. FW_UNUSED(theBorderMouseEvent);
  659.     return FW_kNotHandled;
  660. }
  661.  
  662. //----------------------------------------------------------------------------------------
  663. // FW_MEventHandler::PrivDispatchVirtualKey
  664. //----------------------------------------------------------------------------------------
  665.  
  666. FW_Handled FW_MEventHandler::PrivDispatchVirtualKey(Environment* ev, const FW_CVirtualKeyEvent& theVirtualKeyEvent)
  667. {
  668.     if (fEventHandlers)
  669.     {
  670.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  671.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  672.         {
  673.             if (eventHandler->PrivDispatchVirtualKey(ev, theVirtualKeyEvent) == FW_kHandled)
  674.                 return FW_kHandled;
  675.         }
  676.     }
  677.     
  678.     return IsEnabled(ev) ? HandleVirtualKey(ev, theVirtualKeyEvent) : FW_kNotHandled;
  679. }
  680.  
  681. //----------------------------------------------------------------------------------------
  682. // FW_MEventHandler::HandleVirtualKey
  683. //----------------------------------------------------------------------------------------
  684.  
  685. FW_Handled FW_MEventHandler::HandleVirtualKey(Environment* ev, const FW_CVirtualKeyEvent& theVirtualKeyEvent)
  686. {
  687.     return DoVirtualKey(ev, theVirtualKeyEvent);
  688. }
  689.  
  690. //----------------------------------------------------------------------------------------
  691. // FW_MEventHandler::DoVirtualKey
  692. //----------------------------------------------------------------------------------------
  693.  
  694. FW_Handled FW_MEventHandler::DoVirtualKey(Environment* ev, const FW_CVirtualKeyEvent& theVirtualKeyEvent)
  695. {
  696. FW_UNUSED(ev);
  697. FW_UNUSED(theVirtualKeyEvent);
  698.     return FW_kNotHandled;
  699. }
  700.  
  701. //----------------------------------------------------------------------------------------
  702. // FW_MEventHandler::PrivDispatchCharKey
  703. //----------------------------------------------------------------------------------------
  704.  
  705. FW_Handled FW_MEventHandler::PrivDispatchCharKey(Environment* ev, const FW_CCharKeyEvent& theCharKeyEvent)
  706. {
  707.     if (fEventHandlers)
  708.     {
  709.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  710.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  711.         {
  712.             if (eventHandler->PrivDispatchCharKey(ev, theCharKeyEvent) == FW_kHandled)
  713.                 return FW_kHandled;
  714.         }
  715.     }
  716.     
  717.     return IsEnabled(ev) ? HandleCharKey(ev, theCharKeyEvent) : FW_kNotHandled;
  718. }
  719.  
  720. //----------------------------------------------------------------------------------------
  721. // FW_MEventHandler::HandleCharKey
  722. //----------------------------------------------------------------------------------------
  723.  
  724. FW_Handled FW_MEventHandler::HandleCharKey(Environment* ev, const FW_CCharKeyEvent& theCharKeyEvent)
  725. {
  726.     return DoCharKey(ev, theCharKeyEvent);
  727. }
  728.  
  729. //----------------------------------------------------------------------------------------
  730. // FW_MEventHandler::DoCharKey
  731. //----------------------------------------------------------------------------------------
  732.  
  733. FW_Handled FW_MEventHandler::DoCharKey(Environment* ev, const FW_CCharKeyEvent& theCharKeyEvent)
  734. {
  735. FW_UNUSED(ev);
  736. FW_UNUSED(theCharKeyEvent);
  737.     return FW_kNotHandled;
  738. }
  739.  
  740. //----------------------------------------------------------------------------------------
  741. // FW_MEventHandler::PrivDispatchMenuEvent
  742. //----------------------------------------------------------------------------------------
  743.  
  744. FW_Handled FW_MEventHandler::PrivDispatchMenuEvent(Environment* ev, const FW_CMenuEvent& theMenuEvent)
  745. {
  746.     if (fEventHandlers)
  747.     {
  748.         FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  749.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  750.         {
  751.             if (eventHandler->PrivDispatchMenuEvent(ev, theMenuEvent) == FW_kHandled)
  752.                 return FW_kHandled;
  753.         }
  754.     }
  755.     
  756.     return IsEnabled(ev) ? HandleMenu(ev, theMenuEvent) : FW_kNotHandled;
  757. }
  758.  
  759. //----------------------------------------------------------------------------------------
  760. // FW_MEventHandler::HandleMenu
  761. //----------------------------------------------------------------------------------------
  762.  
  763. FW_Handled FW_MEventHandler::HandleMenu(Environment* ev, const FW_CMenuEvent& theMenuEvent)
  764. {
  765. FW_UNUSED(ev);
  766.     return DoMenu(ev, theMenuEvent);
  767. }
  768.  
  769. //----------------------------------------------------------------------------------------
  770. // FW_MEventHandler::DoMenu
  771. //----------------------------------------------------------------------------------------
  772.  
  773. FW_Handled FW_MEventHandler::DoMenu(Environment* ev, const FW_CMenuEvent& theMenuEvent)
  774. {
  775. FW_UNUSED(ev);
  776. FW_UNUSED(theMenuEvent);
  777.     return FW_kNotHandled;
  778. }
  779.  
  780. //----------------------------------------------------------------------------------------
  781. // FW_MEventHandler::PrivDispatchAdjustMenus
  782. //----------------------------------------------------------------------------------------
  783. //    Attention: behaviors for adjust menus are done AFTER the main handlers. This allows
  784. //    someone to 'override' a handler
  785.  
  786. FW_Handled FW_MEventHandler::PrivDispatchAdjustMenus(Environment *ev, FW_CMenuBar* menuBar, 
  787.                                                 FW_Boolean hasMenuFocus, FW_Boolean isRoot)
  788. {
  789.     FW_Handled handled = IsEnabled(ev) ? HandleAdjustMenus(ev, menuBar, hasMenuFocus, isRoot) : FW_kNotHandled;
  790.  
  791.     if (!handled && fEventHandlers)
  792.     {
  793.          FW_TOrderedCollectionIterator<FW_MEventHandler> ite(fEventHandlers);
  794.         for (FW_MEventHandler* eventHandler = ite.First(); ite.IsNotComplete(); eventHandler = ite.Next())
  795.         {
  796.             if ((handled = eventHandler->PrivDispatchAdjustMenus(ev, menuBar, hasMenuFocus, isRoot)) == FW_kHandled)
  797.                 break;
  798.         }
  799.     }
  800.     
  801.     return handled;
  802. }
  803.  
  804. //----------------------------------------------------------------------------------------
  805. // FW_MEventHandler::HandleAdjustMenus
  806. //----------------------------------------------------------------------------------------
  807.  
  808. FW_Handled FW_MEventHandler::HandleAdjustMenus(Environment *ev, 
  809.                                                 FW_CMenuBar* menuBar, 
  810.                                                 FW_Boolean hasMenuFocus, 
  811.                                                 FW_Boolean isRoot)
  812. {
  813.     return DoAdjustMenus(ev, menuBar, hasMenuFocus, isRoot);
  814. }
  815.  
  816. //----------------------------------------------------------------------------------------
  817. // FW_MEventHandler::DoAdjustMenus
  818. //----------------------------------------------------------------------------------------
  819.  
  820. FW_Handled FW_MEventHandler::DoAdjustMenus(Environment *ev, FW_CMenuBar* menuBar, 
  821.                                             FW_Boolean hasMenuFocus, FW_Boolean isRoot)
  822. {
  823. FW_UNUSED(ev);
  824. FW_UNUSED(menuBar);
  825. FW_UNUSED(hasMenuFocus);
  826. FW_UNUSED(isRoot);
  827.  
  828.     return FW_kNotHandled;    // not done handling
  829. }
  830.