home *** CD-ROM | disk | FTP | other *** search
/ ...taking it to the Macs! / ...taking it to the Macs!.iso / Extras / ActiveX Mac SDK / ActiveX SDK / Containers / SimpleApp / Main.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-20  |  7.9 KB  |  435 lines  |  [TEXT/CWIE]
  1. /***************************************
  2.  
  3. Main.c
  4.     Driver Module for Application
  5.     
  6. *****************************************/
  7.  
  8. #include "headers.h"
  9. #include <limits.h>
  10. #include <Threads.h>
  11. #include "Protos.h"
  12. #include "menus.h"
  13. #include "CActiveXScheduler.h"
  14. #include "CSimpleAppSite.h"
  15. #include "App.h"
  16.  
  17.  
  18. /************************* Globals ***********************/
  19.  
  20. static Boolean gControlHasFocus = false;
  21.  
  22. Boolean    gInBackGround = FALSE;        /* Am I in the background? */
  23. Boolean gSendMouseUp = FALSE;        /* Send the next mouse up event to the control? */
  24. Boolean gMouseInControl = false;    // Is the mouse currently inside the control?
  25.  
  26.  
  27. #define OPTION_KEY(Event)    ( (Event->modifiers & optionKey) != 0 )
  28.  
  29. /*******************  function prototypes *******************/
  30.  
  31. static void AdjustCursor(EventRecord *theEvent);
  32.  
  33. static void DoIdle(EventRecord* theEvent);
  34. static void DoKeyDown(EventRecord *theEvent);
  35. static void DoEvent(EventRecord *theEvent);
  36. static void DoActivateEvent(EventRecord *theEvent);
  37. static void DoHighLevelEvent(EventRecord *theEvent);
  38. static void DoMenu(long menuResult);
  39. static void DoMouseDown(EventRecord *theEvent);
  40. static void DoUpdate(WindowPtr window);
  41. static void DoCloseWindow(WindowPtr window, EventRecord *theEvent);
  42. static void DoContent(WindowPtr window, EventRecord *theEvent);
  43. static void DrawWindow(WindowPtr window);
  44.  
  45. static void EventLoop(void);
  46.  
  47. static long GetSleep(void);
  48.  
  49.  
  50.  
  51.  
  52. void main(void)
  53. {
  54.     Initialize();
  55.     EventLoop();
  56. }
  57.  
  58. void EventLoop()
  59. /* 
  60.     Continuously get events and dispatch to the appropriate handler
  61. */
  62. {
  63.     RgnHandle    cursorRgn;
  64.     Boolean        ignoreResult;
  65.     EventRecord    theEvent;
  66.  
  67.     cursorRgn = NewRgn();
  68.     while (TRUE) 
  69.     {
  70.         ignoreResult = WaitNextEvent(everyEvent,&theEvent, 0,cursorRgn);
  71.         
  72.         AdjustCursor(&theEvent);
  73.         DoEvent(&theEvent);
  74.     } 
  75. }  
  76.  
  77. void DoEvent(EventRecord *theEvent)
  78. /*
  79.     Dispatch the event to the appropriate handler
  80. */
  81. {
  82.     switch (theEvent->what) 
  83.     {
  84.         case nullEvent:
  85.             DoIdle(theEvent);
  86.             break;
  87.  
  88.         case mouseDown: 
  89.             DoMouseDown(theEvent);
  90.             break;
  91.             
  92.         case mouseUp:
  93.             if ( gControl && gSendMouseUp )
  94.             {
  95.                 gControl->DoMouse(MouseUp, theEvent);
  96.                 gSendMouseUp = FALSE;
  97.             }
  98.             break;
  99.             
  100.         case keyDown:
  101.         case autoKey:
  102.             DoKeyDown(theEvent);
  103.             break;
  104.             
  105.         case activateEvt:
  106.             DoActivateEvent(theEvent);
  107.             break;   
  108.                
  109.         case updateEvt:              
  110.             DoUpdate((WindowPtr) theEvent->message);
  111.             break;
  112.  
  113.         case kHighLevelEvent:
  114.             DoHighLevelEvent(theEvent);
  115.             break;
  116.             
  117.     } 
  118.  
  119.     CActiveXScheduler*    Scheduler = CActiveXScheduler::GetActiveXScheduler();
  120.     if (Scheduler)
  121.         Scheduler->Idle(theEvent->what == nullEvent);
  122. }  
  123.  
  124. void DoIdle(EventRecord* theEvent)
  125. {
  126.     Point testPt;
  127.  
  128.     YieldToAnyThread();
  129.  
  130.     if ( gControl )
  131.     {
  132.         // if the mouse is in a control rectangle, 
  133.         testPt = theEvent->where;
  134.         GlobalToLocal(&testPt);
  135.  
  136.         // if the click is in the control, send it the mouse down event
  137.         if ( PtInRect(testPt, &gControlRect) )
  138.         {
  139.             if ( !gMouseInControl )
  140.             {
  141.                 gControl->DoMouse(MouseEnter, theEvent);
  142.                 gMouseInControl = true;
  143.             }
  144.         }
  145.         else if ( gMouseInControl )
  146.         {
  147.             gControl->DoMouse(MouseLeave, theEvent);
  148.             gMouseInControl = false;
  149.             InitCursor();
  150.         }
  151.     }
  152. }
  153.  
  154. void DoActivateEvent(EventRecord *theEvent)
  155. {
  156.     DrawContext Context = {(PortType)0};
  157.     WindowPtr    window;
  158.     
  159.     window = (WindowPtr) theEvent->message;
  160.     if ((theEvent->modifiers & activeFlag) != 0)
  161.     {
  162.         DoActivate(window);
  163.  
  164.         if ( gControl )
  165.         {
  166.             gControl->DoActivate(WindowActivate, 1, theEvent);
  167.         }
  168.     }
  169.     else
  170.     {
  171.         if ( gControl )
  172.         {
  173.             gControl->DoActivate(WindowDeactivate, 1, theEvent);
  174.         }
  175.  
  176.         DoDeactivate(window);
  177.     }
  178. }
  179.  
  180. void DoHighLevelEvent(EventRecord *theEvent)
  181. {
  182.     if ( gControl )
  183.         gControl->DoSystemEvent(theEvent);
  184. }
  185.  
  186.  
  187. void AdjustCursor(EventRecord *theEvent)
  188. {
  189.     Point testPt;
  190.     
  191.     testPt = theEvent->where;
  192.     GlobalToLocal(&testPt);
  193. } 
  194.  
  195. void DoUpdate(WindowPtr window)
  196. /*
  197.     handle an update event detected by GetNextEvent
  198. */
  199. {
  200.     BeginUpdate(window);                    
  201.     DrawWindow(window);
  202.     EndUpdate(window);                        
  203. } 
  204.  
  205. void DoMouseDown(EventRecord *theEvent)
  206. /*
  207.     handle a mouseDown event
  208. */
  209. {
  210.     short        part;
  211.     WindowPtr    window = NULL;
  212.  
  213.     part = FindWindow(theEvent->where, &window);
  214.     
  215.     switch (part) 
  216.     {
  217.         case inMenuBar: 
  218.             AdjustMenus();
  219.             DoMenu(MenuSelect(theEvent->where) );
  220.             break;
  221.  
  222.         case inSysWindow: 
  223.             SystemClick(theEvent,window);
  224.             break;
  225.  
  226.         case inContent:
  227.             DoContent(window,theEvent);
  228.             break;
  229.  
  230.         case inDrag: 
  231.             DragWindow(window,theEvent->where,&qd.screenBits.bounds);
  232.             SetPort(window);
  233.             break;
  234.  
  235.         case inGoAway: 
  236.             if (TrackGoAway(window,theEvent->where))
  237.                 DoCloseWindow(window, theEvent);
  238.             break;
  239.  
  240.         case inGrow:
  241.             //GrowWindow(theEvent->where);
  242.             break;
  243.  
  244.         case inZoomIn:
  245.         case inZoomOut:
  246.             ZoomWindow(window, part, TRUE);
  247.             break;
  248.     }
  249. } 
  250.  
  251. long GetSleep()
  252. {
  253.     long        sleep;
  254.     
  255.     sleep = LONG_MAX;
  256.     return sleep;
  257. } 
  258.  
  259. void DoMenu(long menuResult)
  260. /*
  261.     Handle a user menu selection
  262. */
  263. {
  264.     short    menuID;
  265.     short    menuItem;
  266.     
  267.     menuID = HiWord(menuResult);    
  268.     menuItem = LoWord(menuResult);    
  269.  
  270.     switch (menuID) 
  271.     {
  272.         case mApple: 
  273.             DoAppleMenu(menuID,menuItem);
  274.             break;
  275.  
  276.         case mFile:  
  277.             DoFileMenu(menuItem);
  278.             break;
  279.  
  280.         case mEdit:  
  281.             DoEditMenu(menuItem);
  282.             break;
  283.  
  284.         case mColor:
  285.             DoColorMenu(menuItem);
  286.             break;
  287.  
  288.         }
  289.     HiliteMenu(0);                    
  290. }  
  291.  
  292. void DrawWindow(WindowPtr window)
  293. /*
  294.     draw the window for which an update event was detected
  295. */
  296. {
  297.     GrafPtr        SavePort;
  298.     DrawContext Context = {(PortType)0};
  299.     
  300.     GetPort(&SavePort);
  301.     SetPort(window);
  302.  
  303.     ::EraseRect(&window->portRect);
  304.  
  305.     if ( gControl )
  306.     {
  307.         // Draw a border around the control
  308.         Point    InPenSize = window->pnSize;
  309.         Rect    BorderRect = gControlRect;
  310.  
  311.         ::InsetRect(&BorderRect, -8, -8);
  312.         ::PenSize(7, 7);
  313.         ::FrameRect(&BorderRect);
  314.         ::PenSize(InPenSize.h, InPenSize.v);
  315.  
  316.         // Draw the control
  317.         if (gSite->AcquireContext(WindowContextID, &Context) == S_OK)
  318.         {
  319.             gControl->Draw(&Context);
  320.             gSite->ReleaseContext(&Context);
  321.         }
  322. #ifdef USE_OFFSCREEN
  323.         if (gSite->AcquireContext(OffscreenContextID, &Context) == S_OK)
  324.         {
  325.             gControl->Draw(&Context);
  326.             gSite->ReleaseContext(&Context);
  327.             {
  328.                 Rect        DestRect = { 0, 300, 290, 496};
  329.  
  330.                 //    blit to the screen
  331.                 ::ForeColor(blackColor);
  332.                 ::BackColor(whiteColor);
  333.                 CopyBits((BitMap*)(*(gAppData.Offscreen->portPixMap)),
  334.                         &((GrafPtr)gAppData.Window)->portBits, &gControlRect, &DestRect, srcCopy, NULL);
  335.             }
  336.         }
  337. #endif // USE_OFFSCREEN
  338.     }
  339.     else
  340.     {
  341.         short OldTextSize = window->txSize;
  342.  
  343.         TextSize(24);
  344.         MoveTo(50, 50);
  345.         DrawString("\pDrop a control into the window.");
  346.         TextSize(OldTextSize);
  347.     }
  348.  
  349.     SetPort(SavePort);
  350. } 
  351.  
  352. void DoContent(WindowPtr window, EventRecord *theEvent)
  353. /*
  354.     Handle a user mouse click in a particular window
  355. */
  356. {
  357.     Point    testPt;
  358.     
  359.     if ( IsAppWindow(window) && gControl ) 
  360.     {    
  361.         SetPort(window);
  362.         testPt = theEvent->where;
  363.         GlobalToLocal(&testPt);
  364.     
  365.         // if the click is in the control, send it the mouse down event
  366.         if ( PtInRect(testPt, &gControlRect) )
  367.         {
  368.             gControl->SetFocus(TakeNextCommand, FullFocusSet);
  369.             gControl->DoMouse(MouseDown, theEvent);
  370.             gSendMouseUp = true;
  371.             gControlHasFocus = true;
  372.         }
  373.         else
  374.         {
  375.             if (gControlHasFocus)
  376.             {
  377.                 gControl->SetFocus(ReleaseCommand, FullFocusSet);
  378.                 gControlHasFocus = false;
  379.             }
  380.         }
  381.     }
  382.     
  383. } 
  384.  
  385. void DoKeyDown(EventRecord *theEvent)
  386. /*
  387.     respond to user keypresses
  388. */
  389. {
  390.     char            key;
  391.     WindowPtr        frontMost;
  392.     long            menuResult;
  393.     KeyEventType    theKeyET;
  394.     
  395.     frontMost = FrontWindow();
  396.     if (!IsDAWindow(frontMost)) 
  397.     {
  398.         key = theEvent->message & charCodeMask;
  399.         menuResult = 0;
  400.         
  401.         if ((theEvent->modifiers & cmdKey) != 0) 
  402.         {
  403.             unsigned char menukey = key;
  404.             
  405.             AdjustMenus();
  406.             
  407.             menuResult = MenuKey(menukey);
  408.             if (menuResult != 0)
  409.                 DoMenu(menuResult);
  410.         }
  411.  
  412.         if ( menuResult == 0 && gControlHasFocus )
  413.         {
  414.             if (theEvent->what == autoKey)
  415.                 theKeyET = AutoKey;
  416.             else
  417.                 theKeyET = KeyDown;
  418.  
  419.             if ( gControl )
  420.                 gControl->DoKey(theKeyET, key, theEvent);
  421.         }
  422.         
  423.     } 
  424. } 
  425.  
  426. void DoCloseWindow(WindowPtr window, EventRecord *theEvent)
  427. {
  428. #pragma unused (theEvent)
  429.     if ( gControl )
  430.         RemoveControl();
  431.     DisposeWindow(window);
  432. }    
  433.  
  434.  
  435.