home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 Mobile / Chip_Mobile_2001.iso / palm / business / cube3d / cube3D.exe / cube3D / src / palm.c < prev    next >
C/C++ Source or Header  |  2000-12-26  |  17KB  |  700 lines
  1. /*
  2.  * @(#)palm.c
  3.  *
  4.  * Copyright 1999-2000, Aaron Ardiri (mailto:aaron@ardiri.com)
  5.  * All rights reserved.
  6.  *
  7.  * The  source code  outlines a number of basic Palm Computing Programming
  8.  * principles and you  should be able to take the core structure and write 
  9.  * a large complex program. It is distributed WITHOUT ANY WARRANTY; use it
  10.  * "AS IS" and at your own risk.
  11.  *
  12.  * The code presented is Copyright 1999-2000 by Aaron Ardiri. It should be
  13.  * used for  educational purposes only.  You  shall not modify  the Cube3D 
  14.  * source code in any way and  re-distribute it as your  own,  however you
  15.  * are free to use  the code as  a guide for  developing  programs  on the 
  16.  * Palm Computing Platform.
  17.  */
  18.  
  19. #include "palm.h"
  20.  
  21. typedef struct
  22. {
  23.   Int32 evtTimeOut;
  24.   Int16 timerDiff;
  25.   Int16 ticksPerFrame;
  26.   Int16 timerPointA;
  27.   Int16 timerPointB;
  28. } Globals;
  29.  
  30. // interface
  31. static Boolean mainFormEventHandler(EventType *);
  32. static Boolean infoFormEventHandler(EventType *);
  33. static Boolean helpFormEventHandler(EventType *);
  34. static Boolean xmemFormEventHandler(EventType *);
  35.  
  36. /**
  37.  * The Form:mainForm event handling routine.
  38.  *
  39.  * @param event the event to process.
  40.  * @return true if the event was handled, false otherwise.
  41.  */
  42. static Boolean 
  43. mainFormEventHandler(EventType *event)
  44. {
  45.   Globals *globals;
  46.   Boolean processed = false;
  47.  
  48.   // get globals reference
  49.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  50.  
  51.   switch (event->eType) 
  52.   {
  53.     case frmOpenEvent:
  54.          FrmDrawForm(FrmGetActiveForm());
  55.  
  56.          // initialize the cube environment
  57.          CubeInitialize(35);
  58.  
  59.          // update the form (draw stuff)
  60.          {
  61.            EventType event;
  62.  
  63.            MemSet(&event, sizeof(EventType), 0);
  64.            event.eType = frmUpdateEvent;
  65.            event.data.frmUpdate.formID = FrmGetActiveFormID();
  66.            EvtAddEventToQueue(&event);
  67.          }
  68.  
  69.          processed = true;
  70.          break;
  71.  
  72.     case frmUpdateEvent:
  73.          FrmDrawForm(FrmGetActiveForm());
  74.  
  75.          // draw seperators
  76.          WinDrawLine(  0, 145, 159, 145);
  77.          WinDrawLine(  0, 146, 159, 146);
  78.  
  79.          processed = true;
  80.          break;
  81.  
  82.     case nilEvent:
  83.  
  84.          // make sure the active window is the form
  85.          if (WinGetActiveWindow() == (WinHandle)FrmGetActiveForm()) {
  86.  
  87.            WinHandle winCurrentDraw;
  88.  
  89.            globals->timerPointA = TimGetTicks();
  90.  
  91.            // do the cube thing!
  92.            GraphicsClear();
  93.  
  94.            winCurrentDraw = WinGetDrawWindow();
  95.            WinSetDrawWindow(GraphicsGetDrawWindow());
  96.            CubeAnimate();
  97.            WinSetDrawWindow(winCurrentDraw);
  98.            GraphicsRepaint();
  99.  
  100.            globals->timerPointB = TimGetTicks();
  101.  
  102.            // calculate the delay required
  103.            globals->timerDiff  = (globals->timerPointB - globals->timerPointA);
  104.            globals->evtTimeOut =
  105.              (globals->timerDiff > globals->ticksPerFrame)
  106.                ? 0
  107.                : (globals->ticksPerFrame - globals->timerDiff);
  108.          }
  109.          processed = true;
  110.          break;
  111.  
  112.     case frmCloseEvent:
  113.  
  114.          // terminate the cube environment
  115.          CubeTerminate();
  116.          break;
  117.  
  118.     default:
  119.          break;
  120.   }
  121.  
  122.   return processed;
  123. }
  124.  
  125. /**
  126.  * The Form:infoForm event handling routine.
  127.  *
  128.  * @param event the event to process.
  129.  * @return true if the event was handled, false otherwise.
  130.  */
  131. static Boolean 
  132. infoFormEventHandler(EventType *event)
  133. {
  134.   Globals *globals;
  135.   Boolean processed = false;
  136.  
  137.   // get globals reference
  138.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  139.  
  140.   switch (event->eType) 
  141.   {
  142.     case frmOpenEvent:
  143.          FrmDrawForm(FrmGetActiveForm());
  144.          processed = true;
  145.          break;
  146.    
  147.     case ctlSelectEvent:
  148.  
  149.          switch (event->data.ctlSelect.controlID)
  150.          {
  151.            case infoFormOkButton:
  152.  
  153.                 // send a close event
  154.                 {
  155.                   EventType event;
  156.  
  157.                   MemSet(&event, sizeof(EventType), 0);
  158.                   event.eType = frmCloseEvent;
  159.                   event.data.frmClose.formID = FrmGetActiveFormID();
  160.                   EvtAddEventToQueue(&event);
  161.                 }
  162.                 processed = true;
  163.                 break;
  164.  
  165.            default:
  166.                 break;
  167.          }
  168.          break;
  169.  
  170.     default:
  171.          break;
  172.   }
  173.  
  174.   return processed;
  175. }
  176.  
  177. /**
  178.  * The Form:helpForm event handling routine.
  179.  *
  180.  * @param event the event to process.
  181.  * @return true if the event was handled, false otherwise.
  182.  */
  183. static Boolean 
  184. helpFormEventHandler(EventType *event)
  185. {
  186.   Globals *globals;
  187.   Boolean processed = false;
  188.  
  189.   // get globals reference
  190.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  191.  
  192.   switch (event->eType) 
  193.   {
  194.     case frmOpenEvent:
  195.          FrmDrawForm(FrmGetActiveForm());
  196.          {
  197.            FormType      *frm;
  198.            ScrollBarType *sclBar;
  199.            UInt16        val, min, max, pge;
  200.  
  201.            frm    = FrmGetActiveForm();
  202.            sclBar =  
  203.              (ScrollBarType *)FrmGetObjectPtr(frm, 
  204.                FrmGetObjectIndex(frm, helpFormScrollBar)); 
  205.  
  206.            SclGetScrollBar(sclBar, &val, &min, &max, &pge);
  207.            val = InitInstructions();
  208.            max = (val > pge) ? (val-(pge+16)) : 0;
  209.            SclSetScrollBar(sclBar, 0, min, max, pge);
  210.  
  211.            DrawInstructions(0);
  212.          }
  213.          processed = true;
  214.          break;
  215.    
  216.     case ctlSelectEvent:
  217.  
  218.          switch (event->data.ctlSelect.controlID)
  219.          {
  220.            case helpFormOkButton:
  221.  
  222.                 // send a close event
  223.                 {
  224.                   EventType event;
  225.  
  226.                   MemSet(&event, sizeof(EventType), 0);
  227.                   event.eType = frmCloseEvent;
  228.                   event.data.frmClose.formID = FrmGetActiveFormID();
  229.                   EvtAddEventToQueue(&event);
  230.                 }
  231.  
  232.                 processed = true;
  233.                 break;
  234.  
  235.            default:
  236.                 break;
  237.          }
  238.          break;
  239.  
  240.     case sclRepeatEvent:
  241.          {
  242.            FormType      *frm;
  243.            ScrollBarType *sclBar;
  244.            UInt16        val, min, max, pge;
  245.  
  246.            frm = FrmGetActiveForm();
  247.            sclBar = 
  248.              (ScrollBarType *)FrmGetObjectPtr(frm,
  249.                FrmGetObjectIndex(frm, helpFormScrollBar));
  250.  
  251.            SclGetScrollBar(sclBar, &val, &min, &max, &pge);
  252.            DrawInstructions(val);
  253.          }
  254.  
  255.     case keyDownEvent:
  256.  
  257.          switch (event->data.keyDown.chr)
  258.          {
  259.            case pageUpChr:
  260.                 {
  261.                   FormType      *frm;
  262.                   ScrollBarType *sclBar;
  263.                   UInt16        val, min, max, pge;
  264.  
  265.                   frm = FrmGetActiveForm();
  266.                   sclBar = 
  267.                     (ScrollBarType *)FrmGetObjectPtr(frm,
  268.                       FrmGetObjectIndex(frm, helpFormScrollBar));
  269.  
  270.                   SclGetScrollBar(sclBar, &val, &min, &max, &pge);
  271.                   val = (pge > val) ? 0 : (val-pge); 
  272.                   SclSetScrollBar(sclBar, val, min, max, pge);
  273.                   DrawInstructions(val);
  274.                 }
  275.                 processed = true;
  276.                 break;
  277.  
  278.            case pageDownChr:
  279.                 {
  280.                   FormType      *frm;
  281.                   ScrollBarType *sclBar;
  282.                   UInt16        val, min, max, pge;
  283.  
  284.                   frm = FrmGetActiveForm();
  285.                   sclBar = 
  286.                     (ScrollBarType *)FrmGetObjectPtr(frm,
  287.                       FrmGetObjectIndex(frm, helpFormScrollBar));
  288.  
  289.                   SclGetScrollBar(sclBar, &val, &min, &max, &pge);
  290.                   val = (max < (val+pge)) ? max : (val+pge); 
  291.                   SclSetScrollBar(sclBar, val, min, max, pge);
  292.                   DrawInstructions(val);
  293.                 }
  294.                 processed = true;
  295.                 break;
  296.  
  297.            default:
  298.                 break;
  299.          }
  300.          break;
  301.  
  302.     case frmCloseEvent:
  303.  
  304.          // clean up
  305.          QuitInstructions();
  306.          break;
  307.  
  308.     default:
  309.          break;
  310.   }
  311.  
  312.   return processed;
  313. }
  314.  
  315. /**
  316.  * The Form:xmemForm event handling routine.
  317.  *
  318.  * @param event the event to process.
  319.  * @return true if the event was handled, false otherwise.
  320.  */
  321. static Boolean 
  322. xmemFormEventHandler(EventType *event)
  323. {
  324.   Globals *globals;
  325.   Boolean processed = false;
  326.  
  327.   // get globals reference
  328.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  329.  
  330.   switch (event->eType) 
  331.   {
  332.     case frmOpenEvent:
  333.          FrmDrawForm(FrmGetActiveForm());
  334.          processed = true;
  335.          break;
  336.    
  337.     case ctlSelectEvent:
  338.  
  339.          switch (event->data.ctlSelect.controlID)
  340.          {
  341.            case xmemFormOkButton:
  342.  
  343.                 // send a close event
  344.                 {
  345.                   EventType event;
  346.  
  347.                   MemSet(&event, sizeof(EventType), 0);
  348.                   event.eType = frmCloseEvent;
  349.                   event.data.frmClose.formID = FrmGetActiveFormID();
  350.                   EvtAddEventToQueue(&event);
  351.                 }
  352.                 processed = true;
  353.                 break;
  354.  
  355.            default:
  356.                 break;
  357.          }
  358.          break;
  359.  
  360.     default:
  361.          break;
  362.   }
  363.  
  364.   return processed;
  365. }
  366.  
  367. /**
  368.  * The Palm Computing Platform initialization routine.
  369.  */
  370. void  
  371. InitApplication()
  372. {
  373.   Globals *globals;
  374.  
  375.   // get globals reference
  376.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  377.  
  378.   globals->evtTimeOut    = evtWaitForever;
  379.   globals->ticksPerFrame = SysTicksPerSecond() / CUBE_FPS;
  380.  
  381.   // goto the main form
  382.   FrmGotoForm(mainForm);
  383. }
  384.  
  385. /**
  386.  * The Palm Computing Platform entry routine (mainline).
  387.  *
  388.  * @param cmd         a word value specifying the launch code.
  389.  * @param cmdPBP      pointer to a structure associated with the launch code.
  390.  * @param launchFlags additional launch flags.
  391.  * @return zero if launch successful, non zero otherwise.
  392.  */
  393. UInt32  
  394. PilotMain(UInt16 cmd, MemPtr cmdPBP, UInt16 launchFlags)
  395. {
  396.   UInt32 result = 0;
  397.  
  398.   // what type of launch was this?
  399.   switch (cmd) 
  400.   {
  401.     case sysAppLaunchCmdNormalLaunch:
  402.          {
  403.            Globals *globals;
  404.        Boolean ok;
  405.  
  406.            DeviceInitialize();
  407.  
  408.            // create the globals object, and register it
  409.            globals = (Globals *)MemPtrNew(sizeof(Globals));
  410.        MemSet(globals, sizeof(Globals), 0);
  411.            FtrSet(appCreator, ftrGlobals, (UInt32)globals);
  412.  
  413.        // initialize the graphics engine
  414.            ok = GraphicsInitialize();
  415.  
  416.            // everything worked out ok?
  417.            if (ok) {
  418.          InitApplication();
  419.              EventLoop();
  420.              EndApplication();
  421.            }
  422.  
  423.        // terminate the graphics engine
  424.            GraphicsTerminate();
  425.  
  426.            // unregister the feature
  427.            FtrUnregister(appCreator, ftrGlobals);
  428.  
  429.            DeviceTerminate();
  430.          }
  431.          break;
  432.  
  433.     default:
  434.          break;
  435.   }
  436.  
  437.   return result;
  438. }
  439.  
  440. /**
  441.  * The application event handling routine.
  442.  *
  443.  * @param event the event to process.
  444.  * @return true if the event was handled, false otherwise.
  445.  */
  446. Boolean 
  447. ApplicationHandleEvent(EventType *event)
  448. {
  449.   Globals *globals;
  450.   Boolean processed = false;
  451.  
  452.   // get globals reference
  453.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  454.  
  455.   switch (event->eType)
  456.   {
  457.     case frmLoadEvent:
  458.          {
  459.            UInt16   formID = event->data.frmLoad.formID;
  460.            FormType *frm   = FrmInitForm(formID);
  461.  
  462.            FrmSetActiveForm(frm);
  463.            switch (formID) 
  464.            {
  465.              case mainForm:
  466.                   FrmSetEventHandler(frm, 
  467.                     (FormEventHandlerPtr)mainFormEventHandler);
  468.  
  469.                   processed = true;
  470.                   break;
  471.  
  472.              case infoForm:
  473.                   FrmSetEventHandler(frm, 
  474.                     (FormEventHandlerPtr)infoFormEventHandler);
  475.  
  476.                   processed = true;
  477.                   break;
  478.  
  479.              case helpForm:
  480.                   FrmSetEventHandler(frm, 
  481.                     (FormEventHandlerPtr)helpFormEventHandler);
  482.  
  483.                   processed = true;
  484.                   break;
  485.  
  486.              case xmemForm:
  487.                   FrmSetEventHandler(frm, 
  488.                     (FormEventHandlerPtr)xmemFormEventHandler);
  489.  
  490.                   processed = true;
  491.                   break;
  492.              default:
  493.                   break;
  494.            }
  495.          }
  496.          break;
  497.          
  498.     case winEnterEvent:
  499.          {
  500.            if (event->data.winEnter.enterWindow == 
  501.                 (WinHandle)FrmGetFormPtr(mainForm)) {
  502.              globals->evtTimeOut = 0;
  503.              processed           = true;
  504.            }
  505.          }
  506.          break;
  507.  
  508.     case winExitEvent:
  509.          {
  510.            if (event->data.winEnter.enterWindow == 
  511.                 (WinHandle)FrmGetFormPtr(mainForm)) {
  512.              globals->evtTimeOut = evtWaitForever;
  513.              processed           = true;
  514.            }
  515.          }
  516.          break;
  517.  
  518.     case menuEvent:
  519.  
  520.          switch (event->data.menu.itemID) 
  521.          {
  522.            case menuItemHelp:
  523.                 ApplicationDisplayDialog(helpForm);
  524.  
  525.                 processed = true;
  526.                 break;
  527.  
  528.            case menuItemAbout:
  529.                 ApplicationDisplayDialog(infoForm);
  530.  
  531.                 processed = true;
  532.                 break;
  533.  
  534.            default:
  535.                 break;
  536.          }
  537.          break;
  538.  
  539.     case ctlSelectEvent:
  540.   
  541.          switch (event->data.ctlSelect.controlID)
  542.          {
  543.            case globalFormHelpButton:
  544.  
  545.                 // regenerate menu event
  546.                 {
  547.                   EventType event;
  548.  
  549.                   MemSet(&event, sizeof(EventType), 0);
  550.                   event.eType            = menuEvent;
  551.                   event.data.menu.itemID = menuItemHelp;
  552.                   EvtAddEventToQueue(&event);
  553.                 }
  554.                 processed = true;
  555.                 break;
  556.  
  557.            case globalFormAboutButton:
  558.  
  559.                 // regenerate menu event
  560.                 {
  561.                   EventType event;
  562.  
  563.                   MemSet(&event, sizeof(EventType), 0);
  564.                   event.eType            = menuEvent;
  565.                   event.data.menu.itemID = menuItemAbout;
  566.                   EvtAddEventToQueue(&event);
  567.                 }
  568.                 processed = true;
  569.                 break;
  570.  
  571.            default:
  572.                 break;
  573.          }
  574.          break;
  575.          
  576.     default:
  577.          break;
  578.   }
  579.  
  580.   return processed;
  581. }
  582.  
  583. /**
  584.  * Display a MODAL dialog to the user (this is a modified FrmDoDialog)
  585.  *
  586.  * @param formID the ID of the form to display.
  587.  */
  588. void
  589. ApplicationDisplayDialog(UInt16 formID)
  590. {
  591.   Globals             *globals;
  592.   FormActiveStateType frmCurrState;
  593.   FormType            *frmActive      = NULL;
  594.   WinHandle           winDrawWindow   = NULL;
  595.   WinHandle           winActiveWindow = NULL;
  596.  
  597.   // get globals reference
  598.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  599.  
  600.   // save the active form/window
  601.   if (DeviceSupportsVersion(romVersion3)) {
  602.     FrmSaveActiveState(&frmCurrState);
  603.   }
  604.   else {
  605.     frmActive       = FrmGetActiveForm();
  606.     winDrawWindow   = WinGetDrawWindow();
  607.     winActiveWindow = WinGetActiveWindow();  // < palmos3.0, manual work
  608.   }
  609.  
  610.   {
  611.     EventType event;
  612.     UInt16    err;
  613.     Boolean   keepFormOpen;
  614.  
  615.     MemSet(&event, sizeof(EventType), 0);
  616.  
  617.     // send a load form event
  618.     event.eType = frmLoadEvent;
  619.     event.data.frmLoad.formID = formID;
  620.     EvtAddEventToQueue(&event);
  621.  
  622.     // send a open form event
  623.     event.eType = frmOpenEvent;
  624.     event.data.frmLoad.formID = formID;
  625.     EvtAddEventToQueue(&event);
  626.  
  627.     // handle all events here (trap them before the OS does) :)
  628.     keepFormOpen = true;
  629.     while (keepFormOpen) {
  630.  
  631.       EvtGetEvent(&event, globals->evtTimeOut);
  632.  
  633.       // this is our exit condition! :)
  634.       keepFormOpen = (event.eType != frmCloseEvent);
  635.  
  636.       if (!SysHandleEvent(&event))
  637.         if (!MenuHandleEvent(0, &event, &err))
  638.           if (!ApplicationHandleEvent(&event))
  639.             FrmDispatchEvent(&event);
  640.  
  641.       if (event.eType == appStopEvent) {
  642.         keepFormOpen = false;
  643.         EvtAddEventToQueue(&event);  // tap "applications", need to exit
  644.       }
  645.     }
  646.   }
  647.  
  648.   // restore the active form/window
  649.   if (DeviceSupportsVersion(romVersion3)) {
  650.     FrmRestoreActiveState(&frmCurrState);
  651.   }
  652.   else {
  653.     FrmSetActiveForm(frmActive);
  654.     WinSetDrawWindow(winDrawWindow);
  655.     WinSetActiveWindow(winActiveWindow);     // < palmos3.0, manual work
  656.   }
  657. }
  658.  
  659. /**
  660.  * The Palm Computing Platform event processing loop.
  661.  */
  662. void  
  663. EventLoop()
  664. {
  665.   Globals   *globals;
  666.   EventType event;
  667.   UInt16    err;
  668.  
  669.   // get globals reference
  670.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  671.  
  672.   do {
  673.     EvtGetEvent(&event, globals->evtTimeOut);
  674.  
  675.     if (!SysHandleEvent(&event)) 
  676.       if (!MenuHandleEvent(0, &event, &err)) 
  677.         if (!ApplicationHandleEvent(&event)) 
  678.           FrmDispatchEvent(&event);
  679.  
  680.   } while (event.eType != appStopEvent);
  681. }
  682.  
  683. /**
  684.  * The Palm Computing Platform termination routine.
  685.  */
  686. void  
  687. EndApplication()
  688. {
  689.   Globals *globals;
  690.  
  691.   // get globals reference
  692.   FtrGet(appCreator, ftrGlobals, (UInt32 *)&globals);
  693.  
  694.   // ensure all forms are closed
  695.   FrmCloseAllForms();
  696.  
  697.   // clean up
  698.   MemPtrFree(globals);
  699. }
  700.