home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / fish / disks / d1094.lha / Programs / Grocery / Grocery.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-20  |  47.2 KB  |  1,507 lines
  1. /************************************************************************
  2. *
  3. *  Program:  Grocery.c
  4. *
  5. *  Author: Brian Gragg
  6. *
  7. *  Date:   11/29/92     version 0.1
  8. *           5/15/93     version 1.4 - added create meal menu option
  9. *          10/17/93     version 1.5 - added list scroll option & sort at print
  10. *           9/19/94     version 1.6 - fixed bug in meal generation option
  11. *            3/18/95     version 1.7 - moved about requester to grocery screen
  12. *
  13. *************************************************************************/
  14.  
  15. #define  DATAFILE    "Grocery.data"
  16. #define  BACKFILE    "Grocery.data.bak"
  17. #define  TEMPFILE    "t:groctmp"
  18. #define  MODEID      HIRESLACE_KEY
  19. #define  SWIDTH      640
  20. #define  SHEIGHT     400
  21. #define  SDEPTH      2
  22.  
  23. #define ASLLEFTEDGE 163
  24. #define ASLTOPEDGE  24
  25. #define ASLWIDTH    320
  26. #define ASLHEIGHT   200
  27.  
  28. #define MYGAD_ITEM     (0)
  29. #define MYGAD_AMOUNT   (1)
  30. #define MYGAD_SIZE     (2)
  31. #define MYGAD_GLIST    (3)
  32. #define MYGAD_ILIST    (4)
  33. #define MYGAD_MEALS    (5)
  34. #define MYGAD_EDIT     (6)
  35. #define MYGAD_DELETE   (7)
  36. #define MYGAD_SORT     (8)
  37. #define MYGAD_SORTNAME (9)
  38. #define MYGAD_AISLE   (10)
  39. #define MYGAD_ADD     (11)
  40. #define MAXGADGET     (12)  /* this should be 1 greater than last gadget id */
  41.  
  42. #define NOITEM         65535
  43. #define OPEN           1
  44. #define SAVE           2
  45.  
  46. #include <stdlib.h>
  47. #include <stdio.h>
  48. #include <string.h>
  49. #include <math.h>
  50. #include <time.h>
  51. #include <ctype.h>
  52. #include <exec/types.h>
  53. #include <exec/memory.h>
  54. #include <exec/lists.h>
  55. #include <exec/nodes.h>
  56. #include <dos/dos.h>
  57. #include <libraries/asl.h>
  58. #include <intuition/intuition.h>
  59. #include <intuition/screens.h>
  60. #include <intuition/gadgetclass.h>
  61. #include <libraries/gadtools.h>
  62. #include <intuition/intuitionbase.h>
  63. #include <graphics/gfx.h>
  64. #include <graphics/gfxbase.h>
  65. #include <libraries/dos.h>
  66.  
  67. #include <clib/utility_protos.h>
  68. #include <clib/alib_protos.h>
  69. #include <clib/exec_protos.h>
  70. #include <clib/dos_protos.h>
  71. #include <clib/intuition_protos.h>
  72. #include <clib/graphics_protos.h>
  73. #include <clib/gadtools_protos.h>
  74. #include <clib/asl_protos.h>
  75.  
  76. /* Use SAS/C 6.0 ability to open libraries for you !! */
  77. extern struct Library         *DOSBase;
  78. extern struct Library         *GadToolsBase;
  79. extern struct Library         *AslBase;
  80. extern struct IntuitionBase   *IntuitionBase;
  81. extern struct GfxBase         *GfxBase;
  82. extern struct Library         *SysBase;
  83. extern struct Library         *UtilityBase;
  84.  
  85. struct EasyStruct myES = {
  86.     sizeof(struct EasyStruct), 0, "GroceryList",
  87.     "%s",
  88.     "OK",
  89. };
  90.  
  91.  
  92. struct Screen *myscreen      = NULL;
  93. struct Window *window        = NULL;
  94. struct Menu   *menuStrip     = NULL;
  95. struct APTR   *my_VisualInfo = NULL;
  96. struct Gadget *glist         = NULL;
  97. struct List   *ItemList      = NULL;
  98. struct List   *GrocList      = NULL;
  99. struct List   *MealList      = NULL;
  100. struct List   *AislList      = NULL;
  101. struct Gadget *mygad[MAXGADGET];
  102. struct NewGadget ng;
  103.  
  104. #define NAMENODE_ID    100     /* The type of "NameNode" */
  105. #define MEALNODE_ID    101     /* The type of "MealNode" */
  106.  
  107. struct NameNode {
  108.    struct  Node nn_Node;       /* System Node structure            */
  109.    UBYTE   nn_Item[30];        /* The item (equals the node name)  */
  110.    UBYTE   nn_Size[10];        /* standard size (ie lbs, oz, etc)  */
  111.    UBYTE   nn_Amount[10];      /* usual amount                     */
  112.    WORD    nn_Aisle;           /* the aisle number where it's found*/
  113.    UBYTE   nn_LongName[80];    /* the long name associated with the item */
  114.    WORD    nn_ListPos;         /* ordinal position in a list       */
  115. };
  116.  
  117. struct MealNode {
  118.    struct  Node nn_Node;       /* System Node structure            */
  119.    UBYTE   nn_Meal[30];        /* The meal (equals node name)      */
  120.    struct  List *nn_MealItem;  /* a sublist of items               */
  121. };
  122.    
  123. struct TextAttr Topaz80 = { "topaz.font", 8, 0, 0, };
  124.  
  125. struct NewMenu mynewmenu[] =
  126. {
  127.     { NM_TITLE, "Project",  0 , 0, 0, 0,},
  128.     { NM_ITEM,  "New",       "N", 0, 0, 0,},
  129.     { NM_ITEM,  "Open...",   "O", 0, 0, 0,},
  130.     { NM_ITEM,  NM_BARLABEL,  0 , 0, 0, 0,},
  131.     { NM_ITEM,  "Save",      "S", 0, 0, 0,},
  132.     { NM_ITEM,  "Save As...","A", 0, 0, 0,},
  133.     { NM_ITEM,  NM_BARLABEL,  0 , 0, 0, 0,},
  134.     { NM_ITEM,  "Print",     "P", 0, 0, 0,},
  135.     { NM_ITEM,  NM_BARLABEL,  0 , 0, 0, 0,},
  136.     { NM_ITEM,  "About",      0 , 0, 0, 0,},
  137.     { NM_ITEM,  NM_BARLABEL,  0 , 0, 0, 0,},
  138.     { NM_ITEM,  "Quit",      "Q", 0, 0, 0,},
  139.     { NM_TITLE, "Meals",      0 , 0, 0, 0,},
  140.     { NM_ITEM,  "Create Meal","M", 0, 0, 0,},
  141.  };    
  142.  
  143. char savefilename[256];
  144. char aislename[30][22];
  145. char aisleId[30]; 
  146. WORD pens[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ~0};
  147. UWORD currentAisle = NOITEM;
  148. UWORD currentGroc  = NOITEM;
  149. far char buffer[256], buf[256];
  150.  
  151. #ifdef LATTICE
  152. int __chkabort(void) { return(0); } /* Disable Lattice CTRL/C handling */
  153. #endif
  154.  
  155. /* VERSION STRING */
  156. UBYTE vers[] = "\0$VER: Grocery 1.7";
  157. char screenname[80];
  158. char title[120];
  159.  
  160. /************ my protos *************/
  161. VOID cleanExit(char *);            /* clean up and close           */
  162. int doMenus(VOID);                 /* create menus                 */
  163. VOID handle_window_events(VOID);   /* deal with the IDCMP events   */
  164. VOID getWBPens(VOID);              /* get the workbench pens       */
  165. VOID setupGadgets(VOID);           /* setup the required gadgets   */
  166. VOID AddName(struct List *, UBYTE *, UBYTE *, UBYTE *, WORD);
  167. VOID AddItem(struct List *, UBYTE *, UBYTE *, UBYTE *, WORD);
  168. VOID AddAisle(struct List *, UBYTE *, WORD);
  169. struct List *AddMeal(struct List *, UBYTE *);
  170. VOID FreeMealNodes(struct List *);
  171. VOID FreeNameNodes(struct List *);
  172. VOID readData(VOID);               /* reads data from DATAFILE     */
  173. VOID newMeal(VOID);                /* saves the list as a meal in the database */
  174.  
  175.  
  176. /*************************************************************************/
  177.  
  178. void
  179. main(int argc, char *argv[])
  180. {
  181.    LONG screenTopBorder;
  182.    
  183.    /* Rely on SAS/C 6.0 to open the libraries for me */
  184.  
  185.    getWBPens();
  186.    
  187.    strcpy(title,&vers[7]);
  188.    strcat(title,"  - Brian Gragg March 1995");
  189.    strcpy(screenname,title);
  190.    
  191.    if (NULL == (myscreen = OpenScreenTags(NULL,
  192.              SA_Width,     SWIDTH,
  193.              SA_Height,    SHEIGHT,
  194.              SA_DisplayID, MODEID,
  195.              SA_Depth,     SDEPTH,
  196.              SA_Title,     screenname,
  197.              SA_Pens,      pens,
  198.              SA_ShowTitle, TRUE,
  199.              TAG_END))) 
  200.        cleanExit("Couldn't open screen.");
  201.    
  202.    readData();
  203.    setupGadgets();
  204.  
  205.    screenTopBorder = myscreen->WBorTop + myscreen->Font->ta_YSize +1;
  206.    if (NULL == (window = OpenWindowTags(NULL,
  207.              WA_Top,          screenTopBorder,
  208.              WA_Left,         0,
  209.              WA_Height,       myscreen->Height - screenTopBorder,
  210.              WA_Width,        myscreen->Width,
  211.              WA_CustomScreen, myscreen,
  212.              WA_NoCareRefresh,TRUE,
  213.              WA_IDCMP,        IDCMP_MENUPICK | IDCMP_MOUSEBUTTONS | 
  214.                                LISTVIEWIDCMP | IDCMP_REFRESHWINDOW,
  215.              WA_Gadgets,      glist,
  216.              WA_Activate,     TRUE,
  217.              WA_DetailPen,    3,
  218.              TAG_END)))
  219.        cleanExit("Couldn't open window.");
  220.    
  221.    
  222.    GT_RefreshWindow(window, NULL);
  223.    
  224.    ActivateGadget(mygad[MYGAD_ITEM],window,NULL);
  225.  
  226.    if (doMenus()) 
  227.        cleanExit("Couldn't create menu strip.");
  228.  
  229.    handle_window_events();
  230.    
  231.    cleanExit("");
  232. }
  233.  
  234.  
  235. /*********************************************************************
  236. *   cleanExit("message")
  237. *
  238. *      clean up and exit.  Print message before quiting.
  239. **********************************************************************/
  240.  
  241. VOID
  242. cleanExit(char *message)
  243. {
  244.    if (strlen(message) > 1)
  245.        EasyRequest(NULL, &myES, NULL, message);
  246.        
  247.    if (ItemList != NULL) {     FreeNameNodes(ItemList);
  248.                                FreeMem(ItemList, sizeof(struct List)); }
  249.    if (GrocList != NULL) {     FreeNameNodes(GrocList);
  250.                                FreeMem(GrocList, sizeof(struct List)); }
  251.    if (MealList != NULL) {     FreeMealNodes(MealList);
  252.                                FreeMem(MealList, sizeof(struct List)); }
  253.    if (AislList != NULL) {     FreeNameNodes(AislList);
  254.                                FreeMem(AislList, sizeof(struct List)); }
  255.    
  256.    if (menuStrip != NULL)      FreeMenus(menuStrip);
  257.    if (glist != NULL)          FreeGadgets(glist);
  258.    if (my_VisualInfo != NULL)  FreeVisualInfo(my_VisualInfo);
  259.  
  260.  
  261.    if (window != NULL)         CloseWindow(window);
  262.    if (myscreen != NULL)       CloseScreen(myscreen);
  263.  
  264.    /* Rely on SAS/C 6.0 to close libraries for me */ 
  265.    
  266.    exit(0);  
  267. }
  268.  
  269.  
  270. /*********************************************************************
  271. *   getWBPens()
  272. *
  273. *      get the colors from the workbench drawinfo structure
  274. **********************************************************************/
  275.  
  276. VOID
  277. getWBPens(VOID)
  278. {
  279.    UBYTE *pubScreenName = "Workbench";
  280.    int   i;
  281.    
  282.    struct Screen *pub_screen = NULL;
  283.    struct DrawInfo *screen_drawinfo = NULL;
  284.  
  285.    /* Get a lock on the Workbench screen */
  286.    pub_screen = LockPubScreen(pubScreenName);
  287.    if ( pub_screen == NULL )
  288.    {
  289.        EasyRequest(NULL, &myES, NULL, "Couldn't get a lock on workbench.");
  290.        for (i=0; i<4; i++)
  291.            pens[i] = i;
  292.        return;
  293.    }
  294.        
  295.    screen_drawinfo = GetScreenDrawInfo(pub_screen);
  296.    if ( screen_drawinfo == NULL)
  297.    {
  298.        UnlockPubScreen(pubScreenName,pub_screen);
  299.        EasyRequest(NULL, &myES, NULL, "Couldn't get workbench's drawinfo structure.");
  300.        for (i=0; i<4; i++)
  301.            pens[i] = i;
  302.        return;
  303.    }
  304.  
  305.    for (i=0; pens[i] != ~0; i++)
  306.       pens[i] = screen_drawinfo->dri_Pens[i];
  307.    
  308.    FreeScreenDrawInfo(pub_screen,screen_drawinfo);
  309.    UnlockPubScreen(pubScreenName,pub_screen);
  310. }
  311.  
  312. /*********************************************************************
  313. *   doMenus()
  314. *   return 0=ok  1=failed
  315. **********************************************************************/
  316.  
  317. int
  318. doMenus(VOID)
  319. {
  320.    if (NULL != (menuStrip = CreateMenus(mynewmenu, TAG_END)))
  321.    {
  322.        if (LayoutMenus(menuStrip, my_VisualInfo, TAG_END))
  323.        {
  324.            if (SetMenuStrip(window, menuStrip))
  325.            {
  326.                return(0);
  327.            }
  328.        }
  329.        FreeMenus(menuStrip);
  330.    }
  331.    return(1);
  332. }
  333.  
  334.  
  335. /*********************************************************************
  336. *   readData()
  337. *
  338. **********************************************************************/
  339.  
  340. VOID
  341. readData(VOID)
  342. {
  343.    FILE   *fileptr = NULL;      /* a pointer to a file handle */
  344.    char   *item, *amount, *size, meal[30];
  345.    long   place;
  346.    struct List *list;
  347.    char   *pointer;
  348.    int    i, j;
  349.       
  350.    GrocList = AllocMem(sizeof(struct List),MEMF_CLEAR);
  351.    ItemList = AllocMem(sizeof(struct List),MEMF_CLEAR);
  352.    MealList = AllocMem(sizeof(struct List),MEMF_CLEAR);
  353.    AislList = AllocMem(sizeof(struct List),MEMF_CLEAR);
  354.  
  355.    if ((GrocList == NULL) || (ItemList == NULL) || (MealList == NULL) || (AislList == NULL))
  356.        cleanExit("Out of memory allocating Lists.");
  357.        
  358.    NewList(GrocList);
  359.    NewList(ItemList);
  360.    NewList(MealList);
  361.    NewList(AislList);
  362.    
  363.    fileptr = fopen(DATAFILE,"r");
  364.    if ( fileptr == NULL )
  365.        cleanExit("Couldn't open data file.");
  366.    
  367.    while ((fgets(buffer,255,fileptr) != NULL) && (strlen(buffer) > 1))
  368.    {
  369.        if (buffer[0] != ';')
  370.        {
  371.            buffer[strlen(buffer)-1] = '\0';
  372.            i = atoi(&buffer[3]);  /* order id */
  373.            j = atoi(buffer);      /* aisle id */
  374.            aisleId[j] = i ;
  375.            strncpy(aislename[i],&buffer[6],13);
  376.            AddAisle(AislList,&buffer[6], (WORD)i); 
  377.        }
  378.    }
  379.  
  380.    while ((fgets(meal,29,fileptr) != NULL) && (strncmp(meal,"EXIT!",5)))
  381.    {
  382.        meal[strlen(meal)-1] = '\0';
  383.        list = AddMeal(MealList,meal);
  384.        
  385.        while ((fgets(buffer,255,fileptr) != NULL) && (strlen(buffer)>5) && 
  386.                    (strrchr(buffer,'`') != NULL))
  387.        {
  388.            pointer   =strrchr(buffer,'`');
  389.            pointer[0]='\0';
  390.            place     = atol(&pointer[1]);
  391.            pointer   =strrchr(buffer,'`');
  392.            pointer[0]='\0';
  393.            size      = &pointer[1];
  394.            pointer   =strrchr(buffer,'`');
  395.            pointer[0]='\0';
  396.            amount    = &pointer[1];
  397.            item      = buffer;
  398.  
  399.            AddName(list,item,amount,size,aisleId[place]);
  400.        }
  401.    }
  402.  
  403.    fgets(buffer,255,fileptr); /* read in blank line */
  404.    
  405.    
  406.    while ((fgets(buffer,255,fileptr) != NULL) && (strlen(buffer)>1))
  407.    {
  408.        pointer   =strrchr(buffer,'`');
  409.        pointer[0]='\0';
  410.        place     = atol(&pointer[1]);
  411.        pointer   =strrchr(buffer,'`');
  412.        pointer[0]='\0';
  413.        size      = &pointer[1];
  414.        pointer   =strrchr(buffer,'`');
  415.        pointer[0]='\0';
  416.        amount    = &pointer[1];
  417.        item      = buffer;
  418.        
  419.        AddName(ItemList,item,amount,size,aisleId[place]);
  420.    }
  421.  
  422.    fclose(fileptr);
  423. }
  424.  
  425.  
  426. /*********************************************************************
  427. *   setupGadgets()
  428. *
  429. **********************************************************************/
  430.  
  431. VOID
  432. setupGadgets(VOID)
  433. {
  434.    struct Gadget *gad;
  435.    
  436.    if (NULL == (my_VisualInfo = GetVisualInfo(myscreen, TAG_END)))
  437.        cleanExit("Couldn't GetVisualInfo.");
  438.  
  439.    gad = CreateContext(&glist);
  440.    
  441.    /** ITEM GADGET **/
  442.    ng.ng_LeftEdge   = 17;
  443.    ng.ng_TopEdge    = 348;
  444.    ng.ng_Width      = 215;
  445.    ng.ng_Height     = 21;
  446.    ng.ng_GadgetText = "Item";
  447.    ng.ng_VisualInfo = my_VisualInfo;
  448.    ng.ng_GadgetID   = MYGAD_ITEM;
  449.    ng.ng_TextAttr   = &Topaz80;
  450.    ng.ng_Flags      = PLACETEXT_BELOW;
  451.  
  452.    mygad[MYGAD_ITEM] = gad = CreateGadget(STRING_KIND, gad, &ng, 
  453.                    GA_TabCycle,      TRUE,
  454.                    GA_Immediate,     TRUE,
  455.                    STRINGA_ExitHelp, TRUE,
  456.                    TAG_END);
  457.  
  458.    /** AMOUNT GADGET **/
  459.    ng.ng_LeftEdge   = 236;
  460.    ng.ng_Width      = 84;
  461.    ng.ng_GadgetText = "Amount";
  462.    ng.ng_GadgetID   = MYGAD_AMOUNT;
  463.  
  464.    mygad[MYGAD_AMOUNT] = gad = CreateGadget(STRING_KIND, gad, &ng, 
  465.                    GA_TabCycle,    TRUE,
  466.                    GA_Immediate,   TRUE,
  467.                    TAG_END);   ng.ng_LeftEdge   = 17;
  468.  
  469.    /** UNITS GADGET **/
  470.    ng.ng_LeftEdge   = 324;
  471.    ng.ng_GadgetText = "Units";
  472.    ng.ng_GadgetID   = MYGAD_SIZE,
  473.  
  474.    mygad[MYGAD_SIZE] = gad = CreateGadget(STRING_KIND, gad, &ng, 
  475.                    GA_TabCycle,    TRUE,
  476.                    GA_Immediate,   TRUE,
  477.                    TAG_END);
  478.  
  479.    /** AISLE GADGET **/
  480.    ng.ng_LeftEdge   = 423;
  481.    ng.ng_TopEdge    = 316;
  482.    ng.ng_Width      = 185;
  483.    ng.ng_Height     = 60;
  484.    ng.ng_GadgetText = "Asile";
  485.    ng.ng_GadgetID   = MYGAD_AISLE;
  486.    
  487.    mygad[MYGAD_AISLE] = gad = CreateGadget(LISTVIEW_KIND, gad, &ng, 
  488.                    GTLV_Labels,        AislList,
  489.                    GTLV_ScrollWidth,   18,
  490.                    GTLV_Top,           1,
  491.                    LAYOUTA_Spacing,    1,
  492.                    GTLV_ShowSelected,  NULL,
  493.                    TAG_END);
  494.  
  495.    /** MEALS GADGET **/
  496.    ng.ng_LeftEdge   = 423;
  497.    ng.ng_TopEdge    = 223;
  498.    ng.ng_Width      = 185;
  499.    ng.ng_Height     = 80;
  500.    ng.ng_GadgetText = "Meals";
  501.    ng.ng_GadgetID   = MYGAD_MEALS;
  502.    
  503.    mygad[MYGAD_MEALS] = gad = CreateGadget(LISTVIEW_KIND, gad, &ng, 
  504.                    GTLV_Labels,        MealList,
  505.                    GTLV_ScrollWidth,   18,
  506.                    GTLV_Top,           0,
  507.                    LAYOUTA_Spacing,    1,
  508.                    TAG_END);
  509.  
  510.    /** ILIST GADGET **/
  511.    ng.ng_TopEdge    = 15;
  512.    ng.ng_Height     = 208;
  513.    ng.ng_GadgetText = "Items List";
  514.    ng.ng_GadgetID   = MYGAD_ILIST;
  515.    ng.ng_Flags      = PLACETEXT_ABOVE;
  516.    
  517.    mygad[MYGAD_ILIST] = gad = CreateGadget(LISTVIEW_KIND, gad, &ng, 
  518.                    GTLV_Labels,        ItemList,
  519.                    GTLV_ScrollWidth,   18,
  520.                    GTLV_Top,           0,
  521.                    LAYOUTA_Spacing,    1,
  522.                    TAG_END);
  523.  
  524.  
  525.    /** GLIST GADGET **/
  526.    ng.ng_LeftEdge   = 17;
  527.    ng.ng_Width      = 390;
  528.    ng.ng_Height     = 292;
  529.    ng.ng_GadgetText = "Grocery List";
  530.    ng.ng_GadgetID   = MYGAD_GLIST;
  531.    
  532.    mygad[MYGAD_GLIST] = gad = CreateGadget(LISTVIEW_KIND, gad, &ng, 
  533.                    GTLV_Labels,        GrocList,
  534.                    GTLV_ScrollWidth,   18,
  535.                    GTLV_Top,           0,
  536.                    LAYOUTA_Spacing,    1,
  537.                    GTLV_ShowSelected,  NULL,
  538.                    TAG_END);
  539.  
  540.    /** EDIT GADGET **/
  541.    ng.ng_LeftEdge   = 17;
  542.    ng.ng_TopEdge    = 310;
  543.    ng.ng_Width      = 56;
  544.    ng.ng_Height     = 20;
  545.    ng.ng_GadgetText = "EDIT";
  546.    ng.ng_GadgetID   = MYGAD_EDIT;
  547.    ng.ng_Flags      = PLACETEXT_IN;
  548.  
  549.    mygad[MYGAD_EDIT] = gad = CreateGadget(BUTTON_KIND, gad, &ng, TAG_END);
  550.  
  551.  
  552.    /** DELETE GADGET **/
  553.    ng.ng_LeftEdge   = 80;
  554.    ng.ng_GadgetText = "DELETE";
  555.    ng.ng_GadgetID   = MYGAD_DELETE;
  556.  
  557.    mygad[MYGAD_DELETE] = gad = CreateGadget(BUTTON_KIND, gad, &ng, TAG_END);
  558.  
  559.  
  560.    /** SORT BY AISLE GADGET **/
  561.    ng.ng_LeftEdge   = 143;
  562.    ng.ng_Width      = 94;
  563.    ng.ng_GadgetText = "AISLE SORT";
  564.    ng.ng_GadgetID   = MYGAD_SORT;
  565.  
  566.  
  567.    mygad[MYGAD_SORT] = gad = CreateGadget(BUTTON_KIND, gad, &ng, TAG_END);
  568.  
  569.    /** SORT BY NAME GADGET **/
  570.    ng.ng_LeftEdge   = 244;
  571.    ng.ng_GadgetText = "NAME SORT";
  572.    ng.ng_GadgetID   = MYGAD_SORTNAME;
  573.  
  574.    mygad[MYGAD_SORTNAME] = gad = CreateGadget(BUTTON_KIND, gad, &ng, TAG_END);
  575.  
  576.  
  577.    /** ADD GADGET **/
  578.    ng.ng_LeftEdge   = 345;
  579.    ng.ng_Width      = 62;
  580.    ng.ng_GadgetText = "ADDITEM";
  581.    ng.ng_GadgetID   = MYGAD_ADD;
  582.  
  583.    mygad[MYGAD_ADD] = gad = CreateGadget(BUTTON_KIND, gad, &ng, TAG_END);
  584.  
  585.    
  586.  
  587. }
  588.  
  589. /*********************************************************************
  590. *      NODE FUNCTIONS
  591. *
  592. *   AddName()  &  FreeNameNodes()  &  FindNode()  & alphaEnqueue
  593. *
  594. *      used to build and clear nodes from a list
  595. **********************************************************************/
  596.  
  597. VOID
  598. alphaEnqueue(struct List *list, struct Node *node)
  599. {                              /* inserts a node queued by pri then name */
  600.     struct Node *worknode;
  601.     BOOL   found = FALSE;
  602.  
  603.     worknode = list->lh_Head; /* First node */
  604.     while (worknode != NULL)
  605.     {
  606.         if ((worknode->ln_Pri < node->ln_Pri) ||
  607.             ((worknode->ln_Pri == node->ln_Pri) &&
  608.              (strcmp(worknode->ln_Name,node->ln_Name) > 0)))
  609.         {
  610.            Insert(list, node, worknode->ln_Pred);
  611.            found = TRUE;
  612.            break;
  613.         }
  614.         worknode = worknode->ln_Succ;
  615.     }
  616.     if ( found == FALSE )
  617.        AddTail(list,node);
  618. }
  619.  
  620.  
  621.  
  622. /* Allocate a NameNode structure, copy the given name into the structure,
  623.  * then add it the specified list. 
  624. */
  625.  
  626. VOID 
  627. AddName(struct List *list, UBYTE *item, UBYTE *amount, UBYTE *size, WORD aisle)
  628. {
  629.     struct NameNode *namenode;
  630.  
  631.     if (!( namenode = AllocMem(sizeof(struct NameNode),MEMF_CLEAR) ))
  632.         cleanExit("Out of memory adding a node.");
  633.  
  634.     strcpy(namenode->nn_Item,item);
  635.     strcpy(namenode->nn_Size,size);
  636.     strcpy(namenode->nn_Amount,amount);
  637.     namenode->nn_Aisle = aisle;
  638.     namenode->nn_Node.ln_Name = namenode->nn_Item;
  639.     namenode->nn_Node.ln_Type = NAMENODE_ID;
  640.     namenode->nn_Node.ln_Pri  = 0;
  641.     alphaEnqueue((struct List *)list,(struct Node *)namenode);
  642. }
  643.  
  644. VOID
  645. AddItem(struct List *list, UBYTE *item, UBYTE *amount, UBYTE *size, WORD aisle)
  646. {
  647.     struct NameNode *namenode;
  648.  
  649.     if (!( namenode = AllocMem(sizeof(struct NameNode),MEMF_CLEAR) ))
  650.         cleanExit("Out of memory adding a node.");
  651.  
  652.     strcpy(namenode->nn_Item,item);
  653.     strcpy(namenode->nn_Size,size);
  654.     strcpy(namenode->nn_Amount,amount);
  655.     namenode->nn_Aisle = aisle;
  656.     namenode->nn_Node.ln_Type = NAMENODE_ID;
  657.     namenode->nn_Node.ln_Pri  = 0;
  658.     sprintf(buffer,"%-18.18s %8.8s %-7.7s %-14.14s\0",namenode->nn_Item, namenode->nn_Amount,
  659.            namenode->nn_Size, aislename[namenode->nn_Aisle]);
  660.     strcat(namenode->nn_LongName,buffer);
  661.     namenode->nn_Node.ln_Name = namenode->nn_LongName;
  662.     AddTail((struct List *)list,(struct Node *)namenode);
  663. }
  664.  
  665. VOID 
  666. AddAisle(struct List *list, UBYTE *name, WORD aisle)
  667. {
  668.     struct NameNode *namenode;
  669.  
  670.     if (!( namenode = AllocMem(sizeof(struct NameNode),MEMF_CLEAR) ))
  671.         cleanExit("Out of memory adding a node.");
  672.  
  673.     strcpy(namenode->nn_Item,name);
  674.     namenode->nn_Aisle = aisle;
  675.     namenode->nn_Node.ln_Name = namenode->nn_Item;
  676.     namenode->nn_Node.ln_Type = NAMENODE_ID;
  677.     namenode->nn_Node.ln_Pri  = 40-aisle;
  678.     Enqueue((struct List *)list,(struct Node *)namenode);
  679. }
  680.  
  681.  
  682. struct List *
  683. AddMeal(struct List *list, UBYTE *meal)
  684. {
  685.     struct MealNode *mealnode;
  686.  
  687.     if (!( mealnode = AllocMem(sizeof(struct MealNode),MEMF_CLEAR) ))
  688.         cleanExit("Out of memory adding a meal.");
  689.  
  690.     strcpy(mealnode->nn_Meal,meal);
  691.     mealnode->nn_Node.ln_Name = mealnode->nn_Meal;
  692.     mealnode->nn_Node.ln_Type = MEALNODE_ID;
  693.     mealnode->nn_Node.ln_Pri  = 0;
  694.     if (!(mealnode->nn_MealItem = AllocMem(sizeof(struct List),MEMF_CLEAR)))
  695.        cleanExit("No memory for meal list.");
  696.     NewList(mealnode->nn_MealItem);
  697.     alphaEnqueue((struct List *)list,(struct Node *)mealnode);
  698.     return(mealnode->nn_MealItem);
  699. }
  700.  
  701.  
  702. /*
  703.  * Free the entire list, including the header.  The header is not updated
  704.  * as the list is freed.  This function demonstrates how to avoid
  705.  * referencing freed memory when deallocating nodes.
  706.  */
  707. VOID FreeNameNodes(struct List *list)
  708. {
  709.     struct NameNode *worknode;
  710.     struct NameNode *nextnode;
  711.  
  712.     worknode = (struct NameNode *)(list->lh_Head); /* First node */
  713.     while (nextnode = (struct NameNode *)(worknode->nn_Node.ln_Succ)) {
  714.         FreeMem(worknode,sizeof(struct NameNode));
  715.         worknode = nextnode;
  716.     }
  717. }
  718.  
  719. VOID FreeMealNodes(struct List *list)
  720. {
  721.     struct MealNode *worknode;
  722.     struct MealNode *nextnode;
  723.  
  724.     worknode = (struct MealNode *)(list->lh_Head); /* First node */
  725.     while (nextnode = (struct MealNode *)(worknode->nn_Node.ln_Succ)) 
  726.     {
  727.         FreeNameNodes(worknode->nn_MealItem);
  728.         FreeMem(worknode->nn_MealItem, sizeof(struct List));
  729.         FreeMem(worknode,sizeof(struct MealNode));
  730.         worknode = nextnode;
  731.     }
  732.  
  733. }
  734.  
  735.  
  736. struct Node *
  737. FindNode(struct List *list, int number)
  738. {
  739.    struct Node *node;
  740.    int    i;
  741.  
  742.    if (list->lh_TailPred == (struct Node *)list)
  743.        return(NULL);
  744.    else {
  745.        for (node = list->lh_Head, i=0; i<number ; node = node->ln_Succ, i++)
  746.            ;
  747.    return(node);
  748.    }
  749. }
  750.  
  751.  
  752. /*********************************************************************
  753. *   getFile(Prompt)
  754. *   
  755. *      gets a file using the ASL file requester & the prompt
  756. **********************************************************************/
  757.  
  758.  
  759. BPTR
  760. getFile(char *prompt,int type)
  761. {
  762.     struct FileRequester *fr;
  763.     static BYTE savefile[100] = "";
  764.     static BYTE savedir[255]  = "";
  765.     char doit[10];
  766.     ULONG fileflag;
  767.     long  mode;
  768.     BPTR  fh = -1L;
  769.  
  770.     if (type == OPEN)
  771.     { 
  772.        strcpy(doit,"OPEN");
  773.        fileflag = 0L;
  774.     }
  775.     else
  776.     {
  777.        strcpy(doit,"SAVE");
  778.        fileflag = FILF_SAVE;
  779.     }
  780.     
  781.     if (fr = (struct FileRequester *)
  782.          AllocAslRequestTags(ASL_FileRequest,
  783.              ASL_Hail,       (ULONG)prompt,
  784.              ASL_Height,     200,
  785.              ASL_Width,      320,
  786.              ASL_LeftEdge,   163,
  787.              ASL_TopEdge,    50,
  788.              ASL_OKText,     (ULONG)doit,
  789.              ASL_CancelText, (ULONG)"CANCEL",
  790.              ASL_Window,     window,
  791.              ASL_File,       savefile,
  792.              ASL_Dir,        savedir,
  793.              ASL_FuncFlags,  fileflag,
  794.              TAG_DONE))
  795.      {
  796.          if (AslRequest(fr,NULL))  
  797.          {
  798.              strcpy(savedir, fr->rf_Dir);
  799.              strcpy(savefile, fr->rf_File);
  800.  
  801.              /* setup filename and load it */             
  802.              strcpy(buffer,fr->rf_Dir);
  803.              if (AddPart(buffer,fr->rf_File,255))
  804.              {
  805.                 if (type == OPEN)
  806.                    mode = MODE_OLDFILE;
  807.                 else
  808.                    mode = MODE_NEWFILE;
  809.                 fh = Open(buffer,mode);
  810.                 strcpy(savefilename,buffer);
  811.                 sprintf(screenname,"%s    [FILE: %s]",title,fr->rf_File);
  812.                 ShowTitle(myscreen,TRUE);
  813.              }
  814.          }
  815.          else
  816.            fh = 0L;    /* CANCEL */
  817.          FreeAslRequest(fr);
  818.     }
  819.     return(fh);
  820. }
  821.  
  822.  
  823. /*********************************************************************
  824. *   Menu selection (NEW)
  825. *
  826. **********************************************************************/
  827.  
  828. VOID
  829. doNew(VOID)
  830. {
  831.    GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  832.        GTLV_Labels, ~0, TAG_DONE);
  833.    FreeNameNodes(GrocList);
  834.    FreeMem(GrocList, sizeof(struct List));
  835.    if (!(GrocList = AllocMem(sizeof(struct List),MEMF_CLEAR)))
  836.        cleanExit("No memory for Grocery list.");
  837.    NewList(GrocList);
  838.    GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  839.        GTLV_Labels, GrocList, TAG_DONE);
  840. }
  841.  
  842.  
  843. /*********************************************************************
  844. *   Menu selection (OPEN)
  845. *
  846. **********************************************************************/
  847.  
  848. VOID
  849. doOpen(VOID)
  850. {
  851.    BPTR   pfile;
  852.    char   *pointer;
  853.    char   *item, *amount, *size;
  854.    long   place = 0L;
  855.     
  856.    if (-1 == (pfile = getFile("Select Save Open:",OPEN)))
  857.    {
  858.        sprintf(buf,"Couldn't open file '%s'.",buffer);
  859.        EasyRequest(window, &myES, NULL, buf);
  860.    }
  861.    
  862.    doNew();
  863.  
  864.    GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  865.             GTLV_Labels, ~0, TAG_DONE);   
  866.  
  867.    while (FGets(pfile,buffer,255) != NULL)
  868.    {
  869.        pointer   =strrchr(buffer,'`');
  870.        pointer[0]='\0';
  871.        place     = atol(&pointer[1]);
  872.        pointer   =strrchr(buffer,'`');
  873.        pointer[0]='\0';
  874.        size      = &pointer[1];
  875.        pointer   =strrchr(buffer,'`');
  876.        pointer[0]='\0';
  877.        amount    = &pointer[1];
  878.        item      = buffer;
  879.        AddItem(GrocList,item,amount,size,aisleId[place]);
  880.    }
  881.    GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  882.             GTLV_Labels, GrocList, TAG_DONE);
  883.    
  884.    Close(pfile);
  885. }          
  886.  
  887. /*********************************************************************
  888. *   Menu selection (SAVE & SAVE AS)
  889. *
  890. **********************************************************************/
  891.  
  892. VOID
  893. doSave(VOID)
  894. {
  895.    BPTR   pfile;
  896.    struct NameNode *node;
  897.    int    i;
  898.  
  899.    if (GrocList->lh_TailPred == (struct Node *)GrocList)
  900.        return;  /* empty list */
  901.  
  902.    if (savefilename[0] == '\0')
  903.    {
  904.        pfile = getFile("Select Save File:",SAVE);
  905.        if (pfile == -1 )
  906.        {
  907.            sprintf(buf,"Couldn't open file '%s'\nIt may already exist.",buffer);
  908.            EasyRequest(window, &myES, NULL, buf);
  909.        }
  910.            
  911.        if (pfile == 0 )
  912.            return;
  913.    }
  914.    else
  915.    {
  916.        DeleteFile(savefilename);
  917.        if (-1 == (pfile = Open(savefilename,MODE_NEWFILE)))
  918.        {
  919.          sprintf(buffer,"Couldn't open file '%s'.",savefilename);
  920.          EasyRequest(window, &myES, NULL, buffer);
  921.        }
  922.    }
  923.    
  924.    if (pfile == -1) return;
  925.    
  926.    for (node=(struct NameNode *)GrocList->lh_Head ; 
  927.           node->nn_Node.ln_Succ ; 
  928.           node = (struct NameNode *)node->nn_Node.ln_Succ)
  929.    {   
  930.        for (i = 0; i < 30; i++)
  931.            if (aisleId[i] == node->nn_Aisle)
  932.                break;
  933.                
  934.        sprintf(buffer, "%s`%s`%s`%d\n", node->nn_Item, node->nn_Amount,
  935.             node->nn_Size, i);
  936.             
  937.        if (-1 == Write(pfile, buffer, strlen(buffer)))
  938.        {
  939.            EasyRequest(window, &myES, NULL, "Save File Failed.");
  940.            break;
  941.        }
  942.    }
  943.    strcpy(buf,screenname);
  944.    sprintf(screenname,"Saved to file: %s",savefilename);
  945.    ShowTitle(myscreen,TRUE);
  946.    strcpy(screenname,buf);
  947.        
  948.    Close(pfile);
  949. }
  950.  
  951.  
  952. /*********************************************************************
  953. *   Sort List 
  954. *               doSort(ID)   ID= MYGAD_SORT  or MYGAD_SORTNAME
  955. **********************************************************************/
  956.  
  957. VOID
  958. doSort(int ID)
  959. {
  960. struct NameNode *node, *nextnode;
  961. struct List *list;
  962.  
  963.       if (GrocList->lh_TailPred == (struct Node *)GrocList)
  964.           return;  /* empty list */
  965.       if (!(list = AllocMem(sizeof(struct List),MEMF_CLEAR)))
  966.           cleanExit("No memory for list.");
  967.       NewList(list);
  968.       GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  969.               GTLV_Labels, ~0, TAG_DONE);
  970.       
  971.       for (nextnode=node=(struct NameNode *)GrocList->lh_Head ; 
  972.              nextnode->nn_Node.ln_Succ ; node = nextnode)
  973.       {
  974.           nextnode = (struct NameNode *)node->nn_Node.ln_Succ;
  975.           Remove((struct Node *)node);
  976.           if (ID == MYGAD_SORT)
  977.               node->nn_Node.ln_Pri = 40-node->nn_Aisle;
  978.           else
  979.               node->nn_Node.ln_Pri = 0;
  980.           alphaEnqueue(list,(struct Node *)node);
  981.       }
  982.       FreeMem(GrocList, sizeof(struct List));
  983.       GrocList = list;
  984.       GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  985.               GTLV_Labels, GrocList, TAG_DONE);
  986.       currentGroc = NOITEM;
  987.       ActivateGadget(mygad[MYGAD_ITEM],window,NULL);
  988. }
  989.  
  990.  
  991. /*********************************************************************
  992. *   Menu selection (PRINT)
  993. *
  994. **********************************************************************/
  995.  
  996. VOID
  997. doPrint(VOID)
  998. {
  999.    BPTR   pfile;
  1000.    struct NameNode *node;
  1001.    char   line[70];
  1002.  
  1003.    doSort(MYGAD_SORT);
  1004.    
  1005.    if (GrocList->lh_TailPred == (struct Node *)GrocList)
  1006.        return;  /* empty list */
  1007.    
  1008.    if (!(pfile = Open( "PRT:", MODE_NEWFILE)))
  1009.        EasyRequest(window, &myES, NULL, "Could not access printer.");
  1010.    
  1011.    Write(pfile, "zw", 8L);    
  1012.    for (node=(struct NameNode *)GrocList->lh_Head;
  1013.         node->nn_Node.ln_Succ ; 
  1014.         node = (struct NameNode *)node->nn_Node.ln_Succ)
  1015.    {
  1016.        if (node->nn_Aisle == ((struct NameNode *)node->nn_Node.ln_Succ)->nn_Aisle)
  1017.            strcpy(line,"");
  1018.        else
  1019.            strcpy(line,"");
  1020.        
  1021.        sprintf(buffer,
  1022.            "%s%10.10s %-30.30s %-10.10s %-21.21s\n",
  1023.            line,node->nn_Amount, node->nn_Item,
  1024.            node->nn_Size, aislename[node->nn_Aisle]);
  1025.        if (-1 == Write(pfile, buffer, strlen(buffer)))
  1026.        {
  1027.            EasyRequest(window, &myES, NULL, "Printing Failed.");
  1028.            break;
  1029.        }
  1030.    }
  1031.    Write(pfile,"zw",8L);
  1032.    Close(pfile);
  1033. } 
  1034.  
  1035.  
  1036. /*********************************************************************
  1037. *   node = findBestFit(string)
  1038. *
  1039. *      finds the item whose name best fist the string.
  1040. **********************************************************************/
  1041.  
  1042. struct NameNode *
  1043. findBestFit(char *namestring)
  1044. {
  1045.    struct NameNode *node;
  1046.    int    i = 0;
  1047.    
  1048.    for (node=(struct NameNode *)ItemList->lh_Head ; 
  1049.            node->nn_Node.ln_Succ, Stricmp(node->nn_Item,namestring)<0; 
  1050.            node = (struct NameNode *)node->nn_Node.ln_Succ, i++);
  1051.    node->nn_ListPos = i;
  1052.    return(node);
  1053. }
  1054.  
  1055.  
  1056. /*********************************************************************
  1057. *   getItem(node)
  1058. *
  1059. *      gets the info from the item and loads item,amount,size,location 
  1060. *          requesters
  1061. **********************************************************************/
  1062.  
  1063. VOID
  1064. getItem(struct NameNode *node)
  1065. {
  1066.    GT_SetGadgetAttrs(mygad[MYGAD_ITEM],window,NULL,
  1067.            GTST_String, node->nn_Item, TAG_DONE);
  1068.    GT_SetGadgetAttrs(mygad[MYGAD_AMOUNT],window,NULL,
  1069.            GTST_String, node->nn_Amount, TAG_DONE);
  1070.    GT_SetGadgetAttrs(mygad[MYGAD_SIZE],window,NULL,
  1071.            GTST_String, node->nn_Size, TAG_DONE);
  1072.    GT_SetGadgetAttrs(mygad[MYGAD_AISLE],window,NULL,
  1073.            GTLV_Selected, node->nn_Aisle, TAG_DONE);
  1074. /* turning this on will cause the item list to move the
  1075.    clicked on selection to the top each time.           
  1076.    GT_SetGadgetAttrs(mygad[MYGAD_ILIST],window,NULL,
  1077.            GTLV_Top, node->nn_ListPos, TAG_DONE);      
  1078. */
  1079.    ActivateGadget(mygad[MYGAD_AMOUNT],window,NULL);
  1080.    currentAisle = node->nn_Aisle;
  1081. }
  1082.  
  1083.  
  1084.  
  1085.  
  1086. /*********************************************************************
  1087. *   MEALS -> CREATE MEAL  menu option
  1088. *
  1089. **********************************************************************/
  1090.  
  1091.  
  1092. VOID 
  1093. newMeal(VOID)
  1094. {
  1095.    FILE   *fileptr = NULL;      /* a pointer to a file handle */
  1096.    FILE   *tempptr = NULL;
  1097.    struct List *list;
  1098.    struct NameNode *node;
  1099.    int i;
  1100.  
  1101.    struct EasyStruct yesno = {
  1102.        sizeof(struct EasyStruct), 0, "GroceryList",
  1103.        "%s",
  1104.        "OK|CANCEL",    
  1105.        };
  1106.  
  1107.    if (GrocList->lh_TailPred == (struct Node *)GrocList)
  1108.    {
  1109.        EasyRequest(window, &myES, NULL, "Grocery List empty.\nTo use this option, fill the grocery list with the\nitems in the meal and put the meal name\nin the ITEM box.  Then select CREATE MEAL");
  1110.        return;  /* empty list */
  1111.    }
  1112.  
  1113.    if (strlen(((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer) < 1)
  1114.    {
  1115.        EasyRequest(window, &myES, NULL, "Item Field empty.\nTo use this option, fill the grocery list with the\nitems in the meal and put the meal name\nin the ITEM box.  Then select CREATE MEAL");
  1116.        return;  /* empty list */
  1117.    }
  1118.  
  1119.    sprintf(buffer,"Copy current list to a meal item\ncalled %s?",
  1120.        ((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer);
  1121.    if (0L == EasyRequest(window, &yesno, NULL, buffer))
  1122.        return;
  1123.  
  1124.    /* OPEN FILES */
  1125.    fileptr = fopen(DATAFILE,"r");
  1126.    if ( fileptr == NULL )
  1127.        cleanExit("Couldn't open data file.");
  1128.    tempptr = fopen(TEMPFILE,"w");
  1129.    if ( tempptr == NULL )
  1130.    {
  1131.        fclose(fileptr);
  1132.        fileptr = 0L;
  1133.        remove(TEMPFILE);
  1134.        EasyRequest(window, &myES, NULL, "Couldn't open temporary file.");
  1135.        return;
  1136.    }
  1137.    
  1138.    /* COPY THE DATA FILE UP TO THE END OF THE MEALS SECTION */
  1139.    while ((fgets(buffer,255,fileptr) != NULL) && (strncmp(buffer,"EXIT!",5) != 0))
  1140.    {
  1141.        fputs(buffer,tempptr);
  1142.    }
  1143.  
  1144.    /* END OF MEALS SECTION NOT FOUND !!!!!  WE HAVE A PROBLEM */
  1145.    if (strncmp(buffer,"EXIT!",5) != 0)
  1146.    {
  1147.        fclose(fileptr);
  1148.        fclose(tempptr);
  1149.        fileptr = 0L;
  1150.        tempptr = 0L;
  1151.        remove(TEMPFILE);
  1152.        EasyRequest(window, &myES, NULL, 
  1153.            "Error reading data file.  EXIT! line not found");
  1154.        return;
  1155.    }
  1156.   
  1157.    /* OKAY, LETS ADD THE MEAL */
  1158.    /* ADD MEAL NAME */   
  1159.    fputs(((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer,tempptr);
  1160.    fputc('\n',tempptr);
  1161.    GT_SetGadgetAttrs(mygad[MYGAD_MEALS],window,NULL,
  1162.             GTLV_Labels, ~0, TAG_DONE);
  1163.  
  1164.    list = AddMeal(MealList,strcat(((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer,
  1165.        strnset(buffer,' ',29-strlen(((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer))));
  1166.    
  1167.    /* NOW ADD THE ITEMS */
  1168.    for (node=(struct NameNode *)GrocList->lh_Head;
  1169.         node->nn_Node.ln_Succ ; 
  1170.         node = (struct NameNode *)node->nn_Node.ln_Succ)
  1171.    {
  1172.        for (i=0;i<31;i++)
  1173.            if (aisleId[i] == node->nn_Aisle)
  1174.                break;
  1175.        if (1 > fprintf(tempptr,
  1176.            "%s`%s`%s`%d\n",
  1177.            node->nn_Item,node->nn_Amount,
  1178.            node->nn_Size, i))
  1179.        {
  1180.            fclose(tempptr);
  1181.            fclose(fileptr);
  1182.            tempptr = 0L;
  1183.            fileptr = 0L;
  1184.            remove(TEMPFILE);
  1185.            EasyRequest(window, &myES, NULL, "Couldn't write to temp file.");
  1186.            return;
  1187.        }
  1188.        AddName(list,node->nn_Item,node->nn_Amount,node->nn_Size,
  1189.        node->nn_Aisle);
  1190.    }
  1191.    
  1192.    /* NOW COPY THE REST OF THE DATA */
  1193.    GT_SetGadgetAttrs(mygad[MYGAD_MEALS],window,NULL,
  1194.             GTLV_Labels, MealList, TAG_DONE);
  1195.  
  1196.    fputc('\n',tempptr);
  1197.    fputs("EXIT!\n",tempptr);
  1198.     while (fgets(buffer,255,fileptr) != NULL)
  1199.    {
  1200.        fputs(buffer,tempptr);
  1201.    }
  1202.  
  1203.    /* CLEAN UP FILES */
  1204.    fclose(fileptr);
  1205.    fileptr=0L;
  1206.    fclose(tempptr);
  1207.    tempptr=0L;
  1208.    remove(BACKFILE);
  1209.    rename(DATAFILE, BACKFILE);
  1210.    sprintf(buffer,"copy %s %s \012delete >nil: %s",TEMPFILE, DATAFILE, TEMPFILE);
  1211.    Execute(buffer,0L,0L);
  1212.  
  1213. }
  1214.  
  1215.  
  1216.  
  1217. /*********************************************************************
  1218. *   handle_window_events()
  1219. *
  1220. **********************************************************************/
  1221.  
  1222.  
  1223. VOID 
  1224. handle_window_events(VOID)
  1225. {
  1226. struct IntuiMessage *msg;
  1227. SHORT done;
  1228. UWORD menuNumber;
  1229. UWORD menuNum;
  1230. UWORD itemNum;
  1231. UWORD subNum;
  1232. WORD   mousex, mousey;
  1233. ULONG  class;
  1234. USHORT code;
  1235. struct MenuItem *item;
  1236. char   buffer[60];
  1237. struct MealNode *mnode;
  1238. struct NameNode *node, *nextnode;
  1239. struct List *list;
  1240. struct Gadget *gad;
  1241. char   *items, *amounts, *sizes;
  1242. BPTR   pfile;
  1243. int    i;
  1244.  
  1245. done = FALSE;
  1246. while (FALSE == done)
  1247.     {
  1248.     /* we only have one signal bit, so we do not have to check which
  1249.     ** bit broke the Wait().
  1250.     */
  1251.     Wait(1L << window->UserPort->mp_SigBit);
  1252.  
  1253.     while ( (FALSE == done) &&
  1254.             (NULL != (msg = (struct IntuiMessage *)GT_GetIMsg(window->UserPort))))
  1255.     {
  1256.         class = msg->Class;
  1257.         code  = msg->Code;
  1258.         mousex= msg->MouseX;
  1259.         mousey= msg->MouseY;
  1260.         gad   = (struct Gadget *)msg->IAddress; /*not valid for non-gadget event*/
  1261.         
  1262.         GT_ReplyIMsg(msg);
  1263.         
  1264.         switch (class)
  1265.             {
  1266.             case IDCMP_MENUPICK:
  1267.                 menuNumber = code;
  1268.                 while (menuNumber != MENUNULL) 
  1269.                     {
  1270.                     item = ItemAddress(menuStrip, menuNumber);
  1271.  
  1272.                     /* process the item here! */
  1273.                     menuNum = MENUNUM(menuNumber);
  1274.                     itemNum = ITEMNUM(menuNumber);
  1275.                     subNum  = SUBNUM(menuNumber);
  1276.  
  1277.                     /* stop if quit is selected. */
  1278.                     switch ( menuNum )
  1279.                     {
  1280.                        case 0:         /*** PROJECT ***/
  1281.                           switch ( itemNum )
  1282.                           {
  1283.                              case 0:   /* NEW */
  1284.                                  doNew();
  1285.                                  break;
  1286.                                  
  1287.                              case 1:   /* OPEN... */
  1288.                                  doOpen();
  1289.                                  break;
  1290.                              
  1291.                              case 4:   /* SAVE AS ... */
  1292.                                  savefilename[0] = '\0';    
  1293.                              case 3:   /* SAVE */
  1294.                                  doSave();
  1295.                                  break;
  1296.                              
  1297.                              case 6:   /* PRINT */
  1298.                                  doPrint();
  1299.                                  break;
  1300.                              
  1301.                              case 8:   /* ABOUT */
  1302.                                  sprintf(buffer,"%s\nBrian Gragg  Oct 1993 ",&vers[7]);
  1303.                                  EasyRequest(window, &myES, NULL,buffer);
  1304.                                  break;
  1305.                                  
  1306.                              case 10:   /* QUIT */
  1307.                                  done = TRUE;
  1308.                                  break;
  1309.                           }
  1310.                           break;
  1311.                           
  1312.                        case 1:        /*** MEALS ***/
  1313.                          switch (itemNum )
  1314.                          {
  1315.                            case 0:    /* CREATE MEAL */
  1316.                                newMeal();
  1317.                                break;
  1318.                          }
  1319.                           
  1320.                        case 2:        /*** OPTIONS ***/
  1321.                          switch (itemNum )
  1322.                          {
  1323.                            case 0:    /* SCROLLING LIST */
  1324.                                break;
  1325.                          }
  1326.                     }           
  1327.                                
  1328.                     menuNumber = item->NextSelect;
  1329.                     }
  1330.                 break;
  1331.             
  1332.             case IDCMP_GADGETUP:
  1333.                switch (gad->GadgetID)
  1334.                {
  1335.                    case MYGAD_MEALS:
  1336.                        GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  1337.                                GTLV_Labels, ~0, TAG_DONE);
  1338.                        if ((mnode = (struct MealNode *)FindNode(MealList,code))==NULL)
  1339.                            break;    /* not a valid mnode */
  1340.                        list = mnode->nn_MealItem;
  1341.                        if (list->lh_TailPred == (struct Node *)list)
  1342.                            break;  /* empty list */
  1343.                        for (node=(struct NameNode *)list->lh_Head ; 
  1344.                               node->nn_Node.ln_Succ ; 
  1345.                               node = (struct NameNode *)node->nn_Node.ln_Succ)
  1346.                            AddItem(GrocList,node->nn_Item,node->nn_Amount,
  1347.                                            node->nn_Size,node->nn_Aisle);
  1348.                        GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  1349.                                GTLV_Labels, GrocList, TAG_DONE);
  1350.                        currentGroc = NOITEM;
  1351.                        ActivateGadget(mygad[MYGAD_ITEM],window,NULL);
  1352.                        break;
  1353.                         
  1354.                    case MYGAD_ILIST:
  1355.                        if (NULL == 
  1356.                          (node = (struct NameNode *)FindNode(ItemList,code)))
  1357.                            break;    /* not a valid node */
  1358.                        node->nn_ListPos = code;
  1359.                        getItem(node);
  1360.                        break;
  1361.                        
  1362.                    case MYGAD_ITEM:
  1363.                        if (code == 0x5F)   /* HELP key */
  1364.                        {
  1365.                            node = findBestFit(((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer);
  1366.                            if (node != NULL) 
  1367.                            {
  1368.                                getItem(node);
  1369.                                GT_SetGadgetAttrs(mygad[MYGAD_ILIST],window,NULL,
  1370.                                           GTLV_Top, node->nn_ListPos, TAG_DONE);      
  1371.                            }
  1372.                            break;
  1373.                        }
  1374.                    case MYGAD_AMOUNT:
  1375.                    case MYGAD_SIZE:
  1376.                        if (code == 9) break;  /* ignore tab key */
  1377.                        items = ((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer;
  1378.                        amounts = ((struct StringInfo *)mygad[MYGAD_AMOUNT]->SpecialInfo)->Buffer;
  1379.                        sizes = ((struct StringInfo *)mygad[MYGAD_SIZE]->SpecialInfo)->Buffer;
  1380.  
  1381.                        if ((strlen(items) < 3) || (strlen(amounts) < 0) ||
  1382.                            (strlen(sizes) < 1) || (currentAisle == NOITEM))
  1383.                        {
  1384.                            DisplayBeep(myscreen);
  1385.                            break;
  1386.                        }
  1387.                            
  1388.                        GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  1389.                                GTLV_Labels, ~0, TAG_DONE);
  1390.                        AddItem(GrocList, items, amounts, sizes, currentAisle);
  1391.                           
  1392.                        GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  1393.                                GTLV_Labels, GrocList, TAG_DONE);
  1394.                        currentGroc = NOITEM;
  1395.                        /* now clear the string gadgets */
  1396.                        GT_SetGadgetAttrs(mygad[MYGAD_ITEM],window,NULL,
  1397.                                GTST_String, "", TAG_DONE);
  1398.                        GT_SetGadgetAttrs(mygad[MYGAD_AMOUNT],window,NULL,
  1399.                                GTST_String, "", TAG_DONE);
  1400.                        GT_SetGadgetAttrs(mygad[MYGAD_SIZE],window,NULL,
  1401.                                GTST_String, "", TAG_DONE);
  1402.                        GT_SetGadgetAttrs(mygad[MYGAD_AISLE],window,NULL,
  1403.                                GTLV_Selected, NOITEM, TAG_DONE);
  1404.                        ActivateGadget(mygad[MYGAD_ITEM],window,NULL);
  1405.                        currentAisle = NOITEM;
  1406.                        break;
  1407.                        
  1408.                    case MYGAD_AISLE:
  1409.                        currentAisle = code;
  1410.                        ActivateGadget(mygad[MYGAD_AMOUNT],window,NULL);
  1411.                        break;
  1412.                        
  1413.                    case MYGAD_EDIT:
  1414.                        if (NULL == 
  1415.                          (node = (struct NameNode *)FindNode(GrocList,currentGroc)))
  1416.                            break;    /* not a valid node */
  1417.                        GT_SetGadgetAttrs(mygad[MYGAD_ITEM],window,NULL,
  1418.                                GTST_String, node->nn_Item, TAG_DONE);
  1419.                        GT_SetGadgetAttrs(mygad[MYGAD_AMOUNT],window,NULL,
  1420.                                GTST_String, node->nn_Amount, TAG_DONE);
  1421.                        GT_SetGadgetAttrs(mygad[MYGAD_SIZE],window,NULL,
  1422.                                GTST_String, node->nn_Size, TAG_DONE);
  1423.                        GT_SetGadgetAttrs(mygad[MYGAD_AISLE],window,NULL,
  1424.                                GTLV_Selected, node->nn_Aisle, TAG_DONE);
  1425.                        ActivateGadget(mygad[MYGAD_AMOUNT],window,NULL);
  1426.                        currentAisle = node->nn_Aisle;
  1427.                    case MYGAD_DELETE:
  1428.                        if (NULL == 
  1429.                           (node = (struct NameNode *)FindNode(GrocList,currentGroc)))
  1430.                            break;    /* not a valid node */
  1431.                        GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  1432.                                GTLV_Labels, ~0, TAG_DONE);
  1433.                        Remove((struct Node *)node);
  1434.                        GT_SetGadgetAttrs(mygad[MYGAD_GLIST],window,NULL,
  1435.                                GTLV_Labels, GrocList, TAG_DONE);
  1436.                        FreeMem(node,sizeof(struct NameNode));
  1437.                        currentGroc = NOITEM;
  1438.                        ActivateGadget(mygad[MYGAD_ITEM],window,NULL);
  1439.                        break;
  1440.   
  1441.                    case MYGAD_GLIST:
  1442.                        currentGroc = code;
  1443.                        ActivateGadget(mygad[MYGAD_ITEM],window,NULL);
  1444.                        break;
  1445.                        
  1446.                    case MYGAD_SORT:
  1447.                    case MYGAD_SORTNAME:
  1448.                        doSort((int)gad->GadgetID);
  1449.                        break;
  1450.                    
  1451.                    case MYGAD_ADD:
  1452.                        items = ((struct StringInfo *)mygad[MYGAD_ITEM]->SpecialInfo)->Buffer;
  1453.                        amounts = ((struct StringInfo *)mygad[MYGAD_AMOUNT]->SpecialInfo)->Buffer;
  1454.                        sizes = ((struct StringInfo *)mygad[MYGAD_SIZE]->SpecialInfo)->Buffer;
  1455.  
  1456.                        if ((strlen(items) < 3) || (strlen(amounts) < 1) ||
  1457.                            (strlen(sizes) < 1) || (currentAisle == NOITEM))
  1458.                        {
  1459.                            DisplayBeep(myscreen);  /* bad data */
  1460.                            break;
  1461.                        }
  1462.                        
  1463.                        /* Save the new item to the DATAFILE */
  1464.                        
  1465.                        if (!(pfile = Open(DATAFILE,MODE_OLDFILE)))
  1466.                        {
  1467.                            EasyRequest(window, &myES, NULL, "Couldn't open data file");
  1468.                            break;
  1469.                        }
  1470.                        
  1471.                        Seek(pfile,0,OFFSET_END);
  1472.                        for (i = 0; i < 30; i++)
  1473.                            if (aisleId[i] == currentAisle)
  1474.                                break;
  1475.                        sprintf(buffer, "%s`%s`%s`%d\n", items, amounts,
  1476.                                    sizes, i);
  1477.                        Write(pfile, buffer, strlen(buffer));
  1478.                        Close(pfile);
  1479.                        
  1480.                        /* Update the Item List */
  1481.                        GT_SetGadgetAttrs(mygad[MYGAD_ILIST],window,NULL,
  1482.                                GTLV_Labels, ~0, TAG_DONE);
  1483.                        
  1484.                        AddName(ItemList, items, amounts, sizes, currentAisle);
  1485.                           
  1486.                        GT_SetGadgetAttrs(mygad[MYGAD_ILIST],window,NULL,
  1487.                                GTLV_Labels, ItemList, TAG_DONE);
  1488.                        ActivateGadget(mygad[MYGAD_AMOUNT],window,NULL);
  1489.                        break;
  1490.                        
  1491.                    default:
  1492.                        break;
  1493.                }
  1494.             case IDCMP_REFRESHWINDOW:
  1495.                GT_BeginRefresh(window);
  1496.                GT_EndRefresh(window, TRUE);
  1497.                break;
  1498.    
  1499.             default:
  1500.                break;
  1501.                
  1502.             }
  1503.         }
  1504.     }
  1505. }
  1506.  
  1507.