home *** CD-ROM | disk | FTP | other *** search
/ Hand Held Organizer Toolkit / walnutcreekcdrom-handheldorganizertoolkit-march1998.iso / PalmPilot / development / sample_source_code / currex_srcs.c < prev    next >
C/C++ Source or Header  |  1997-12-30  |  16KB  |  632 lines
  1.  
  2.  
  3. /***********************************************************************
  4.  *
  5.  *    Copyright ⌐ Palm Computing 1995 -- All Rights Reserved
  6.  *
  7.  * PROJECT: Memo Pad Sample Application
  8.  *
  9.  * FILE: MemoPad.c (Phase 1)
  10.  *
  11.  * DESCRIPTION: Sample application to demonstrate the various
  12.  *     features available.
  13.  *
  14.  *    OBJECTIVE: Create an initial main form with a title and an
  15.  *     exit button.
  16.  *
  17.  * REVISION HISTORY:
  18.  *      9/1/95    David        Initial version
  19.  *
  20.  **********************************************************************/
  21.  
  22. #include <Pilot.h>                // all the system toolbox headers
  23. #include <FloatMgr.h>
  24.  
  25. #include "CurrExRsc.h"        // application resource defines
  26.  
  27.  
  28. /***********************************************************************
  29.  * Prototypes for internal functions
  30.  **********************************************************************/
  31. static void StartApplication(void);
  32. static Boolean MainFormHandleEvent(EventPtr event);
  33. static void EventLoop(void);
  34. static Boolean CalculateTarget();
  35. static Boolean CalculateHome();
  36.  
  37. Handle rateHandle;
  38. Handle targetHandle;
  39. Handle homeHandle;
  40.  
  41. //char targetStr[20] = "";
  42. //char homeStr[20] = "";
  43.  
  44. static Boolean InRateField = false;
  45. static Boolean InHomeField = false;
  46. static Boolean InTargetField = false;
  47.  
  48. static void SetPrefs(char *rate, char *target, char *home);
  49. static void UpdatePrefs();
  50.  
  51. typedef struct
  52.     {
  53.         Char rate[22];
  54.         Char target[22];
  55.         Char home[22];
  56.     } CurrExPreferenceType;
  57.     
  58. CurrExPreferenceType prefs;
  59.  
  60. static void SetPrefs(char *rate, char *target, char *home)
  61. {
  62.     StrCopy(prefs.rate, rate);
  63.     StrCopy(prefs.target, target);
  64.     StrCopy(prefs.home, home);
  65. }
  66.  
  67. static void UpdatePrefs()
  68. {
  69.     FormPtr    frm;
  70.     FieldPtr ratePtr, targetPtr, homePtr;
  71.  
  72.     frm = FrmGetFirstForm();    
  73.  
  74.     ratePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainRateField))));
  75.     homePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainHomeField))));
  76.     targetPtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainTarget0Field))));
  77.  
  78.     StrCopy(prefs.rate, FldGetTextPtr(ratePtr));
  79.     StrCopy(prefs.target, FldGetTextPtr(targetPtr));
  80.     StrCopy(prefs.home, FldGetTextPtr(homePtr));
  81.  
  82.     PrefSetAppPreferences('Curr', 1, &prefs, sizeof(CurrExPreferenceType));
  83. }
  84.  
  85. /***********************************************************************
  86.  *
  87.  * FUNCTION:     StartApplication
  88.  *
  89.  * DESCRIPTION:  This routine sets up the initial state of the application.
  90.  *
  91.  * PARAMETERS:   None.
  92.  *
  93.  * RETURNED:     Nothing.
  94.  *
  95.  ***********************************************************************/
  96. static void StartApplication(void)
  97. {
  98.     FormPtr    frm;
  99.     FieldPtr ratePtr, targetPtr, homePtr;
  100.     CharPtr targetText, rateText, homeText;
  101.  
  102.     rateHandle = MemHandleNew(20+1);
  103.     targetHandle = MemHandleNew(20 + 1);
  104.     homeHandle = MemHandleNew(20 + 1);
  105.  
  106.     // Initialize and draw the main memo pad form.
  107.     frm = FrmInitForm(mainForm);    
  108.     FrmSetActiveForm(frm);
  109.         
  110.     FrmDrawForm(frm);
  111.  
  112.     if (PrefGetAppPreferences('Curr', 1, &prefs, sizeof(CurrExPreferenceType)) == NULL)
  113.         SetPrefs("0", "0", "0");
  114.  
  115.     //Put old text values back onto screen
  116.     ratePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainRateField))));
  117.     homePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainHomeField))));
  118.     targetPtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainTarget0Field))));
  119.  
  120.     FldInsert(ratePtr, prefs.rate, StrLen(prefs.rate));
  121.     FldInsert(homePtr, prefs.home, StrLen(prefs.home));
  122.     FldInsert(targetPtr, prefs.target, StrLen(prefs.target));
  123.  
  124.     FldSetDirty(ratePtr, false);
  125.     FldSetDirty(homePtr, false);
  126.     FldSetDirty(targetPtr, false);
  127.     
  128.     CalculateTarget();
  129.     CalculateHome();
  130. }
  131.  
  132. /***********************************************************************
  133.  *
  134.  * FUNCTION:        MainFormHandleEvent
  135.  *
  136.  * DESCRIPTION:    Handles processing of events for the ╥main╙ form.
  137.  *
  138.  * PARAMETERS:        event    - the most recent event.
  139.  *
  140.  * RETURNED:        True if the event is handled, false otherwise.
  141.  *
  142.  ***********************************************************************/
  143. static Boolean MainFormHandleEvent(EventPtr event)
  144. {
  145.         Boolean        handled = false;
  146.  
  147.           if (event->eType == ctlSelectEvent)        // P2. process menu events for this form
  148.         {
  149.         
  150.             FormPtr frm;
  151.             FieldPtr ratePtr;
  152.             FieldPtr homePtr;
  153.             FieldPtr target0Ptr;
  154.             
  155.             if (event->data.ctlEnter.controlID == clearButton)
  156.             {
  157.                 // clear button was pressed
  158.                 frm = FrmGetFormPtr(mainForm);
  159.                 
  160.                 //Clear all the boxes
  161.                 ratePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainRateField))));        
  162.                 FldFreeMemory(ratePtr);
  163.                 FldInsert(ratePtr, "0", StrLen("0"));
  164.                 FldSetDirty(ratePtr, true);
  165.                                 
  166.                 homePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainHomeField))));
  167.                 FldFreeMemory(homePtr);
  168.                 FldInsert(homePtr, "0", StrLen("0"));
  169.                 FldSetDirty(homePtr, true);
  170.  
  171.                 target0Ptr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainTarget0Field))));
  172.                 FldFreeMemory(target0Ptr);
  173.                 FldInsert(target0Ptr, "0", StrLen("0"));
  174.                 FldSetDirty(target0Ptr, true);
  175.                     
  176.                 FrmDrawForm(frm);    
  177.                 UpdatePrefs();
  178.                 CalculateTarget();
  179.                 CalculateHome();
  180.                 
  181.                 handled = true;            
  182.             }
  183.         } 
  184.      else
  185.       if (event->eType == fldEnterEvent)
  186.       {
  187.               //Are we going to change the rate?
  188.               if (event->data.fldEnter.fieldID == mainRateField)
  189.               {
  190.                   InRateField = true;
  191.                   InHomeField = false;
  192.                   InTargetField = false;
  193.               }
  194.               else
  195.               if (event->data.fldEnter.fieldID == mainTarget0Field)
  196.               {
  197.                   InTargetField = true;
  198.                   InRateField = false;
  199.                   InHomeField = false;
  200.               }
  201.               else
  202.               if (event->data.fldEnter.fieldID == mainHomeField)
  203.               {
  204.                   InHomeField = true;
  205.                   InRateField = false;
  206.                   InTargetField = false;
  207.               }
  208.               else
  209.             {
  210.                  InHomeField = false;
  211.                   InRateField = false;
  212.                   InTargetField = false;
  213.             }              
  214.      }
  215.      else
  216.      if (event->eType == keyDownEvent)
  217.      {
  218.  
  219.              if ( InRateField || InHomeField || InTargetField)
  220.              {
  221.              
  222.                   //What's the key?
  223.                  if (  ( (event->data.keyDown.chr >= 0x30) && (event->data.keyDown.chr <= 0x39) )
  224.                       ||(event->data.keyDown.chr == 0x2e) || (event->data.keyDown.chr == 0x08) )
  225.                 {                
  226.                     //Let the system handle this first
  227.                     FrmHandleEvent(FrmGetActiveForm(), event);
  228.  
  229.                       if (InRateField || InHomeField)
  230.                           CalculateTarget();
  231.                 
  232.                     if (InRateField || InTargetField)
  233.                           CalculateHome();    
  234.                                             
  235.                      UpdatePrefs();
  236.                   
  237.                   }
  238.                       
  239.                   handled = true;
  240.              }
  241.      }
  242.  
  243.     return(handled);
  244. }
  245.  
  246. static Boolean CalculateTarget()
  247. {
  248.     FormPtr frm;
  249.     FieldPtr ratePtr;
  250.     FieldPtr homePtr;
  251.     FieldPtr targetPtr;
  252.     
  253.     CharPtr targetText;
  254.     char targetStr[20];
  255.     char tempStr[20];
  256.     CharPtr e;
  257.     CharPtr dp;
  258.     CharPtr rateStr;
  259.     CharPtr hStr;
  260.  
  261.     frm = FrmGetFormPtr(mainForm);
  262.                 
  263.     if (frm != NULL)
  264.     {                                                
  265.         FloatType rate;
  266.         FloatType home;
  267.         FloatType target;
  268.         int doneDec;
  269.         int decimal;
  270.         int i;
  271.                                                 
  272.         ratePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainRateField))));
  273.         homePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainHomeField))));
  274.         targetPtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainTargetField))));
  275.  
  276.         if ( (FldGetTextLength(ratePtr) == 0) || (FldGetTextLength(homePtr) == 0) )
  277.         {
  278.             targetText = MemHandleLock(targetHandle);
  279.             StrCopy(targetText, "0");
  280.             MemHandleUnlock(targetHandle);    
  281.             FldSetTextHandle(targetPtr, targetHandle);
  282.             FldDrawField(targetPtr);
  283.             return true;
  284.         }
  285.     
  286.         rateStr = FldGetTextPtr(ratePtr);
  287.         hStr = FldGetTextPtr(homePtr);
  288.                 
  289.         
  290.         if (    ( (rateStr == NULL) || (StrLen(rateStr) == 0) || (!StrCompare(rateStr, "0")) )
  291.              || ( (hStr == NULL) || (StrLen(hStr) == 0) || (!StrCompare(hStr, "0")) ) )
  292.         {
  293.             targetText = MemHandleLock(targetHandle);
  294.             StrCopy(targetText, "0");
  295.             MemHandleUnlock(targetHandle);    
  296.             FldSetTextHandle(targetPtr, targetHandle);
  297.             FldDrawField(targetPtr);
  298.             return true;
  299.         }
  300.  
  301.         FplInit();
  302.         rate = FplAToF(rateStr);
  303.         home = FplAToF(hStr);
  304.         
  305.         target = FplMul(rate, home);
  306.  
  307. /*
  308.         if (FplFloatToLong(target) == 0)
  309.         {
  310.             targetText = MemHandleLock(targetHandle);
  311.             StrCopy(targetText, "?");
  312.             MemHandleUnlock(targetHandle);    
  313.             FldSetTextHandle(targetPtr, targetHandle);
  314.             FldDrawField(targetPtr);
  315.             FplFree();
  316.             return true;
  317.         }                                                
  318. */
  319.  
  320.         FplFToA(target, targetStr);
  321.                         
  322.         FplFree();
  323.                         
  324.         //Format string
  325.  
  326.                         // targetStr contains too many dp's - lets strip them...
  327.                         // We also need  to convert 'e' into real numbers
  328.                         
  329.                         e = StrChr(targetStr, 'e');
  330.                         e[0] = '\0';
  331.                         
  332.                         e++;
  333.                         
  334.                         decimal = StrAToI(e);
  335.                         
  336.                         //There's a bug here!
  337.                         if (decimal < 0)
  338.                         {
  339.                             // A number that is less than 1
  340.                             if (decimal == -1)
  341.                             {                                
  342.                                 tempStr[0]='0';
  343.                                 tempStr[1]='.';
  344.                                 tempStr[2]=targetStr[0];
  345.                                 tempStr[3]=targetStr[2];
  346.                                 tempStr[4]='\0';                                
  347.                             }
  348.                             else
  349.                             if (decimal == -2)
  350.                             {
  351.                                 tempStr[0]='0';
  352.                                 tempStr[1]='.';
  353.                                 tempStr[2]='0';
  354.                                 tempStr[3]=targetStr[0];
  355.                                 tempStr[4]='\0';
  356.                             }
  357.                             else
  358.                             {
  359.                                 //We don't care anymore, its zero to 2dp!
  360.                                 StrCopy(tempStr, "0.00"); //Actually it may be .01!
  361.                             }
  362.                         }
  363.                         else
  364.                         {
  365.                             // point needs to move 'decimal' places right
  366.                             tempStr[0] = targetStr[0];
  367.                         
  368.                             doneDec =1;
  369.                             for (i=2;i<=StrLen(targetStr)+1;i++)
  370.                             {
  371.                                 if ((i-2)==decimal)
  372.                                 {
  373.                                     tempStr[i-doneDec] = '.';
  374.                                     doneDec = 0;
  375.                                 }     
  376.                                 tempStr[i-doneDec] = targetStr[i];
  377.                             }                        
  378.                                             
  379.                             dp = StrChr(tempStr, '.');
  380.                             if (dp != NULL)
  381.                                     dp[3] = '\0';
  382.                             else
  383.                                 StrCopy(tempStr, "Too many!");
  384.                         }            
  385.                         
  386.         targetText = MemHandleLock(targetHandle);
  387.         StrCopy(targetText, tempStr);
  388.         MemHandleUnlock(targetHandle);
  389.         
  390.         // Set the field's text to the data in the new memory chunk.
  391.         FldSetTextHandle(targetPtr, targetHandle);
  392.  
  393.         FldDrawField(targetPtr);                
  394.     }
  395.  
  396.     return true;
  397. }
  398.  
  399. static Boolean CalculateHome()
  400. {
  401.     FormPtr frm;
  402.     FieldPtr ratePtr;
  403.     FieldPtr homePtr;
  404.     FieldPtr targetPtr;
  405.  
  406.     CharPtr homeText;
  407.     CharPtr targStr;
  408.     char homeStr[20];
  409.     char tempStr[20];
  410.     CharPtr e;
  411.     CharPtr dp;
  412.     CharPtr rateStr;
  413.  
  414.     frm = FrmGetFormPtr(mainForm);
  415.                 
  416.     if (frm != NULL)
  417.     {                                                                        
  418.         FloatType rate;
  419.         FloatType home;
  420.         FloatType target;
  421.         int doneDec;
  422.         int decimal;
  423.         int i;
  424.                         
  425.                         
  426.         ratePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainRateField))));
  427.         homePtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainHome0Field))));
  428.         targetPtr = (FieldPtr)(FrmGetObjectPtr(frm, (FrmGetObjectIndex(frm, mainTarget0Field))));
  429.         
  430.         if ( (FldGetTextLength(ratePtr) <= 0) || (FldGetTextLength(targetPtr) <= 0) )
  431.         {
  432.             homeText = MemHandleLock(homeHandle);
  433.             StrCopy(homeText, "0");
  434.             MemHandleUnlock(homeHandle);
  435.             FldSetTextHandle(homePtr, homeHandle);
  436.             FldDrawField(homePtr);
  437.             return true;
  438.         }
  439.         
  440.         rateStr = FldGetTextPtr(ratePtr);
  441.         targStr = FldGetTextPtr(targetPtr);
  442.         
  443.         if ( ( (rateStr == NULL) || (StrLen(rateStr) == 0) || (!StrCompare(rateStr, "0")) )
  444.             || ( (targStr == NULL) || (StrLen(targStr) == 0) || (!StrCompare(targStr, "0")) ) )
  445.         {
  446.             homeText = MemHandleLock(homeHandle);
  447.             StrCopy(homeText, "0");
  448.             MemHandleUnlock(homeHandle);
  449.             FldSetTextHandle(homePtr, homeHandle);
  450.             FldDrawField(homePtr);
  451.             return true;
  452.         }
  453.  
  454.         FplInit();
  455.         target = FplAToF(targStr);
  456.         rate = FplAToF(rateStr);
  457.  
  458. /*
  459.         if ( (FplFloatToLong(rate) == 0) || (FplFloatToLong(target) == 0) )
  460.         {
  461.             homeText = MemHandleLock(homeHandle);
  462.             StrCopy(homeText, "X");
  463.             MemHandleUnlock(homeHandle);
  464.             FldSetTextHandle(homePtr, homeHandle);
  465.             FldDrawField(homePtr);
  466.             FplFree();
  467.             return true;
  468.         }
  469. */
  470.         home = FplDiv(target, rate);        
  471.  
  472.         FplFToA(home, homeStr);
  473.                 
  474.         FplFree();
  475.                         
  476.         // homeStr contains too many dp's - lets strip them...
  477.         // We also need  to convert 'e' into real numbers
  478.                         
  479.                         e = StrChr(homeStr, 'e');
  480.                         e[0] = '\0';
  481.                         
  482.                         e++;
  483.                         
  484.                         decimal = StrAToI(e);
  485.                         
  486.                         //There's a bug here!
  487.                         if (decimal < 0)
  488.                         {
  489.                             // A number that is less than 1
  490.                             if (decimal == -1)
  491.                             {                                
  492.                                 tempStr[0]='0';
  493.                                 tempStr[1]='.';
  494.                                 tempStr[2]=homeStr[0];
  495.                                 tempStr[3]=homeStr[2];
  496.                                 tempStr[4]='\0';
  497.                             }
  498.                             else
  499.                             if (decimal == -2)
  500.                             {
  501.                                 tempStr[0]='0';
  502.                                 tempStr[1]='.';
  503.                                 tempStr[2]='0';
  504.                                 tempStr[3]=homeStr[0];
  505.                                 tempStr[4]='\0';
  506.                             }
  507.                             else
  508.                             {
  509.                                 //We don't care anymore, its zero to 2dp!
  510.                                 StrCopy(tempStr, "0.00"); //Actually it may be .01!
  511.                             }
  512.                         }
  513.                         else
  514.                         {
  515.                             // point needs to move 'decimal' places right
  516.                             tempStr[0] = homeStr[0];
  517.                         
  518.                             doneDec =1;
  519.                             for (i=2;i<=StrLen(homeStr)+1;i++)
  520.                             {
  521.                                 if ((i-2)==decimal)
  522.                                 {
  523.                                     tempStr[i-doneDec] = '.';
  524.                                     doneDec = 0;
  525.                                 }     
  526.                                 tempStr[i-doneDec] = homeStr[i];
  527.                             }                        
  528.                                             
  529.                             dp = StrChr(tempStr, '.');
  530.                             if (dp != NULL)
  531.                                     dp[3] = '\0';
  532.                             else
  533.                                 StrCopy(tempStr, "Error");
  534.                         }            
  535.  
  536.         homeText = MemHandleLock(homeHandle);
  537.         StrCopy(homeText, tempStr);
  538.         MemHandleUnlock(homeHandle);
  539.         
  540.         // Set the field's text to the data in the new memory chunk.
  541.         FldSetTextHandle(homePtr, homeHandle);
  542.                 
  543.         FldDrawField(homePtr);
  544. }
  545.  
  546.  
  547.     return true;
  548. }
  549.  
  550. /***********************************************************************
  551.  *
  552.  * FUNCTION:        EventLoop
  553.  *
  554.  * DESCRIPTION:    A simple loop that obtains events from the Event
  555.  *                        Manager and passes them on to various applications and
  556.  *                        system event handlers before passing them on to
  557.  *                        FrmHandleEvent for default processing.
  558.  *
  559.  * PARAMETERS:        None.
  560.  *
  561.  * RETURNED:        Nothing.
  562.  *
  563.  ***********************************************************************/
  564. static void EventLoop(void)
  565. {
  566.     EventType    event;
  567.     Word            error;
  568.     
  569.     do
  570.         {
  571.         // Get the next available event.
  572.         EvtGetEvent(&event, evtWaitForever);
  573.         
  574.         // Give the system a chance to handle the event.
  575.         if (! SysHandleEvent (&event))
  576.  
  577.             // P2. Give the menu bar a chance to update and handle the event.    
  578.             if (! MenuHandleEvent(NULL, &event, &error))
  579.  
  580.                 // Give the application a chance to handle the event.
  581.                 if (! MainFormHandleEvent(&event))
  582.     
  583.                     // Let the form object provide default handling of the event.
  584.                     FrmHandleEvent(FrmGetActiveForm(), &event);
  585.         } 
  586.     while (event.eType != appStopEvent);
  587.                                 // ** SPECIAL NOTE **
  588.                                 // In order for the Emulator to exit
  589.                                 // cleanly when the File|Quit menu option is
  590.                                 // selected, the running application
  591.                                 // must exit.  The emulator will generate an 
  592.                                 // ╥appStopEvent╙ when Quit is selected.
  593. }
  594.  
  595.  
  596. /***********************************************************************
  597.  *
  598.  * FUNCTION:        PilotMain
  599.  *
  600.  * DESCRIPTION:    This function is the equivalent of a main() function
  601.  *                        in standard ╥C╙.  It is called by the Emulator to begin
  602.  *                        execution of this application.
  603.  *
  604.  * PARAMETERS:        cmd - command specifying how to launch the application.
  605.  *                        cmdPBP - parameter block for the command.
  606.  *                        launchFlags - flags used to configure the launch.            
  607.  *
  608.  * RETURNED:        Any applicable error code.
  609.  *
  610.  ***********************************************************************/
  611. DWord PilotMain(Word cmd, Ptr cmdPBP, Word launchFlags)
  612. {
  613.  
  614.     if (cmd == sysAppLaunchCmdNormalLaunch)
  615.     {
  616.         // Set up initial form.
  617.         StartApplication();
  618.         
  619.         // Start up the event loop.
  620.         EventLoop();
  621.         
  622.         UpdatePrefs();
  623.  
  624.     }
  625.         
  626.     return(0);
  627.  
  628. }
  629.  
  630.  
  631.  
  632.