home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / QuickDraw 3D / Samples / SampleCode / Utility Library / Source / Q3UL.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-14  |  12.8 KB  |  591 lines  |  [TEXT/CWIE]
  1. /*
  2.  *
  3.  * Utility library for QuickDraw 3D.
  4.  *
  5.  * Nick Thompson, nickt@apple.com
  6.  * Send bug reports and feedback to devsupport@apple.com.
  7.  *
  8.  * ©1997 Apple Computer Inc, All Rights Reserved 
  9.  *
  10.  * Modification History:
  11.  *
  12.  */
  13.  
  14. #include <assert.h>
  15. #include <DiskInit.h>
  16. #include <Fonts.h>
  17. #include <QuickDraw.h>
  18. #include <Windows.h>
  19.  
  20. #include "QD3D.h"
  21. #include "Q3UL.h"
  22. #include "Q3ULPriv.h"
  23. #include "Q3UL_QD3DUtils.h"
  24.  
  25. /* currently we have our window list stored in an array, this
  26.  * could be extended to use a variable length array (we add items
  27.  * to the array as needed, or as a linked list.  For now we just
  28.  * want to keep it as simple as possible.
  29.  */
  30.  
  31. TQ3UL_WindowDescriptor        gWindowArray[ MAXNUMWINDOWS ] ;
  32. Boolean                        gQuitFlag = false ;
  33.  
  34. /*------------------------------------------------------------------------------
  35.  * zero out the referenced element of the windows array.
  36.  */
  37.  
  38. static void iZeroWinElement( TQ3UL_WindowRef windowID )
  39. {
  40. #if defined( DEBUGGING ) && DEBUGGING
  41.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  42. #endif 
  43.     gWindowArray[windowID].window    = NULL ;
  44.     gWindowArray[windowID].refType    = 0L ;
  45.     gWindowArray[windowID].refCon     = 0L ;
  46.     
  47.     gWindowArray[windowID].theCloseHandler        = NULL ;
  48.     gWindowArray[windowID].theKeyHandler         = NULL ;
  49.     gWindowArray[windowID].theMouseDownHandler    = NULL ;
  50.     gWindowArray[windowID].theMouseUpHandler     = NULL ;
  51.     gWindowArray[windowID].theMouseDragHandler    = NULL ;
  52.     gWindowArray[windowID].theRedrawHandler     = NULL ;
  53.     gWindowArray[windowID].theIdleHandler         = NULL ;
  54.     
  55.     gWindowArray[windowID].theView = NULL ;
  56. }
  57.  
  58. /*------------------------------------------------------------------------------
  59.  * get the index of the specified window, -1 if it can't be found.
  60.  */
  61.  
  62. static long iWindowPtrToIdx( WindowPtr theWindow )
  63. {
  64.     long    idx ;
  65.     for(idx = 0; idx<MAXNUMWINDOWS; idx++ )
  66.         if(gWindowArray[idx].window == theWindow)
  67.             break ;
  68.             
  69.     if(idx < 0 || idx >= MAXNUMWINDOWS)
  70.         idx = -1 ;
  71.  
  72.     return idx ;    
  73. }
  74.  
  75. /*------------------------------------------------------------------------------
  76.  * get the high 16 bits of a long.
  77.  */
  78.  
  79. short HiWrd(long aLong)
  80. {
  81.     return    (((aLong) >> 16) & 0xFFFF) ;
  82. }
  83.  
  84. /*------------------------------------------------------------------------------
  85.  * get the low 16 bits of a long.
  86.  */
  87.  
  88. short LoWrd(long aLong)
  89. {
  90.     return    ((aLong) & 0xFFFF) ;
  91. }
  92.  
  93. /*------------------------------------------------------------------------------
  94.  * Initialize the utility library.  Calls Q3Initialize.  Initialize any other
  95.  * data structures used by the library.
  96.  */
  97.  
  98. TQ3Status Q3UL_Initialize( void )
  99. {
  100.     TQ3Status        theStatus ;
  101.     long            i ;
  102.     
  103.     /* first step is to initialize the window array
  104.      * to known values
  105.      */
  106.      
  107.     for( i = 0; i<MAXNUMWINDOWS; i++)
  108.         iZeroWinElement( i ) ;
  109.     
  110.     /*
  111.      * next step is to initialize the toolbox managers
  112.      */
  113.     
  114.     MaxApplZone() ;
  115.     MoreMasters() ; MoreMasters() ; MoreMasters() ; 
  116.     
  117.     InitGraf( &qd.thePort );
  118.     InitFonts();
  119.     InitWindows();
  120.     InitCursor();
  121.  
  122.     FlushEvents( everyEvent, 0 ) ;
  123.     
  124.     /*
  125.      * finally initialize QuickDraw 3D
  126.      */
  127.     
  128.     theStatus = Q3Initialize() ;
  129.     
  130.     return theStatus ;
  131. } 
  132.  
  133.  
  134. /*------------------------------------------------------------------------------
  135.  * Call Q3Exit(), clean up and dispose of anything the library allocated
  136.  */
  137. TQ3Status Q3UL_Terminate( void )
  138. {
  139.     TQ3Status        theStatus ;
  140.     
  141.     /* signal the main event loop that we are done */
  142.     gQuitFlag = true ;
  143.     
  144.     /* close the connection to the QD3D library */
  145.     theStatus = Q3Exit() ;
  146.     
  147.     return theStatus ;
  148. } 
  149.  
  150. /*------------------------------------------------------------------------------
  151.  * 
  152.  */
  153. void    Q3UL_SetPrivType( 
  154.     TQ3UL_WindowRef windowID, 
  155.     unsigned long refType)
  156. {
  157. #if defined( DEBUGGING ) && DEBUGGING
  158.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  159. #endif
  160.     gWindowArray[windowID].refType = refType ;
  161. }
  162.  
  163. /*------------------------------------------------------------------------------
  164.  * 
  165.  */
  166. unsigned long Q3UL_GetPrivType( 
  167.     TQ3UL_WindowRef windowID )
  168. {
  169. #if defined( DEBUGGING ) && DEBUGGING
  170.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  171. #endif
  172.     return gWindowArray[windowID].refType ;
  173. }
  174.  
  175. /*------------------------------------------------------------------------------
  176.  * 
  177.  */
  178. void    Q3UL_SetPrivData( 
  179.     TQ3UL_WindowRef windowID, 
  180.     void *priv)
  181. {
  182. #if defined( DEBUGGING ) && DEBUGGING
  183.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  184. #endif
  185.     if( priv != NULL )
  186.         gWindowArray[windowID].refCon = (unsigned long)priv ;
  187. }
  188.  
  189. /*------------------------------------------------------------------------------
  190.  * 
  191.  */
  192. void    *Q3UL_GetPrivData( 
  193.     TQ3UL_WindowRef windowID )
  194. {
  195. #if defined( DEBUGGING ) && DEBUGGING
  196.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  197. #endif
  198.     return (void *)gWindowArray[windowID].refCon ;
  199. }
  200.  
  201.  
  202. /*------------------------------------------------------------------------------
  203.  * 
  204.  */
  205.  
  206. void    Q3UL_RegisterCloseWindowHandler( 
  207.     TQ3UL_WindowRef             windowID, 
  208.     TQ3UL_CloseWindowHandler     theCloseHandler )
  209. {
  210. #if defined( DEBUGGING ) && DEBUGGING
  211.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  212. #endif
  213.     gWindowArray[windowID].theCloseHandler = theCloseHandler ;
  214.  
  215. }
  216.  
  217. /*------------------------------------------------------------------------------
  218.  * 
  219.  */
  220.  
  221. void    Q3UL_RegisterKeyHandler( 
  222.     TQ3UL_WindowRef     windowID, 
  223.     TQ3UL_KeyHandler     theKeyHandler )
  224. {
  225. #if defined( DEBUGGING ) && DEBUGGING
  226.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  227. #endif
  228.     gWindowArray[windowID].theKeyHandler = theKeyHandler ;
  229. }
  230.  
  231.  
  232.  
  233. /*------------------------------------------------------------------------------
  234.  * 
  235.  */
  236.  
  237. void Q3UL_RegisterMouseDownHandler( 
  238.     TQ3UL_WindowRef         windowID, 
  239.     TQ3UL_MouseDownHandler     theMouseDownHandler )
  240. {
  241. #if defined( DEBUGGING ) && DEBUGGING
  242.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  243. #endif
  244.     gWindowArray[windowID].theMouseDownHandler = theMouseDownHandler ;
  245. }
  246.  
  247.  
  248.  
  249. /*------------------------------------------------------------------------------
  250.  * 
  251.  */
  252.  
  253. void Q3UL_RegisterMouseUpHandler( 
  254.     TQ3UL_WindowRef         windowID, 
  255.     TQ3UL_MouseUpHandler     theMouseUpHandler )
  256. {
  257. #if defined( DEBUGGING ) && DEBUGGING
  258.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  259. #endif
  260.     gWindowArray[windowID].theMouseUpHandler = theMouseUpHandler ;
  261.  
  262. }
  263.  
  264.  
  265.  
  266. /*------------------------------------------------------------------------------
  267.  * 
  268.  */
  269.  
  270. void Q3UL_RegisterMouseDragHandler( 
  271.     TQ3UL_WindowRef         windowID, 
  272.     TQ3UL_MouseDragHandler     theMouseDragHandler )
  273. {
  274. #if defined( DEBUGGING ) && DEBUGGING
  275.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  276. #endif
  277.     gWindowArray[windowID].theMouseDragHandler = theMouseDragHandler ;
  278.  
  279. }
  280.  
  281.  
  282.  
  283. /*------------------------------------------------------------------------------
  284.  * 
  285.  */
  286.  
  287. void Q3UL_RegisterRedraw( 
  288.     TQ3UL_WindowRef         windowID, 
  289.     TQ3UL_RedrawHandler     theRedrawHandler )
  290. {
  291. #if defined( DEBUGGING ) && DEBUGGING
  292.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  293. #endif
  294.     gWindowArray[windowID].theRedrawHandler = theRedrawHandler ;
  295.  
  296. }
  297.  
  298.  
  299.  
  300. /*------------------------------------------------------------------------------
  301.  * 
  302.  */
  303.  
  304. void Q3UL_RegisterIdle( 
  305.     TQ3UL_WindowRef         windowID, 
  306.     TQ3UL_IdleHandler         theIdleHandler )
  307. {
  308. #if defined( DEBUGGING ) && DEBUGGING
  309.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  310. #endif
  311.     gWindowArray[windowID].theIdleHandler = theIdleHandler ;
  312. }
  313.  
  314.  
  315.  
  316. /*------------------------------------------------------------------------------
  317.  * 
  318.  */
  319.  
  320. TQ3UL_WindowRef Q3UL_NewWindow(
  321.     short width, 
  322.     short height )
  323. {
  324.     WindowPtr        theWindow ;
  325.     static    short    staggerPos = 50 ;
  326.     int                i ;
  327.  
  328.     /* skanky hack to offset the window, not that you 
  329.      * could create something that is offscreen, so really
  330.      * should check to see if the values need to wrap.
  331.      */
  332.     Rect            boundsRect  ;
  333.     
  334.     boundsRect.top = boundsRect.left = staggerPos ;
  335.     boundsRect.bottom = staggerPos+height ;
  336.     boundsRect.right = staggerPos+height ;
  337.  
  338.     /* find a place for the window in the array */
  339.     while( i < MAXNUMWINDOWS )
  340.     {
  341.         if( gWindowArray[i].window == NULL ) 
  342.             break ;
  343.     }
  344.     
  345.     if( i >= MAXNUMWINDOWS )
  346.     {
  347.         /* can create a window, the array is full */
  348.         SysBeep(10) ;
  349.         return -1 ;
  350.     } 
  351.     
  352.     /* create a new window of width x height */
  353.     theWindow = NewCWindow ( NULL, 
  354.                              &boundsRect, 
  355.                              "\pUntitled", 
  356.                              false, 
  357.                              zoomDocProc, 
  358.                              (WindowPtr)-1, 
  359.                              true, 
  360.                              0L ) ;
  361.     
  362.     if( theWindow != NULL )
  363.         gWindowArray[i].window = theWindow ;         
  364.         
  365.     /*
  366.      * set up a quickDraw 3D view for this window 
  367.      */
  368.      
  369.     gWindowArray[i].theView = Q3UL_NewView( i ) ;
  370.                      
  371.     ShowWindow(theWindow) ;
  372.     
  373.     return i ;
  374.     
  375. }
  376.  
  377.  
  378.  
  379. /*------------------------------------------------------------------------------
  380.  * Dispose of a utility library window, make sure you dispose of associated
  381.  * storage before calling this.
  382.  */
  383.  
  384. void Q3UL_DestroyWindow( 
  385.     TQ3UL_WindowRef windowID )
  386. {
  387. #if defined( DEBUGGING ) && DEBUGGING
  388.     assert( windowID >= 0 && windowID < MAXNUMWINDOWS ) ;
  389. #endif
  390.     /*
  391.      * first get rid of the view we created for this object
  392.      */
  393.     Q3Object_Dispose( gWindowArray[windowID].theView ) ;
  394.     
  395.     /*
  396.      * get rid of the window itself
  397.      */
  398.     DisposeWindow( gWindowArray[windowID].window ) ;
  399.  
  400.     /* reset the fields to nil */
  401.     iZeroWinElement( windowID ) ;
  402.  
  403. }
  404.  
  405.  
  406.  
  407.  
  408. /*------------------------------------------------------------------------------
  409.  * 
  410.  */
  411.  
  412. void Q3UL_ResizeFrontWindow( 
  413.     short x, 
  414.     short y )
  415. {
  416.  
  417. }
  418.  
  419.  
  420.  
  421. /*------------------------------------------------------------------------------
  422.  * 
  423.  */
  424.  
  425. void Q3UL_ZoomFrontWindow()
  426. {
  427.  
  428. }
  429.  
  430.  
  431.  
  432. /*------------------------------------------------------------------------------
  433.  * 
  434.  */
  435.  
  436. void Q3UL_MoveFrontWindow( 
  437.     short top, 
  438.     short left )
  439. {
  440.     MoveWindow ( FrontWindow(), left, top, true ) ;    
  441. }
  442.  
  443. /*------------------------------------------------------------------------------
  444.  * 
  445.  */
  446.  
  447. void Q3UL_RedrawWindow(
  448.     TQ3UL_WindowRef windowID )
  449. {
  450.     GrafPtr        savedPort ;
  451.     
  452.     GetPort( &savedPort ) ;
  453.     SetPort( gWindowArray[windowID].window ) ;
  454.     InvalRect( &gWindowArray[windowID].window->portRect ) ;    
  455.     SetPort( savedPort ) ;
  456. }
  457.  
  458. /*------------------------------------------------------------------------------
  459.  * 
  460.  */
  461.  
  462. void Q3UL_MainEventLoop(void)
  463. {
  464.     EventRecord     event;
  465.     WindowPtr       window;
  466.     short           thePart;
  467.     Rect            screenRect, updateRect;
  468.     Point            aPoint = {100, 100};
  469.     TQ3UL_WindowRef    windowID ;
  470.     
  471.  
  472.     while( !gQuitFlag )
  473.     {
  474.         if (WaitNextEvent( everyEvent, &event, 0, nil ))
  475.         {
  476.  
  477.             switch (event.what) {
  478.                 case mouseDown:
  479.                 
  480.                     thePart = FindWindow( event.where, &window );
  481.                     windowID = iWindowPtrToIdx( window ) ;
  482.                     
  483.                     switch( thePart ) {
  484.                         case inMenuBar: 
  485.                             break;
  486.                         
  487.                         case inDrag:
  488.                             /* drag the window by the title bar */
  489.                             screenRect = (**GetGrayRgn()).rgnBBox;
  490.                             DragWindow( FrontWindow(), event.where, &screenRect );
  491.                             break ;
  492.                     
  493.                         case inContent:
  494.                         
  495.                             /* content region: if the window is not the front
  496.                              * window make it so 
  497.                              */
  498.                             if (window != FrontWindow())
  499.                                 SelectWindow( window );
  500.                             
  501.                             /* if we have a mouse hanfler, call it, passing in the window 
  502.                              * reference, and the x, and y position 
  503.                              */
  504.                             if(gWindowArray[windowID].theMouseDownHandler != NULL )
  505.                                 (*gWindowArray[windowID].theMouseDownHandler)( 
  506.                                         windowID,
  507.                                         event.where.h,
  508.                                         event.where.v );
  509.                             
  510.                             break ;
  511.                     
  512.                         case inGoAway:
  513.                             if (TrackGoAway( window, event.where )) {
  514.                                 /* check to see if there is a close handler for this window */
  515.                                 if( gWindowArray[windowID].theCloseHandler)
  516.                                 {
  517.                                     /* yes: then call it */
  518.                                     (*gWindowArray[windowID].theCloseHandler)(windowID) ;
  519.                                 }
  520.                                 else
  521.                                 {
  522.                                     /* jusr dispose of the window */
  523.                                     DisposeWindow ( window );
  524.                                 }
  525.  
  526.                             }
  527.                             break ;
  528.                             
  529.                         default:
  530.                             break ;
  531.                     }
  532.                     break ;
  533.                             
  534.                         
  535.                 case updateEvt:
  536.                 
  537.                     window = (WindowPtr)event.message;
  538.                     windowID = iWindowPtrToIdx( window ) ;
  539.                     updateRect = (**(window->visRgn)).rgnBBox;
  540.                     SetPort( window ) ;
  541.                     BeginUpdate( window );
  542.                     
  543.                     /* check to see if there is a redraw handler for this window */
  544.                     if( gWindowArray[windowID].theRedrawHandler)
  545.                     {
  546.                         /* yes: then call it */
  547.                         (*gWindowArray[windowID].theRedrawHandler)(windowID,gWindowArray[windowID].theView) ;
  548.                     }
  549.  
  550.                     EndUpdate( window );
  551.                     break ;
  552.                     
  553.                 case keyDown:
  554.                 case autoKey:
  555.                     /* check to see if there is a redraw handler for this window */
  556.                     if( gWindowArray[windowID].theKeyHandler)
  557.                     {
  558.                         /* yes: then call it */
  559.                         (*gWindowArray[windowID].theKeyHandler)
  560.                             (windowID,
  561.                             event.where.h,
  562.                             event.where.v,
  563.                             (event.message & charCodeMask) ) ;
  564.                     }
  565.  
  566.                     break;
  567.                     
  568.                 case diskEvt:
  569.                     if ( HiWrd(event.message) != noErr ) 
  570.                         (void) DIBadMount(aPoint, event.message);
  571.                     break;
  572.                     
  573.                 case osEvt:
  574.                 case activateEvt:
  575.                     break;
  576.  
  577.  
  578.             }
  579.         }
  580.         else {
  581.             /* check to see if there is a idle handler for this window */
  582.             if( gWindowArray[windowID].theIdleHandler)
  583.             {
  584.                 /* yes: then call it */
  585.                 (*gWindowArray[windowID].theIdleHandler)(windowID) ;
  586.             }
  587.         }
  588.     }
  589. }
  590.  
  591.