home *** CD-ROM | disk | FTP | other *** search
/ Amiga Times / AmigaTimes.iso / sonstiges / tools / amiCheck / Source / dataBase.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-10-06  |  84.1 KB  |  3,644 lines
  1. /************************************************
  2. * dataBase.c
  3. *
  4. *       This library keeps track of the register
  5. *       items.  It also calls regGadget to
  6. *       update the display accordingly.
  7. *
  8. ************************************************/
  9. #include <exec/types.h>
  10. #include <exec/lists.h>
  11. #include <exec/nodes.h>
  12. #include <exec/memory.h>
  13.  
  14. #include <clib/intuition_protos.h>
  15. #include <clib/dos_protos.h>
  16. #include <clib/icon_protos.h>
  17. #include <intuition/sghooks.h>
  18. #include <intuition/gadgetclass.h>
  19. #include <clib/alib_protos.h>
  20. #include <clib/exec_protos.h>
  21. #include <string.h>
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <time.h>
  25. #include <fcntl.h>
  26.  
  27. #include "regGadget.h"
  28. #include "amiCheck.h"
  29. #include "dataBase.h"
  30. #include "qdatePanel.h"
  31. #include "memoPanel.h"
  32. #include "namePanel.h"
  33. #include "amntPanel.h"
  34. #include "dataBaseFile.h"
  35.  
  36.  
  37. extern STRPTR demoptr;
  38.  
  39. /* globals and special structures */
  40. struct MinList  entries, filtered;
  41. struct List templates,testtemps, memolist, datelist, namelist, amntlist;
  42. struct List categories, sortfields, grouplist;
  43.  
  44. accntState     usrAccount;
  45. sortState     sortStates;
  46.  
  47. UWORD decimalModulos[] = {
  48.     1,
  49.     10,
  50.     100,
  51.     1000,
  52.     10000,
  53. };
  54.  
  55. char *decimalFormat[] = {
  56.     "%u",
  57.     "%u.%01u",
  58.     "%u.%02u",
  59.     "%u.%03u",
  60.     "%u.%04u",
  61. };
  62.  
  63. arexxNode arexxMacros[MAXMACROS] = 
  64. {
  65. {"UUUUUUUUUUUUUUUUUUUU",""},
  66. {"UUUUUUUUUUUUUUUUUUUU",""},
  67. {"UUUUUUUUUUUUUUUUUUUU",""},
  68. {"UUUUUUUUUUUUUUUUUUUU",""},
  69. {"UUUUUUUUUUUUUUUUUUUU",""},
  70. {"UUUUUUUUUUUUUUUUUUUU",""},
  71. {"UUUUUUUUUUUUUUUUUUUU",""},
  72. {"UUUUUUUUUUUUUUUUUUUU",""},
  73. {"UUUUUUUUUUUUUUUUUUUU",""},
  74. {"UUUUUUUUUUUUUUUUUUUU",""},
  75.  
  76. #if 0
  77. {"MMMMMMMMMMMMMMMMMMMM",""},
  78. {"MMMMMMMMMMMMMMMMMMMM",""},
  79. {"MMMMMMMMMMMMMMMMMMMM",""},
  80. {"MMMMMMMMMMMMMMMMMMMM",""},
  81. {"MMMMMMMMMMMMMMMMMMMM",""},
  82. {"MMMMMMMMMMMMMMMMMMMM",""},
  83. {"MMMMMMMMMMMMMMMMMMMM",""},
  84. {"MMMMMMMMMMMMMMMMMMMM",""},
  85. {"MMMMMMMMMMMMMMMMMMMM",""},
  86. #endif
  87. };
  88.  
  89. BOOL  amiChangedItems;
  90. UWORD entryCount;
  91. UWORD currCheckNumber;
  92. dateType currDate;
  93. UWORD currCentury;
  94. UWORD dateFormat = DATE_MMDDYY;
  95.  
  96. struct stateVars amntState;
  97. balanceType filtAmnt;
  98.  
  99. sortNode sortEntries[SORTENTRIES];
  100.  
  101. struct TagItem strAmntTags[] =
  102. {
  103.     /*{STRINGA_ExitHelp,TRUE},*/
  104.     /*{STRINGA_Justification, STRINGRIGHT},*/
  105.     {GTST_MaxChars,AMNTSIZE},
  106.     {TAG_DONE},
  107. };
  108.  
  109. struct TagItem strDateTags[] =
  110. {
  111.     /*{STRINGA_ExitHelp,TRUE},*/
  112.     {GTST_MaxChars,DATESIZE},
  113.     {TAG_DONE},
  114. };
  115.  
  116. struct TagItem strNameTags[] =
  117. {
  118.     /*{STRINGA_ExitHelp,TRUE},*/
  119.     {GTST_MaxChars,STRINGSIZE},
  120.     {TAG_DONE},
  121. };
  122.  
  123. struct TagItem strMemoTags[] =
  124. {
  125.     /*{STRINGA_ExitHelp,TRUE},*/
  126.     {GTST_MaxChars,STRINGSIZE},
  127.     {TAG_DONE},
  128. };
  129.  
  130. struct TagItem strTempTags[] =
  131. {
  132.     /*{STRINGA_ExitHelp,TRUE},*/
  133.     {GTST_MaxChars,TEMPNAMESIZE},
  134.     {TAG_DONE},
  135. };
  136.  
  137. struct TagItem strCatTags[] =
  138. {
  139.     /*{STRINGA_ExitHelp,TRUE},*/
  140.     {GTST_MaxChars,CATNAMESIZE},
  141.     {TAG_DONE},
  142. };
  143.  
  144. struct TagItem strCheckTags[] =
  145. {
  146.     /*{STRINGA_ExitHelp,TRUE},*/
  147.     {GTIN_Number, 1},
  148.     {GTIN_MaxChars,6},
  149.     {TAG_DONE},
  150. };
  151.  
  152. struct TagItem TxtBorder[] = 
  153. {
  154.     {GTTX_Border, TRUE},
  155.     {GTTX_Text, ""},
  156.     {TAG_DONE},
  157. };
  158.  
  159. struct TagItem TxtNoBorder[] = 
  160. {
  161.     {GTTX_Border, FALSE},
  162.     {GTTX_Text, ""},
  163.     {TAG_DONE},
  164. };
  165.  
  166.  
  167. struct TagItem TxtZero[] =
  168. {
  169.     {GTTX_Border, TRUE},
  170.     {GTTX_Text,"     "},
  171.     {STRINGA_Justification, STRINGRIGHT},
  172.     {TAG_DONE},
  173. };
  174.  
  175. struct TagItem TxtInt[] =
  176. {
  177.     {GTIN_Number, 0},
  178.     {GTIN_MaxChars,6},
  179.     {TAG_DONE},
  180. };
  181.  
  182. struct TagItem NumBorder[] =
  183. {
  184.     {GTNM_Border, TRUE},
  185.     {TAG_DONE},
  186. };
  187.  
  188. struct TagItem ListView[] =
  189. {
  190.         {GTLV_ShowSelected, NULL},
  191.         {TAG_DONE},
  192. };
  193.  
  194. struct TagItem MiscButton[] =
  195. {
  196.         {ALT_Image, ALTI_GetMisc},
  197.         {TAG_DONE},
  198. };
  199.  
  200.  
  201. printControl checkPrint =
  202. {
  203.     5000,TRUE,TRUE,1,0,
  204. };
  205.  
  206. STRPTR fptlabels[] =
  207. {
  208.         "080935cour12",
  209.     "081004cour10",
  210.     "081013cour10",
  211.        "081064cour10",
  212.     "081065cour10",
  213.     "081098cour10",
  214.     "081123cour10",
  215.  
  216.     "091098cour10",
  217.      "091064cour10", 
  218.     "090935cour12",
  219.     "Last Used",
  220.     NULL,
  221. };
  222.  
  223. formControl checkForms = 
  224. {
  225.  "PRT:",
  226.  
  227.     /* 080935 cour p12*/
  228.     {    TRUE,        /* sheet feed */
  229.         17,3,         /* lines/check, checks/page */
  230.         36, 35, 4,    /* pay field m/w/l */
  231.         82,11,4,     /* Date field m/w/l */
  232.         82,10,5,    /* Amount field m/w/l */
  233.         30,38,13,    /* Memo field m/w/l */
  234.         1,3,27,        /* Voucher type, m/w */
  235.         30,60,6,     /* String field m/w/l */
  236.         3,        /* lines to skip */
  237.             120             /* cols/page */       
  238.     },
  239.  
  240.  {
  241.     /* 080935 cour p12*/
  242.     {    TRUE,        /* sheet feed */
  243.         17,3,         /* lines/check, checks/page */
  244.         36, 35, 4,    /* pay field m/w/l */
  245.         82,11,4,     /* Date field m/w/l */
  246.         82,10,5,    /* Amount field m/w/l */
  247.         30,38,13,    /* Memo field m/w/l */
  248.         1,3,27,        /* Voucher type, m/w */
  249.         30,60,6,     /* String field m/w/l */
  250.         3,        /* lines to skip */
  251.             120             /* cols/page */       
  252.     },
  253.  
  254.   
  255.     /* 081004 cour p10*/
  256.     {    TRUE,        /* sheet feed */
  257.         21,1,         /* lines/check, checks/page */
  258.         5, 55, 12,    /* pay field m/w/l */
  259.         49,11,10,     /* Date field m/w/l */
  260.         66,9,10,    /* Amount field m/w/l */
  261.         2,40,17,    /* Memo field m/w/l */
  262.         3,0,0,        /* Voucher type, m/w */
  263.         7,65,7,     /* String field m/w/l */
  264.         3,        /* lines to skip */
  265.             80              /* cols/page */
  266.     },
  267.  
  268.     /* 081013 cour p10*/
  269.     {    TRUE,        /* sheet feed */
  270.         21,1,         /* lines/check, checks/page */
  271.         5, 45, 13,    /* pay field m/w/l */
  272.         50,11,7,     /* Date field m/w/l */
  273.         67,9,7,        /* Amount field m/w/l */
  274.         1,40,17,    /* Memo field m/w/l */
  275.         2,0,0,        /* Voucher type, m/w */
  276.         5,70,10,     /* String field m/w/l */
  277.         3,        /* lines to skip */
  278.             80              /* cols/page */
  279.  
  280.     },
  281.  
  282.       
  283.     /* 081064 cour p10*/
  284.     {    TRUE,        /* sheet feed */
  285.         21,1,         /* lines/check, checks/page */
  286.         8, 55, 8,    /* pay field m/w/l */
  287.         66,11,6,     /* Date field m/w/l */
  288.         66,9,8,        /* Amount field m/w/l */
  289.         6,35,16,    /* Memo field m/w/l */
  290.         3,0,0,        /* Voucher type, m/w */
  291.         1,70,10,     /* String field m/w/l */
  292.         3,        /* lines to skip */
  293.             80              /* cols/page */
  294.     },
  295.  
  296.     /* 081065 cour p10*/
  297.     {    TRUE,        /* sheet feed */
  298.         21,1,         /* lines/check, checks/page */
  299.         5, 55, 12,    /* pay field m/w/l */
  300.         49,11,6,     /* Date field m/w/l */
  301.         66,9,6,        /* Amount field m/w/l */
  302.         2,40,17,    /* Memo field m/w/l */
  303.         3,0,0,        /* Voucher type, m/w */
  304.         5,65,8,     /* String field m/w/l */
  305.         3,        /* lines to skip */
  306.             80              /* cols/page */
  307.     },
  308.  
  309.     /* 081098 cour p10*/
  310.     {    TRUE,        /* sheet feed */
  311.         21,1,         /* lines/check, checks/page */
  312.         5, 45, 14,    /* pay field m/w/l */
  313.         55,11,6,     /* Date field m/w/l */
  314.         67,9,6,        /* Amount field m/w/l */
  315.         1,40,17,    /* Memo field m/w/l */
  316.         2,0,0,        /* Voucher type, m/w */
  317.         5,70,10,     /* String field m/w/l */
  318.         3,        /* lines to skip */
  319.          80              /* cols/page */      
  320.     },
  321.  
  322.  
  323.     /* 081123 cour p10*/
  324.     {    TRUE,        /* sheet feed */
  325.         21,1,         /* lines/check, checks/page */
  326.         5, 50, 14,    /* pay field m/w/l */
  327.         66,11,5,     /* Date field m/w/l */
  328.         66,9,8,        /* Amount field m/w/l */
  329.         1,40,17,    /* Memo field m/w/l */
  330.         3,0,0,        /* Voucher type, m/w */
  331.         5,65,9,     /* String field m/w/l */
  332.         3,        /* lines to skip */
  333.             80              /* cols/page */
  334.     },
  335.  
  336.  
  337.     /* * * line printers * * */
  338.  
  339.      /* 091098 cour p10*/
  340.     {    FALSE,        /* sheet feed */
  341.         21,1,         /* lines/check, checks/page */
  342.         5, 50, 14,    /* pay field m/w/l */
  343.         53,11,6,     /* Date field m/w/l */
  344.         66,9,6,        /* Amount field m/w/l */
  345.         2,40,17,    /* Memo field m/w/l */
  346.         4,0,0,        /* Voucher type, m/w */
  347.         5,65,10,     /* String field m/w/l */
  348.         2,        /* lines to skip */
  349.             80              /* cols/page */
  350.     },
  351.  
  352.      /* 091064 cour p10*/
  353.     {    FALSE,        /* sheet feed */
  354.         21,1,         /* lines/check, checks/page */
  355.         7, 55, 8,    /* pay field m/w/l */
  356.         66,11,5,     /* Date field m/w/l */
  357.         66,12,8,    /* Amount field m/w/l */
  358.         4,35,17,    /* Memo field m/w/l */
  359.         0,0,0,        /* Voucher type, m/w */
  360.         1,65,10,     /* String field m/w/l */
  361.         2,        /* lines to skip */
  362.             80              /* cols/page */
  363.     },
  364.      /* 090935 cour p12*/
  365.     {    FALSE,        /* sheet feed */
  366.         17,1,         /* lines/check, checks/page */
  367.         36, 35, 4,    /* pay field m/w/l */
  368.         83,11,4,     /* Date field m/w/l */
  369.         83,10,5,    /* Amount field m/w/l */
  370.         28,30,13,    /* Memo field m/w/l */
  371.         1,3,27,        /* Voucher type, m/w */
  372.         30,60,6,     /* String field m/w/l */
  373.         3,        /* lines to skip */
  374.             95              /* cols/page */
  375.     },
  376.  }
  377. };
  378.  
  379. char daysinmonth[12] = {31,29,31,30,31,30,31,31,30,31,30,31};
  380. char easymonths[12][4] = {
  381.     "Jan",
  382.     "Feb",
  383.     "Mar",
  384.     "Apr",
  385.     "May",
  386.     "Jun",
  387.     "Jul",
  388.     "Aug",
  389.     "Sep",
  390.     "Oct",
  391.     "Nov",
  392.     "Dec",
  393. };
  394.  
  395.  
  396. reportSetting reportControl;
  397. searchState searchControl;
  398. filterSetting filterControl;
  399.  
  400. /*
  401.  * prototypes
  402.  */
  403. BOOL DataLeapYear(LONG);
  404. BOOL DataStrSet(char *, char *);
  405. void DataSortInit(void);
  406. BOOL DataSortLevel(filterNode *, filterNode **, filterNode **, sortNode *);
  407. void DataReplaceEntryCats(struct List *);
  408. void DataReplaceTempCats(struct List *);
  409. editCatNode *DataLocateCat(struct List *, char *);
  410. BOOL DataSearchMatch(filterNode *, searchState *);
  411. void DataInitBalances(void);
  412. BOOL DataDateRange(entryNode *, filterSetting *);
  413. int DataWriteEntry(int,entryNode *);
  414. void DataExtractDate(dateType *, char *out);
  415. void DataCreateDate(dateType *, char *out, BOOL year);
  416. BOOL DataVerifyDateDec12(char *instr, char *newstr);
  417. BOOL DataVerifyDate12Dec(char *instr, char *newstr);
  418. BOOL DataVerifyDateMMDDYY(char *instr, char *newstr);
  419. BOOL DataVerifyDateDDMMYY(char *instr, char *newstr);
  420. int DataWriteTemplate(int fd, templateNode *temp);
  421.  
  422.  
  423. /****************************************************
  424. * DataListInit()
  425. *
  426. *  Initialize lists
  427. ****************************************************/
  428. void DataListInit(void)
  429. {
  430.  NewList(&grouplist);
  431.  NewList((struct List *)&entries);
  432.  NewList((struct List *)&filtered);
  433.  NewList(&templates);
  434.  NewList(&categories);
  435.  NewList(&testtemps);
  436.  NewList(&sortfields);
  437.  NewList(&memolist);
  438.  NewList(&datelist);
  439.  NewList(&namelist);
  440.  NewList(&amntlist);
  441. }
  442.  
  443. /****************************************************
  444. * DataInit()
  445. *
  446. *    Initialize the lists, create default templates
  447. *****************************************************/
  448. BOOL DataInit(void)
  449. {
  450.  time_t t;
  451.  struct tm *pt;
  452.  templateNode temp;
  453.  categoryNode cat;
  454.  amountType defamount = 0;
  455.  int x;
  456.  
  457.  /*
  458.   * install default templates
  459.   */
  460.  memset(&temp, 0, sizeof(templateNode));
  461.  
  462.  strcpy(temp.tempname,"Check"); 
  463.  strcpy(temp.template.category,"None");
  464.  temp.template.type=CHECKTYPE; 
  465.  DataAddTemp(&templates, &temp); 
  466.  
  467.  strcpy(temp.tempname,"Withdrawal"); 
  468.  strcpy(temp.template.category,"None");
  469.  temp.template.type=WITHDRAWALTYPE; 
  470.  DataAddTemp(&templates, &temp);
  471.  
  472.  strcpy(temp.tempname,"Deposit");
  473.  strcpy(temp.template.category,"None");
  474.  temp.template.type=DEPOSITTYPE; 
  475.  DataAddTemp(&templates,&temp); 
  476.  
  477.  strcpy(temp.tempname,"Script");
  478.  strcpy(temp.template.category,"None");
  479.  temp.template.type=SCRIPTTYPE; 
  480.  DataAddTemp(&templates, &temp); 
  481.  
  482.  /*
  483.   * install default categories
  484.   */
  485.  memset(&cat, 0, sizeof(categoryNode));
  486.  
  487.  strcpy(cat.catname,"None");
  488.  DataAddCat(&categories,&cat);
  489.  
  490.  /*
  491.   * other globals
  492.   */
  493.  amntState.currTemplate = 0;
  494.  amntState.currCheckNumber = 1;
  495.  
  496.  /* get century */
  497.  time (&t);
  498.  pt=localtime(&t);
  499.  currDate.day = pt->tm_mday;
  500.  currDate.month = pt->tm_mon + 1;
  501.  currDate.year = pt->tm_year + 1900;
  502.  currCentury = 1900 + (pt->tm_year/100);
  503.  
  504.  QDateAdd(&currDate);
  505.  
  506.  entryCount = 0;
  507.  
  508.  /* initialize filter to all */
  509.  memset(&filterControl,0,sizeof(filterSetting));
  510.  filterControl.checks=TRUE;
  511.  filterControl.withdrawals=TRUE;
  512.  filterControl.deposits=TRUE;
  513.  filterControl.checkfrom = filterControl.checkto = 1;
  514.  memcpy(&filterControl.dateFrom,&currDate,sizeof(dateType));
  515.  memcpy(&filterControl.dateTo,&currDate,sizeof(dateType));
  516.  
  517.  strcpy(filterControl.category,"None");
  518.  
  519.  /* initialize sort array */
  520.  DataSortInit();
  521.  memset(&sortStates,0,sizeof(sortState));
  522.  
  523.  /* initialize account */
  524.  memset(&usrAccount,0,sizeof(accntState));
  525.  usrAccount.checknumber = amntState.currCheckNumber;
  526.  memcpy(&usrAccount.openDate,&currDate,sizeof(dateType));
  527.  memcpy(&usrAccount.closeDate,&currDate,sizeof(dateType));
  528.  usrAccount.decimal = 2;
  529.  
  530.  /* initalize balance */
  531.  DataInitBal(DEPOSITTYPE,&defamount,&amntState.currAmnt);
  532.  DataInitBal(DEPOSITTYPE,&defamount,&amntState.stateAmnt);
  533.  DataInitBal(DEPOSITTYPE,&defamount,&filtAmnt);
  534.  
  535.  /* initialize search control */
  536.  memset(&searchControl,0,sizeof(searchState));
  537.  memcpy(&searchControl.searchdate,&currDate,sizeof(dateType));
  538.  searchControl.lastrow = -1;
  539.  searchControl.checknum = 1;
  540.  
  541.  memset(&reportControl,0,sizeof(reportSetting));
  542.  reportControl.rows = 66;
  543.  reportControl.cols = 80;
  544.  
  545.  
  546.  for (x=0;x<MAXMACROS;x++) {
  547.     memset(arexxMacros[x].macroname,0,20+1);
  548.     sprintf(arexxMacros[x].macroname,"<unassigned %d>",x+1);
  549.     arexxMacros[x].macrofile[0]=0;
  550.  }
  551.  
  552.  amiChangedItems = FALSE;
  553.  return (TRUE);
  554. }
  555.  
  556. /***************************************************
  557. * DataNode2Ord
  558. *
  559. *     Returns ordinal entry in list by name
  560. *
  561. ****************************************************/
  562. LONG DataNode2Ord (struct List *list, char *name)
  563. {
  564.  struct Node *result;
  565.  struct Node *temp;
  566.  LONG ord = 0;
  567.  
  568.  result = DataFindName(list,name);
  569.  
  570.  if (result == NULL) 
  571.     return (0);
  572.  
  573.  temp = list->lh_Head;
  574.  while (temp != result) {
  575.     ord++;
  576.     temp = temp->ln_Succ;
  577.  }
  578.  
  579.  return (ord);
  580. }
  581.  
  582. /***************************************************
  583. * DataOrd2Node
  584. *
  585. *     Returns Node ptr from ordinal entry
  586. ****************************************************/
  587. struct Node *DataOrd2Node(struct List *list,LONG ord)
  588. {
  589.  struct Node *temp = list->lh_Head;
  590.  LONG myord = 0;
  591.  
  592.  while (temp && myord != ord) {
  593.     myord++;
  594.     temp = temp->ln_Succ;
  595.  }
  596.  
  597.  return (temp);
  598. }
  599.  
  600. /***************************************************
  601. * DataAddCat()
  602. *
  603. *    Adds a category
  604. ****************************************************/
  605. BOOL DataAddCat(struct List *categories, categoryNode *info )
  606. {
  607.  categoryNode *temp;
  608.  
  609.     if ((temp = AllocVec(sizeof(categoryNode),MEMF_CLEAR))){
  610.  
  611.         memcpy((void *)temp,(void *)info,sizeof(categoryNode));
  612.         temp->node.ln_Type = NT_USER;
  613.         temp->node.ln_Pri = 0;
  614.         temp->node.ln_Name = temp->catname;
  615.  
  616.         AddTail(categories,(struct Node *)temp);
  617.     }
  618.     else return (FALSE);
  619.  
  620.  return (TRUE);
  621. }
  622.  
  623. /***************************************************
  624. * DataTestFilter()
  625. *
  626. *    Determine if node belongs to filter set
  627. ****************************************************/
  628. BOOL DataTestFilter(entryNode *en, filterSetting *set)
  629. {
  630.  BOOL retval = TRUE;
  631.  
  632.  /* type check - returns quickly if it can */
  633.  switch (en->type) {
  634.     case CHECKTYPE:
  635.         if (set->checks != TRUE) return (FALSE);
  636.         break;
  637.  
  638.     case WITHDRAWALTYPE:
  639.         if (set->withdrawals != TRUE) return(FALSE);
  640.         break;
  641.  
  642.     case DEPOSITTYPE:
  643.         if (set->deposits != TRUE) return(FALSE);
  644.         break;
  645.  }
  646.  
  647.  /* check range check */
  648.  if (en->type == CHECKTYPE) {
  649.      if (set->checkrange == FILTERIN) {
  650.         if (en->check < set->checkfrom || en->check > set->checkto)
  651.         return (FALSE);
  652.         
  653.      }
  654.      else  if (set->checkrange == FILTEROUT) {
  655.         if (en->check >= set->checkfrom && en->check <= set->checkto)
  656.         return (FALSE);
  657.     }
  658.  }
  659.  
  660.  /* amount range check */
  661.  if (set->amntrange == FILTERIN) {
  662.     if (en->amount < set->amountFrom || en->amount > set->amountTo) 
  663.         return (FALSE);
  664.  }
  665.  else if (set->amntrange == FILTEROUT) {
  666.     if (en->amount >= set->amountFrom && en->amount <= set->amountTo)
  667.         return (FALSE);
  668.  }
  669.  
  670.  /* date range check */
  671.  if (set->daterange == FILTERIN && DataDateRange(en,set) == FALSE)
  672.     return (FALSE);
  673.  
  674.  else if (set->daterange == FILTEROUT && DataDateRange(en,set) == TRUE) 
  675.     return (FALSE);
  676.  
  677.  
  678.  /* category check */
  679.  if (set->usecategory == FILTERIN) {
  680.     if (strcmpi(set->category, en->category) != 0)
  681.         return (FALSE);
  682.  }
  683.  else if (set->usecategory == FILTEROUT) {
  684.     if (strcmpi(set->category, en->category) == 0)
  685.         return (FALSE);
  686.  }
  687.     
  688.  
  689.  /* set operations */
  690.  if ( (en->flags & set->andflag) != set->andflag)
  691.     return (FALSE);
  692.  
  693.  if ( (en->flags & set->notflag) != 0)
  694.     return (FALSE);
  695.  
  696.  /* payee check  */
  697.  if (set->usepayee == FILTERIN ) {
  698.     if ( !MatchPatternNoCase(set->payeetoken, en->name) )
  699.         return (FALSE);
  700.  }
  701.  else if (set->usepayee == FILTEROUT) {
  702.     if (MatchPatternNoCase(set->payeetoken,en->name) )
  703.         return (FALSE);
  704.  }
  705.  
  706.  /* memo check */
  707.  if (set->usememo == FILTERIN) {
  708.     if (!MatchPatternNoCase(set->memotoken, en->memo) )
  709.         return (FALSE);
  710.  }
  711.  else if (set->usememo == FILTEROUT) {
  712.     if (MatchPatternNoCase(set->memotoken,en->memo) )
  713.         return (FALSE);
  714.  }
  715.  
  716.   return (retval);
  717. }
  718.  
  719. /*************************************************
  720. * DataDateRange()
  721. *
  722. *    Range for dates
  723. **************************************************/
  724. BOOL DataDateRange(entryNode *en, filterSetting *set)
  725. {
  726. /* check years */
  727. if( en->date.year < set->dateFrom.year || en->date.year > set->dateTo.year)
  728.     return (FALSE);
  729.  
  730. /* check months */
  731. if (en->date.year == set->dateFrom.year && en->date.month < set->dateFrom.month)
  732.     return (FALSE);
  733.  
  734. if (en->date.year == set->dateTo.year && en->date.month > set->dateTo.month)
  735.     return (FALSE);
  736.  
  737. /* check days */
  738. if (en->date.year == set->dateFrom.year && en->date.month == set->dateFrom.month &&
  739.     en->date.day < set->dateFrom.day)
  740.     return (FALSE);
  741.  
  742. if (en->date.year == set->dateTo.year && en->date.month == set->dateTo.month &&
  743.     en->date.day > set->dateTo.day)
  744.     return (FALSE);
  745.  
  746. return (TRUE);
  747. }
  748.  
  749. /***************************************************
  750. * DataRemoveEntry()
  751. *
  752. *    removes an entry from the list
  753. ****************************************************/
  754. void DataRemoveEntry(entryNode *info, filterNode *filt)
  755. {
  756.  DataRemoveFilter(filt);
  757.  Remove((struct Node *)info);
  758.  FreeVec(info);
  759. }
  760.  
  761. /***************************************************
  762. * DataRemoveFilter()
  763. *
  764. * Removes supplied filter 
  765. ***************************************************/
  766. void DataRemoveFilter(filterNode *filt)
  767. {
  768.  if (filt == NULL)
  769.     return;
  770.  
  771.  entryCount--;
  772.  Remove((struct Node *)filt);
  773.  FreeVec(filt);
  774. }
  775.  
  776. /***************************************************
  777. * DataRemoveEntryFilter()
  778. *
  779. *    Removes a filter based on the node 
  780. ****************************************************/
  781. void DataRemoveEntryFilter(entryNode *node)
  782. {
  783.  filterNode *filt = (filterNode *)filtered.mlh_Head;
  784.  
  785.  /* is this an empty list? */
  786.  if (filtered.mlh_TailPred == &filtered)
  787.     return;
  788.  
  789.  /* locate filter */
  790.  while (filt->node.mln_Succ != NULL) {
  791.     if (filt->entry == node) {
  792.         DataRemoveFilter(filt);
  793.         break;
  794.     }
  795.  
  796.     filt = (filterNode *)filt->node.mln_Succ;
  797.  }
  798.  
  799. }
  800.  
  801. /***************************************************
  802. * DataInsertFilter()
  803. *
  804. *    Add a filter node
  805. ****************************************************/
  806. BOOL DataInsertFilter(filterNode *fparent,filterNode **ret, 
  807.             entryNode *join, struct MinList *filtered)
  808. {
  809.  int x;
  810.  filterNode *temp;
  811.  
  812.  *ret = NULL;
  813.  
  814.     if ((temp = AllocVec(sizeof(filterNode),MEMF_CLEAR))){
  815.  
  816.         temp->entry = join;
  817.     
  818.         for (x=0;x<4;x++)
  819.             temp->printChars[x]= -1;    
  820.  
  821.         Insert((struct List *)filtered,(struct Node *)temp, (struct Node *)fparent);        
  822.     }
  823.     else return (FALSE);
  824.  
  825.  *ret = temp;
  826.  return (TRUE);
  827. }
  828.  
  829. /***************************************************
  830. * DataInsertEntry()
  831. *
  832. *    Add a transaction to proper place
  833. ****************************************************/
  834. BOOL DataInsertEntry(filterNode *fparent, entryNode *eparent,
  835.     entryNode *info, struct MinList *entrylist, filterNode **filt, 
  836.     entryNode **entry)
  837. {
  838.   entryNode *temp;
  839.  
  840.   *filt = NULL;
  841.   *entry = NULL;
  842.  
  843.     if ((temp = AllocVec(sizeof(entryNode),MEMF_CLEAR))){
  844.  
  845.         memcpy((void *)temp,(void *)info,sizeof(entryNode));
  846.         Insert((struct List *)entrylist,(struct Node *)temp, 
  847.             (struct Node *)eparent);
  848.         *entry = temp;
  849.     }
  850.     else return (FALSE);
  851.  
  852.  /* filter it */
  853.  if (DataTestFilter(temp, &filterControl) == TRUE)
  854.     DataInsertFilter(fparent,filt,temp,&filtered);
  855.  
  856.  return (TRUE);
  857. }
  858.  
  859.  
  860. /***************************************************
  861. * DataAddEntry()
  862. *
  863. *    Add a transaction
  864. ****************************************************/
  865. BOOL DataAddEntry(entryNode *info, struct MinList *entrylist, filterNode **filt)
  866. {
  867.   entryNode *temp;
  868.  
  869.  *filt = NULL;
  870.  
  871.  if ((temp = AllocVec(sizeof(entryNode),MEMF_CLEAR))){
  872.  
  873.     memcpy((void *)temp,(void *)info,sizeof(entryNode));
  874.     AddTail((struct List *)entrylist,(struct Node *)temp);        
  875.  }
  876.  else return (FALSE);
  877.  
  878.  /* filter it */
  879.  if (DataTestFilter(temp, &filterControl) == TRUE)
  880.     DataAddFilter(filt,temp,&filtered);
  881.  
  882.  return (TRUE);
  883.  
  884. }
  885.  
  886. /***************************************************
  887. * DataAddTemp()
  888. *
  889. *    Adds a template
  890. ****************************************************/
  891. BOOL DataAddTemp(struct List *templist, templateNode *info)
  892. {
  893.  templateNode *temp;
  894.  
  895.     if ((temp = AllocVec(sizeof(templateNode),MEMF_CLEAR))){
  896.  
  897.         memcpy((void *)temp,(void *)info,sizeof(templateNode));
  898.         temp->node.ln_Type = NT_USER;
  899.         temp->node.ln_Pri = 0;
  900.         temp->node.ln_Name = temp->tempname;
  901.         AddTail(templist,(struct Node *)temp);        
  902.     }
  903.     else return (FALSE);
  904.  
  905.  return (TRUE);
  906. }
  907.  
  908. /***************************************************
  909. * DataAddFilter()
  910. *
  911. *    Add a filter node
  912. ****************************************************/
  913. BOOL DataAddFilter(filterNode **ret, entryNode *join, struct MinList *filtered)
  914. {
  915.  int x;
  916.  filterNode *temp;
  917.  
  918.  *ret = NULL;
  919.  
  920.     if ((temp = AllocVec(sizeof(filterNode),MEMF_CLEAR))){
  921.  
  922.         temp->entry = join;
  923.     
  924.         for (x=0;x<4;x++)
  925.             temp->printChars[x]= -1;    
  926.  
  927.         AddTail((struct List *)filtered,(struct Node *)temp);        
  928.     }
  929.     else return (FALSE);
  930.  
  931.  *ret = temp;
  932.  return (TRUE);
  933.  
  934. }
  935.  
  936. /*****************************************************
  937. * DataFreeAll()
  938. *
  939. *    Free all database allocations
  940. *****************************************************/
  941. void DataFreeAll(void)
  942. {
  943.   DataFreeList((struct List *)&entries);
  944.   DataFreeList((struct List *)&templates);
  945.   DataFreeList((struct List *)&filtered);
  946.   DataFreeList((struct List *)&categories);
  947.   DataFreeGroupCats((struct List *)&grouplist);
  948.   DataFreeList((struct List *)&grouplist);
  949.   DataFreeList((struct List *)&datelist);
  950.   DataFreeList((struct List *)&memolist);
  951.   DataFreeList((struct List *)&namelist);
  952.   DataFreeList((struct List *)&amntlist);
  953. }
  954.  
  955. /****************************************************
  956. * DataStoreAmnt()
  957. *
  958. *    Takes the user string and stores it in a template
  959. *****************************************************/
  960. void DataStoreAmnt(amountType *amount, char *str)
  961. {
  962.  ULONG d=0,c=0;
  963.  
  964.  if (*str == NULL)
  965.     *amount = 0;
  966.  else {
  967.      /* later we will add "DataExtractAmount" */
  968.     if (usrAccount.decimal)
  969.          sscanf(str,"%u.%u",&d,&c);
  970.     else    sscanf(str,"%u",&d);
  971.  
  972.      *amount = (d*decimalModulos[usrAccount.decimal]) + c;
  973.  }
  974. }
  975.  
  976. /***************************************************
  977. * DataStoreDate()
  978. *
  979. *    Stores date into string
  980. ****************************************************/
  981. void DataStoreDate (dateType *date, char *str)
  982. {
  983.  DataExtractDate(date,str);
  984. }
  985.  
  986. /****************************************************
  987. * DataBuildRegDate()
  988. *
  989. *    Builds the reduced date for the register
  990. *****************************************************/
  991. void DataBuildRegDate(dateType *date, char *str)
  992. {
  993.  DataCreateDate(date,str,TRUE);
  994. }
  995.  
  996. /****************************************************
  997. * DataBuildDate()
  998. *
  999. *    Builds string from node of date
  1000. *****************************************************/
  1001. void DataBuildDate (dateType *date, char *str)
  1002. { 
  1003.  DataCreateDate(date,str,FALSE);
  1004. }
  1005.  
  1006. /****************************************************
  1007. * DataBuildAmnt()
  1008. *
  1009. *    Routine to build a string from amnt
  1010. *****************************************************/
  1011. void DataBuildAmnt(BOOL zero, amountType *amount, char *str)
  1012. {
  1013.  if (zero != TRUE && *amount == 0)
  1014.     str[0]=0;
  1015.  else {
  1016.     sprintf(str,
  1017.         decimalFormat[usrAccount.decimal],
  1018.         (*amount/decimalModulos[usrAccount.decimal]),
  1019.         (*amount%decimalModulos[usrAccount.decimal]) 
  1020.         );
  1021.  }
  1022. }
  1023.  
  1024. /****************************************************
  1025. * DataBuildBal()
  1026. *
  1027. *    Routine to build a string from balance
  1028. *****************************************************/
  1029. void DataBuildBal(UBYTE decimal, balanceType *bal, char *str)
  1030. {
  1031. char negval = ' ';
  1032.  
  1033.  if (bal->neg) 
  1034.     negval = '-';
  1035.     
  1036.  sprintf(str,"%c",negval);
  1037.  str++;
  1038.     
  1039.  /* again, eventually we will do a createamount */
  1040.  sprintf(str,decimalFormat[decimal],bal->dollar,bal->cent);
  1041. }
  1042.  
  1043. /*******************************************************
  1044. * DataMoveList()
  1045. *
  1046. *    Accept new list as new original list.
  1047. ********************************************************/
  1048. void DataMoveList(struct List *src, struct List *dest)
  1049. {
  1050.  DataFreeList(dest);
  1051.  memcpy(dest,src,sizeof(struct List));
  1052.  
  1053.  dest->lh_Head->ln_Pred = (struct Node *)&(dest->lh_Head);
  1054.  dest->lh_TailPred->ln_Succ = (struct Node *)&(dest->lh_Tail);
  1055.  
  1056.  /* zap out original */
  1057.  NewList(src);
  1058. }
  1059.  
  1060. /*******************************************************
  1061. * DataIsUnique()
  1062. *
  1063. *    Takes any list and replies if an entry is
  1064. *    unique by name.  Boolean option opens
  1065. *    requestor notifying user with custon strings.
  1066. ********************************************************/
  1067. BOOL DataIsUnique(GUIFront *gui, struct List *lst, char *name, BOOL req,
  1068.         char *reqstr)
  1069. {
  1070.  struct Window *win = NULL;
  1071.  struct EasyStruct es;
  1072.  
  1073.  if (strlen(name) > 0 && DataFindName(lst,name) == NULL)
  1074.     return (TRUE);
  1075.  
  1076.  /* oh no, notify user */
  1077.  if (req == TRUE) {
  1078.     GF_GetGUIAttr(gui,
  1079.         GUI_Window,&win,
  1080.         TAG_DONE);
  1081.  
  1082.     DisplayBeep(win->WScreen);
  1083.     if (win != NULL) {
  1084.         es.es_StructSize = sizeof(struct EasyStruct);
  1085.         es.es_Flags = 0;
  1086.         es.es_Title = "amiCheck NOTICE:";
  1087.         es.es_TextFormat = reqstr;
  1088.         es.es_GadgetFormat = "OK";
  1089.         GF_LockGUI(gui);
  1090.         GF_EasyRequest(gui,win,&es,NULL);
  1091.         GF_UnlockGUI(gui);
  1092.     }
  1093.  }
  1094.  
  1095.  return (FALSE);
  1096. }
  1097.  
  1098. /*****************************************************************
  1099. * DataVerifyAmnt()
  1100. *
  1101. *     Force valid entry of amount strings
  1102. ******************************************************************/
  1103. BOOL DataVerifyAmnt(char *instr,char *newstr)
  1104. {
  1105. amountType amnt = 0;
  1106. char *dot1, *dot2, *str, *skip;
  1107. ULONG x=0,y=0,temp;
  1108. char amnthold[AMNTSIZE+1];
  1109.  
  1110.  *newstr = NULL;
  1111.  amnthold[AMNTSIZE]=NULL;
  1112.  strcpy(amnthold,instr);
  1113.  str = amnthold;
  1114.  
  1115.  /* something odd in there? */
  1116.  if (str == NULL)
  1117.     return (FALSE);
  1118.  
  1119.  /* clip spaces off front and end */
  1120.  while (*str == ' ') str++;
  1121.  skip = &amnthold[strlen(amnthold) - 1];
  1122.  while (*skip == ' ' && skip != str) {
  1123.     *skip = NULL;
  1124.     skip--;
  1125.  }
  1126.  
  1127.  if (DataStrSet(str,"0123456789. ") == FALSE) {
  1128.         return (FALSE);
  1129.  }
  1130.  
  1131.  /* grab decimal point if one */
  1132.  dot1 = strchr(str,'.');
  1133.  if (dot1 != NULL) {
  1134.  
  1135.     /* more than two decimal places? */
  1136.     dot2 = dot1+1;
  1137.     temp = strlen(dot2);
  1138.     if (temp > usrAccount.decimal) 
  1139.         return (FALSE);
  1140.     
  1141.     /* pull out data into integers */
  1142.     if (dot1 == str) 
  1143.          sscanf(str,".%u",&y);
  1144.     else sscanf(str,"%u.%u",&x,&y);
  1145.  
  1146.     /* adjust for ".5 -> .50" */
  1147.     if (temp < usrAccount.decimal)
  1148.         y *= decimalModulos[usrAccount.decimal-temp];
  1149.  
  1150.     /* another period? */
  1151.     dot2 = strchr(dot2,'.');
  1152.     if (dot2 != NULL) {
  1153.         return (FALSE);
  1154.     }
  1155.  }
  1156.  else sscanf(str,"%u",&x);
  1157.  
  1158.  /* build new string */
  1159.  amnt = (x*decimalModulos[usrAccount.decimal]) + y;
  1160.  DataBuildAmnt(FALSE,&amnt,newstr);
  1161.  
  1162.  return (TRUE);
  1163. }
  1164.  
  1165. /****************************************************************
  1166. * DataVerifyDate()
  1167. *
  1168. *    Verifies and builds date string
  1169. ****************************************************************/
  1170. BOOL DataVerifyDate(char *instr, char *newstr)
  1171. {
  1172. BOOL retval;
  1173.  
  1174. switch (dateFormat) {
  1175.     case DATE_MMDDYY:
  1176.         retval = DataVerifyDateMMDDYY(instr,newstr);
  1177.         break;
  1178.     case DATE_DDMMYY:
  1179.         retval = DataVerifyDateDDMMYY(instr,newstr);
  1180.         break;
  1181.     case DATE_DEC_12:
  1182.         retval = DataVerifyDateDec12(instr,newstr);
  1183.         break;
  1184.     case DATE_12_DEC:
  1185.         retval = DataVerifyDate12Dec(instr,newstr);
  1186.         break;
  1187. }
  1188.  
  1189. return (retval);
  1190. }
  1191.  
  1192. /********************************************************************
  1193. * DataLeapYear()
  1194. *
  1195. *     TRUE if year is leap year
  1196. *********************************************************************/
  1197. BOOL DataLeapYear(LONG year)
  1198. {
  1199.  
  1200.  /* quick /4 check for now */
  1201.  if ( year%4 || !(year%100) )
  1202.     return (FALSE);
  1203.  
  1204.  return (TRUE);
  1205. }
  1206.  
  1207.  
  1208. /*******************************************************************
  1209. * DataAnnounce()
  1210. *
  1211. *    Announce message to user
  1212. *******************************************************************/
  1213. void DataAnnounce(GUIFront *gui, char *str)
  1214. {
  1215.  struct Window *win = NULL;
  1216.  struct EasyStruct es;
  1217.  
  1218.  if (str == NULL)
  1219.     return;
  1220.  
  1221.  /* oh no, notify user */
  1222.  GF_GetGUIAttr(gui,
  1223.     GUI_Window,&win,
  1224.     TAG_DONE);
  1225.  
  1226.  if (win != NULL) {
  1227.     es.es_StructSize = sizeof(struct EasyStruct);
  1228.     es.es_Flags = 0;
  1229.     es.es_Title = "amiCheck NOTICE:";
  1230.     es.es_TextFormat = str;
  1231.     es.es_GadgetFormat = "OK";
  1232.     GF_LockGUI(gui);
  1233.     GF_EasyRequest(gui,win,&es,NULL);
  1234.     GF_UnlockGUI(gui);
  1235.  }
  1236. }
  1237.  
  1238. /*******************************************************************
  1239. * DataQuery()
  1240. *
  1241. *    Query from  user
  1242. *******************************************************************/
  1243. int DataQuery(GUIFront *gui, char *str, char *query)
  1244. {
  1245.  struct Window *win = NULL;
  1246.  struct EasyStruct es;
  1247.  int val = 0;
  1248.  
  1249.  if (str == NULL)
  1250.     return (val);
  1251.  
  1252.  /* oh no, notify user */
  1253.  GF_GetGUIAttr(gui,
  1254.     GUI_Window,&win,
  1255.     TAG_DONE);
  1256.  
  1257.  if (win != NULL) {
  1258.     es.es_StructSize = sizeof(struct EasyStruct);
  1259.     es.es_Flags = 0;
  1260.     es.es_Title = "amiCheck NOTICE:";
  1261.     es.es_TextFormat = str;
  1262.     es.es_GadgetFormat = query;
  1263.     GF_LockGUI(gui);
  1264.     val = GF_EasyRequest(gui,win,&es,NULL);
  1265.     GF_UnlockGUI(gui);
  1266.  }
  1267.  
  1268.  return (val);
  1269. }
  1270.  
  1271. /**************************************************************
  1272. * DataStrSet ()
  1273. *
  1274. *    SAS/C strcspn replacement
  1275. **************************************************************/
  1276. BOOL DataStrSet(char *src, char *input)
  1277. {
  1278.  WORD a,b;
  1279.  BOOL found;
  1280.  
  1281.  for (a=0;a<strlen(src);a++) {
  1282.     found = FALSE;
  1283.     for (b=0;b<strlen(input);b++) {
  1284.         if (src[a] == input[b]) {
  1285.             found = TRUE;
  1286.             break;
  1287.         }
  1288.     }
  1289.     if (found == FALSE)
  1290.         return (FALSE);
  1291.  }
  1292.  
  1293.  return (TRUE);
  1294. }
  1295.  
  1296. /********************************************************
  1297. * DataUpdateFilters()
  1298. *
  1299. *    Updates the filtered items to the filter criteria
  1300. *    (not all transactions, for SPEED :)
  1301. ********************************************************/
  1302. void DataUpdateFilters(struct MinList *filtered)
  1303. {
  1304.  filterNode *work, *next;
  1305.  
  1306.  if ((struct Node *)(filtered->mlh_TailPred) == (struct Node *)filtered)
  1307.     return;
  1308.  
  1309.  work = (filterNode *)(filtered->mlh_Head);
  1310.  while (next = (filterNode *)(work->node.mln_Succ)) {
  1311.     if (!DataTestFilter(work->entry,&filterControl)) 
  1312.             DataRemoveFilter(work);
  1313.     
  1314.     work = next;
  1315.  } 
  1316. }
  1317.  
  1318. /********************************************************
  1319. * DataBalConvert()
  1320. *
  1321. *    Converts a balance from one decimal format to
  1322. *    another (some data loss possible)
  1323. *********************************************************/
  1324. void DataBalConvert(balanceType *bal, UBYTE from, UBYTE to)
  1325. {
  1326.  UWORD diff;
  1327.  
  1328.  if (from == to)
  1329.     return;
  1330.  
  1331.  if (from > to) {
  1332.     diff = decimalModulos[from - to];
  1333.     bal->cent /= diff;
  1334.  }
  1335.  else    {
  1336.     diff = decimalModulos[to-from];
  1337.     bal->cent *= diff;
  1338.  }
  1339. }
  1340.  
  1341. /********************************************************
  1342. * DataBalToAmnt()
  1343. *
  1344. *    Converts a balance to standard amount type
  1345. *********************************************************/
  1346. void DataBalToAmnt(balanceType *bal, UBYTE *type, amountType *amount)
  1347. {
  1348.  if (bal->neg)
  1349.     *type = WITHDRAWALTYPE;
  1350.  else    *type = DEPOSITTYPE;
  1351.  
  1352.  *amount = (bal->dollar * decimalModulos[usrAccount.decimal]) +
  1353.         bal->cent;
  1354. }
  1355.  
  1356. /********************************************************
  1357. * DataUpdateBal()
  1358. *
  1359. *    Updates a balance, supply string. Decimal assumed
  1360. *    from account setting
  1361. *********************************************************/
  1362. void DataUpdateBal(UBYTE type, amountType *amount, balanceType *bal, char *str)
  1363. {
  1364.  DataAddBal(type, amount, bal);
  1365.  DataBuildBal(usrAccount.decimal,bal,str);
  1366. }
  1367.  
  1368. /********************************************************
  1369. * DataAddBal()
  1370. *
  1371. *    Updates a balance. Decimal assumed
  1372. *    from account setting
  1373. *********************************************************/
  1374. void DataAddBal(UBYTE type, amountType *amount, balanceType *bal)
  1375. {
  1376.  balanceType amntBal;
  1377.  
  1378.  DataInitBal(type, amount, &amntBal);
  1379.  DataBalAddBal(usrAccount.decimal,bal,&amntBal,bal);
  1380. }
  1381.  
  1382. /********************************************************
  1383. * DataBalAddBal()
  1384. *
  1385. *    Adds two balances.
  1386. *********************************************************/
  1387. void DataBalAddBal(UBYTE decimal,balanceType *dest, 
  1388.     balanceType *bal1, balanceType *bal2)
  1389. {
  1390.  balanceType b1, b2;
  1391.  memcpy(&b1,bal1,sizeof(balanceType));
  1392.  memcpy(&b2,bal2, sizeof(balanceType));
  1393.  
  1394.  /* now we need to look at the two balances efficiently */
  1395.  
  1396.  /* - + + */
  1397.  if (b2.neg && !b1.neg) {
  1398.     /* bal is greater or equal to */
  1399.     if ( (b1.dollar > b2.dollar) ||
  1400.          (b1.dollar == b2.dollar && b1.cent >= b2.cent)) {
  1401.             
  1402.         /* borrow if needed */
  1403.         if (b1.cent < b2.cent) {
  1404.             b1.dollar--;
  1405.             b1.cent += decimalModulos[decimal];
  1406.         }
  1407.         b1.cent -= b2.cent;
  1408.         b1.dollar -= b2.dollar;
  1409.     } 
  1410.     /* bal just shrunk! */
  1411.     else {
  1412.         b1.neg = TRUE;
  1413.  
  1414.         /* borrow if needed */
  1415.         if (b2.cent < b1.cent) {
  1416.             b2.dollar--;
  1417.             b2.cent += decimalModulos[decimal];
  1418.         }
  1419.         b1.cent = b2.cent - b1.cent;
  1420.         b1.dollar = b2.dollar - b1.dollar;
  1421.     }
  1422.  }
  1423.  
  1424.  /* + + - */
  1425.  else if (b1.neg && !b2.neg) {
  1426.     /* bal is breater or equal to */
  1427.     if ( (b1.dollar > b2.dollar) ||
  1428.          (b1.dollar == b2.dollar && b1.cent >= b2.cent)) {
  1429.             
  1430.         /* borrow if needed */
  1431.         if (b1.cent < b2.cent) {
  1432.             b1.dollar--;
  1433.             b1.cent += decimalModulos[decimal];
  1434.         }
  1435.         b1.cent -= b2.cent;
  1436.         b1.dollar -= b2.dollar;
  1437.     } 
  1438.     /* bal just shrunk! */
  1439.     else {
  1440.         b1.neg = FALSE;
  1441.  
  1442.         /* borrow if needed */
  1443.         if (b2.cent < b1.cent) {
  1444.             b2.dollar--;
  1445.             b2.cent += decimalModulos[decimal];
  1446.         }
  1447.         b1.cent = b2.cent - b1.cent;
  1448.         b1.dollar = b2.dollar - b1.dollar;
  1449.     }
  1450.  }
  1451.  
  1452.  /* + + +  or - + - */
  1453.  else {
  1454.     b1.dollar += b2.dollar;
  1455.     b1.cent += b2.cent;
  1456.     if (b1.cent >= decimalModulos[decimal]) {
  1457.         b1.dollar++;
  1458.         b1.cent -= decimalModulos[decimal];
  1459.     }
  1460.  } 
  1461.  
  1462.  memcpy(dest,&b1,sizeof(balanceType));
  1463.  if (dest->dollar == 0 && dest->cent == 0)
  1464.     dest->neg = FALSE;
  1465. }
  1466.  
  1467. /********************************************************
  1468. * DataCmpAmntBal()
  1469. *
  1470. *    Compares an amount and a balance. -1 if amnt is 
  1471. *    smaller, 0 if equal and 1 if larger.  The negative
  1472. *    aspect is currently ignored.
  1473. *********************************************************/
  1474. int DataCmpAmntBal(amountType *amnt, balanceType *bal)
  1475. {
  1476.  balanceType store;
  1477.  
  1478.  DataInitBal(DEPOSITTYPE,amnt,&store);
  1479.  return (DataCmpBal(FALSE,&store,bal));
  1480. }
  1481.  
  1482. /********************************************************
  1483. * DataCmpBal()
  1484. *
  1485. *    Compares two balances. -1 if b1 is smaller, 0
  1486. *    if equal and 1 if larger.
  1487. *********************************************************/
  1488. int DataCmpBal(BOOL neg, balanceType *b1,  balanceType *b2)
  1489. {
  1490.  
  1491.  /* do we consider the negative aspect? */
  1492.  if (neg) {
  1493.     if (b1->neg && !b2->neg)
  1494.         return -1;
  1495.     else if (!b1->neg && b2->neg)
  1496.         return 1;
  1497.     else if (b1->dollar == b2->dollar && b1->cent == b2->cent)
  1498.         return 0;
  1499.     else if ( (b1->dollar > b2->dollar) || 
  1500.          (b1->dollar == b2->dollar && b1->cent > b2->cent))
  1501.         return -1;
  1502.     else return 1;
  1503.     
  1504.  }
  1505.  else {
  1506.     if (b1->dollar == b2->dollar && b1->cent == b2->cent)
  1507.         return 0;
  1508.     else if ( (b1->dollar > b2->dollar) || 
  1509.          (b1->dollar == b2->dollar && b1->cent > b2->cent))
  1510.         return 1;
  1511.     else return -1;
  1512.  }
  1513. }
  1514.  
  1515. /********************************************************
  1516. * DataInitBal()
  1517. *
  1518. *    Inits a balance with an amount.  The decimal
  1519. *    is assumed to be the current account's
  1520. *********************************************************/
  1521. void DataInitBal(UBYTE type, amountType *amount, balanceType *bal)
  1522. {
  1523.  
  1524.  bal->dollar = *amount / decimalModulos[usrAccount.decimal];
  1525.  bal->cent = *amount % decimalModulos[usrAccount.decimal];
  1526.  
  1527.  /* now make negative if necessary */
  1528.  if (type != DEPOSITTYPE)
  1529.     bal->neg = TRUE;
  1530.  else    bal->neg = FALSE;
  1531. }
  1532.  
  1533. /************************************************************
  1534. * DataRebuildFilters()
  1535. *
  1536. *    We have changed something and need to free up and
  1537. *    test _ALL_ transactions again.
  1538. *************************************************************/
  1539. void DataRebuildFilters(void)
  1540. {
  1541.  entryNode *work, *next;
  1542.  filterNode *filt;
  1543.  
  1544.  DataFreeList((struct List *)&filtered);
  1545.  
  1546.  entryCount = 0;
  1547.  if (entries.mlh_TailPred == (struct Node *)&entries)
  1548.     return;
  1549.  
  1550.  work = (entryNode *)(entries.mlh_Head);
  1551.  while (next = (entryNode *)(work->node.mln_Succ)) {
  1552.     if (DataTestFilter(work,&filterControl) == TRUE) {
  1553.         entryCount++;
  1554.         DataAddFilter(&filt, work, &filtered);
  1555.     }
  1556.     work = next;
  1557.  }
  1558. }
  1559.  
  1560. /**************************************************************
  1561. * DataSitNSpin()
  1562. *
  1563. *    Wait for window activation
  1564. ***************************************************************/
  1565. void DataSitNSpin(struct Gadget *ga, struct Window *win)
  1566. {
  1567.  BOOL done = FALSE;
  1568.  struct IntuiMessage *imsg = NULL;
  1569.  
  1570.  if (simpleRefresh == TRUE)
  1571.     return;
  1572.  
  1573.  do {
  1574.     while (imsg == NULL)
  1575.         imsg = GF_GetIMsg(guiapp);
  1576.     if (imsg->Class == IDCMP_ACTIVEWINDOW)
  1577.         done = TRUE;
  1578.     GF_ReplyIMsg(imsg);
  1579.  
  1580.  } while (!done);
  1581.  
  1582.  if (ga != NULL && win != NULL)
  1583.     ActivateGadget(ga,win,NULL);
  1584.     
  1585. }
  1586.  
  1587. /***************************************************************
  1588. * DataSortInit()
  1589. *
  1590. *    Initializes the sort field array
  1591. ****************************************************************/
  1592. void DataSortInit(void)
  1593. {
  1594.  strcpy(sortEntries[SORTCHECK].field,"Check Number");
  1595.  sortEntries[SORTCHECK].node.ln_Name = sortEntries[SORTCHECK].field;
  1596.  sortEntries[SORTCHECK].order = 0;
  1597.  sortEntries[SORTCHECK].index = SORTCHECK;
  1598.  
  1599.  strcpy(sortEntries[SORTDATE].field,"Transaction Date");
  1600.  sortEntries[SORTDATE].node.ln_Name = sortEntries[SORTDATE].field;
  1601.  sortEntries[SORTDATE].order = 0;
  1602.  sortEntries[SORTDATE].index = SORTDATE;
  1603.  
  1604.  strcpy(sortEntries[SORTAMNT].field,"Amount"); 
  1605.  sortEntries[SORTAMNT].node.ln_Name = sortEntries[SORTAMNT].field;
  1606.  sortEntries[SORTAMNT].order = 0;
  1607.  sortEntries[SORTAMNT].index = SORTAMNT;
  1608.  
  1609.  strcpy(sortEntries[SORTNAME].field,"Name Field");
  1610.  sortEntries[SORTNAME].node.ln_Name = sortEntries[SORTNAME].field;
  1611.  sortEntries[SORTNAME].order = 0;
  1612.  sortEntries[SORTNAME].index = SORTNAME;
  1613.  
  1614.  strcpy(sortEntries[SORTMEMO].field,"Memo Field");
  1615.  sortEntries[SORTMEMO].node.ln_Name = sortEntries[SORTMEMO].field;
  1616.  sortEntries[SORTMEMO].order = 0;
  1617.  sortEntries[SORTMEMO].index = SORTMEMO;
  1618.  
  1619.  strcpy(sortEntries[SORTCATEGORY].field,"Category");
  1620.  sortEntries[SORTCATEGORY].node.ln_Name = sortEntries[SORTCATEGORY].field;
  1621.  sortEntries[SORTCATEGORY].order = 0;
  1622.  sortEntries[SORTCATEGORY].index = SORTCATEGORY;
  1623. }
  1624.  
  1625. /*******************************************************
  1626. * DataMoveSort()
  1627. *
  1628. *    move a sort list from one to another
  1629. ********************************************************/
  1630. void DataMoveSort(struct List *to, sortNode *to_nodes, 
  1631.     struct List *from, sortNode *from_nodes)
  1632. {
  1633.  sortNode *node = (sortNode *)from->lh_Head;
  1634.  
  1635.  NewList(to);
  1636.  
  1637.  if (IsListEmpty(from))
  1638.     return;
  1639.  
  1640.  while (node->node.ln_Succ != NULL) {
  1641.     AddTail(to, &to_nodes[node->index]);
  1642.     node = (sortNode *)node->node.ln_Succ;
  1643.  }
  1644.  
  1645. }
  1646.  
  1647. /**********************************************************
  1648. * DataReconcile()
  1649. *
  1650. *    Reconciles the current account
  1651. ***********************************************************/
  1652. balanceType DataReconcile(BOOL mark)
  1653. {
  1654.  entryNode *next, *node = (entryNode *)entries.mlh_Head;
  1655.  balanceType curr;
  1656.  
  1657.  DataInitBal(DEPOSITTYPE,&usrAccount.beginAmount,&curr);
  1658.  
  1659.  if (entries.mlh_TailPred == &entries)
  1660.     return (curr);
  1661.  
  1662.  while ( (next = (entryNode *)node->node.mln_Succ)) {
  1663.     if ( (node->flags & CLEARED) &&  !(node->flags & VOIDED)) {
  1664.         DataAddBal(node->type, &node->amount, &curr);
  1665.         if (mark == TRUE) node->flags |= RECONCILED;
  1666.     }
  1667.  
  1668.     node = next;
  1669.  }
  1670.  
  1671.  if (mark) amntState.stateAmnt = curr;
  1672.  return (curr);
  1673. }
  1674.  
  1675. /**************************************************************
  1676. * DataSortFilter()
  1677. *
  1678. *    Sorts filter entries (recursive). Refilter before?
  1679. ****************************************************************/
  1680. void DataSortFilter(filterNode *top, filterNode *bottom, sortNode *node)
  1681. {
  1682.  BOOL swap = TRUE,done = FALSE;
  1683.  filterNode *newtop, *newbottom;
  1684.  filterNode *temptop, *temp, *tempswap;
  1685.  sortNode *next = (sortNode *)node->node.ln_Succ;
  1686.  
  1687.  /* move through each item and sort... not fast but _rhobust_ and easy */
  1688.  temptop = top;
  1689.  temp = (filterNode *)temptop->node.mln_Succ;
  1690.  while (!done) {
  1691.  
  1692.     /* place temptop node: */
  1693.     swap = FALSE;
  1694.     while (!swap && temp != NULL && temp->node.mln_Succ != NULL) {
  1695.         
  1696.         switch (node->index) {
  1697.             case SORTCHECK:
  1698.                 if (node->order == SORTASCEND) {
  1699.                     if (temptop->entry->check > temp->entry->check) 
  1700.                         swap = TRUE;
  1701.                 }
  1702.                 else {
  1703.                     if (temptop->entry->check < temp->entry->check) 
  1704.                         swap = TRUE;
  1705.                 }
  1706.                 break;
  1707.  
  1708.             case SORTDATE:
  1709.                 if (node->order == SORTASCEND) {
  1710.                     if (temptop->entry->date.year > temp->entry->date.year)
  1711.                         swap = TRUE;
  1712.                     else if (temptop->entry->date.year == temp->entry->date.year &&
  1713.                          temptop->entry->date.month > temp->entry->date.month)
  1714.                         swap = TRUE;
  1715.                     else if (temptop->entry->date.year == temp->entry->date.year &&
  1716.                          temptop->entry->date.month == temp->entry->date.month &&
  1717.                          temptop->entry->date.day > temp->entry->date.day)
  1718.                         swap = TRUE;
  1719.                 }
  1720.                 else {
  1721.                     if (temptop->entry->date.year < temp->entry->date.year)
  1722.                         swap = TRUE;
  1723.                     else if (temptop->entry->date.year == temp->entry->date.year &&
  1724.                          temptop->entry->date.month < temp->entry->date.month)
  1725.                         swap = TRUE;
  1726.                     else if (temptop->entry->date.year == temp->entry->date.year &&
  1727.                          temptop->entry->date.month == temp->entry->date.month &&
  1728.                          temptop->entry->date.day < temp->entry->date.day)
  1729.                         swap = TRUE;
  1730.                 }
  1731.                 break;
  1732.  
  1733.             case SORTAMNT:
  1734.                 if (node->order == SORTASCEND) {
  1735.                     if (temptop->entry->amount > temp->entry->amount)
  1736.                         swap = TRUE;
  1737.                 }
  1738.                 else {
  1739.                     if (temptop->entry->amount < temp->entry->amount)
  1740.                         swap = TRUE;
  1741.                 }
  1742.                 break;
  1743.  
  1744.             case SORTNAME:
  1745.                 if (node->order == SORTASCEND) {
  1746.                     if (strcmpi(temptop->entry->name,temp->entry->name) > 0)
  1747.                         swap = TRUE;
  1748.                 }
  1749.                 else {
  1750.                     if (strcmpi(temptop->entry->name,temp->entry->name) < 0)
  1751.                         swap = TRUE;
  1752.                 }
  1753.                 break;
  1754.  
  1755.             case SORTMEMO:
  1756.                 if (node->order == SORTASCEND) {
  1757.                     if (strcmpi(temptop->entry->memo,temp->entry->memo) > 0)
  1758.                         swap = TRUE;
  1759.                 }
  1760.                 else {
  1761.                     if (strcmpi(temptop->entry->memo,temp->entry->memo) < 0)
  1762.                         swap = TRUE;
  1763.                 }
  1764.                 break;
  1765.  
  1766.             case SORTCATEGORY:
  1767.                 if (node->order == SORTASCEND) {
  1768.                     if (strcmpi(temptop->entry->category,temp->entry->category) > 0)
  1769.                         swap = TRUE;
  1770.                 }
  1771.                 else {
  1772.                     if (strcmpi(temptop->entry->category,temp->entry->category) < 0)
  1773.                         swap = TRUE;
  1774.                 }
  1775.                 break;
  1776.         }
  1777.  
  1778.        /* have we scanned the sector? */
  1779.             if (temp == bottom || swap == TRUE)
  1780.         break;
  1781.  
  1782.        /* nope! move on to the next */
  1783.        temp = (filterNode *)temp->node.mln_Succ;
  1784.     }    
  1785.  
  1786.      if (swap) {
  1787.         /* we will swap temptop with temp */
  1788.  
  1789.         /* locate new parent for temptop */
  1790.         tempswap = (filterNode *)temp->node.mln_Pred;
  1791.         if (tempswap == temptop) 
  1792.             tempswap = temp;
  1793.  
  1794.         /* is this the top? */
  1795.         if (temptop == top)
  1796.             top = temp;
  1797.  
  1798.         /* is this the bottom? */
  1799.         if (temp == bottom)
  1800.             bottom = temptop;
  1801.  
  1802.         Remove((struct Node *)temp);
  1803.         Insert((struct List *)&filtered,(struct Node *)temp,(struct Node *)temptop); 
  1804.         Remove((struct Node *)temptop);
  1805.         Insert((struct List *)&filtered,(struct Node *)temptop,(struct Node *)tempswap);
  1806.  
  1807.         /* point to temp for next search */
  1808.         temptop = temp;
  1809.         temp = (filterNode *)temptop->node.mln_Succ;
  1810.     }
  1811.     else {
  1812.         /* the current item needs no movement, next! */
  1813.         if (temptop == bottom) 
  1814.             done = TRUE;
  1815.  
  1816.         else {
  1817.             temptop = (filterNode *)temptop->node.mln_Succ;
  1818.             
  1819.             /* prepare for next round of sorting */
  1820.             if (temptop == NULL || temptop == bottom || temptop->node.mln_Succ == NULL) 
  1821.                 done = TRUE;
  1822.             else temp = (filterNode *)temptop->node.mln_Succ;
  1823.         }
  1824.     }
  1825.  }
  1826.  
  1827.  /* finished, now jump to next level */
  1828.  newtop = newbottom = top;
  1829.  if (next != NULL && next->node.ln_Succ != NULL) {
  1830.  
  1831.     /* find ALL tops and bottoms of this level and sort them */
  1832.     while (    DataSortLevel(bottom,&newtop,&newbottom, node))
  1833.         DataSortFilter(newtop,newbottom,next);    
  1834.  }
  1835. }
  1836.  
  1837. /****************************************************************
  1838. * DataSortLevel()
  1839. *
  1840. *    Finds next block of sublevel entries that need sorting
  1841. *****************************************************************/
  1842. BOOL DataSortLevel(filterNode *bottom, filterNode **stop, filterNode **sbottom, sortNode *sort)
  1843. {
  1844.  BOOL retval = FALSE;
  1845.  BOOL skip = FALSE;
  1846.  UWORD skipcount = 0;
  1847.  filterNode *temptop = NULL; 
  1848.  filterNode *temp;
  1849.  
  1850.  /* are we at the top or subsequent search? */
  1851.  if (*sbottom == *stop) 
  1852.     temptop = *stop;
  1853.  else
  1854.     temptop = (filterNode *)(*sbottom)->node.mln_Succ;
  1855.  
  1856.  /* don't go any farther if this is the bottom */
  1857.  if (*sbottom == bottom || temptop == NULL || temptop == bottom || temptop->node.mln_Succ == NULL) 
  1858.     return(retval);
  1859.  
  1860.  /* scan through while level is equal */
  1861.  temp = (filterNode *)temptop->node.mln_Succ;
  1862.  while (temp != NULL && temp->node.mln_Succ != NULL) {
  1863.     skip = FALSE;
  1864.  
  1865.     /* is this node == to temptop? */
  1866.     switch (sort->index) {
  1867.         case SORTCHECK:
  1868.             if (temptop->entry->check == temp->entry->check) 
  1869.                     skip = TRUE;
  1870.             break;
  1871.  
  1872.         case SORTDATE:
  1873.             if (temptop->entry->date.year == temp->entry->date.year &&
  1874.                  temptop->entry->date.month == temp->entry->date.month &&
  1875.                  temptop->entry->date.day == temp->entry->date.day)
  1876.                     skip = TRUE;
  1877.             break;
  1878.  
  1879.         case SORTAMNT:
  1880.              if (temptop->entry->amount == temp->entry->amount)
  1881.                     skip = TRUE;
  1882.             break;
  1883.  
  1884.         case SORTNAME:
  1885.             if (strcmpi(temptop->entry->name,temp->entry->name) == 0)
  1886.                 skip = TRUE;
  1887.             break;
  1888.  
  1889.         case SORTMEMO:
  1890.             if (strcmpi(temptop->entry->memo,temp->entry->memo) == 0)
  1891.                 skip = TRUE;
  1892.             break;
  1893.  
  1894.         case SORTCATEGORY:
  1895.             if (strcmpi(temptop->entry->category,temp->entry->category) == 0)
  1896.                 skip = TRUE;
  1897.             break;
  1898.  
  1899.     }
  1900.     
  1901.     if (skip == TRUE) {
  1902.         /* yes, check next one (find whole block) */
  1903.         skipcount++;
  1904.         if (temp == bottom) {
  1905.             temp = (filterNode *)temp->node.mln_Succ;
  1906.             break;
  1907.         }
  1908.         else temp = (filterNode *)temp->node.mln_Succ;
  1909.     }
  1910.  
  1911.     else {
  1912.         /* have we captured a region? */
  1913.         if (skipcount > 0)
  1914.             break;
  1915.  
  1916.         /* move temptop down.. */
  1917.         temptop = temp;
  1918.         if (temptop == bottom || temptop == NULL) break;
  1919.         temp = (filterNode *)temptop->node.mln_Succ;
  1920.     }
  1921.  }
  1922.  
  1923.  /* ok what did we grab? */
  1924.  if (skipcount > 0) {
  1925.     temp = (filterNode *)temp->node.mln_Pred;
  1926.     retval = TRUE;
  1927.     *stop = temptop;
  1928.     *sbottom = temp;
  1929.  }
  1930.  
  1931.  return (retval);
  1932. }
  1933.  
  1934. /*************************************************************
  1935. * DataNewEditCat()
  1936. *
  1937. *    Creates a new editcat node and places it at tail
  1938. **************************************************************/
  1939. editCatNode *DataNewEditCat(struct List *el, categoryNode *cat)
  1940. {
  1941.  editCatNode *work;
  1942.  
  1943.  work = (editCatNode *)AllocVec(sizeof(editCatNode), MEMF_CLEAR);
  1944.  memcpy(&work->new,cat,sizeof(categoryNode));
  1945.  work->oldnode = FALSE;
  1946.  work->new.node.ln_Name = work->new.catname;
  1947.  AddTail((struct List *)el,(struct Node *)work);
  1948.  return (work);
  1949. }
  1950.  
  1951. /*************************************************************
  1952. * DataFreeGroupCats()
  1953. *
  1954. *    Special routine to free up group nodes
  1955. **************************************************************/
  1956. void DataFreeGroupCats(struct List *gl)
  1957. {
  1958.  groupNode *work = NULL;
  1959.  
  1960.  while ( (work = (groupNode *)DataGetNext(gl,(struct Node *)work)) != NULL) 
  1961.     DataFreeList(&work->catlist);
  1962. }
  1963.  
  1964. /*************************************************************
  1965. * DataNewGroup()
  1966. *
  1967. *    Creates a new group node and places it at tail
  1968. **************************************************************/
  1969. groupNode *DataNewGroup(struct List *gl, groupNode *grp)
  1970. {
  1971.  groupNode *work;
  1972.  
  1973.  work = (groupNode *)AllocVec(sizeof(groupNode), MEMF_CLEAR);
  1974.  memcpy(work,grp,sizeof(groupNode));
  1975.  NewList(&work->catlist);
  1976.  work->node.ln_Name = work->groupname;
  1977.  AddTail((struct List *)gl,(struct Node *)work);
  1978.  return (work);
  1979. }
  1980.  
  1981. /*************************************************************
  1982. * DataFreeList()
  1983. *
  1984. *    Special free routine for a generic list
  1985. **************************************************************/
  1986. void DataFreeList(struct List *list)
  1987. {
  1988.  struct Node *work = list->lh_Head;
  1989.  struct Node *next;
  1990.  
  1991.  if (IsListEmpty(list))
  1992.     return;
  1993.  
  1994.  while ( (next= work->ln_Succ)) {
  1995.     FreeVec(work);
  1996.     work = next;
  1997.  }
  1998.  
  1999.  NewList(list);
  2000. }
  2001.  
  2002. /**************************************************************
  2003. * DataCopyCatList()
  2004. *
  2005. *    A special copy routine for the edit cat list
  2006. **************************************************************/
  2007. void DataCopyCatList(struct List *editlist, struct List *catlist) 
  2008. { 
  2009.  categoryNode *cat =  (categoryNode *)catlist->lh_Head;
  2010.  editCatNode *work;
  2011.  
  2012.  NewList((struct List *)editlist); 
  2013.  if (IsListEmpty(catlist))
  2014.     return;
  2015.  
  2016.  while (cat->node.ln_Succ) {
  2017.     work = (editCatNode *)AllocVec(sizeof(editCatNode), MEMF_CLEAR);
  2018.     memcpy(&work->original,cat,sizeof(categoryNode));
  2019.     memcpy(&work->new,cat,sizeof(categoryNode));
  2020.     work->oldnode = TRUE;
  2021.     work->new.node.ln_Name = work->new.catname;
  2022.     AddTail((struct List *)editlist,(struct Node *)work);
  2023.     cat = (categoryNode*)cat->node.ln_Succ;
  2024.  }
  2025. }
  2026.  
  2027. /********************************************************
  2028. * DataCopyList()
  2029. *
  2030. *    Copy a simple list from one to another
  2031. *********************************************************/
  2032. void DataCopyList(struct List *src, struct List *dest, funcptr func)
  2033. {
  2034.  struct MinNode *work = NULL;
  2035.  
  2036.  /* free up dest */
  2037.  DataFreeList(dest);
  2038.  
  2039.  while ( (work = (struct MinNode *)DataGetNext(src,(struct Node *)work)) != NULL)
  2040.     func(dest,work);
  2041. }
  2042.  
  2043. /****************************************************
  2044. * DataCopyGroupList()
  2045. *
  2046. *    Copies a group list from one list to the other
  2047.  
  2048. ******************************************************/
  2049. void DataCopyGroupList(struct List *src, struct List *dest)
  2050. {
  2051.  groupNode *new, *work = NULL;
  2052.  
  2053.  /* clean up dest */
  2054.  DataFreeGroupCats(dest);
  2055.  DataFreeList(dest);
  2056.  
  2057.  /* copy each node over */
  2058.  while ( (work = (groupNode *)DataGetNext(src,(struct Node *)work)) != NULL) {
  2059.     new = DataNewGroup(dest,work);
  2060.     DataCopyList(&work->catlist, &new->catlist, (funcptr)DataAddCat);
  2061.  }
  2062.  
  2063. }
  2064.  
  2065. /****************************************************
  2066. * DataMoveCatList()
  2067. *
  2068. *    Moves the special edit list into the original.
  2069. *    replaces ALL system wide categories with
  2070. *    their modified version or NONE if deleted.
  2071. ******************************************************/
  2072. void DataMoveCatList(struct List *edit)
  2073. {
  2074.  editCatNode *en, *next;
  2075.  
  2076.  /* replace the database entries */
  2077.  DataReplaceEntryCats(edit);
  2078.  DataReplaceTempCats(edit);
  2079.  /*DataReplaceGroupCats(&grouplist, edit);*/
  2080.  
  2081.  /* replace all control structures */
  2082.  en = DataLocateCat(edit,filterControl.category);
  2083.  strcpy(filterControl.category,en->new.catname);
  2084.  
  2085.  en = DataLocateCat(edit,searchControl.catstr);
  2086.  /* only replace search if _exact_ match */
  2087.  if (strcmpi(en->original.catname,searchControl.catstr) == 0)
  2088.      strcpy(searchControl.catstr,en->new.catname);
  2089.  
  2090. /* what the hell was I thinking...
  2091.  en = DataLocateCat(edit,sortEntries[SORTCATEGORY].field);
  2092.  strcpy(sortEntries[SORTCATEGORY].field,en->new.catname);
  2093. */
  2094.  
  2095.  /* free up original list */
  2096.  DataFreeList(&categories);
  2097.  
  2098.  /* create new cat list */
  2099.  en = (editCatNode *)edit->lh_Head;
  2100.  while ( (next = (editCatNode *)en->new.node.ln_Succ)) {
  2101.     DataAddCat(&categories,(categoryNode *)(&en->new));
  2102.     en = next;
  2103.  }
  2104.  
  2105.   /* free up edit list */
  2106.  DataFreeList(edit);
  2107. }
  2108.  
  2109. /********************************************************
  2110. * DataReplaceGroupCats()
  2111. *
  2112. *    replaces all categories with their new names
  2113. *********************************************************/
  2114. void DataReplaceGroupCats(struct List *grps, struct List *new)
  2115. {
  2116.  editCatNode *en;
  2117.  groupNode *node = NULL;
  2118.  categoryNode *cat;
  2119.  struct Node *find;
  2120.  
  2121.  while ( (node = (groupNode *)DataGetNext(grps, node)) != NULL) {
  2122.     cat = NULL;
  2123.     while ( (cat = (categoryNode *)DataGetNext(&node->catlist,cat)) != NULL) {
  2124.         /* replace all control structures */
  2125.         en = DataLocateCat(new, cat->catname);
  2126.         if (strcmpi(en->new.catname,"none") == 0) {
  2127.              find = DataFindName(new,cat->catname);
  2128.             if (find == NULL) {
  2129.                 Remove(cat);
  2130.                 FreeVec(cat);
  2131.                 cat = NULL;
  2132.             }
  2133.              else     strcpy(cat->catname,en->new.catname);
  2134.         }
  2135.         else    strcpy(cat->catname,en->new.catname);
  2136.     }
  2137.  }
  2138. }
  2139.  
  2140. /********************************************************
  2141. * DataReplaceTempCats()
  2142. *
  2143. *    replaces all categories with their new names
  2144. *********************************************************/
  2145. void DataReplaceTempCats(struct List *new)
  2146. {
  2147.  editCatNode *found;
  2148.  templateNode *node, *next;
  2149.  
  2150.  if (templates.lh_TailPred == (struct Node *)&templates)
  2151.     return;
  2152.  
  2153.  node = (templateNode *)templates.lh_Head;
  2154.  while ( (next = (templateNode *)node->node.ln_Succ) ){
  2155.     found = DataLocateCat(new,node->template.category);
  2156.     strcpy(node->template.category,found->new.catname);
  2157.  
  2158.     node = next;
  2159.  }
  2160. }
  2161.  
  2162. /********************************************************
  2163. * DataReplaceEntryCats()
  2164. *
  2165. *    replaces all categories with their new names
  2166. *********************************************************/
  2167. void DataReplaceEntryCats(struct List *new)
  2168. {
  2169.  editCatNode *found;
  2170.  entryNode *node, *next;
  2171.  
  2172.  if (entries.mlh_TailPred == &entries)
  2173.     return;
  2174.  
  2175.  node = (entryNode *)entries.mlh_Head;
  2176.  while ( (next = (entryNode *)node->node.mln_Succ) ){
  2177.     found = DataLocateCat(new,node->category);
  2178.     strcpy(node->category,found->new.catname);
  2179.  
  2180.     node = next;
  2181.  }
  2182. }
  2183.  
  2184. /********************************************************
  2185. * DataLocateCat()
  2186. *
  2187. *    Locate an original cat name.. return NONE if deleted
  2188. **********************************************************/
  2189. editCatNode *DataLocateCat(struct List *new, char *cat)
  2190. {
  2191.  editCatNode *temp, *next;
  2192.  
  2193.  temp = (editCatNode *)new->lh_Head;
  2194.  while ( (next = (editCatNode *)temp->new.node.ln_Succ) ){
  2195.     if (temp->oldnode == TRUE && strcmpi(cat,temp->original.catname) == 0)
  2196.         return (temp);
  2197.  
  2198.     temp = next;
  2199.  } 
  2200.  
  2201.  return ( (editCatNode*)(new->lh_Head));
  2202. }
  2203.  
  2204. /**********************************************************
  2205. * DataSearchFilter()
  2206. *
  2207. *    Searches through a fliter list for search match
  2208. ***********************************************************/
  2209. WORD DataSearchFilter(struct MinList *fl, searchState *search)
  2210. {
  2211.  WORD entry = 0, firstrow = -1;
  2212.  BOOL findfirst;
  2213.  filterNode *work = (filterNode *)fl->mlh_Head, *next;
  2214.  
  2215.  if (fl->mlh_TailPred == fl)
  2216.     return ( -1 );
  2217.  
  2218.  /* is there any criteria to begin with? */
  2219.  if (!search->check && !search->amnt && !search->date && !search->category &&
  2220.     !search->name && !search->memo)
  2221.     return (-1);
  2222.  
  2223.  /* can we return on the first match? */
  2224.  if (search->lastrow == -1 || search->lastrow >= entryCount)
  2225.     findfirst = TRUE;
  2226.  else findfirst = FALSE;
  2227.  
  2228.  while ( (next = (filterNode *)work->node.mln_Succ) ) {
  2229.  
  2230.     if (DataSearchMatch(work,search)) {
  2231.         if (firstrow == -1) {
  2232.             firstrow = entry;
  2233.             if (findfirst || entry > search->lastrow)
  2234.                 return (entry);
  2235.         }
  2236.         else if (entry > search->lastrow)
  2237.             return (entry);
  2238.     }
  2239.  
  2240.     /* next! */
  2241.     entry++;
  2242.     work = next;
  2243.  }
  2244.  
  2245.  /* did we match before entry? */
  2246.  return (firstrow);
  2247. }
  2248.  
  2249. /********************************************************************
  2250. * DataSearchMatch()
  2251. *
  2252. *    Match a filter to a search criteria
  2253. *********************************************************************/
  2254. BOOL DataSearchMatch(filterNode *fn, searchState *search)
  2255. {
  2256.  
  2257.  if (search->check && fn->entry->type != CHECKTYPE)
  2258.     return (FALSE);
  2259.  
  2260.  if (search->check && (fn->entry->check != search->checknum))
  2261.     return (FALSE);
  2262.  
  2263.  if (search->memo && !MatchPatternNoCase(search->memostrtoken, fn->entry->memo))
  2264.     return (FALSE);
  2265.  
  2266.  if (search->name && !MatchPatternNoCase(search->namestrtoken, fn->entry->name))
  2267.     return (FALSE);
  2268.  
  2269.  if (search->category && !MatchPatternNoCase(search->catstrtoken, fn->entry->category))
  2270.     return (FALSE);
  2271.  
  2272.  if (search->amnt && (fn->entry->amount != search->amount))
  2273.     return (FALSE);
  2274.  
  2275.  if (search->date && (fn->entry->date.year != search->searchdate.year || 
  2276.               fn->entry->date.month != search->searchdate.month ||
  2277.               fn->entry->date.day != search->searchdate.day) )
  2278.     return (FALSE);
  2279.  
  2280.  return (TRUE);
  2281. }
  2282.  
  2283. /**********************************************************
  2284. * DataFindName()
  2285. *
  2286. *    Case insensitive "FindName"
  2287. ***********************************************************/
  2288. struct Node *DataFindName(struct List *l, char *name)
  2289. {
  2290.  struct Node *work = (struct Node *)l->lh_Head, *next;
  2291.  
  2292.  if (IsListEmpty(l))
  2293.     return (NULL);
  2294.  
  2295.  while ( (next = (struct Node *)work->ln_Succ)) {
  2296.     if (strcmpi(work->ln_Name,name) == 0)
  2297.         return (work);
  2298.     work = next;
  2299.  }
  2300.  
  2301.  return (NULL);
  2302. }
  2303.  
  2304. /**********************************************************
  2305. * DataFindNode()
  2306. *
  2307. *    search for node
  2308. ***********************************************************/
  2309. WORD DataFindNode(struct List *l, struct Node *node)
  2310. {
  2311.  WORD index = 0;
  2312.  struct Node *work = (struct Node *)l->lh_Head, *next;
  2313.  
  2314.  if (IsListEmpty(l))
  2315.     return (-1);
  2316.  
  2317.  while ( (next = (struct Node *)work->ln_Succ)) {
  2318.     if (work == node)
  2319.         return (index);
  2320.     work = next;
  2321.     index++;
  2322.  }
  2323.  
  2324.  return (-1);
  2325. }
  2326.  
  2327. /************************************************************
  2328. * DataBalance()
  2329. *
  2330. *    calculate a balance based on flags. ignores
  2331. *     account default balance
  2332. ************************************************************/
  2333. balanceType DataBalance(UBYTE flags, struct MinList *list)
  2334. {
  2335.  amountType amnt=0;
  2336.  balanceType bal;
  2337.  entryNode *entry = (entryNode *)list->mlh_Head, *next;
  2338.  
  2339.  DataInitBal(DEPOSITTYPE,&amnt,&bal);
  2340.  
  2341.  if (IsListEmpty((struct List *)list))
  2342.     return (bal);
  2343.  
  2344.  while ( (next = (entryNode *)entry->node.mln_Succ)) {
  2345.     if ( !(entry->flags & VOIDED) && (entry->flags & flags) == flags) {
  2346.         /*if (entry->type == DEPOSITTYPE)*/
  2347.             DataAddBal(DEPOSITTYPE,&entry->amount,&bal);
  2348. /*
  2349.         bal += entry->amount;
  2350.  
  2351.         else
  2352.             bal -= entry->amount;
  2353. */
  2354.     }
  2355.     entry = next;
  2356.  }
  2357.  
  2358.  return (bal);
  2359. }
  2360.  
  2361. /************************************************************
  2362. * DataSaveFile()
  2363. *
  2364. *    Save an account
  2365. *************************************************************/
  2366. BOOL DataSaveFile(char *fname, BOOL create)
  2367. {
  2368.  int fd;
  2369.  UWORD magicnum = MAGICNUM;
  2370.  UWORD temp;
  2371.  struct netInfoVars netInfo;
  2372.  categoryNode *cat=NULL;
  2373.  templateNode *tmpl=NULL;
  2374.  entryNode *entry=NULL;
  2375.  sortNode *tempsort = NULL;
  2376.  memoNode *memo = NULL;
  2377.  nameNode *nm = NULL;
  2378.  amntNode *am = NULL;
  2379.  groupNode *group = NULL;
  2380.  
  2381.  
  2382.  if ( (fd = open(fname,O_WRONLY | ((create)?O_CREAT:0) ,0)) == -1)
  2383.     return(FALSE);
  2384.  
  2385.  /* write magic number */
  2386.  if (write (fd,&magicnum,sizeof(UWORD)) == -1) {
  2387.     close (fd);
  2388.     return (FALSE);
  2389.  }
  2390.  
  2391.  /* calculate and write tax info */
  2392.  netInfo.taxdeductcurr = DataBalance( (UBYTE)TAXDEDUCT,&entries);
  2393.  netInfo.taxdeductstate = DataBalance( (UBYTE)(TAXDEDUCT | RECONCILED),&entries);
  2394.  netInfo.currAmnt = amntState.currAmnt;
  2395.  netInfo.stateAmnt = amntState.stateAmnt;
  2396.  netInfo.decimal = usrAccount.decimal;
  2397.  if (write (fd, &netInfo, sizeof(struct netInfoVars)) == -1) {
  2398.     close(fd);
  2399.     return (FALSE);
  2400.  }
  2401.  
  2402.  /* write user macros*/
  2403.  if (write (fd, arexxMacros, sizeof(arexxNode)*MAXMACROS) == -1) {
  2404.         close (fd);
  2405.         return (FALSE);
  2406.  }
  2407.  
  2408.  /* write user check form */
  2409.  if (write (fd,&checkForms.userForm,sizeof(checkForm)) == -1) {
  2410.     close(fd);
  2411.     return (FALSE);
  2412.  }
  2413.  
  2414.  /* write print prefs */
  2415.  if (write (fd,&checkPrint,sizeof(printControl)) == -1) {
  2416.     close(fd);
  2417.     return (FALSE);
  2418.  }
  2419.  
  2420.  /* write report structure */
  2421.  if (write (fd,&reportControl,sizeof(reportSetting)) == -1) {
  2422.     close (fd);
  2423.     return (FALSE);
  2424.  }
  2425.  
  2426.  /* write filter structure */
  2427.  if (write (fd,&filterControl,sizeof(filterSetting)) == -1) {
  2428.     close (fd);
  2429.     return (FALSE);
  2430.  }
  2431.  
  2432.  /* write search structure */
  2433.  if (write (fd,&searchControl, sizeof(searchState)) == -1) {
  2434.     close (fd);
  2435.     return (FALSE);
  2436.  }
  2437.  
  2438.  /* write num of sorts */
  2439.  temp = DataCountNodes(&sortfields);
  2440.  if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2441.     close (fd);
  2442.     return (FALSE);
  2443.  }
  2444.  
  2445.  /* write sort structure */
  2446.  while ( (tempsort = (sortNode *)DataGetNext(&sortfields,tempsort)))
  2447.     if (write (fd,tempsort,sizeof(sortNode)) == -1) {
  2448.         close(fd);
  2449.         return (FALSE);
  2450.     }
  2451.  
  2452.  /* write sort state */
  2453.  if (write (fd, &sortStates, sizeof(sortState)) == -1){
  2454.     close(fd);
  2455.     return (FALSE);
  2456.  }
  2457.  
  2458.  /* write account structure */
  2459.  if (write (fd, &usrAccount,sizeof(accntState)) == -1) {
  2460.     close(fd);
  2461.     return (FALSE);
  2462.  }
  2463.  
  2464.  /* write num of categories */
  2465.  temp = DataCountNodes(&categories);
  2466.  if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2467.     close(fd);
  2468.     return (FALSE);
  2469.  }
  2470.  
  2471.  /* write categories */
  2472.  while ( (cat = (categoryNode*)DataGetNext(&categories,cat)))
  2473.     if (write(fd,cat,sizeof(categoryNode)) == -1) {
  2474.         close(fd);
  2475.         return (FALSE);
  2476.     }
  2477.  
  2478.  /* write num groups */
  2479.  temp = DataCountNodes(&grouplist);
  2480.  if (write(fd,&temp,sizeof(UWORD)) == -1) {
  2481.     close(fd);
  2482.     return (FALSE);
  2483.  }
  2484.  
  2485.  /* write groups, one at a time */
  2486.  while ( (group = (groupNode *)DataGetNext(&grouplist,group))) {
  2487.     if (write(fd,group,sizeof(groupNode)) == -1) {
  2488.         close(fd);
  2489.         return(FALSE);
  2490.     }
  2491.  
  2492.     temp = DataCountNodes(&group->catlist);
  2493.     if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2494.         close(fd);
  2495.         return (FALSE);
  2496.     }
  2497.  
  2498.     cat = NULL;
  2499.     while ( (cat = (categoryNode*)DataGetNext(&group->catlist,cat)))
  2500.         if (write(fd,cat,sizeof(categoryNode)) == -1) {
  2501.             close(fd);
  2502.             return (FALSE);
  2503.         }
  2504.  }
  2505.  
  2506.  /* write num of templates */
  2507.  temp = DataCountNodes(&templates);
  2508.  if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2509.     close(fd);
  2510.     return (FALSE);
  2511.  }
  2512.  
  2513.  /* write templates */
  2514.  while ( (tmpl = (templateNode*)DataGetNext(&templates,tmpl)))
  2515.     if (DataWriteTemplate(fd, tmpl) != 0) {
  2516.         close(fd);
  2517.         return(FALSE);
  2518.     }
  2519.  
  2520.  /* write num of entries */
  2521.  temp = DataCountNodes((struct List *)&entries);
  2522.  if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2523.     close(fd);
  2524.     return (FALSE);
  2525.  }
  2526.  
  2527.  /* write entries */
  2528.  while ( (entry = (entryNode*)DataGetNext((struct List *)&entries, (struct Node *)entry)))
  2529.     if (DataWriteEntry(fd,entry) != 0) {
  2530.         close(fd);
  2531.         return(FALSE);
  2532.     }
  2533.  
  2534.  
  2535.  /* checkbook state information */
  2536.  if (write (fd,&amntState,sizeof(struct stateVars)) == -1) {
  2537.     close(fd);
  2538.     return (FALSE);
  2539.  }
  2540.  
  2541.  
  2542.  /* save the memo list */
  2543.  temp = DataCountNodes((struct List *)&memolist);
  2544.  if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2545.     close(fd);
  2546.     return (FALSE);
  2547.  }
  2548.  
  2549.  /* write memos */
  2550.  while ( (memo = (memoNode*)DataGetNext((struct List *)&memolist, (struct Node *)memo)))
  2551.     if (write(fd,memo,sizeof(memoNode)) == -1) {
  2552.         close(fd);
  2553.         return (FALSE);
  2554.     }
  2555.  
  2556.  /* do the same for the names list and amnts list */
  2557.  temp = DataCountNodes((struct List *)&namelist);
  2558.  if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2559.     close(fd);
  2560.     return (FALSE);
  2561.  }
  2562.  
  2563.  /* write names */
  2564.  while ( (nm = (nameNode*)DataGetNext((struct List *)&namelist, (struct Node *)nm)))
  2565.     if (write(fd,nm,sizeof(nameNode)) == -1) {
  2566.         close(fd);
  2567.         return (FALSE);
  2568.     }
  2569.  
  2570.  temp = DataCountNodes((struct List *)&amntlist);
  2571.  if (write (fd, &temp, sizeof(UWORD)) == -1) {
  2572.     close(fd);
  2573.     return (FALSE);
  2574.  }
  2575.  
  2576.  /* write names */
  2577.  while ( (am = (amntNode*)DataGetNext((struct List *)&amntlist, (struct Node *)am)))
  2578.     if (write(fd,am,sizeof(amntNode)) == -1) {
  2579.         close(fd);
  2580.         return (FALSE);
  2581.     }
  2582.  
  2583.  close(fd);
  2584.  return (TRUE);
  2585. }
  2586.  
  2587. /************************************************************
  2588. * DataLoadFile()
  2589. *
  2590. *    Load an account
  2591. *************************************************************/
  2592. BOOL DataLoadFile(char *fname)
  2593. {
  2594.  int fd;
  2595.  int x,y;
  2596.  UWORD magicnum;
  2597.  UWORD temp,temp3;
  2598.  categoryNode cat;
  2599.  entryNode entry;
  2600.  memoNode memo;
  2601.  nameNode nm;
  2602.  amntNode am;
  2603.  templateNode tmpl;
  2604.  sortNode tempsort;
  2605.  filterNode *filt;
  2606.  groupNode *group, tempgroup;
  2607.  struct netInfoVars netInfo;
  2608.  
  2609.  if ( (fd = open(fname,O_RDONLY,0)) == -1)
  2610.     return (FALSE);
  2611.  
  2612.  /* read magic number */
  2613.  read (fd,&magicnum,sizeof(UWORD));
  2614.  
  2615.  if (magicnum > MAGICNUM || magicnum < MAGICNUMOLD1 ) {
  2616.     close(fd);
  2617.     return (FALSE);
  2618.  }
  2619.  
  2620.  /* read tax vars */
  2621.  DataReadTaxVars(magicnum,fd, &netInfo);
  2622.  
  2623.  usrAccount.decimal = netInfo.decimal;
  2624.  
  2625.  /* read in user macros*/
  2626.  if (magicnum > MAGICNUMOLD8) {
  2627.     read (fd, arexxMacros, sizeof(arexxNode)*MAXMACROS);
  2628.  }
  2629.  
  2630.  if (magicnum >= MAGICNUMOLD6) {
  2631.      /* user check form */
  2632.     if (magicnum == MAGICNUMOLD6)
  2633.          read (fd,&checkForms.userForm,sizeof(checkForm)-(sizeof(ULONG)*3));
  2634.     else     read (fd,&checkForms.userForm,sizeof(checkForm));
  2635.  
  2636.      /* print prefs */
  2637.      read (fd,&checkPrint,sizeof(printControl));
  2638.  }
  2639.  
  2640.  /* read report structure */
  2641.  read (fd,&reportControl,sizeof(reportSetting));
  2642.  
  2643.  /* read filter structure */
  2644.  DataReadFilterSetting(magicnum,fd,&filterControl);
  2645.  
  2646.  /* read search structure */
  2647.  DataReadSearchControl(magicnum,fd,&searchControl);
  2648.  
  2649.  /* read num of sorts */
  2650.  read (fd, &temp, sizeof(UWORD));
  2651.  
  2652.  /* read sort structure */
  2653.  NewList(&sortfields);
  2654.  for (x=0;x<temp;x++) {
  2655.     read (fd,&tempsort,sizeof(sortNode));
  2656.     memcpy(&sortEntries[tempsort.index],&tempsort,sizeof(sortNode));
  2657.     sortEntries[tempsort.index].node.ln_Succ = sortEntries[tempsort.index].node.ln_Pred = 0;
  2658.     sortEntries[tempsort.index].node.ln_Name = sortEntries[tempsort.index].field;
  2659.     AddTail(&sortfields,&sortEntries[tempsort.index]);
  2660.  }
  2661.  
  2662.  /* read sort state */
  2663.  read (fd, &sortStates, sizeof(sortState));
  2664.  
  2665.  /* read account structure */
  2666.  DataReadAccountInfo(magicnum,fd,&usrAccount);
  2667.  
  2668.  /* read num of categories */
  2669.  read (fd, &temp, sizeof(UWORD));
  2670.  
  2671.  /* read categories */
  2672.  DataFreeList(&categories);
  2673.  for (x=0;x<temp;x++) {
  2674.     read (fd,&cat,sizeof(categoryNode));
  2675.     DataAddCat(&categories,&cat);
  2676.  }
  2677.  
  2678.  /* read in groups */
  2679.  if (magicnum > MAGICNUMOLD7) {
  2680.  
  2681.     /* read num of groups */
  2682.      read (fd, &temp, sizeof(UWORD));
  2683.  
  2684.     DataFreeGroupCats(&grouplist);
  2685.     DataFreeList(&grouplist);
  2686.     
  2687.     /* read in each group */
  2688.     for (x=0;x<temp;x++) {
  2689.         read(fd,&tempgroup,sizeof(groupNode));
  2690.         group = DataNewGroup(&grouplist,&tempgroup);
  2691.         
  2692.         /* read each group category in */
  2693.         read(fd,&temp3,sizeof(UWORD));
  2694.         for (y=0;y<temp3;y++) {
  2695.             read(fd,&cat,sizeof(categoryNode));
  2696.             DataAddCat(&group->catlist,&cat);
  2697.         }
  2698.     }
  2699.  }
  2700.  
  2701.  /* read num of templates */
  2702.  read (fd, &temp, sizeof(UWORD));
  2703.  
  2704.  /* read templates */
  2705.  DataFreeList(&templates);
  2706.  for (x=0;x<temp;x++) {
  2707.     DataReadTemplate(magicnum,fd,&tmpl);
  2708.     DataAddTemp(&templates, &tmpl);
  2709.  }
  2710.  
  2711.  /* read num of entries */
  2712.  read (fd, &temp, sizeof(UWORD));
  2713.  
  2714.  /* read entries */
  2715.  DataFreeList((struct List *)&filtered);
  2716.  entryCount = 0;
  2717.  DataFreeList((struct List *)&entries);
  2718.  for (x=0;x<temp;x++) {
  2719.     DataReadEntry(magicnum,fd,&entry);
  2720.     DataAddEntry(&entry,&entries,&filt);
  2721.     if (filt) entryCount++;
  2722.  }
  2723.  
  2724.  /* basic state variables */
  2725.  DataReadStateVars(magicnum,fd, &amntState);
  2726.  
  2727.  /* read in memos */
  2728.  if (magicnum >= MAGICNUMOLD4) {
  2729.     DataFreeList(&memolist);
  2730.     read (fd, &temp, sizeof(UWORD));
  2731.     for (x=0;x<temp;x++) {
  2732.         read (fd,&memo,sizeof(memoNode));
  2733.         MemoNewEdit(&memolist,&memo);
  2734.      }
  2735.  }
  2736.  
  2737.  if (magicnum > MAGICNUMOLD4) {
  2738.     DataFreeList(&namelist);
  2739.     read(fd,&temp,sizeof(UWORD));
  2740.     for (x=0;x<temp;x++) {
  2741.         read (fd,&nm,sizeof(nameNode));
  2742.         NameNewEdit(&namelist,&nm);
  2743.      }
  2744.  
  2745.     DataFreeList(&amntlist);
  2746.     read(fd,&temp,sizeof(UWORD));
  2747.     for (x=0;x<temp;x++) {
  2748.         read (fd,&am,sizeof(amntNode));
  2749.         AmntNewEdit(&amntlist,&am);
  2750.      }
  2751.  }
  2752.  
  2753.  DataInitBalances();
  2754.  
  2755.  if (close (fd))
  2756.     return (FALSE);
  2757.  return (TRUE);
  2758. }
  2759.  
  2760. /*******************************************************
  2761. * DataCountNodes()
  2762. *
  2763. *    Count # nodes in a list
  2764. ********************************************************/
  2765. UWORD DataCountNodes(struct List *lst)
  2766. {
  2767.  UWORD ret = 0;
  2768.  struct Node *work = lst->lh_Head;
  2769.  struct Node *next;
  2770.  
  2771.  if (IsListEmpty(lst))
  2772.     return (ret);
  2773.  
  2774.  while (( next = work->ln_Succ)) {
  2775.     ret++;
  2776.     work = next;
  2777.  }
  2778.  
  2779.  return (ret);
  2780. }
  2781.  
  2782. /*******************************************************
  2783. * DataGetNext()
  2784. *
  2785. *    Get the next node in the list
  2786. ********************************************************/
  2787. struct Node *DataGetNext(struct List *lst, struct Node *parent)
  2788. {
  2789.  if (IsListEmpty(lst))
  2790.     return (NULL);
  2791.  
  2792.  if (parent == NULL)
  2793.     return (lst->lh_Head);
  2794.  
  2795.  if (parent->ln_Succ->ln_Succ)
  2796.     return (parent->ln_Succ);
  2797.  
  2798.  return (NULL);
  2799. }
  2800.  
  2801. /*******************************************************
  2802. * DataGetFileName()
  2803. *
  2804. *    Obtain the file name from an ASL requestor
  2805. ********************************************************/
  2806. BOOL DataGetFileName(char *dest, short destsize, char *drawer, char *file)
  2807. {
  2808.  strncpy(dest, drawer, destsize);
  2809.  return (AddPart( dest, file, destsize));
  2810. }
  2811.  
  2812. /*******************************************************
  2813. * DataAttachIcon()
  2814. *
  2815. *    Attaches icons to files    
  2816. ********************************************************/
  2817. void DataAttachIcon(char *iconpath, char *iconname, char *fname)
  2818. {
  2819.  struct DiskObject *diskobj;
  2820.  char icon[200];
  2821.  
  2822.  sprintf(icon,"%s%s",iconpath,iconname);
  2823.  if ( (diskobj = GetDiskObjectNew(icon)) != NULL) {
  2824.      PutDiskObject(fname,diskobj);
  2825.     FreeDiskObject(diskobj);
  2826.  }
  2827. }
  2828.  
  2829. /********************************************************
  2830. * DataRunningBals()
  2831. *
  2832. *    Calculates running balances for the filters
  2833. *********************************************************/
  2834. balanceType DataRunningBals(struct MinList *entries, struct MinList *filtered)
  2835. {
  2836.  amountType zero = 0;
  2837.  balanceType scale,bal;
  2838.  filterNode *filt;
  2839.  entryNode *next, *entry = (entryNode *)entries->mlh_Head;
  2840.  
  2841.  DataInitBal(DEPOSITTYPE,&usrAccount.beginAmount,&bal);
  2842.  DataInitBal(DEPOSITTYPE,&zero, &scale);
  2843.  
  2844.  if (entries->mlh_TailPred == (struct Node *)entries)
  2845.     return (bal);
  2846.  
  2847.  if (filtered->mlh_TailPred == (struct Node *)filtered)
  2848.     return (bal);
  2849.  
  2850.  while ( (next = (entryNode *)entry->node.mln_Succ)) {
  2851.     if (!(entry->flags & VOIDED)) {
  2852.         DataAddBal(entry->type,&entry->amount,&bal);
  2853.     }
  2854.  
  2855.     if (DataTestFilter(entry,&filterControl) == TRUE) {
  2856.  
  2857.         if ( DataCmpAmntBal(&entry->amount,&scale) == 1)
  2858.             DataInitBal(DEPOSITTYPE,&entry->amount,&scale);
  2859.         else if ( DataCmpBal(FALSE, &bal, &scale) == 1)
  2860.             memcpy(&scale,&bal,sizeof(balanceType));
  2861.  
  2862.         filt = (filterNode *)filtered->mlh_Head;
  2863.     
  2864.          /* locate filter */
  2865.          while (filt->node.mln_Succ != NULL) {
  2866.             if (filt->entry == entry) {
  2867.                 if (filt->entry->flags & VOIDED)
  2868.                     DataInitBal(DEPOSITTYPE,&zero,&filt->runningBal);
  2869.                 else
  2870.                     memcpy(&filt->runningBal,&bal,sizeof(balanceType));
  2871.                 break;
  2872.             }
  2873.  
  2874.             filt = (filterNode *)filt->node.mln_Succ;
  2875.         }
  2876.     }    
  2877.     entry = next;
  2878.  }
  2879.  
  2880.  DataAddBal(DEPOSITTYPE,&usrAccount.beginAmount,&scale);
  2881.  return (scale);
  2882. }
  2883.  
  2884. /********************************************************
  2885. * DataSummarize()
  2886. *
  2887. *      Obtain summary information from account
  2888. *********************************************************/
  2889. BOOL DataSummarize(char *fname, netNode *net)
  2890. {
  2891.  int fd;
  2892.  unsigned short magicnum;
  2893.  
  2894.  if ( (fd = open(fname,O_RDONLY,0)) == -1)
  2895.     return (FALSE);
  2896.  
  2897.  /* read magic number */
  2898.  read (fd,&magicnum,sizeof(UWORD));
  2899.  
  2900.  if (magicnum < MAGICNUMOLD3) {
  2901.     close(fd);
  2902.     return (FALSE);
  2903.  }
  2904.  
  2905.  DataReadTaxVars(magicnum,fd,&net->balances);
  2906.  
  2907.  strcpy(net->acname,fname);
  2908.  close(fd);
  2909.  return (TRUE);
  2910. }
  2911.  
  2912. /************************************************************
  2913. * DataFilterBalance()
  2914. *
  2915. *    calculate the filter balance
  2916. ************************************************************/
  2917. void DataFilterBalance(struct MinList *list)
  2918. {
  2919.  amountType zero = 0;
  2920.  balanceType bal;
  2921.  filterNode *filter = (filterNode *)list->mlh_Head, *next;
  2922.  
  2923.  DataInitBal(DEPOSITTYPE,&zero,&bal);
  2924.  DataInitBal(DEPOSITTYPE,&zero,&filtAmnt);
  2925.  
  2926.  if (IsListEmpty((struct List *)list))
  2927.     return;
  2928.  
  2929.  while ( (next = (filterNode *)filter->node.mln_Succ)) {
  2930.     if ( !(filter->entry->flags & VOIDED) ) {
  2931.         DataAddBal(filter->entry->type, &filter->entry->amount,&bal);
  2932.     }
  2933.     filter = next;
  2934.  }
  2935.  
  2936.  memcpy(&filtAmnt, &bal, sizeof(balanceType));
  2937.  
  2938.  return;
  2939. }
  2940.  
  2941. /*******************************************************
  2942. * DataInitBalances()
  2943. *
  2944. *     Initializes stmt and curr balances from load.
  2945. *    They are read from the account, but don't trust
  2946. *    them.
  2947. ********************************************************/
  2948. void DataInitBalances(void)
  2949. {
  2950.  entryNode *entry = NULL;
  2951.  
  2952.  DataInitBal(DEPOSITTYPE,&usrAccount.beginAmount,&amntState.currAmnt);
  2953.   
  2954.  while ( (entry = (entryNode *)DataGetNext((struct List *)&entries,(struct Node *)entry)) != NULL) {
  2955.     if (!(entry->flags & VOIDED)) {
  2956.         DataAddBal(entry->type,&entry->amount,&amntState.currAmnt);
  2957.      }
  2958.  }
  2959. }
  2960.  
  2961. /*******************************************************
  2962. * DataWriteTemplate()
  2963. *
  2964. *    Write a template to file 
  2965. ********************************************************/
  2966. int DataWriteTemplate(int fd, templateNode *temp)
  2967. {
  2968.  if (write(fd,temp->tempname,TEMPNAMESIZE) == -1)
  2969.     return -1;
  2970.  
  2971.  return (DataWriteEntry(fd,&temp->template));
  2972. }
  2973.  
  2974. /*******************************************************
  2975. * DataWriteEntry()
  2976. *
  2977. *    Pack entries in file format and write out.     
  2978. ********************************************************/
  2979. int DataWriteEntry(int fd, entryNode *entry)
  2980. {
  2981.  struct packit out;
  2982.  UBYTE catsize;
  2983.  
  2984.  out.type = entry->type;
  2985.  out.check = entry->check;
  2986.  out.flags = entry->flags;
  2987.  out.amount = entry->amount;
  2988.  out.date.year = entry->date.year;
  2989.  out.date.day = entry->date.day;
  2990.  out.date.month = entry->date.month;
  2991.  out.namesize = strlen(entry->name);
  2992.  out.memosize = strlen(entry->memo);
  2993.  
  2994.  out.addr1size = out.addr2size = out.addr3size = out.addr4size = 0;
  2995.  out.numBudgets = 1;
  2996.  
  2997.  /* write out each datumn */
  2998.  if (write (fd,&out,sizeof(struct packit)) != sizeof(struct packit))
  2999.     return (-1);
  3000.  
  3001.  /* write out strings */
  3002.  if (write(fd,entry->name,out.namesize) != out.namesize)
  3003.     return (-1);
  3004.  if (write(fd,entry->memo,out.memosize) != out.memosize)
  3005.     return (-1);
  3006.  
  3007.  /* now for each category available... (currently just one) */ 
  3008.  
  3009.  catsize = strlen(entry->category);
  3010.  if (write(fd,&catsize,sizeof(UBYTE)) != sizeof(UBYTE))
  3011.     return (-1);
  3012.  if (write(fd,entry->category,catsize) != catsize)
  3013.     return (-1);
  3014.  if (write(fd,&entry->amount,sizeof(amountType)) != sizeof(amountType))
  3015.     return (-1);
  3016.  
  3017.  return (0);
  3018. }
  3019.  
  3020. /*************************************************************
  3021. * DataCreateDate()
  3022. *
  3023. *    Create date based on multiple formats 
  3024. **************************************************************/
  3025. void DataCreateDate(dateType *date, char *out, BOOL year)
  3026. {
  3027.  
  3028. switch (dateFormat) {
  3029.     case DATE_MMDDYY:
  3030.         if (year)
  3031.             sprintf(out,"%02d/%02d/%2d",date->month,date->day,date->year % 100);
  3032.         else    sprintf(out,"%02d/%02d/%4d",date->month,date->day,date->year);
  3033.         break;
  3034.  
  3035.     case DATE_DDMMYY:
  3036.         if (year)
  3037.             sprintf(out,"%02d/%02d/%2d",date->day,date->month,date->year % 100);
  3038.         else    sprintf(out,"%02d/%02d/%4d",date->day,date->month,date->year);
  3039.  
  3040.         break;
  3041.  
  3042.     case DATE_DEC_12:
  3043.         if (year)
  3044.             sprintf(out,"%s-%02d-%2d",easymonths[date->month-1],date->day,date->year % 100);
  3045.         else    sprintf(out,"%s-%02d-%4d",easymonths[date->month-1],date->day,date->year);
  3046.  
  3047.         break;
  3048.  
  3049.     case DATE_12_DEC:
  3050.         if (year)
  3051.             sprintf(out,"%02d-%s-%2d",date->day,easymonths[date->month-1],date->year % 100);
  3052.         else    sprintf(out,"%02d-%s-%4d",date->day,easymonths[date->month-1],date->year);
  3053.  
  3054.         break;
  3055. }
  3056. }
  3057.  
  3058. /***************************************************************
  3059. * DataExtractDate()
  3060. *
  3061. *    extract date fields from date strings
  3062. ****************************************************************/
  3063. void DataExtractDate(dateType *date, char *out)
  3064. {
  3065.  ULONG day,year,month;
  3066.  char str[4];
  3067.  int x;
  3068.  
  3069.  str[3]=0;
  3070.  
  3071.  switch (dateFormat) {
  3072.     case DATE_MMDDYY:
  3073.         sscanf(out,"%d/%d/%d",&month,&day,&year);
  3074.         break;
  3075.  
  3076.     case DATE_DDMMYY:
  3077.         sscanf(out,"%d/%d/%d",&day,&month,&year);
  3078.         break;
  3079.  
  3080.     case DATE_DEC_12:
  3081.         sscanf(out,"%c%c%c-%d-%d",&str[0],&str[1],&str[2],&day,&year);
  3082.         for (x=0;x<12;x++)
  3083.             if (strcmpi(easymonths[x],str) == 0) {
  3084.                 month = x+1;
  3085.                 break;
  3086.             }
  3087.         break;
  3088.  
  3089.     case DATE_12_DEC:
  3090.         sscanf(out,"%d-%c%c%c-%d",&day,&str[0],&str[1],&str[2],&year);
  3091.         for (x=0;x<12;x++)
  3092.             if (strcmpi(easymonths[x],str) == 0) {
  3093.                 month = x+1;
  3094.                 break;
  3095.             }
  3096.  
  3097.         break;
  3098.  }
  3099.  
  3100.  date->day = day;
  3101.  date->month = month;
  3102.  date->year = year;
  3103. }
  3104.  
  3105. /****************************************************************
  3106. * DataVerifyDateMMDDYY()
  3107. *
  3108. *    Verifies and builds date string
  3109. ****************************************************************/
  3110. BOOL DataVerifyDateMMDDYY(char *instr, char *newstr)
  3111. {
  3112. char *section1, *section2, *last, *skip, *str;
  3113. ULONG day,year,month;
  3114. char strhold[DATESIZE+1];
  3115. dateType date;
  3116.  
  3117.  if (instr == NULL)
  3118.     return (FALSE);
  3119.  
  3120.  strcpy(strhold,instr);
  3121.  strhold[DATESIZE] = NULL;
  3122.  str = strhold;
  3123.  
  3124.  /* clip spaces off front and end */
  3125.  while (*str == ' ') str++;
  3126.  skip = &strhold[strlen(strhold) - 1];
  3127.  while (*skip == ' ' && skip != str) {
  3128.     *skip = NULL;
  3129.     skip--;
  3130.  }
  3131.  
  3132.  if (DataStrSet(str,"0123456789/ ") == FALSE)
  3133.     return (FALSE);
  3134.  
  3135.  /* quick check for '/' count, grab sections */
  3136.  section1 = strchr(str,'/');
  3137.  if (section1 == NULL)
  3138.     return (FALSE);
  3139.  *section1 = NULL;
  3140.  section1++;
  3141.  section2 = strchr(section1,'/');
  3142.  if (section2 == NULL)
  3143.     return (FALSE);
  3144.  *section2 = NULL;
  3145.  section2++;
  3146.  last = strchr(section2,'/');
  3147.  if (last != NULL)
  3148.     return (FALSE);
  3149.  
  3150.  /* check for "/" */
  3151.  if (strlen(section2) == 1)
  3152.     return (FALSE);
  3153.  
  3154.  /* now we have str->month, section1->day, section2->year */
  3155.  
  3156.  /* grab values, then compare later */
  3157.  sscanf(str,"%d",&month);
  3158.  sscanf(section1,"%d",&day);
  3159.  sscanf(section2,"%d",&year);
  3160.  if (month > 12 || month == 0)
  3161.     return (FALSE);
  3162.  if (day > 31 || day == 0)
  3163.     return (FALSE);
  3164.  
  3165.  if (year > 9999) return (FALSE);
  3166.  if (year < 100) year += currCentury;
  3167.  
  3168.  /* check for days in month */
  3169.  if (daysinmonth[month-1] < day )
  3170.     return (FALSE);
  3171.  
  3172.  if (month == 2 && day == daysinmonth[month-1] && !DataLeapYear(year))
  3173.     return (FALSE);
  3174.  
  3175.  date.day = day;
  3176.  date.month = month;
  3177.  date.year = year;
  3178.  DataCreateDate(&date,newstr, FALSE);
  3179.  return (TRUE);
  3180. }
  3181.  
  3182. /****************************************************************
  3183. * DataVerifyDateDDMMYY()
  3184. *
  3185. *    Verifies and builds date string
  3186. ****************************************************************/
  3187. BOOL DataVerifyDateDDMMYY(char *instr, char *newstr)
  3188. {
  3189. char *section1, *section2, *last, *skip, *str;
  3190. ULONG day,year,month;
  3191. char strhold[DATESIZE+1];
  3192. dateType date;
  3193.  
  3194.  if (instr == NULL)
  3195.     return (FALSE);
  3196.  
  3197.  strcpy(strhold,instr);
  3198.  strhold[DATESIZE] = NULL;
  3199.  str = strhold;
  3200.  
  3201.  /* clip spaces off front and end */
  3202.  while (*str == ' ') str++;
  3203.  skip = &strhold[strlen(strhold) - 1];
  3204.  while (*skip == ' ' && skip != str) {
  3205.     *skip = NULL;
  3206.     skip--;
  3207.  }
  3208.  
  3209.  if (DataStrSet(str,"0123456789/ ") == FALSE)
  3210.     return (FALSE);
  3211.  
  3212.  /* quick check for '/' count, grab sections */
  3213.  section1 = strchr(str,'/');
  3214.  if (section1 == NULL)
  3215.     return (FALSE);
  3216.  *section1 = NULL;
  3217.  section1++;
  3218.  section2 = strchr(section1,'/');
  3219.  if (section2 == NULL)
  3220.     return (FALSE);
  3221.  *section2 = NULL;
  3222.  section2++;
  3223.  last = strchr(section2,'/');
  3224.  if (last != NULL)
  3225.     return (FALSE);
  3226.  
  3227.  /* check for "/" */
  3228.  if (strlen(section2) == 1)
  3229.     return (FALSE);
  3230.  
  3231.  /* now we have str->month, section1->day, section2->year */
  3232.  
  3233.  /* grab values, then compare later */
  3234.  sscanf(str,"%d",&day);
  3235.  sscanf(section1,"%d",&month);
  3236.  sscanf(section2,"%d",&year);
  3237.  if (month > 12 || month == 0)
  3238.     return (FALSE);
  3239.  if (day > 31 || day == 0)
  3240.     return (FALSE);
  3241.  
  3242.  if (year > 9999) return (FALSE);
  3243.  if (year < 100) year += currCentury;
  3244.  
  3245.  /* check for days in month */
  3246.  if (daysinmonth[month-1] < day )
  3247.     return (FALSE);
  3248.  
  3249.  if (month == 2 && day == daysinmonth[month-1] && !DataLeapYear(year))
  3250.     return (FALSE);
  3251.  
  3252.  date.day = day;
  3253.  date.month = month;
  3254.  date.year = year;
  3255.  DataCreateDate(&date,newstr, FALSE);
  3256.  return (TRUE);
  3257. }
  3258.  
  3259. /****************************************************************
  3260. * DataVerifyDateDec12()
  3261. *
  3262. *    Verifies and builds date string
  3263. ****************************************************************/
  3264. BOOL DataVerifyDateDec12(char *instr, char *newstr)
  3265. {
  3266. char *section1, *section2, *last, *skip, *str;
  3267. ULONG day,year,month;
  3268. int x;
  3269. char strhold[DATESIZE+1];
  3270. dateType date;
  3271.  
  3272.  if (instr == NULL)
  3273.     return (FALSE);
  3274.  
  3275.  strcpy(strhold,instr);
  3276.  strhold[DATESIZE] = NULL;
  3277.  str = strhold;
  3278.  
  3279.  /* clip spaces off front and end */
  3280.  while (*str == ' ') str++;
  3281.  skip = &strhold[strlen(strhold) - 1];
  3282.  while (*skip == ' ' && skip != str) {
  3283.     *skip = NULL;
  3284.     skip--;
  3285.  }
  3286.  
  3287.  /* find date */
  3288.  month = 0;
  3289.  for (x=0;x<12;x++) {
  3290.     if (strnicmp (easymonths[x],str,3) == 0    ) {
  3291.         month = x+1;
  3292.         break;
  3293.     }
  3294.  }
  3295.  
  3296.  if (month == 0)
  3297.     return (FALSE);
  3298.  
  3299.  /* quick check for '-' count, grab sections */
  3300.  section1 = strchr(str,'-');
  3301.  if (section1 == NULL)
  3302.     return (FALSE);
  3303.  *section1 = NULL;
  3304.  section1++;
  3305.  section2 = strchr(section1,'-');
  3306.  if (section2 == NULL)
  3307.     return (FALSE);
  3308.  *section2 = NULL;
  3309.  section2++;
  3310.  last = strchr(section2,'-');
  3311.  if (last != NULL)
  3312.     return (FALSE);
  3313.  
  3314.  /* check for "-" */
  3315.  if (strlen(section2) == 1)
  3316.     return (FALSE);
  3317.  
  3318.  /* now we have str->month, section1->day, section2->year */
  3319.  
  3320.  /* grab values, then compare later */
  3321.  sscanf(section1,"%d",&day);
  3322.  sscanf(section2,"%d",&year);
  3323.  if (month > 12 || month == 0)
  3324.     return (FALSE);
  3325.  if (day > 31 || day == 0)
  3326.     return (FALSE);
  3327.  
  3328.  if (year > 9999) return (FALSE);
  3329.  if (year < 100) year += currCentury;
  3330.  
  3331.  /* check for days in month */
  3332.  if (daysinmonth[month-1] < day )
  3333.     return (FALSE);
  3334.  
  3335.  if (month == 2 && day == daysinmonth[month-1] && !DataLeapYear(year))
  3336.     return (FALSE);
  3337.  
  3338.  date.day = day;
  3339.  date.month = month;
  3340.  date.year = year;
  3341.  DataCreateDate(&date,newstr, FALSE);
  3342.  
  3343.  return (TRUE);
  3344. }
  3345.  
  3346. /****************************************************************
  3347. * DataVerifyDate12Dec()
  3348. *
  3349. *    Verifies and builds date string
  3350. ****************************************************************/
  3351. BOOL DataVerifyDate12Dec(char *instr, char *newstr)
  3352. {
  3353. char *section1, *section2, *last, *skip, *str;
  3354. ULONG day,year,month;
  3355. int x;
  3356. char strhold[DATESIZE+1];
  3357. dateType date;
  3358.  
  3359.  if (instr == NULL)
  3360.     return (FALSE);
  3361.  
  3362.  strcpy(strhold,instr);
  3363.  strhold[DATESIZE] = NULL;
  3364.  str = strhold;
  3365.  
  3366.  /* clip spaces off front and end */
  3367.  while (*str == ' ') str++;
  3368.  skip = &strhold[strlen(strhold) - 1];
  3369.  while (*skip == ' ' && skip != str) {
  3370.     *skip = NULL;
  3371.     skip--;
  3372.  }
  3373.  
  3374.  /* quick check for '-' count, grab sections */
  3375.  section1 = strchr(str,'-');
  3376.  if (section1 == NULL)
  3377.     return (FALSE);
  3378.  *section1 = NULL;
  3379.  section1++;
  3380.  section2 = strchr(section1,'-');
  3381.  if (section2 == NULL)
  3382.     return (FALSE);
  3383.  *section2 = NULL;
  3384.  section2++;
  3385.  last = strchr(section2,'-');
  3386.  if (last != NULL)
  3387.     return (FALSE);
  3388.  
  3389.  /* check for "-" */
  3390.  if (strlen(section2) == 1)
  3391.     return (FALSE);
  3392.  
  3393.  /* now we have str->month, section1->day, section2->year */
  3394.  
  3395.  /* grab values, then compare later */
  3396.  
  3397.  month = 0;
  3398.  for (x=0;x<12;x++) {
  3399.     if (strnicmp (easymonths[x],section1,3) == 0    ) {
  3400.         month = x+1;
  3401.         break;
  3402.     }
  3403.  }
  3404.  
  3405.  if (month == 0)
  3406.     return (FALSE);
  3407.  
  3408.  sscanf(str,"%d",&day);
  3409.  sscanf(section2,"%d",&year);
  3410.  if (month > 12 || month == 0)
  3411.     return (FALSE);
  3412.  if (day > 31 || day == 0)
  3413.     return (FALSE);
  3414.  
  3415.  if (year > 9999) return (FALSE);
  3416.  if (year < 100) year += currCentury;
  3417.  
  3418.  /* check for days in month */
  3419.  if (daysinmonth[month-1] < day )
  3420.     return (FALSE);
  3421.  
  3422.  if (month == 2 && day == daysinmonth[month-1] && !DataLeapYear(year))
  3423.     return (FALSE);
  3424.  
  3425.  date.day = day;
  3426.  date.month = month;
  3427.  date.year = year;
  3428.  DataCreateDate(&date,newstr, FALSE);
  3429.  
  3430.  return (TRUE);
  3431. }
  3432.  
  3433. /************************************************************
  3434. * DataAnnounceDate()
  3435. *
  3436. *    Announce date for different formats 
  3437. *************************************************************/
  3438. void DataAnnounceDate(GUIFront *gui)
  3439. {
  3440.  char *str[4] = {
  3441.     "Illegal Date\nFormat: mm/dd/yy",
  3442.     "Illegal Date\nFormat: dd/mm/yy",
  3443.     "Illegal Date\nFormat: mmm-dd-yy",
  3444.     "Illegal Date\nFormat: dd-mmm-yy",
  3445.  };
  3446.  
  3447.  switch (dateFormat) {
  3448.     case DATE_MMDDYY:
  3449.          DataAnnounce(gui,str[0]);
  3450.         break;
  3451.     case DATE_DDMMYY:
  3452.          DataAnnounce(gui,str[1]);
  3453.         break;
  3454.     case DATE_DEC_12:
  3455.         DataAnnounce(gui,str[2]);
  3456.         break;
  3457.     case DATE_12_DEC:
  3458.         DataAnnounce(gui,str[3]);
  3459.         break;
  3460.  }
  3461. }
  3462.  
  3463. /************************************************************
  3464. * DataAnnounceAmount()
  3465. *
  3466. *    Announce illegal amount 
  3467. *************************************************************/
  3468. void DataAnnounceAmount(GUIFront *gui)
  3469. {
  3470.  DataAnnounce(gui,"Illegal amount value.");
  3471. }
  3472.  
  3473. /***********************************************************
  3474. *  DataListUp()
  3475. *
  3476. *    Listview management library: move entry UP
  3477. ************************************************************/
  3478. void DataListUp(GUIFront *gui, struct Gadget *listgad, struct List *list, UWORD *listsel)
  3479. {
  3480.  struct Node *node1, *node2;
  3481.  
  3482.  /* do we have room to move up? */
  3483.  if (*listsel == 0)
  3484.     return;
  3485.  
  3486.  /* detach list */
  3487.  GF_SetGadgetAttrs(gui,listgad,
  3488.      GTLV_Labels, ~0,
  3489.     TAG_DONE);
  3490.  
  3491.  node1 = DataOrd2Node(list,*listsel);
  3492.  if (*listsel > 1)
  3493.     node2 = DataOrd2Node(list,*listsel-2);
  3494.  else    node2 = NULL;
  3495.  
  3496.  Remove(node1);
  3497.  Insert(list, node1, node2);
  3498.         
  3499.  *listsel = *listsel - 1;
  3500.  
  3501.  /* re-attach list */        
  3502.  GF_SetGadgetAttrs(gui,listgad,
  3503.     GTLV_Labels, list,
  3504.     GTLV_Selected,*listsel,
  3505.     GTLV_MakeVisible, *listsel,
  3506.     TAG_DONE);
  3507. }
  3508.  
  3509. /***********************************************************
  3510. *  DataListDown()
  3511. *
  3512. *    Listview management library: move entry DOWN
  3513. ************************************************************/
  3514. void DataListDown(GUIFront *gui, struct Gadget *listgad, struct List *list, UWORD *listsel)
  3515. {
  3516.  struct Node *node1, *node2;
  3517.  
  3518.  /* detach list */
  3519.  GF_SetGadgetAttrs(gui,listgad,
  3520.     GTLV_Labels, ~0,
  3521.     TAG_DONE);
  3522.  
  3523.  node1 = DataOrd2Node(list,*listsel);
  3524.  
  3525.  /* is this the last one? */
  3526.  if ( node1->ln_Succ != (struct Node *)(&list->lh_Tail)) {
  3527.     node2 = DataOrd2Node(list,*listsel+1);
  3528.     Remove(node1);
  3529.     Insert(list,node1,node2);
  3530.  
  3531.     *listsel = *listsel + 1;
  3532.  }
  3533.  
  3534.  /* re-attach list */
  3535.  GF_SetGadgetAttrs(gui,listgad,
  3536.     GTLV_Labels, list,
  3537.     GTLV_Selected,*listsel,
  3538.     GTLV_MakeVisible, *listsel,
  3539.     TAG_DONE);
  3540. }
  3541.  
  3542. /***********************************************************
  3543. *  DataListBottom()
  3544. *
  3545. *    Listview management library: move entry to BOTTOM
  3546. ************************************************************/
  3547. void DataListBottom(GUIFront *gui, struct Gadget *listgad, 
  3548.         struct List *list, UWORD *listsel, UWORD entries)
  3549. {
  3550.  struct Node *node1;
  3551.  
  3552.  /* detach list */
  3553.  GF_SetGadgetAttrs(gui,listgad,
  3554.     GTLV_Labels, ~0,
  3555.     TAG_DONE);
  3556.  
  3557.  node1 = DataOrd2Node(list,*listsel);
  3558.  Remove(node1);
  3559.  AddTail(list,node1);
  3560.  *listsel = entries-1;
  3561.  
  3562.  /* re-attach list */
  3563.  GF_SetGadgetAttrs(gui,listgad,
  3564.     GTLV_Labels, list,
  3565.     GTLV_Selected,*listsel,
  3566.     GTLV_MakeVisible, *listsel,
  3567.     TAG_DONE);    
  3568. }
  3569.  
  3570. /***********************************************************
  3571. *  DataListTop()
  3572. *
  3573. *    Listview management library: move entry to TOP
  3574. ************************************************************/
  3575. void DataListTop(GUIFront *gui, struct Gadget *listgad, 
  3576.         struct List *list, UWORD *listsel, UWORD topmargin)
  3577. {
  3578.  struct Node *node1, *node2;
  3579.  
  3580.  if (*listsel <= topmargin)
  3581.     return;
  3582.  
  3583.  /* detach list */
  3584.  GF_SetGadgetAttrs(gui,listgad,
  3585.     GTLV_Labels, ~0,
  3586.     TAG_DONE);
  3587.     
  3588.  node1 = DataOrd2Node(list,*listsel);
  3589.  if (topmargin != 0 && *listsel > topmargin)
  3590.     node2 = DataOrd2Node(list,topmargin-1);
  3591.  else    node2 = NULL;
  3592.  
  3593.  Remove(node1);
  3594.  Insert(list, node1, node2);
  3595.  
  3596.  *listsel = topmargin;
  3597.  
  3598.  /* re-attach list */
  3599.  GF_SetGadgetAttrs(gui,listgad,
  3600.     GTLV_Labels, list,
  3601.     GTLV_Selected, *listsel,
  3602.     GTLV_MakeVisible, *listsel,
  3603.     TAG_DONE);
  3604. }
  3605.  
  3606. /***********************************************************
  3607. *  DataListRemove()
  3608. *
  3609. *    Listview management library: remove entry
  3610. ************************************************************/
  3611. void DataListRemove(GUIFront *gui, struct Gadget *listgad, 
  3612.         struct List *list, UWORD *listsel)
  3613. {
  3614.  struct Node *node1;
  3615.  
  3616.  /* detach and modify list */
  3617.  GF_SetGadgetAttrs(gui,listgad,
  3618.     GTLV_Labels, ~0,
  3619.     TAG_DONE);
  3620.             
  3621.  node1 = DataOrd2Node(list,*listsel);
  3622.  
  3623.  if (node1->ln_Succ == (struct Node *)(&list->lh_Tail)) 
  3624.     *listsel = *listsel - 1;
  3625.  
  3626.  Remove(node1);
  3627.  FreeVec(node1);
  3628.     
  3629.  /* re-attach list */
  3630.  if (IsListEmpty(list)) {
  3631.      GF_SetGadgetAttrs(gui,listgad,
  3632.         GTLV_Labels, list,
  3633.         GTLV_Selected, ~0,
  3634.         TAG_DONE);        
  3635.  }
  3636.  else {
  3637.      GF_SetGadgetAttrs(gui,listgad,
  3638.         GTLV_Labels, list,
  3639.         GTLV_Selected, *listsel,
  3640.         GTLV_MakeVisible, *listsel,
  3641.         TAG_DONE);        
  3642.  }
  3643. }
  3644.