home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 326.lha / DateRequester / MRDateReq.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-12-28  |  24.7 KB  |  706 lines
  1. /* Date Requester Package
  2.  * Filename:    MRDateReq.c
  3.  * Author:      Mark R. Rinfret
  4.  * Description:
  5.  *
  6.  * This package contains an ARP-compatible (dependent) date requester.
  7.  * The primary function, MRDateRequest(), displays a requester in the
  8.  * caller's window and allows the user to interactively enter/edit the
  9.  * date value. All information is passed via a pointer to a special
  10.  * packet structure.
  11.  *
  12.  * This code is not entirely reentrant. In order to accomplish this, 
  13.  * the requester and associated gadgets would have to be duplicated and
  14.  * a method for obtaining gadget pointers from gadget ID's implemented.
  15.  * If someone wants to put this in a shared library, that, at a minimum
  16.  * must be done.
  17.  *      
  18.  * 09/01/89 -MRR- Rewritten to use ARP date functions; new requester layout.
  19.  *
  20.  */
  21.  
  22. #include <exec/memory.h>
  23. #include <intuition/intuition.h> 
  24. #include <intuition/intuitionbase.h> 
  25. #include <libraries/dosextens.h>
  26. #include <libraries/arpbase.h>
  27. #include <graphics/gfxbase.h> 
  28. #include <graphics/gfx.h> 
  29. #include <graphics/display.h> 
  30.  
  31. #include <graphics/text.h> 
  32. #include <functions.h>
  33. #include <arpfunctions.h>
  34.  
  35. #include <ctype.h>
  36. #include "MRDates.h"
  37. #include "MRGadgets.h"
  38. #include "MRDateReq.h"
  39.  
  40. /*==================================================================*/
  41.  
  42. #define SetImageData(img, dat) ((struct Image *)(img))->ImageData = dat
  43. #define daterequest             RequesterStructure1
  44.  
  45. #define UP_MONTH_GADGET         1
  46. #define UP_DAY_GADGET           2   
  47. #define UP_YEAR_GADGET          3
  48. #define UP_HOUR_GADGET          4
  49. #define UP_MINUTE_GADGET        5
  50. #define UP_SECOND_GADGET        6
  51. #define DOWN_MONTH_GADGET       7
  52. #define DOWN_DAY_GADGET         8
  53. #define DOWN_YEAR_GADGET        9
  54. #define DOWN_HOUR_GADGET        10
  55. #define DOWN_MINUTE_GADGET      11
  56. #define DOWN_SECOND_GADGET      12
  57. #define NOW_GADGET              13
  58. #define ZERO_GADGET             14
  59. #define OK_GADGET               15
  60. #define CANCEL_GADGET           16
  61. #define YEAR_GADGET             17
  62. #define MONTH_GADGET            18
  63. #define DAY_GADGET              19
  64. #define HOUR_GADGET             20
  65. #define MINUTE_GADGET           21
  66. #define SECOND_GADGET           22
  67. #define DATE_FORMAT_GADGET      23
  68. #define DATE_GADGET             24
  69. #define TIME_GADGET             25
  70. #define DAYNAME_GADGET          26
  71. #define WEEK_PLUS_GADGET        27
  72. #define WEEK_MINUS_GADGET       28
  73. #define PROMPT_GADGET           29
  74.  
  75.  
  76. #include "MRDateReq.pw.c"
  77.  
  78. static void RedrawDateRequester();
  79.  
  80. #define MAX_DATE_FORMAT     3
  81.  
  82. static char *dateFormats[FORMAT_MAX+1] = {
  83.     "DD-MMM-YY",    /* FORMAT_DOS */
  84.     "YY-MM-DD",     /* FORMAT_INT */
  85.     "MM-DD-YY",     /* FORMAT_USA */
  86.     "DD-MM-YY"      /* FORMAT_CDN */
  87.     };
  88.  
  89. /*===================================================================*/
  90.  
  91. /*  FUNCTION
  92.         DupImage - duplicate an image into CHIP ram.
  93.  
  94.     SYNOPSIS
  95.         static USHORT *DupImage(theImage, imageSize)
  96.                                 struct Image   *theImage;
  97.                                 long           *imageSize;
  98.  
  99.     DESCRIPTION
  100.         DupImage calculates the size of the imageData required by
  101.         <theImage> and stores this value into the variable pointed to
  102.         by <imageSize>. It then attempts to allocate memory for the 
  103.         image in CHIP ram. If the allocation is successful, the image
  104.         data is copied and the pointer to the CHIP copy is returned.
  105.         If the allocation fails, NULL is returned.
  106.  
  107.         DupImage is "smart" about the duplication process. It uses the 
  108.         PlanePick field of <theImage> to determine how many planes of 
  109.         data are actually present in <theImage>.
  110. */
  111. static USHORT *
  112. DupImage(theImage, imageSize)
  113.     struct Image    *theImage;
  114.     ULONG           *imageSize;
  115. {
  116.     USHORT  mask;
  117.     USHORT  *newImageData = NULL;
  118.     long    planeSize, totalSize = 0;
  119.  
  120.     if (theImage) {
  121.         /* The size of a plane is
  122.             the number of 16 bit words of width times
  123.             the number of pixels of height times
  124.             the number of bytes per 16 bit word (USHORT).
  125.         */
  126.         planeSize = (ULONG)
  127.         ( ( (theImage->Width + 15L) >> 4L) * 
  128.              theImage->Height * sizeof(USHORT) );
  129.         for (mask = 1L; mask; mask <<= 1L) {
  130.             if (theImage->PlanePick & mask)
  131.                 totalSize += planeSize;
  132.         }
  133.     }
  134.     if (*imageSize = totalSize) {
  135.         newImageData = (USHORT *) AllocMem(totalSize, MEMF_CHIP);
  136.         if (newImageData)
  137.             CopyMem(theImage->ImageData, newImageData, totalSize);
  138.     }
  139.     return newImageData;
  140. }
  141.  
  142. /*  FUNCTION
  143.         FreeMRDatePacket - free memory allocated to an MRDatePacket.
  144.  
  145.     SYNOPSIS
  146.         void FreeMRDatePacket(thePacket)
  147.                     MRDatePacket *thePacket;
  148.  
  149.     DESCRIPTION
  150.         FreeMRDatePacket simply frees the memory allocated to an
  151.         MRDateRequest packet, specified by <thePacket>.
  152. */
  153.  
  154. void
  155. FreeMRDatePacket(thePacket)
  156.     MRDatePacket *thePacket;
  157. {
  158.     if (thePacket->myStrings) {     /* Did I allocate the strings? */
  159.         if (thePacket->ARPDatePacket.dat_StrDay)
  160.             FreeMem(thePacket->ARPDatePacket.dat_StrDay, LEN_DATSTRING);
  161.         if (thePacket->ARPDatePacket.dat_StrDate)
  162.             FreeMem(thePacket->ARPDatePacket.dat_StrDate, LEN_DATSTRING);
  163.         if (thePacket->ARPDatePacket.dat_StrTime)
  164.             FreeMem(thePacket->ARPDatePacket.dat_StrTime, LEN_DATSTRING);
  165.     }
  166.     FreeMem(thePacket, (long) sizeof(*thePacket));
  167. }
  168.  
  169. /*  FUNCTION
  170.         CreateMRDatePacket - allocate and initialize an MRDatePacket.
  171.  
  172.     SYNOPSIS
  173.         MRDatePacket *CreateMRDatePacket(theDate, theFormat, makeStrings)
  174.                                         struct DateStamp *theDate;
  175.                                         int              theFormat;
  176.                                         int              makeStrings;
  177.  
  178.     DESCRIPTION
  179.         InitMRDateRequest() allocates an MRDateRequest packet and initializes
  180.         several of its fields. <theDate> may be a pointer to a DateStamp 
  181.         structure containing the initial (default) date value or it may be
  182.         NULL. If NULL, the current date and time are used as the default.
  183.         <theFormat> is expected to be a value in the range of 0 through
  184.         FORMAT_MAX, as defined in <libraries/arpbase.h>, and is the desired
  185.         date format. If <makeStrings> is non-zero, CreateMRDatePacket() also 
  186.         allocates the strings for the string fields in the embedded
  187.         ARPDatePacket.
  188.  
  189.         A pointer to an MRDateRequest packet is returned if successful. 
  190.         Otherwise, NULL is returned, indicating an out-of-memory
  191.         condition.
  192. */
  193. MRDatePacket *
  194. CreateMRDatePacket(theDate, theFormat, makeStrings)
  195.     struct DateStamp *theDate; 
  196.     int theFormat, makeStrings;
  197. {
  198.     MRDatePacket    *dr;
  199.  
  200.     dr = (MRDatePacket *) AllocMem((long)sizeof(*dr), MEMF_CLEAR);
  201.     if (dr) {
  202.         if ( (theFormat < 0) || (theFormat > FORMAT_MAX))
  203.             theFormat = FORMAT_USA;
  204.         dr->ARPDatePacket.dat_Format = theFormat;
  205.         dr->requester = &daterequest;
  206.         if (theDate)
  207.             dr->ARPDatePacket.dat_Stamp = *theDate;
  208.         else
  209.             DateStamp(&dr->ARPDatePacket.dat_Stamp);
  210.         DSToDate(&dr->ARPDatePacket.dat_Stamp, &dr->newDate);
  211.         if (dr->newDate.Dyear == 0) {
  212.             dr->newDate.Dyear = 1978;
  213.             DateToDS(&dr->newDate, &dr->ARPDatePacket.dat_Stamp);
  214.         }
  215.         if (makeStrings) {
  216.             dr->myStrings = 1;
  217.             dr->ARPDatePacket.dat_StrDay = (BYTE *)
  218.                 AllocMem(LEN_DATSTRING, MEMF_CLEAR);
  219.             dr->ARPDatePacket.dat_StrDate = (BYTE *)
  220.                 AllocMem(LEN_DATSTRING, MEMF_CLEAR);
  221.             dr->ARPDatePacket.dat_StrTime = (BYTE *)
  222.                 AllocMem(LEN_DATSTRING, MEMF_CLEAR);
  223.  
  224.             if ((dr->ARPDatePacket.dat_StrDay == NULL) ||
  225.                 (dr->ARPDatePacket.dat_StrDate == NULL) ||
  226.                 (dr->ARPDatePacket.dat_StrTime == NULL)) {
  227.                 FreeMRDatePacket(dr);
  228.                 dr = NULL;
  229.             }
  230.         }
  231.     }
  232.     return dr;
  233. }
  234.  
  235. /*  FUNCTION
  236.         MRDateRequest - request a date from the user.
  237.  
  238.     SYNOPSIS
  239.         int MRDateRequest(datePacket)
  240.                 MRDatePacket *datePacket;
  241.     DESCRIPTION
  242.         Prior to calling MRDateRequest(), the caller must allocate the
  243.         <datePacket> and initialize the following <datePacket> fields:
  244.             ARPDatePacket.dat_Stamp     - the initial date value
  245.             ARPDatePacket.dat_Format    - one of the ARP date format values
  246.             prompt                      - a short prompt string
  247.             window                      - window in which requester will
  248.                                           appear
  249.  
  250.         Part of this initialization can be performed by InitMRDateRequest().
  251.  
  252.         A requester will be created and initialized with the values
  253.         provided by the user. The user may then interact with the requester
  254.         to specify a new date. Upon return, the following fields of
  255.         <datePacket->ARPDatePacket> will be meaningful:
  256.             dat_Format      - contains final date format
  257.             dat_Stamp       - contains return date value (DateStamp)
  258.  
  259.         In addition, the following fields of <datePacket> contain info:
  260.             newDate         - contains date in MRDate format
  261.             status          - 0 = OK, 1 => error or CANCEL  
  262.             
  263.  */
  264. int
  265. MRDateRequest(datePacket)
  266.     MRDatePacket    *datePacket;
  267. {
  268. #define MYFLAGS (REQSET | GADGETUP | GADGETDOWN)
  269.  
  270.     ULONG           class;          /* message class */
  271.     USHORT          code;           /* message code */
  272.     struct Gadget   *gadget;        /* pointer to gadget affected */
  273.     USHORT          gadgid;         /* gadget ID */
  274.     USHORT          i;
  275.     USHORT          *downImage = NULL, *upImage = NULL;
  276.     LONG            downImageSize, upImageSize;
  277.     struct Image    *image;
  278.     struct IntuiMessage *msg;       /* Intuition message pointer */
  279.     ULONG           IDCMPFlags;     /* current IDCMP flags */
  280.     BOOL            ready;
  281.     BOOL            redraw;         /* TRUE => redraw requester */
  282.     USHORT          *saveDownImage, *saveUpImage;
  283.     LONG            value;
  284.     SHORT           x,y;            /* mouse x and y position */
  285.  
  286.     if ( (datePacket->ARPDatePacket.dat_Format < 0) ||
  287.          (datePacket->ARPDatePacket.dat_Format > FORMAT_MAX) )
  288.         datePacket->ARPDatePacket.dat_Format = FORMAT_DOS;
  289.  
  290.     saveDownImage = GadgetImageData(&downYearGadget);
  291.     saveUpImage = GadgetImageData(&upYearGadget);
  292.     downImage = DupImage(downYearGadget.GadgetRender, &downImageSize);
  293.     if (downImage) {
  294.         image = (struct Image *) downYearGadget.GadgetRender;
  295.         SetImageData(image, downImage);   
  296.         downMonthGadget.GadgetRender = (APTR) image;
  297.         downDayGadget.GadgetRender = (APTR) image;
  298.         downHourGadget.GadgetRender = (APTR) image;
  299.         downMinuteGadget.GadgetRender = (APTR) image;
  300.         downMinuteGadget.GadgetRender = (APTR) image;
  301.         downSecondGadget.GadgetRender = (APTR) image; 
  302.     }
  303.     upImage = DupImage(upYearGadget.GadgetRender, &upImageSize);
  304.     if (upImage) {
  305.         image = (struct Image *) upYearGadget.GadgetRender;
  306.         SetImageData(image, upImage);
  307.         upMonthGadget.GadgetRender = (APTR) image;
  308.         upDayGadget.GadgetRender = (APTR) image;
  309.         upHourGadget.GadgetRender = (APTR) image;
  310.         upMinuteGadget.GadgetRender = (APTR) image;
  311.         upMinuteGadget.GadgetRender = (APTR) image;
  312.         upSecondGadget.GadgetRender = (APTR) image; 
  313.     }
  314.     datePacket->status = 0;
  315.     daterequest.BackFill = 0;
  316.     /* Make sure that the requester's window can see a REQSET message.
  317.      * This allows us to ignore messages until our requester is up.
  318.      */
  319.     IDCMPFlags = datePacket->window->IDCMPFlags;
  320.     ModifyIDCMP(datePacket->window, IDCMPFlags | MYFLAGS);
  321.     if (! Request(&daterequest, datePacket->window)) {
  322.         datePacket->status = 1;
  323.         goto done;
  324.     }
  325.     SetBPen(daterequest.ReqLayer->rp, 1L);
  326.     SetStringGadget(&promptGadget, datePacket->window,
  327.                     datePacket->requester, datePacket->prompt);
  328.  
  329.     datePacket->requester = &daterequest;
  330.     DSToDate(&datePacket->ARPDatePacket.dat_Stamp, &datePacket->newDate);
  331.     RedrawDateRequester(datePacket);
  332.  
  333.     for (ready = 0; ! ready ;) {    /* Wait for REQSET message. */
  334.         Wait(1L << datePacket->window->UserPort->mp_SigBit);
  335.         while (msg = (struct IntuiMessage *)
  336.             GetMsg(datePacket->window->UserPort)) {
  337.             if (msg->Class == REQSET) ready = 1;
  338.             ReplyMsg(msg);
  339.         }
  340.     }
  341.  
  342.     for (;;) {
  343.         Wait(1L << datePacket->window->UserPort->mp_SigBit);
  344.         while (msg = (struct IntuiMessage *) 
  345.                     GetMsg(datePacket->window->UserPort)) {
  346.             class = msg->Class;
  347.             code = msg->Code;
  348.             gadget = (struct Gadget *) msg->IAddress;
  349.             x = msg->MouseX;
  350.             y = msg->MouseY;
  351.             ReplyMsg(msg);      /* acknowledge the message */
  352.  
  353.             redraw = TRUE;          /* Assume a redraw will be needed. */
  354.             switch (class) {
  355.  
  356. #ifdef undef
  357.             case REQSET: 
  358.                 redraw = FALSE;
  359.                 break;
  360. #endif
  361. #ifdef undef
  362.             case GADGETDOWN:
  363.                 gadgid = gadget->GadgetID;
  364.                 switch (gadgid) {
  365.                 default:
  366.                     break;
  367.                 }
  368.                 break;
  369. #endif
  370.             case GADGETUP:
  371.                 gadgid = gadget->GadgetID;
  372.                 switch (gadgid) {
  373.                 case NOW_GADGET:
  374.                     DateStamp(&datePacket->ARPDatePacket.dat_Stamp);
  375.                     DSToDate(&datePacket->ARPDatePacket.dat_Stamp, 
  376.                              &datePacket->newDate);
  377.                     break;
  378.  
  379.                 case ZERO_GADGET:
  380.                     setmem(&datePacket->newDate, 
  381.                            sizeof(datePacket->newDate), 0);
  382.                     datePacket->newDate.Dmonth = 1;
  383.                     datePacket->newDate.Dday = 1;
  384.                     break;
  385.  
  386.                 case WEEK_PLUS_GADGET:
  387.                     datePacket->ARPDatePacket.dat_Stamp.ds_Days += 7;
  388.                     DSToDate(&datePacket->ARPDatePacket.dat_Stamp,
  389.                              &datePacket->newDate);
  390.                     break;
  391.  
  392.                 case WEEK_MINUS_GADGET:
  393.                     if (datePacket->ARPDatePacket.dat_Stamp.ds_Days >= 7)
  394.                         datePacket->ARPDatePacket.dat_Stamp.ds_Days -= 7;
  395.                     else
  396.                         datePacket->ARPDatePacket.dat_Stamp.ds_Days = 0;
  397.                     DSToDate(&datePacket->ARPDatePacket.dat_Stamp,
  398.                              &datePacket->newDate);
  399.                     break;
  400.                         
  401.                 case OK_GADGET:
  402.                     goto done;
  403.                     break;
  404.  
  405.                 case CANCEL_GADGET:
  406.                     datePacket->status = 1;
  407.                     goto done;
  408.                     break;
  409.  
  410.                 case YEAR_GADGET:
  411.                     value = GadgetValue(&yearGadget);
  412.                     if ((value >= 1978) && (value <= 2100))
  413.                         datePacket->newDate.Dyear = value;
  414.                     break;
  415.  
  416.                 case MONTH_GADGET:
  417.                     break;
  418.  
  419.                 case DAY_GADGET:
  420.                     value = GadgetValue(&dayGadget);
  421.                     if ((value >= 1) && (value <= 31))
  422.                         datePacket->newDate.Dday = value;
  423.                     break;
  424.  
  425.                 case HOUR_GADGET:
  426.                     value = GadgetValue(&hourGadget);
  427.                     if ((value >= 0) && (value < 24))
  428.                         datePacket->newDate.Dhour = value;
  429.                     break;
  430.  
  431.                 case MINUTE_GADGET:
  432.                     value = GadgetValue(&minuteGadget);
  433.                     if ((value >= 0) && (value < 60))
  434.                         datePacket->newDate.Dminute = value;
  435.                     break;
  436.  
  437.                 case SECOND_GADGET:
  438.                     value = GadgetValue(&secondGadget);
  439.                     if ((value >= 0) && (value < 60))
  440.                         datePacket->newDate.Dsecond = value;
  441.                     break;
  442.  
  443.                 case UP_YEAR_GADGET:
  444.                     ++datePacket->newDate.Dyear;
  445.                     break;
  446.  
  447.                 case DOWN_YEAR_GADGET:
  448.                     if (datePacket->newDate.Dyear > 1978) 
  449.                         --datePacket->newDate.Dyear;
  450.                     break;
  451.  
  452.                 case UP_MONTH_GADGET:
  453.                     if (++datePacket->newDate.Dmonth > 12) 
  454.                     datePacket->newDate.Dmonth = 1;
  455.                     break;
  456.  
  457.                 case DOWN_MONTH_GADGET:
  458.                     if (--datePacket->newDate.Dmonth < 1) 
  459.                         datePacket->newDate.Dmonth = 12;
  460.                     break;
  461.  
  462.                 case UP_DAY_GADGET:
  463.                     if (datePacket->newDate.Dday < 31) {
  464.                         ++datePacket->newDate.Dday;
  465.                     }
  466.                     break;
  467.  
  468.                 case DOWN_DAY_GADGET:
  469.                     if (datePacket->newDate.Dday > 1) 
  470.                         --datePacket->newDate.Dday;
  471.                     break;
  472.  
  473.                 case UP_HOUR_GADGET:
  474.                     if (++datePacket->newDate.Dhour > 23) 
  475.                         datePacket->newDate.Dhour = 0;
  476.                     break;
  477.  
  478.                 case DOWN_HOUR_GADGET:
  479.                     if (--datePacket->newDate.Dhour < 0) 
  480.                         datePacket->newDate.Dhour = 23;
  481.                     break;
  482.  
  483.                 case UP_MINUTE_GADGET:
  484.                     if (++datePacket->newDate.Dminute > 59) 
  485.                         datePacket->newDate.Dminute = 0;
  486.                     break;
  487.  
  488.                 case DOWN_MINUTE_GADGET:
  489.                     if (--datePacket->newDate.Dminute < 0) 
  490.                         datePacket->newDate.Dminute = 59;
  491.                     break;
  492.  
  493.                 case UP_SECOND_GADGET:
  494.                     if (++datePacket->newDate.Dsecond > 59) 
  495.                         datePacket->newDate.Dsecond = 0;
  496.                     break;
  497.  
  498.                 case DOWN_SECOND_GADGET:
  499.                     if (--datePacket->newDate.Dsecond < 0) 
  500.                         datePacket->newDate.Dsecond = 59;
  501.                     break;
  502.  
  503.                 case DATE_FORMAT_GADGET:
  504.                     if (++datePacket->ARPDatePacket.dat_Format>FORMAT_MAX)
  505.                         datePacket->ARPDatePacket.dat_Format = 0;
  506.                     SetOptionGadget(&dateFormatGadget, datePacket->window,
  507.                         datePacket->requester, 
  508.                         dateFormats[datePacket->ARPDatePacket.dat_Format]);
  509.                     break;
  510.                     
  511.                 default:
  512.                     redraw = FALSE;
  513.                     break;
  514.                 }                   /* end switch(gadgid) */
  515.  
  516.                 /* Reformat the new date value. */
  517.                 if (redraw) {
  518.                     DateToDS(&datePacket->newDate,
  519.                              &datePacket->ARPDatePacket.dat_Stamp);
  520.                     DSToDate(&datePacket->ARPDatePacket.dat_Stamp, 
  521.                              &datePacket->newDate);
  522.                     RedrawDateRequester(datePacket);                 
  523.                 }
  524.                 break;
  525.  
  526.             default:
  527.                 break;          /* ignore the rest */
  528.             }                   /* end switch(class) */
  529.         }
  530.     }
  531. done:
  532.     /* Restore gadget image data pointers. */
  533.     SetImageData(GadgetImage(&downYearGadget), saveDownImage);
  534.     SetImageData(GadgetImage(&upYearGadget), saveUpImage);
  535.  
  536.     /* Restore window's IDCMP flags. */
  537.     ModifyIDCMP(datePacket->window, IDCMPFlags);   
  538.     if (downImage) FreeMem(downImage, downImageSize);
  539.     if (upImage) FreeMem(upImage, upImageSize);
  540.     DateToDS(&datePacket->newDate, &datePacket->ARPDatePacket.dat_Stamp);
  541.     return datePacket->status;
  542. }
  543.  
  544. /*  FUNCTION
  545.  *      RedrawDateRequester - reformat and redisplay the date requester
  546.  * 
  547.  *  SYNOPSIS
  548.  *      static void RedrawDateRequester(datePacket)
  549.  *                      MRDatePacket    *datePacket;
  550.  */
  551. static void
  552. RedrawDateRequester(datePacket)
  553.     MRDatePacket *datePacket;
  554. {
  555.     char    *p, s[20];
  556.  
  557.  
  558.     sprintf(s,"%4d", datePacket->newDate.Dyear);
  559.     SetStringGadget(&yearGadget, datePacket->window, 
  560.                     datePacket->requester, s);
  561.     SetStringGadget(&monthGadget, datePacket->window, datePacket->requester, 
  562.                     calendar[datePacket->newDate.Dmonth-1].Mname);
  563.     sprintf(s,"%02d", datePacket->newDate.Dday);
  564.     SetStringGadget(&dayGadget, datePacket->window, datePacket->requester, s);
  565.     sprintf(s,"%02d", datePacket->newDate.Dhour);
  566.     SetStringGadget(&hourGadget, datePacket->window, 
  567.                     datePacket->requester, s);
  568.     sprintf(s,"%02d", datePacket->newDate.Dminute);
  569.     SetStringGadget(&minuteGadget, datePacket->window, 
  570.                     datePacket->requester, s);
  571.     sprintf(s,"%02d", datePacket->newDate.Dsecond);
  572.     SetStringGadget(&secondGadget, datePacket->window, 
  573.                     datePacket->requester, s);
  574.  
  575.     StamptoStr(datePacket);
  576.     /* There appears to be a bug in ARP's formatting of the time
  577.      * string. A trash character appears where the terminating null
  578.      * should be.
  579.      */
  580.     datePacket->ARPDatePacket.dat_StrTime[8] = 0;
  581.     SetStringGadget(&dateGadget, datePacket->window, 
  582.                     datePacket->requester,
  583.                     datePacket->ARPDatePacket.dat_StrDate);
  584.  
  585.     SetStringGadget(&timeGadget, datePacket->window,
  586.                     datePacket->requester,
  587.                     datePacket->ARPDatePacket.dat_StrTime);
  588.     
  589.     SetStringGadget(&dayNameGadget, datePacket->window,
  590.                     datePacket->requester,
  591.                     datePacket->ARPDatePacket.dat_StrDay);
  592.  
  593.     SetOptionGadget(&dateFormatGadget, datePacket->window,
  594.                     datePacket->requester, 
  595.                     dateFormats[datePacket->ARPDatePacket.dat_Format]);
  596.  
  597. }
  598.     
  599.  
  600. #ifdef DEBUG
  601.  
  602. /* --- Only compiled in the debug version --- */
  603.  
  604. #include <exec/memory.h>
  605.  
  606. /* New window structure */
  607.  
  608. struct NewWindow newwindow = {
  609.     0,0,640,200,0,1,
  610.  
  611. /* IDCMP Flags */
  612.  
  613.     MOUSEMOVE | MENUPICK | MOUSEBUTTONS | 
  614.     CLOSEWINDOW | GADGETDOWN | GADGETUP | REQSET, 
  615.  
  616. /* Flags */
  617.     WINDOWCLOSE | WINDOWDEPTH | ACTIVATE | RMBTRAP | REPORTMOUSE,
  618.  
  619.     NULL,                           /* First gadget */
  620.     NULL,                           /* Checkmark */
  621.     (UBYTE *)"Date Requester Test Program", /* Window title */
  622.     NULL,                           /* No custom streen */
  623.     NULL,                           /* Not a super bitmap window */
  624.     0,0,640,200,                    /* Not used, but set up anyway */
  625.     WBENCHSCREEN
  626. };
  627.  
  628. static struct IntuiText MoreText = {
  629.     AUTOFRONTPEN,               /* FrontPen */
  630.     AUTOBACKPEN,                /* BackPen */
  631.     JAM2,                       /* DrawMode */
  632.     AUTOLEFTEDGE,               /* LeftEdge */
  633.     AUTOTOPEDGE,                /* TopEdge */
  634.     AUTOITEXTFONT,              /* ITextFont */
  635.     (UBYTE *) "Want to play some more?", /* IText */
  636.     NULL                        /* NextText */
  637.     };
  638.  
  639. static struct IntuiText YesText = {
  640.     AUTOFRONTPEN,               /* FrontPen */
  641.     AUTOBACKPEN,                /* BackPen */
  642.     AUTODRAWMODE,               /* DrawMode */
  643.     AUTOLEFTEDGE,               /* LeftEdge */
  644.     AUTOTOPEDGE,                /* TopEdge */
  645.     AUTOITEXTFONT,              /* ITextFont */
  646.     (UBYTE *) "Sure!",          /* IText */
  647.     NULL                        /* NextText */
  648.     };
  649.  
  650. static struct IntuiText NoText = {
  651.     AUTOFRONTPEN,               /* FrontPen */
  652.     AUTOBACKPEN,                /* BackPen */
  653.     JAM2,                       /* DrawMode */
  654.     AUTOLEFTEDGE,               /* LeftEdge */
  655.     AUTOTOPEDGE,                /* TopEdge */
  656.     AUTOITEXTFONT,              /* ITextFont */
  657.     (UBYTE *) "Nope!",          /* IText */
  658.     NULL                        /* NextText */
  659.     };
  660.  
  661. struct ArpBase          *ArpBase;
  662. struct GfxBase          *GfxBase;
  663. struct IntuitionBase    *IntuitionBase;
  664. struct Window           *mywindow;
  665. long                    *ds;
  666.  
  667. main()
  668. {
  669.     static char     *arpNotOpen = "I can not open the ARP library!\n";  
  670.     short           keep_going;
  671.     MRDatePacket    *datePacket = NULL;
  672.  
  673.     ArpBase = (struct ArpBase *) OpenLibrary(ArpName, ArpVersion);
  674.     if (ArpBase == NULL) {
  675.         Write(Output(), arpNotOpen , (long) sizeof(arpNotOpen));
  676.         goto done;
  677.     }
  678.     GfxBase = (struct GfxBase *) ArpBase->GfxBase;
  679.     IntuitionBase = (struct IntuitionBase *) ArpBase->IntuiBase;
  680.  
  681.     datePacket = CreateMRDatePacket(NULL, FORMAT_USA, 1);
  682.  
  683.     mywindow = OpenWindow(&newwindow);
  684.     /* Set initial values in date packet. */
  685.     datePacket->window = mywindow;
  686.     do {
  687.         MRDateRequest(datePacket);
  688.         keep_going = AutoRequest(mywindow, &MoreText, &YesText, &NoText,
  689.                         NULL, NULL, 220L, 50L);
  690.     } while (keep_going);
  691.  
  692. done:
  693.     if (datePacket)
  694.         FreeMRDatePacket(datePacket);
  695.  
  696.     if (mywindow)
  697.         CloseWindow(mywindow);
  698.  
  699.     if (IntuitionBase)
  700.         CloseLibrary(IntuitionBase);
  701.  
  702. }
  703.  
  704. #endif
  705.  
  706.