home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 Mobile / Chip_Mobile_2001.iso / palm / hobby / palmoon / palmoon.EXE / palmoon.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-07-31  |  14.6 KB  |  581 lines
  1. #include <PalmOS.h>
  2. #include <StringMgr.h>
  3. #include <FloatMgr.h>
  4. #include <SysEvtMgr.h>
  5. #include "MathLib.h"
  6. #include "moontool.h"
  7.  
  8. #include "palmoon.resource.h"
  9.  
  10. #define CREATORID 'PMon'
  11.  
  12. const Char *g_sMon[12] = {"Jan","Feb","Mar","Apl","May","Jun",
  13.                         "Jul","Aug","Sep","Oct","Nov","Dec"};
  14.  
  15. const Char *g_sTZ[22]={"HST","HAST","AKST","PST","MST",
  16.                        "CST","EST","AST","NST","UTC",
  17.                        "UCT","CUT","UT","GMT","WET",
  18.                        "CET","MET","MEZ","EET","IST",
  19.                        "JST","NZST"};
  20. Int32 g_lTD[22]={0-36000L,0-36000L,0-32400L,0-28800L,0-25200L,
  21.                        0-21600L,0-18000L,0-14400L,0-12600L,0L,
  22.                        0L,0L,0L,0L,0L,
  23.                        3600L,3600L,3600L,7200L,19800L,
  24.                        32400L,43200L};
  25.  
  26.  
  27. typedef struct{
  28.   Int32 lTimeDifferenceSeconds;
  29.   Char  sZoneName[5];
  30.   Int16 FlagView;
  31. } AppPrefType;
  32.  
  33. const Int16 fv_LOCALTIME = 0x0001;
  34. const Int16 fv_MODIFIED  = 0x0002;
  35. const Int16 fv_MJD       = 0x0004;
  36. const Int16 fv_JDVIEW    = 0x0008;
  37.  
  38. static AppPrefType g;
  39.  
  40.  
  41. Char *StrDToA(Char *s, FlpCompDouble d);
  42. void *GetObjectPtr(Int16 objIndex);
  43.  
  44. void SetTZView(const Char *abbr, Int32 diff);
  45.  
  46. void PrintJulianDate(FlpCompDouble jd);
  47. void PrintCurrentTime(DateTimeType dtt, Char *tz);
  48. void PrintMoonPhase(FlpCompDouble cphase);
  49. void PrintAgeOfMoon(FlpCompDouble aom);
  50. void PrintLunation(Int32 lunation);
  51. void PrintMisc(const double adPhasar[5], const double adPhasarGMT[5],
  52.                FlpCompDouble jd, Int16 *nexteventindex);
  53.  
  54. static Err StartApplication(void);
  55. static void StopApplication(void);
  56. static Boolean AboutFormHandleEvent(EventPtr event);
  57. static Boolean TimezoneFormHandleEvent(EventPtr event);
  58. static Boolean formPalMoonIDHandleEvent(EventPtr event);
  59. static Boolean ApplicationHandleEvent(EventPtr event);
  60. static void EventLoop(void);
  61. UInt32 PilotMain(UInt16 launchCode, MemPtr cmdPBP, UInt16 launchFlags);
  62.  
  63.  
  64.  
  65. Char *StrDToA(Char *s, FlpCompDouble d)
  66. {
  67.   Int32 p, q;
  68.   FlpCompDouble e;
  69.   
  70.   p = _d_dtoi(d.fd);
  71.   e.d = ((d.d - p)* 1000000.0)+0.5;
  72.   q = abs(_d_dtoi(e.fd));
  73.   while(q>=1000000){q-=1000000;p++;}//workaround(v1.03)
  74.  
  75.   StrPrintF(s, "%ld.%06ld", p, q); /* max 10+1+6 characters and NULL */
  76.  
  77.   return s;
  78. }
  79.  
  80.  
  81.  
  82. void *GetObjectPtr(Int16 objIndex)
  83. {
  84.   FormPtr form;
  85.   form = FrmGetActiveForm();
  86.   return FrmGetObjectPtr(form, FrmGetObjectIndex(form, objIndex));
  87. }
  88.  
  89.  
  90.  
  91. void SetTZView(const Char *abbr, Int32 diff)
  92. {
  93.   FieldPtr fieldptr;
  94.  
  95.   fieldptr = (FieldPtr)GetObjectPtr(fieldZoneNameID);
  96.   FldDelete(fieldptr, 0, 4);
  97.   FldInsert(fieldptr, abbr, StrLen(abbr));
  98.   FldDrawField(fieldptr);
  99.  
  100.   Char tmp[32];    /* max 1+10 chrs + null*/
  101.   StrPrintF(tmp, "%s%ld", (diff>0)?"+":"-", abs(diff));
  102.   fieldptr = (FieldPtr)GetObjectPtr(fieldTimeDifferenceID);
  103.   FldDelete(fieldptr, 0, 6);
  104.   FldInsert(fieldptr, tmp, StrLen(tmp));
  105.   FldDrawField(fieldptr);
  106. }
  107.  
  108.  
  109.  
  110. static Err StartApplication(void)
  111. {
  112.   Err error;
  113.   error = SysLibFind(MathLibName, &MathLibRef);
  114.   if(error){  // Just an example; handle it gracefully
  115.     error = SysLibLoad(LibType, MathLibCreator, &MathLibRef);
  116.   }
  117.   ErrFatalDisplayIf(error, "Can't find MathLib");
  118.   error = MathLibOpen(MathLibRef, MathLibVersion);
  119.   ErrFatalDisplayIf(error, "Can't open MathLib"); 
  120.  
  121.   UInt16 prefSize=sizeof(g);
  122.   Int16 prefExist = PrefGetAppPreferences(CREATORID, 0, &g, &prefSize, false);
  123.   if(prefExist == noPreferenceFound){
  124.     StrNCopy(g.sZoneName, "JST", sizeof(g.sZoneName));
  125.     g.lTimeDifferenceSeconds=32400;
  126.     g.FlagView=fv_LOCALTIME;
  127.   }
  128.  
  129.   FrmGotoForm(formPalMoonID);
  130.  
  131.   return 0;
  132. }
  133.  
  134.  
  135.  
  136. static void StopApplication(void)
  137. {
  138.   FrmCloseAllForms();
  139.  
  140.   PrefSetAppPreferences(CREATORID, 0, 1, &g, sizeof(g), false);
  141.  
  142.   UInt16 usecount;
  143.   Err error;
  144.   error = MathLibClose(MathLibRef, &usecount);
  145.   ErrFatalDisplayIf(error, "Can't close MathLib");
  146.   if(usecount == 0){
  147.     SysLibRemove(MathLibRef); 
  148.   }
  149. }
  150.  
  151.  
  152.  
  153. static Boolean AboutFormHandleEvent(EventPtr event)
  154. {
  155.   Boolean handled = false;
  156.  
  157.   switch(event->eType){
  158.     case frmOpenEvent:
  159.       FrmDrawForm(FrmGetActiveForm());
  160.       handled = true;
  161.       break;
  162.  
  163.     case ctlSelectEvent:
  164.       switch(event->data.ctlSelect.controlID){
  165.         case buttonAboutOKID:
  166.           FrmReturnToForm(formPalMoonID);
  167.           handled = true;
  168.           break;
  169.  
  170.         default:
  171.           break;
  172.       }
  173.       break;
  174.  
  175.     default:
  176.       break;
  177.   }
  178.   return handled;
  179. }
  180.  
  181.  
  182. static Boolean TimezoneFormHandleEvent(EventPtr event)
  183. {
  184.   Boolean handled = false;
  185.  
  186.   switch(event->eType){
  187.     case frmOpenEvent:
  188.       FrmDrawForm(FrmGetActiveForm());
  189.       SetTZView(g.sZoneName, g.lTimeDifferenceSeconds);
  190.       handled = true;
  191.       break;
  192.  
  193.     case popSelectEvent:
  194.       switch(event->data.popSelect.listID){
  195.         case listZoneNamePresetID:
  196.           SetTZView(g_sTZ[event->data.popSelect.selection],
  197.                     g_lTD[event->data.popSelect.selection]);
  198.           handled = false;
  199.           break;
  200.  
  201.         default:
  202.           break;
  203.       }
  204.       break;
  205.  
  206.     case ctlSelectEvent:
  207.       switch(event->data.ctlSelect.controlID){
  208.         case buttonTimeZoneCancelID:
  209.           FrmReturnToForm(formPalMoonID);
  210.           handled = true;
  211.           break;
  212.  
  213.         case buttonTimeZoneOKID:
  214.           FieldPtr fieldptr;
  215.           fieldptr = (FieldPtr)GetObjectPtr(fieldTimeDifferenceID);
  216.           g.lTimeDifferenceSeconds = StrAToI(FldGetTextPtr(fieldptr));
  217.           fieldptr = (FieldPtr)GetObjectPtr(fieldZoneNameID);
  218.           StrNCopy(g.sZoneName, FldGetTextPtr(fieldptr), sizeof(g.sZoneName));
  219.           g.FlagView |= fv_MODIFIED;
  220.           FrmReturnToForm(formPalMoonID);
  221.           handled = true;
  222.           break;
  223.  
  224.         default:
  225.           break;
  226.       }
  227.       break;
  228.  
  229.     default:
  230.       break;
  231.   }
  232.   return handled;
  233. }
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248. void PrintJulianDate(FlpCompDouble jd){
  249.   static Char buf[32];
  250.   FieldPtr fieldptr;
  251.  
  252.   if(g.FlagView&fv_MJD){
  253.     jd.d-=2400000.5; /* See, http://tycho.usno.navy.mil/mjd.html */
  254.     StrDToA(buf, jd); /* max 10+1+10 characters and NULL */
  255.     StrCat(buf, " MJD");
  256.   }else{
  257.     StrDToA(buf, jd); /* max 10+1+10 characters and NULL */
  258.     StrCat(buf, " JD");
  259.   }
  260.   fieldptr = (FieldPtr)GetObjectPtr(fieldJulianDateID);
  261.   FldSetTextPtr(fieldptr, buf);
  262.   FldDrawField(fieldptr);
  263. }
  264.  
  265. void PrintCurrentTime(DateTimeType dtt, Char *tz){
  266.   static Char buf[32];//at least 24+1
  267.   FieldPtr fieldptr;
  268.  
  269.   StrPrintF(buf, "%02d:%02d:%02d %02d %s %04d %s",
  270.             dtt.hour,dtt.minute,dtt.second,
  271.             dtt.day,g_sMon[dtt.month-1],dtt.year,tz);
  272.   fieldptr = (FieldPtr)GetObjectPtr(fieldCurrentTimeID);
  273.   FldSetTextPtr(fieldptr, buf);
  274.   FldDrawField(fieldptr);
  275. }
  276.  
  277. void PrintMoonPhase(FlpCompDouble cphase){
  278.   static Char buf[32];
  279.   FieldPtr fieldptr;
  280.  
  281.   cphase.d *= 100.0;
  282.   StrDToA(buf, cphase); /* max 10+1+10 characters and NULL */
  283.   StrCat(buf, " %");
  284.   fieldptr = (FieldPtr)GetObjectPtr(fieldMoonPhaseID);
  285.   FldSetTextPtr(fieldptr, buf);
  286.   FldDrawField(fieldptr);
  287. }
  288.  
  289. void PrintAgeOfMoon(FlpCompDouble aom){
  290.   static Char buf[32];
  291.   FieldPtr fieldptr;
  292.   FlpCompDouble fcdTemp;
  293.  
  294.   Int32 aom_d = _d_dtoi(aom.fd);
  295.   fcdTemp.d = 24.0 * (aom.d - floor(aom.d));
  296.   Int32 aom_h = _d_dtoi(fcdTemp.fd);
  297.   fcdTemp.d = fmod(1440.0 * (aom.d - floor(aom.d)), 60.0);
  298.   Int32 aom_m = _d_dtoi(fcdTemp.fd);
  299.   fcdTemp.d = fmod(60.0 * 1440.0 * (aom.d - floor(aom.d)), 60.0);
  300.   Int32 aom_s = _d_dtoi(fcdTemp.fd);
  301.  
  302.   StrPrintF(buf, "%ldday%s %02ld:%02ld:%02ld",
  303.             aom_d, (aom_d==1) ? "" : "s", aom_h, aom_m, aom_s);
  304.   fieldptr = (FieldPtr)GetObjectPtr(fieldAgeOfMoonID);
  305.   FldSetTextPtr(fieldptr, buf);
  306.   FldDrawField(fieldptr);
  307. }
  308.  
  309. void PrintLunation(Int32 lunation){
  310.   FieldPtr fieldptr;
  311.   static Char buf1[32], buf2[32];
  312.  
  313.   /* Lunation 1st */
  314.   StrPrintF(buf1, "%ld", lunation);
  315.   fieldptr = (FieldPtr)GetObjectPtr(fieldLunation1ID);
  316.   FldSetTextPtr(fieldptr, buf1);
  317.   FldDrawField(fieldptr);
  318.  
  319.   /* Lunaion 2nd */
  320.   StrPrintF(buf2, "%ld", lunation+1);
  321.   fieldptr = (FieldPtr)GetObjectPtr(fieldLunation2ID);
  322.   FldSetTextPtr(fieldptr, buf2);
  323.   FldDrawField(fieldptr);
  324. }
  325.  
  326. void PrintMisc(const double adPhasar[5], const double adPhasarGMT[5],
  327.                FlpCompDouble jd, Int16 *nexteventindex){
  328.   Int32 yy;
  329.   Int16 mm, dd, hh, mmm, ss;
  330.   FieldPtr fieldptr;
  331.   static Char buf[5][32];
  332.   Boolean flagUL=false;
  333.  
  334.   for(Int16 n=0;n<5;n++){
  335.     if(g.FlagView&fv_JDVIEW){
  336.       FlpCompDouble fcdTemp;
  337.       if(g.FlagView&fv_MJD){
  338.         fcdTemp.d = adPhasarGMT[n]-2400000.5;
  339.         /* See, http://tycho.usno.navy.mil/mjd.html */
  340.         StrDToA(buf[n], fcdTemp); /* max 10+1+10 characters and NULL */
  341.         StrCat(buf[n], " MJD");
  342.       }else{
  343.         fcdTemp.d = adPhasarGMT[n];
  344.         StrDToA(buf[n], fcdTemp); /* max 10+1+10 characters and NULL */
  345.         StrCat(buf[n], " JD");
  346.       }
  347.     }else{
  348.       jyear(adPhasar[n], &yy, &mm, &dd);
  349.       jhms(adPhasar[n], &hh, &mmm, &ss);
  350.       StrPrintF(buf[n], "%02d:%02d:%02d %02d %s %04ld %s",
  351.                 hh,mmm,ss, dd, g_sMon[mm-1], yy,
  352.                 (g.FlagView&fv_LOCALTIME) ? g.sZoneName:"GMT");
  353.     }
  354.     fieldptr = (FieldPtr)GetObjectPtr(fieldLastNewID+n);
  355.  
  356.     FieldAttrType attr;
  357.     FldGetAttributes(fieldptr, &attr);
  358.     if((!flagUL) && (adPhasarGMT[n]>jd.d)){
  359.       attr.underlined = solidUnderline;
  360.       *nexteventindex=n;
  361.       flagUL=true;
  362.     }else{
  363.       attr.underlined = noUnderline;
  364.     }
  365.     FldSetAttributes(fieldptr, &attr);
  366.  
  367.     FldSetTextPtr(fieldptr, buf[n]);
  368.     FldDrawField(fieldptr);
  369.   }
  370. }
  371.  
  372.  
  373.  
  374. static Boolean formPalMoonIDHandleEvent(EventPtr event)
  375. {
  376.   Boolean handled = false;
  377.  
  378.   switch(event->eType){
  379.     case frmOpenEvent:
  380.       FrmDrawForm(FrmGetActiveForm());
  381.       handled = true;
  382.       break;
  383.  
  384.     case menuEvent:
  385.       switch(event->data.menu.itemID) {
  386.         case menuPalMoonTZID:
  387.           g.FlagView^=fv_LOCALTIME;
  388.           g.FlagView|=fv_MODIFIED;
  389.           handled = true;
  390.           break;
  391.  
  392.         case menuPalMoonJDViewID:
  393.           g.FlagView^=fv_JDVIEW;
  394.           g.FlagView|=fv_MODIFIED;
  395.           handled = true;
  396.           break;
  397.  
  398.         case menuPalMoonMJDID:
  399.           g.FlagView^=fv_MJD;
  400.           g.FlagView|=fv_MODIFIED;
  401.           handled = true;
  402.           break;
  403.  
  404.         case menuPalMoonTimeZoneID:
  405.           FrmPopupForm(formTimeZoneID);
  406.           handled = true;
  407.           break;
  408.  
  409.         case menuPalMoonAboutID:
  410.           FrmPopupForm(formAboutID);
  411.           handled = true;
  412.           break;
  413.  
  414.         default:
  415.           break;
  416.       }
  417.       break;
  418.  
  419.     case nilEvent:
  420.       /* CHECKER */
  421.       MenuBarType *b;
  422.       b = MenuGetActiveMenu();
  423.       if(b->attr.visible){
  424.         handled = true;
  425.         break;
  426.       }
  427.  
  428.       UInt32 lLOCALSeconds, lGMTSeconds;
  429.       DateTimeType dttLOCAL, dttGMT;
  430.       FlpCompDouble jd;
  431.       FlpCompDouble p,cphase,aom,cdist,cangdia,csund,csuang;
  432.       static UInt32 lPrevSec;
  433.  
  434.       lLOCALSeconds = TimGetSeconds();
  435.  
  436.       if((g.FlagView&fv_MODIFIED) || (lLOCALSeconds != lPrevSec)){
  437.         lPrevSec = lLOCALSeconds;
  438.  
  439.         TimSecondsToDateTime(lLOCALSeconds, &dttLOCAL);
  440.         lGMTSeconds = lLOCALSeconds - g.lTimeDifferenceSeconds;
  441.         TimSecondsToDateTime(lGMTSeconds, &dttGMT);
  442.         jtime(&dttGMT, &jd);
  443.  
  444.         p.d = phase(jd.d, &(cphase.d), &(aom.d), &(cdist.d),
  445.                     &(cangdia.d), &(csund.d), &(csuang.d));
  446.  
  447.         /*****************
  448.           JulianDate View
  449.          *****************/
  450.         PrintJulianDate(jd);
  451.  
  452.         /******************
  453.           CurrentTime View
  454.          ******************/
  455.         if(g.FlagView&fv_LOCALTIME){
  456.           PrintCurrentTime(dttLOCAL, g.sZoneName);
  457.         }else{
  458.           PrintCurrentTime(dttGMT, "GMT");
  459.         }
  460.  
  461.         /****************
  462.           MoonPhase View
  463.          ****************/
  464.         PrintMoonPhase(cphase);
  465.  
  466.         /*************
  467.           Age of Moon
  468.          *************/
  469.         PrintAgeOfMoon(aom);
  470.  
  471.         double adPhasar[5];
  472.         static double adPhasarGMT[5];
  473.         static Int16 nexteventindex;
  474.  
  475.         if((g.FlagView&fv_MODIFIED) || (jd.d > adPhasarGMT[nexteventindex])){
  476.           nexteventindex=0;
  477.           double diff=0.5;
  478.           while(1){//workaround(v1.03)
  479.             phasehunt(jd.d + diff, adPhasarGMT);
  480.             if(jd.d < adPhasarGMT[0]){diff-=1.0;}
  481.             else if(adPhasarGMT[4] < jd.d){diff+=1.0;}
  482.             else{break;}
  483.           }
  484.           //adPhasar[] is the modified value.
  485.           for(Int16 n=0;n<5;n++){
  486.             if(g.FlagView&fv_LOCALTIME){
  487.               adPhasar[n]=adPhasarGMT[n]+(g.lTimeDifferenceSeconds/86400.0);
  488.             }else{
  489.               adPhasar[n]=adPhasarGMT[n];
  490.             }
  491.           }
  492.  
  493.           FlpCompDouble fcdTemp;
  494.           Int32 lunation;
  495.  
  496.           fcdTemp.d = floor(((adPhasarGMT[0]+7.0)-lunatbase)/synmonth)+1;
  497.           lunation = _d_dtoi(fcdTemp.fd);
  498.  
  499.           /*************************
  500.             Lunation and Misc. View
  501.            *************************/
  502.           PrintLunation(lunation);
  503.           PrintMisc(adPhasar, adPhasarGMT, jd, &nexteventindex);
  504.  
  505.           g.FlagView^=fv_MODIFIED;
  506.         }
  507.       }
  508.       handled = true;
  509.       break;
  510.  
  511.     default:
  512.       break;
  513.   }
  514.   return handled;
  515. }
  516.  
  517.  
  518. static Boolean ApplicationHandleEvent(EventPtr event)
  519. {
  520.   FormPtr frm;
  521.   UInt16 formId;
  522.   Boolean handled = false;
  523.  
  524.   if(event->eType == frmLoadEvent){
  525.     formId = event->data.frmLoad.formID;
  526.     frm = FrmInitForm(formId);
  527.     FrmSetActiveForm(frm);
  528.  
  529.     switch(formId){
  530.       case formPalMoonID:
  531.         FrmSetEventHandler(frm, formPalMoonIDHandleEvent);
  532.         handled = true;
  533.         break;
  534.       case formTimeZoneID:
  535.         FrmSetEventHandler(frm, TimezoneFormHandleEvent);
  536.         handled = true;
  537.         break;
  538.       case formAboutID:
  539.         FrmSetEventHandler(frm, AboutFormHandleEvent);
  540.         handled = true;
  541.         break;
  542.     }
  543.   }
  544.   return handled;
  545. }
  546.  
  547.  
  548. static void EventLoop(void)
  549. {
  550.   EventType event;
  551.   UInt16 error;
  552.  
  553.   do{
  554.     EvtGetEvent(&event, 10);
  555.     if(!SysHandleEvent(&event)){
  556.       if(!MenuHandleEvent(0, &event, &error)){
  557.         if(!ApplicationHandleEvent(&event)){
  558.           FrmDispatchEvent(&event);
  559.         }
  560.       }
  561.     }
  562.   }while(event.eType != appStopEvent);
  563.  
  564. }
  565.  
  566.  
  567. UInt32 PilotMain(UInt16 launchCode, MemPtr cmdPBP, UInt16 launchFlags)
  568. {
  569.   Err err = 0;
  570.  
  571.   if(launchCode == sysAppLaunchCmdNormalLaunch){
  572.     if((err = StartApplication()) == 0){
  573.       EventLoop();
  574.       StopApplication();
  575.     }
  576.   }
  577.  
  578.   return err;
  579. }
  580.  
  581.