home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / OpenGL 1.0 SDK / Source / Libraries / tk / tkevent.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-05-18  |  11.0 KB  |  583 lines  |  [TEXT/CWIE]
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3.  
  4. #include "tk.h"
  5. #include "tkprivate.h"
  6. #include "tkmacglobals.h"
  7.  
  8.  
  9. #if defined(__MWERKS__) || defined(__SC__)
  10.     #include "console.h"
  11. #endif
  12.  
  13. #if defined(__MWERKS__)
  14.     #include "SIOUX.h"
  15. #endif
  16.  
  17. void    (*ExposeFunc)(int, int) = NULL;
  18. void    (*ReshapeFunc)(int, int) = NULL;
  19. void    (*DisplayFunc)(void) = NULL;
  20. GLenum    (*KeyDownFunc)(int, GLenum) = NULL;
  21. GLenum    (*MouseDownFunc)(int, int, GLenum) = NULL;
  22. GLenum    (*MouseUpFunc)(int, int, GLenum) = NULL;
  23. GLenum    (*MouseMoveFunc)(int, int, GLenum) = NULL;
  24. void    (*IdleFunc)(void) = NULL;
  25.  
  26. Boolean    gDone = false;
  27. Boolean    gDrawFlag = true;
  28.  
  29. void DoMenuCommand(long    menuAndItem);
  30. void DoDrag(WindowPtr    myWindow,Point    mouseloc);
  31. void DoContentClick(WindowPtr    myWindow, EventRecord *event);
  32. Boolean IsDAccWindow(WindowPtr    myWindow);
  33. void DoGoAwayBox(WindowPtr myWindow, Point mouseloc);
  34. void DoCloseWindow(WindowPtr myWindow);
  35. void DoKeyDown(EventRecord *event);
  36. void DoDiskEvent(EventRecord *event);
  37. void DoOSEvent(EventRecord *event);
  38. void DoUpdate(WindowPtr myWindow);
  39. void DoZoom(WindowPtr myWindow, Point mouseloc, int part);
  40. void DoActivate(WindowPtr myWindow, int myModifiers);
  41. void DoAboutBox(void);
  42. void DoNextEvent(void);
  43. void DoMenuCommand(long    menuAndItem);
  44. void DoReshape(int width,int height);
  45. void DoCallIdle(void);
  46. void DoMouseDown(EventRecord *event);
  47. void DoMouseUp(EventRecord *event);
  48. void DoMenuAdjust(void);
  49. void DoKeyUp(EventRecord *event);
  50.  
  51. static void DoGrow(WindowPtr myWindow, Point mouseloc)
  52. {
  53.     Rect    growBounds;
  54.     long    newSize;
  55.     
  56.     growBounds = (**GetGrayRgn()).rgnBBox;
  57.     growBounds.right -= growBounds.left;
  58.     growBounds.bottom -= growBounds.top;
  59.     growBounds.left = 20;
  60.     growBounds.top = 20;
  61.     
  62.     newSize = GrowWindow(myWindow,mouseloc,&growBounds);
  63.     
  64.     if(newSize)
  65.     {
  66.         SizeWindow(myWindow, newSize & 0x0000FFFF, newSize >> 16, false);
  67.         SetPort(myWindow);
  68.         DoReshape(LoWord(newSize),HiWord(newSize));
  69.     }
  70. }
  71.  
  72. static void DoZoom(WindowPtr myWindow, Point mouseloc, int part)
  73. {
  74.     short w, h;
  75.     
  76.     if(TrackBox(myWindow, mouseloc, part))
  77.     {
  78.         ZoomWindow(myWindow, part, false);
  79.         w = abs(myWindow->portRect.right - myWindow->portRect.left);
  80.         h = abs(myWindow->portRect.top - myWindow->portRect.bottom);
  81.  
  82.         DoReshape(w, h);
  83.     }
  84. }
  85.  
  86. static void DoReshape(int width, int height)
  87. {
  88.     tkWindow.width = width;
  89.     tkWindow.height = height;
  90.     
  91.     if(!tkWindow.context) return;
  92.     
  93.     aglUpdateContext(aglGetCurrentContext());
  94.  
  95.     if(ReshapeFunc)
  96.     {        
  97.         (*ReshapeFunc)(tkWindow.width,tkWindow.height);
  98.         gDrawFlag = true;
  99.     }
  100. }
  101.  
  102. static void DoRedraw(void)
  103. {
  104.     static GLboolean update_grow = GL_TRUE;
  105.     
  106.     if(!tkWindow.context) return;
  107.     
  108.     if(DisplayFunc && gDrawFlag) 
  109.     {
  110.         gDrawFlag = false;
  111.         (*DisplayFunc)();
  112.     }
  113. }
  114.  
  115. void DoCallIdle(void)
  116. {
  117.     if(!tkWindow.context) return;
  118.     
  119.     if(IdleFunc)
  120.     {
  121.         (*IdleFunc)();
  122.         gDrawFlag = true;
  123.     }
  124. }
  125.  
  126. void DoMouseDown(EventRecord *event)
  127. {    
  128.     int            myPart;
  129.     WindowPtr    myWindow;
  130.     
  131.     myPart = FindWindow(event->where, &myWindow);
  132.     
  133.     switch(myPart)
  134.     {
  135.         case inMenuBar:
  136.             DrawMenuBar();
  137.             DoMenuCommand(MenuSelect(event->where));
  138.         break;
  139.         case inSysWindow:
  140.             SystemClick(event, myWindow);
  141.         break;
  142.         case inDrag:
  143.             DoDrag(myWindow, event->where);
  144.         break;
  145.         case inGoAway:
  146.             DoGoAwayBox(myWindow, event->where);
  147.         break;
  148.         case inGrow:
  149.             DoGrow(myWindow, event->where);
  150.         break;
  151.         case inZoomIn:
  152.         case inZoomOut:
  153.             DoZoom(myWindow, event->where, myPart);
  154.         break;
  155.         case inContent:
  156.             if (myWindow != FrontWindow())
  157.             {
  158.                 SelectWindow(myWindow);
  159.             }
  160.             else
  161.             {
  162.                 DoContentClick(myWindow,event);
  163.             }
  164.         break;
  165.     }
  166. }
  167.  
  168. void DoMouseUp(EventRecord *event)
  169. {
  170.     if(MouseUpFunc)
  171.     {
  172.         if(event->modifiers & shiftKey)
  173.         {
  174.             gDrawFlag = (*MouseUpFunc)(event->where.h, event->where.v, TK_RIGHTBUTTON);
  175.         }
  176.         else if(event->modifiers & optionKey)
  177.         {
  178.             gDrawFlag = (*MouseUpFunc)(event->where.h, event->where.v, TK_MIDDLEBUTTON);
  179.         }
  180.         else
  181.         {
  182.             gDrawFlag = (*MouseUpFunc)(event->where.h, event->where.v, TK_LEFTBUTTON);
  183.         }
  184.     }
  185. }
  186.  
  187. void DoDrag(WindowPtr myWindow, Point mouseloc)
  188. {
  189.     Rect    dragBounds;
  190.     
  191.     dragBounds = (**GetGrayRgn()).rgnBBox;
  192.     DragWindow(myWindow,mouseloc,&dragBounds);
  193.  
  194.     aglUpdateContext(aglGetCurrentContext());
  195. }
  196.  
  197. void DoContentClick(WindowPtr myWindow, EventRecord *event)
  198. {
  199.     if(tkWindow.fullscreen) return;
  200.     
  201.     SetPort(myWindow);
  202.     GlobalToLocal(&event->where);
  203.     
  204.     if(MouseDownFunc)
  205.     {
  206.         if(event->modifiers & shiftKey)
  207.         {
  208.             gDrawFlag = (*MouseDownFunc)(event->where.h, event->where.v, TK_RIGHTBUTTON);
  209.         }
  210.         else if(event->modifiers & optionKey)
  211.         {
  212.             gDrawFlag = (*MouseDownFunc)(event->where.h, event->where.v, TK_MIDDLEBUTTON);
  213.         }
  214.         else
  215.         {
  216.             gDrawFlag = (*MouseDownFunc)(event->where.h, event->where.v, TK_LEFTBUTTON);
  217.         }
  218.     }
  219. }
  220.  
  221. Boolean IsDAccWindow(WindowPtr myWindow)
  222. {
  223.     if(myWindow == nil) 
  224.     { 
  225.         return false;
  226.     }
  227.     else
  228.     { 
  229.         return(((WindowPeek)myWindow)->windowKind < 0);
  230.     }
  231. }
  232.  
  233. void DoGoAwayBox(WindowPtr myWindow, Point mouseloc)
  234. {
  235.     if(TrackGoAway(myWindow,mouseloc))
  236.     { 
  237.         DoCloseWindow(myWindow); 
  238.     }
  239. }
  240.  
  241. void DoCloseWindow(WindowPtr myWindow)
  242. {
  243.     if(myWindow)
  244.     {
  245.         if(IsDAccWindow(myWindow))
  246.         {
  247.             CloseDeskAcc(((WindowPeek)myWindow)->windowKind);
  248.         }
  249.         else 
  250.         {
  251.             tkQuit();
  252.         }
  253.     }
  254. }
  255.  
  256. void DoMenuAdjust(void)
  257. {
  258. }
  259.  
  260. void DoKeyDown(EventRecord *event)
  261. { 
  262.     char    myCharCode;
  263.     char    myKeyCode;
  264.     int        myKey;
  265.     GLenum    mask;
  266.     
  267.     myCharCode    = (char)BitAnd(event->message,charCodeMask);
  268.     
  269.     if(BitAnd(event->modifiers,cmdKey) != 0)
  270.     {
  271.         DoMenuAdjust();
  272.         DoMenuCommand(MenuKey(myCharCode));
  273.     }
  274.     else 
  275.     {
  276.         myKeyCode = event->message & keyCodeMask;
  277.         
  278.         switch(myCharCode)
  279.         {
  280.             case '0':    myKey    = TK_0; break;
  281.             case '1':    myKey    = TK_1; break;
  282.             case '2':    myKey    = TK_2; break;
  283.             case '3':    myKey    = TK_3; break;
  284.             case '4':    myKey    = TK_4; break;
  285.             case '5':    myKey    = TK_5; break;
  286.             case '6':    myKey    = TK_6; break;
  287.             case '7':    myKey    = TK_7; break;
  288.             case '8':    myKey    = TK_8; break;
  289.             case '9':    myKey    = TK_9; break;
  290.             case 'A':    myKey    = TK_A; break;
  291.             case 'B':    myKey    = TK_B; break;
  292.             case 'C':    myKey    = TK_C; break;
  293.             case 'D':    myKey    = TK_D; break;
  294.             case 'E':    myKey    = TK_E; break;
  295.             case 'F':    myKey    = TK_F; break;
  296.             case 'G':    myKey    = TK_G; break;
  297.             case 'H':    myKey    = TK_H; break;
  298.             case 'I':    myKey    = TK_I; break;
  299.             case 'J':    myKey    = TK_J; break;
  300.             case 'K':    myKey    = TK_K; break;
  301.             case 'L':    myKey    = TK_L; break;
  302.             case 'M':    myKey    = TK_M; break;
  303.             case 'N':    myKey    = TK_N; break;
  304.             case 'O':    myKey    = TK_O; break;
  305.             case 'P':    myKey    = TK_P; break;
  306.             case 'Q':    myKey    = TK_Q; break;
  307.             case 'R':    myKey    = TK_R; break;
  308.             case 'S':    myKey    = TK_S; break;
  309.             case 'T':    myKey    = TK_T; break;
  310.             case 'U':    myKey    = TK_U; break;
  311.             case 'V':    myKey    = TK_V; break;
  312.             case 'W':    myKey    = TK_W; break;
  313.             case 'X':    myKey    = TK_X; break;
  314.             case 'Y':    myKey    = TK_Y; break;
  315.             case 'Z':    myKey    = TK_Z; break;
  316.             case 'a':    myKey    = TK_a; break;
  317.             case 'b':    myKey    = TK_b; break;
  318.             case 'c':    myKey    = TK_c; break;
  319.             case 'd':    myKey    = TK_d; break;
  320.             case 'e':    myKey    = TK_e; break;
  321.             case 'f':    myKey    = TK_f; break;
  322.             case 'g':    myKey    = TK_g; break;
  323.             case 'h':    myKey    = TK_h; break;
  324.             case 'i':    myKey    = TK_i; break;
  325.             case 'j':    myKey    = TK_j; break;
  326.             case 'k':    myKey    = TK_k; break;
  327.             case 'l':    myKey    = TK_l; break;
  328.             case 'm':    myKey    = TK_m; break;
  329.             case 'n':    myKey    = TK_n; break;
  330.             case 'o':    myKey    = TK_o; break;
  331.             case 'p':    myKey    = TK_p; break;
  332.             case 'q':    myKey    = TK_q; break;
  333.             case 'r':    myKey    = TK_r; break;
  334.             case 's':    myKey    = TK_s; break;
  335.             case 't':    myKey    = TK_t; break;
  336.             case 'u':    myKey    = TK_u; break;
  337.             case 'v':    myKey    = TK_v; break;
  338.             case 'w':    myKey    = TK_w; break;
  339.             case 'x':    myKey    = TK_x; break;
  340.             case 'y':    myKey    = TK_y; break;
  341.             case 'z':    myKey    = TK_z; break;
  342.             case ' ':    myKey    = TK_SPACE; break;
  343.             case 0x0D:    myKey    = TK_RETURN; break;
  344.             case 0x1B:    myKey    = TK_ESCAPE; break;
  345.             case 0x1C:    myKey    = TK_LEFT; break;
  346.             case 0x1D:    myKey    = TK_RIGHT; break;
  347.             case 0x1E:    myKey    = TK_UP; break;
  348.             case 0x1F:    myKey    = TK_DOWN; break;
  349.             default:     myKey    = GL_FALSE; break; 
  350.         }
  351.         
  352.         if (myKey && KeyDownFunc)
  353.         {
  354.             mask = 0;
  355.             
  356.             if (event->modifiers & controlKey)
  357.             {
  358.                 mask |= TK_CONTROL;
  359.             }
  360.             
  361.             if (event->modifiers & shiftKey)
  362.             {
  363.                 mask |= TK_SHIFT;
  364.             }
  365.             
  366.             gDrawFlag = true;
  367.             (*KeyDownFunc)(myKey, mask);
  368.             
  369.             return;
  370.         }
  371.     }
  372. }
  373.  
  374. static void DoDiskEvent(EventRecord    *event)
  375. {
  376.  
  377. }
  378.  
  379. static void    DoOSEvent(EventRecord    *event)
  380. {
  381.  
  382. }
  383.  
  384. static void DoUpdate(WindowPtr    myWindow)
  385. { 
  386.     GrafPtr        origPort;
  387.     
  388.     GetPort(&origPort);
  389.     SetPort(myWindow);
  390.         
  391.     BeginUpdate(myWindow);    
  392.     EndUpdate(myWindow);
  393.     
  394.     aglUpdateContext(aglGetCurrentContext());
  395.     
  396.     SetPort(origPort);
  397.         
  398.     gDrawFlag = true;
  399. }
  400.  
  401. static void DoActivate(WindowPtr    myWindow,int    myModifiers)
  402. {
  403.  
  404. }
  405.  
  406. static void DoAboutBox(void)
  407. {
  408.     DialogPtr    myDialog;
  409.     short        itemHit;
  410.  
  411.     myDialog = GetNewDialog(kAboutDialog, nil, (WindowPtr) -1);
  412.     ModalDialog(nil, &itemHit);
  413.     DisposeDialog(myDialog);
  414. }
  415.  
  416. static void DoMenuCommand(long    menuAndItem)
  417. {
  418.     int            myMenuNum;
  419.     int            myItemNum;
  420.     int            myResult;
  421.     Str255        myDAName;
  422.     WindowPtr    myWindow;
  423.     
  424.     myMenuNum    = HiWord(menuAndItem);
  425.     myItemNum    = LoWord(menuAndItem);
  426.     
  427.     GetPort(&myWindow);
  428.     
  429.     switch (myMenuNum) 
  430.     {
  431.         case mApple:
  432.             switch (myItemNum)
  433.             {
  434.                 case iAbout: 
  435.                     DoAboutBox();
  436.                 break;
  437.                 default: 
  438.                     GetMenuItemText(GetMenuHandle(mApple), myItemNum, myDAName);
  439.                     myResult = OpenDeskAcc(myDAName);
  440.                 break;
  441.             }
  442.         break;
  443.         case mFile:
  444.             switch (myItemNum)
  445.             {
  446.                 case iQuit:
  447.                     tkQuit();
  448.                 break;
  449.             }
  450.         break;
  451.     }
  452.     
  453.     HiliteMenu(0);
  454. }
  455.  
  456. static Boolean DoConsoleEvent(EventRecord *event)
  457. {
  458.     GLboolean flag = GL_FALSE;
  459.     
  460.     #if defined(__MWERKS__)
  461.         flag = SIOUXHandleOneEvent(event);
  462.     #endif
  463.     
  464.     return flag;
  465. }
  466.  
  467. static void DoNextEvent(void)
  468. {
  469.     Boolean           gotEvent;
  470.     EventRecord       event;
  471.     static double  t0 = -10.0, t1;
  472.     
  473.     gotEvent = WaitNextEvent(everyEvent, &event, 0, nil);
  474.  
  475.     if(gotEvent && !DoConsoleEvent(&event)) 
  476.     {
  477.         switch(event.what)
  478.         {
  479.             case mouseDown:
  480.                 DoMouseDown(&event);
  481.             break;
  482.             case mouseUp:
  483.                 DoMouseUp(&event);
  484.             break;
  485.             case keyDown:
  486.                 DoKeyDown(&event);
  487.             break;
  488.             case keyUp:
  489.             break;
  490.             case autoKey:
  491.                 DoKeyDown(&event);
  492.             break;
  493.             case updateEvt:
  494.                 DoUpdate((WindowPtr) event.message);
  495.             break;
  496.             case diskEvt:
  497.                 DoDiskEvent(&event);
  498.             break;
  499.             case activateEvt:
  500.                 DoActivate((WindowPtr) event.message, event.modifiers);
  501.             break;
  502.             case osEvt:
  503.                 DoOSEvent(&event);
  504.             break;
  505.             default:
  506.                 DoCallIdle();
  507.             break;
  508.         }
  509.     }
  510.     else
  511.     {
  512.         DoCallIdle();
  513.     }
  514. }
  515.  
  516. void tkExec(void)
  517. {
  518.     gDrawFlag = true;
  519.  
  520.     if(tkWindow.drawable)
  521.     {
  522.         BeginUpdate((GrafPort *) tkWindow.drawable);
  523.         EndUpdate((GrafPort *) tkWindow.drawable);
  524.     }
  525.     
  526.     DoReshape(tkWindow.width,tkWindow.height);
  527.  
  528.     while(!gDone)
  529.     {
  530.         DoNextEvent();
  531.         DoRedraw();
  532.     }
  533.     
  534.     tkCloseWindow();
  535. }
  536.  
  537.  
  538. void tkExposeFunc(void (*Func)(int, int))
  539. {
  540.     ExposeFunc = Func;
  541. }
  542.  
  543.  
  544. void tkReshapeFunc(void (*Func)(int, int))
  545. {
  546.     ReshapeFunc = Func;
  547. }
  548.  
  549.  
  550. void tkDisplayFunc(void (*Func)(void))
  551. {
  552.     DisplayFunc = Func;
  553. }
  554.  
  555.  
  556. void tkKeyDownFunc(GLenum (*Func)(int, GLenum))
  557. {
  558.     KeyDownFunc = Func;
  559. }
  560.  
  561. void tkMouseDownFunc(GLenum (*Func)(int, int, GLenum))
  562. {
  563.     MouseDownFunc = Func;
  564. }
  565.  
  566.  
  567. void tkMouseUpFunc(GLenum (*Func)(int, int, GLenum))
  568. {
  569.     MouseUpFunc = Func;
  570. }
  571.  
  572.  
  573. void tkMouseMoveFunc(GLenum (*Func)(int, int, GLenum))
  574. {
  575.     MouseMoveFunc = Func;
  576. }
  577.  
  578.  
  579. void tkIdleFunc(void (*Func)(void))
  580. {
  581.     IdleFunc = Func;
  582. }
  583.