home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Utilities / amiCheck / Source / regGadget.c < prev    next >
C/C++ Source or Header  |  1998-06-11  |  36KB  |  1,601 lines
  1. /***************************************************************
  2. * regGadget.c 
  3. *
  4. * Creates and maintains the custom register display gadget
  5. *
  6. ***************************************************************/
  7.  
  8. #include <strings.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <libraries/guifront.h>
  12. #include <intuition/gadgetclass.h>
  13. #include <exec/memory.h>
  14. #include <clib/graphics_protos.h>
  15. #include <clib/exec_protos.h>
  16. #include <clib/diskfont_protos.h>
  17. #include <intuition/screens.h>
  18. #include <clib/intuition_protos.h>
  19. #include <graphics/gfxmacros.h> 
  20. #include <graphics/gfxbase.h>
  21.  
  22. #include "amiCheck.h"
  23. #include "mainPanel.h"
  24. #include "regGadget.h"
  25. #include "dataBase.h"
  26.  
  27. extern struct GfxBase *GfxBase;
  28.  
  29. #define WaitBlit();
  30.  
  31. #define RTEST(x)        {if ((x)==FALSE) return FALSE;}
  32.  
  33. #define AREA_SIZE       200
  34. #define NUMCOLS         7
  35. #define COLBUFFER       4       /* pixels on either side */
  36.  
  37. /*
  38.  * globals and typedefs
  39.  */
  40. BOOL editDisable = TRUE;
  41.  
  42. /* typedef for register row */
  43. typedef struct {
  44.         ULONG rpY;      /* start of row */
  45.         ULONG height;   /* height of row */ 
  46.         ULONG fontY;    /* distance from top for text */
  47. } regRowType;
  48.  
  49. /* typedef for register column */
  50. typedef struct {
  51.         ULONG rpX;      /* start of column */
  52.         ULONG width;    /* width of column */
  53.         ULONG fontX;    /* distance from start for text */
  54. } regColType;
  55.  
  56. /* typedef for register cell */
  57. typedef struct {
  58.         regRowType              *cellRow;
  59.         regColType              *cellCol;
  60. } regCellType;
  61.  
  62. /* tool to index regGrid */
  63. #define REGGRID(r,c)   regGrid[(r)*numCols + (c)]
  64.  
  65.  
  66. regColType  registerCols[NUMCOLS];
  67. regRowType  *registerRows = NULL;
  68. regCellType *regGrid = NULL;
  69. filterNode  *regTopNode = NULL;
  70.  
  71. char *regTypeArray[3] = {
  72.     "Check",
  73.     "Withdrawal",
  74.     "Deposit",
  75. };
  76. long regPrintChars[3];
  77. long regPrintFlags[3];
  78.  
  79. /* vars for our geometry */
  80. ULONG regWidth, regHeight;
  81. ULONG regTop, regLeft;
  82. ULONG numRows;               /* number of items that fit */
  83. ULONG numCols = NUMCOLS;
  84. ULONG entryHeight;           /* pixels of entry */
  85. ULONG depth;
  86.  
  87. extern GadgetSpec gadgetspecs[]; 
  88.  
  89. /* vars for our working RP */
  90. struct RastPort workRP, *activeRP = NULL;
  91. chip struct BitMap   workbuffer;
  92. chip struct AreaInfo workarea;
  93. chip struct TmpRas   worktmp;
  94. chip void *tmprp = NULL;
  95. chip UWORD areaBuffer[AREA_SIZE];
  96.  
  97. /* vars for our header RP */
  98. struct RastPort headerRP;
  99. chip struct BitMap   headerbuffer;
  100. chip struct AreaInfo headerarea;
  101. chip struct TmpRas   headertmp;
  102. chip void *headertmprp = NULL;
  103. chip UWORD headerareaBuffer[AREA_SIZE];
  104. ULONG hWidth,hHeight,hTop,hLeft;
  105.  
  106. /* vars for our FONT */
  107. struct TextFont *regFont = NULL;
  108.  
  109. /* misc control vars */
  110. ULONG selRow = -1;      /* selected row */
  111. ULONG regValidRows;        /* number of valid rows from top */
  112. ULONG regTopRow;
  113.  
  114. /* lets remember the register window! */
  115. struct Window *guiWindow = NULL;
  116.  
  117. /* special register config var */
  118. BOOL showMemo = FALSE;
  119.  
  120. /*
  121.  * Configurations!
  122.  */
  123.  
  124. /* headers for register */
  125. char *headers[] = {
  126.         "Type",
  127.         "Date",
  128.         "Description",
  129.         "V",
  130.         "C",
  131.     "T",
  132.         "$ Amount",
  133. };
  134.  
  135.  
  136. /* 
  137.  * local prototypes 
  138.  */
  139. BOOL RegRPInit(void);
  140. BOOL RegLayout(void);
  141. BOOL RegAllocHeader(void);
  142. void RegRenderGrid(void);
  143. void RegRenderHeader(void);
  144.  
  145. void RegDeselect(BOOL);
  146. void RegScrollSetup(ULONG,ULONG,ULONG);
  147. void RegFillRow(filterNode *, WORD);
  148. void RegScrollListUp(void);
  149. void RegLastPage(void);
  150.  
  151. /*
  152.  * routines
  153.  */
  154.  
  155. /*************************************************************
  156. * RegSwapMemo()
  157. *
  158. *    Swaps memo in register
  159. **************************************************************/
  160. void RegSwapMemo(void)
  161. {
  162.  long entries, lastselRow, lasttop;
  163.  
  164.  /* preserve some globals */
  165.  lasttop = regTopRow;
  166.  lastselRow = selRow;
  167.  entries = entryCount;
  168.  
  169.  AmiLock();
  170.   if (showMemo)
  171.     showMemo = FALSE;
  172.  else    showMemo = TRUE;
  173.  
  174.  /* free up arrays */
  175.  if (registerRows != NULL) {
  176.         FreeVec(registerRows);
  177.  }
  178.  
  179.  if (regGrid != NULL) {
  180.         FreeVec(regGrid);
  181.  }
  182.         
  183.  RegLayout();
  184.  
  185.  entryCount = entries;
  186.  if (entryCount > numRows)
  187.     regValidRows = numRows;
  188.  else    regValidRows = entryCount;
  189.  
  190.  RegClearGrid();
  191.  
  192.  selRow = lastselRow;
  193.  if (entryCount > numRows && entryCount-lasttop < regValidRows)
  194.     lasttop = entryCount - regValidRows;
  195.  
  196.  if (selRow != -1)
  197.     RegMoveToSel(&filtered);
  198.  else    RegMoveList(&filtered,lasttop);
  199.  
  200.  RegRefresh(FALSE);
  201.  RegScrollSetup(regTopRow,entryCount,regValidRows);
  202.  AmiUnlock();
  203. }
  204.  
  205. /**************************************************************
  206. * RegInit()
  207. *
  208. * Initialize the register gadget
  209. *
  210. **************************************************************/
  211. BOOL RegInit(void)
  212. {
  213. int x;
  214.  
  215.  /* build structures */       
  216.  RTEST(RegRPInit());
  217.  RTEST(RegLayout());
  218.  RTEST(RegAllocHeader());
  219.  
  220.  /* create default imagery */
  221.  RegRenderHeader();
  222.  RegClearGrid();
  223.  
  224.  /* set up scroller */
  225.  RegScrollSetup(0,0,0);
  226.  regTopRow = regValidRows = 0;
  227.  
  228.  RegRefresh(TRUE);
  229.  
  230.  for (x=0;x<3;x++) {
  231.     regPrintFlags[x] = regPrintChars[x] = -1;
  232.  }
  233.       
  234.  return (TRUE);    
  235. } 
  236.  
  237. /**************************************************************
  238. * RegAllocHeader()
  239. *
  240. *       Allocates RP and BitMap for header.  Must be done
  241. *       _after_ reglayout() has selected and opened the font.
  242. *
  243. ***************************************************************/
  244. BOOL RegAllocHeader(void)
  245. {
  246.  ULONG x;
  247.  
  248.  hTop = AC_MainSpecs[GID_REGHEADER]->gs_Gadget->TopEdge + 1;
  249.  hLeft = AC_MainSpecs[GID_REGHEADER]->gs_Gadget->LeftEdge + 2;
  250.  hWidth =  AC_MainSpecs[GID_REGHEADER]->gs_Gadget->Width - 4;
  251.  hHeight=  AC_MainSpecs[GID_REGHEADER]->gs_Gadget->Height - 2;
  252.  
  253.  /* create bitmap */
  254.  InitBitMap(&headerbuffer,depth, hWidth,hHeight);
  255.  
  256.  for (x=0;x<depth;x++) {
  257.         headerbuffer.Planes[x] = (PLANEPTR)AllocRaster(hWidth+1,hHeight+1);
  258.         if (headerbuffer.Planes[x] == NULL) return (FALSE);
  259.  }
  260.  
  261.  /* create area buffer */
  262.  for (x=0;x<AREA_SIZE;x++) headerareaBuffer[x] =0;
  263.  InitArea(&headerarea, headerareaBuffer, (AREA_SIZE*2)/5);
  264.  
  265.  /* create TmpRas */
  266.  headertmprp =  (void *)AllocVec((hWidth+1)*(hHeight+1), MEMF_CHIP);
  267.  if (headertmprp == NULL) return (FALSE);
  268.  
  269.  InitTmpRas(&headertmp,headertmprp,(hWidth+1)*(hHeight+1));
  270.  
  271.  /* link in to our work rastport */
  272.  InitRastPort(&headerRP);
  273.  headerRP.BitMap = &headerbuffer;
  274.  headerRP.AreaInfo = &headerarea;
  275.  headerRP.TmpRas = &headertmp;
  276.  headerRP.Layer = NULL;
  277.  
  278.  /* initialize our pen colors */
  279.  SetAPen(&headerRP,DETAILPEN);
  280.   
  281.  /* fill area with color */
  282.  SetRast(&headerRP,DETAILPEN);
  283. /*
  284.  RectFill(&headerRP,0,0,hWidth,hHeight);
  285. */
  286.  
  287.  SetFont(&headerRP,regFont);
  288.          
  289.  return (TRUE);
  290. }
  291.  
  292. /**************************************************************
  293. * RegRenderHeader()
  294. *
  295. *       Renders the header titles above the register
  296. *
  297. ***************************************************************/
  298. void RegRenderHeader(void)
  299. {
  300.  ULONG x, top;
  301.  
  302.  /* set pen color */
  303.  SetAPen(&headerRP,BLOCKPEN);
  304.  
  305.  top = regFont->tf_Baseline;
  306.    
  307.  if (regFont->tf_YSize <= hHeight) {
  308.      for (x=0;x<numCols;x++) {
  309.                Move(&headerRP,REGGRID(0,x).cellCol->rpX + COLBUFFER,top);
  310.         Text(&headerRP,headers[x],strlen(headers[x]));
  311.      }
  312.  }
  313.  
  314. }
  315.  
  316. /**************************************************************
  317. * RegRPInit()
  318. *
  319. * initialize our playground 
  320. *
  321. **************************************************************/
  322. BOOL RegRPInit()
  323. {
  324. UWORD x;
  325.  
  326.  /* define geometry (-2 accounts for shadowing border) */
  327.  regWidth =  AC_MainSpecs[GID_REGFIELD]->gs_Gadget->Width - 4;
  328.  regHeight=  AC_MainSpecs[GID_REGFIELD]->gs_Gadget->Height - 2;
  329.  regTop   =  AC_MainSpecs[GID_REGFIELD]->gs_Gadget->TopEdge + 1;
  330.  regLeft  =  AC_MainSpecs[GID_REGFIELD]->gs_Gadget->LeftEdge + 2;
  331.  
  332.  /* the one and only delicate hack of our program */
  333.  AC_MainSpecs[GID_REGFIELD]->gs_Gadget->Activation |= GACT_IMMEDIATE;
  334.  
  335.  /* 
  336.   * extract information about our main window 
  337.   */
  338.  
  339.    
  340.  GF_GetGUIAttr(gui, GUI_Window, &guiWindow, TAG_DONE);
  341.  
  342.  activeRP = guiWindow->RPort;
  343.  depth = activeRP->BitMap->Depth;  
  344.             
  345.  /* 
  346.   * create working rast port area 
  347.   */
  348.  
  349.  /* create bitmap */
  350.  InitBitMap(&workbuffer,depth, regWidth, regHeight);
  351.  
  352.  for (x=0;x<depth;x++) {
  353.         workbuffer.Planes[x] = (PLANEPTR)AllocRaster(regWidth+1, 
  354.                                         regHeight+1);
  355.         if (workbuffer.Planes[x] == NULL) return (FALSE);
  356.  }
  357.  
  358.  /* create area buffer */
  359.  for (x=0;x<AREA_SIZE;x++) areaBuffer[x] =0;
  360.  InitArea(&workarea, areaBuffer, (AREA_SIZE*2)/5);
  361.  
  362.  /* create TmpRas */
  363.  tmprp = (void *)AllocVec((regWidth+1)*(regHeight+1), MEMF_CHIP);
  364.  if (tmprp == NULL) return (FALSE);
  365.  
  366.  InitTmpRas(&worktmp,tmprp,(regWidth+1)*(regHeight+1));
  367.  
  368.  /* link in to our work rastport */
  369.  InitRastPort(&workRP);
  370.  workRP.BitMap = &workbuffer;
  371.  workRP.AreaInfo = &workarea;
  372.  workRP.TmpRas = &worktmp;
  373.  workRP.Layer = NULL;
  374.  
  375.  return (TRUE);
  376. }
  377.  
  378. /*************************************************************
  379. * RegLayout()
  380. *
  381. * calculates the number of possible entries, the starting
  382. * position of each item.
  383. *
  384. **************************************************************/
  385. BOOL RegLayout(void)
  386. {
  387. struct TextAttr regAttr;
  388. UWORD regFontHeight;
  389. #if 0
  390. char regFontName[50];
  391. BOOL regScreen;
  392. #endif
  393. ULONG height;
  394. int x,temp,desc;
  395. char *colFixes[NUMCOLS] = {
  396.         "Withdrawal",
  397.         "DEC000000", 
  398.         "",
  399.         "V",
  400.         "C",
  401.     "T",
  402.         "000000000.00",
  403. };
  404.  
  405.  
  406.  GF_GetGUIAttr(gui,
  407.         GUI_ActualFont,®Attr,
  408.         TAG_DONE);
  409.         
  410.  
  411. #if 0
  412.  /* grab information from guifront on fonts */
  413.  GF_GetPrefsAttr(gui,
  414.         PRF_GadgetScreenFont,®Attr,
  415.         TAG_DONE);
  416.         
  417.  /* are we using the screen font? */
  418.  if (regScreen)
  419.         regAttr = guiWindow->WScreen->Font;
  420.  else {
  421.         if ( GF_GetPrefsAttr(gui,
  422.                 PRF_GadgetFontYSize, ®FontHeight,
  423.                 PRF_GadgetFontName,  regFontName,
  424.                 TAG_DONE) != 2) {
  425.  
  426.         regAttr = guiWindow->WScreen->Font;
  427.     }
  428.     else  regAttr = guiWindow->WScreen->Font;
  429.  }
  430.  
  431. #endif
  432.  
  433.  /* at last, open the damn thing */
  434.  regFont = OpenDiskFont(®Attr);
  435.  if (regFont == NULL) return (FALSE);
  436.  
  437.  SetFont(&workRP,regFont);  
  438.  
  439.  /* calculate entry separators */
  440.  height = regFont->tf_YSize + regFont->tf_YSize/8 + 1;
  441.  /* * * * */  
  442.  if (showMemo) height *= 2;
  443.  
  444.  numRows = regHeight/height;
  445.  
  446.  /* tweek height to absorb excess space - numRows is same */
  447.  entryHeight = height + (regHeight%height)/numRows;
  448.  temp = regHeight%entryHeight;
  449.  
  450.  /* install rows */
  451.  registerRows =  (regRowType *)AllocVec(sizeof(regRowType)*numRows,
  452.                                         MEMF_ANY); 
  453.  if (registerRows == NULL) return (FALSE);
  454.  
  455.  height = (entryHeight / 2) - (regFont->tf_YSize/2) +
  456.            regFont->tf_Baseline;
  457.  
  458.  
  459. #if 0
  460.  registerRows[0].fontY = height + 1;
  461.  registerRows[0].rpY = 0; /*entryHeight + ((temp>0)?1:0);*/
  462.  registerRows[0].height = entryHeight + ((temp>0)?1:0);
  463.  
  464.  for (x=1;x<numRows;x++) {
  465.     
  466.            registerRows[x].fontY = height + 1;
  467.     registerRows[x].height = entryHeight + ((x<temp)?1:0);
  468.         registerRows[x].rpY = registerRows[x-1].rpY + registerRows[x-1].height;
  469.  }
  470.  
  471. #endif
  472.  registerRows[0].fontY = height + 1;
  473.  registerRows[0].rpY = 0;
  474.  registerRows[0].height = entryHeight; /* should never get extra line... cest la vi! */
  475.  
  476.  for (x=1;x<numRows;x++) {
  477.     
  478.            registerRows[x].fontY = height + 1;
  479.     registerRows[x].height = entryHeight + ( (x > numRows-temp )?1:0);
  480.         registerRows[x].rpY = registerRows[x-1].rpY + registerRows[x-1].height;
  481.  }
  482.  
  483.  /* install cols */
  484.  temp = desc = 0;
  485.  for (x=0;x<numCols;x++) {
  486.         registerCols[x].fontX = COLBUFFER;
  487.         if (x == 0) registerCols[x].rpX = 0;
  488.         else        registerCols[x].rpX = registerCols[x-1].rpX +
  489.                                           registerCols[x-1].width + 1;
  490.  
  491.         /* need to give description all extra space */
  492.         if (strlen(colFixes[x]) == 0) {
  493.         desc = x;
  494.         registerCols[x].width = 0;
  495.     }
  496.         else {
  497.                 registerCols[x].width = TextLength(&workRP,
  498.                                    colFixes[x],strlen(colFixes[x])) +
  499.                                 COLBUFFER*2 ;
  500.                                 
  501.                 temp += registerCols[x].width;
  502.         }                             
  503.  }  
  504.  
  505.  /* now fix for description list */
  506.  registerCols[desc].width = regWidth - temp;
  507.  for (x=desc+1;x<numCols;x++) {
  508.         registerCols[x].rpX += registerCols[desc].width; 
  509.  }
  510.  
  511.  /* now build the cell grid */
  512.  regGrid = (regCellType *)AllocVec(sizeof(regCellType)*numCols*numRows,
  513.                                MEMF_ANY);
  514.  if (regGrid == NULL) return (FALSE);
  515.  
  516.  for (x=0;x<numRows;x++) {
  517.         for (temp=0;temp<numCols;temp++) {
  518.                 REGGRID(x,temp).cellRow = ®isterRows[x];
  519.                 REGGRID(x,temp).cellCol = ®isterCols[temp];
  520.         }
  521.  }       
  522.  
  523.  return (TRUE);
  524. }
  525.  
  526. /*************************************************************
  527. * RegRenderCellFlush()
  528. *
  529. *    Flush the text (right justify)
  530. **************************************************************/
  531. void RegRenderCellFlush(ULONG row, ULONG col, char *str, char pen,
  532. long *printchars)
  533. {
  534.   ULONG x,y,b, width, length;
  535.   struct TextExtent resultExtent;
  536.   
  537.   /* set pen */
  538.   SetAPen(&workRP,pen);
  539.   
  540.   /* quick pull out some info on cell */
  541.   y = REGGRID(row,col).cellRow->rpY;
  542.   b = REGGRID(row,col).cellRow->fontY;
  543.   x = REGGRID(row,col).cellCol->rpX + REGGRID(row,col).cellCol->fontX;
  544.   width = REGGRID(row,col).cellCol->width - COLBUFFER;
  545.   
  546.   /* clip str to make fit... */
  547.   if (*printchars == -1)
  548.     *printchars = TextFit(&workRP,str,strlen(str),&resultExtent,NULL,1,
  549.         REGGRID(row,col).cellCol->width-(COLBUFFER*3) + 1,
  550.         REGGRID(row,col).cellRow->height );
  551.  
  552.   length = TextLength(&workRP,str,*printchars);
  553.   if (length < width-(COLBUFFER*3)+1)
  554.     x += (width-(COLBUFFER*3)+1) - length;
  555.  
  556.   /* stuf it in */
  557.   Move(&workRP,x,y+b);
  558.   Text(&workRP,str, *printchars);
  559.  
  560.   if (row == numRows-1) {
  561.     SetAPen(&workRP,TEXTPEN);
  562.     Move(&workRP,1,regHeight-1);
  563.     Draw(&workRP,regWidth-1,regHeight-1);
  564.   }
  565. }
  566.  
  567. /*************************************************************
  568. * RegRenderCell()
  569. *
  570. *       Renders string contents into a given cell. Does
  571. *       necessary clipping of the string.
  572. *
  573. ***************************************************************/
  574. void RegRenderCell(ULONG row, ULONG col, char *str, char pen, 
  575. long *printchars, BOOL memo)
  576. {
  577.   ULONG x,y,b, width;
  578.   struct TextExtent resultExtent;
  579.   
  580.   /* set pen */
  581.   SetAPen(&workRP,pen);
  582.  
  583.   /* quick pull out some info on cell */
  584.   y = REGGRID(row,col).cellRow->rpY;
  585.   b = REGGRID(row,col).cellRow->fontY;
  586.   x = REGGRID(row,col).cellCol->rpX + REGGRID(row,col).cellCol->fontX;
  587.   width = REGGRID(row,col).cellCol->width - COLBUFFER;
  588.  
  589.   /* clip str to make fit... */
  590.   if (*printchars == -1) {
  591.     *printchars = TextFit(&workRP,str,strlen(str),&resultExtent,NULL,1,
  592.         REGGRID(row,col).cellCol->width-(COLBUFFER*2) + 1,
  593.         REGGRID(row,col).cellRow->height );
  594.   }
  595.  
  596.   /* special case description/memo stuff */
  597.   if (showMemo == TRUE && col == 2 ) {
  598.     if (memo == FALSE) {
  599.  
  600.  b = (entryHeight / 4) - (regFont->tf_YSize/2) +
  601.            regFont->tf_Baseline;
  602.  
  603. /*        b -= (regFont->tf_YSize/2);*/
  604.     }
  605.     else {
  606.         if (*printchars > strlen(str))
  607.             *printchars = strlen(str);
  608.  
  609.  b = (entryHeight ) - (regFont->tf_YSize/2) + 1 /* -
  610.            regFont->tf_Baseline*/;
  611.  
  612. /*        b  += (regFont->tf_YSize/2);*/
  613.     }
  614.   }
  615.   
  616.   /* stuf it in */
  617.   Move(&workRP,x,y+b);
  618.   Text(&workRP,str,*printchars);
  619.  
  620.   if (row == numRows-1) {
  621.     SetAPen(&workRP,TEXTPEN);
  622.     Move(&workRP,1,regHeight-1);
  623.     Draw(&workRP,regWidth-1,regHeight-1);
  624.   }
  625.  
  626. }
  627.  
  628. /*************************************************************
  629. * RegRenderGrid()
  630. *
  631. * Renders the register grid.  Simple enough...
  632. *
  633. **************************************************************/
  634. void RegRenderGrid(void)
  635. {
  636.  int x;
  637.  
  638.  /* set our pens */
  639.  SetAPen(&workRP,BLOCKPEN);
  640.  
  641.  /* horizontals */ 
  642.  for (x=0;x<numRows;x++) {
  643.         Move(&workRP,0,registerRows[x].rpY);
  644.         Draw(&workRP,regWidth,registerRows[x].rpY);
  645.  
  646.      if (showMemo) {
  647.         SetDrPt(&workRP,0xAAAA);
  648.         Move(&workRP,registerCols[2].rpX,registerRows[x].rpY + entryHeight/2);
  649.             Draw(&workRP,registerCols[3].rpX,registerRows[x].rpY + entryHeight/2);
  650.         SetDrPt(&workRP,~0);
  651.  
  652.         if (x != 0 && x < numRows){
  653.                 Move(&workRP,0,registerRows[x].rpY-1);
  654.                 Draw(&workRP,regWidth,registerRows[x].rpY-1);
  655.         }
  656.  
  657.      }
  658.  }
  659.  
  660.  /* verticals */
  661.  for (x=0;x<numCols;x++) {
  662.         Move(&workRP,registerCols[x].rpX,0);
  663.         Draw(&workRP,registerCols[x].rpX,regHeight);
  664.  }
  665.  
  666.  /* set highlight pen */
  667.  SetAPen(&workRP,TEXTPEN);
  668.  
  669.  /* put depth into our register window */
  670.  Move(&workRP,1,regHeight-1);
  671.  Draw(&workRP,regWidth,regHeight-1);
  672.  Move(&workRP,regWidth-1,1);
  673.  Draw(&workRP,regWidth-1,regHeight);
  674. }
  675.  
  676. /*************************************************************
  677. * RegRefresh()
  678. *
  679. * Blits the work area into the window
  680. *
  681. **************************************************************/
  682. void RegRefresh(BOOL header)
  683. {
  684.  
  685. #if 0  
  686.  /* blit over the working register bitmap into window */
  687.  ClipBlit(&workRP,0,0,activeRP,regLeft,regTop,
  688.         regWidth,regHeight,(ULONG)0xc0);
  689. #endif
  690.  
  691.  
  692. /*
  693. BltBitMapRastPort(workRP.BitMap,0,0,activeRP,regLeft,regTop,
  694.         regWidth,regHeight,0xc0);
  695. WaitBlit();*/
  696.  
  697. ClipBlit(&workRP,0,0,activeRP,regLeft,regTop,regWidth,regHeight,(ULONG)0xc0);
  698.  
  699. if (header) {
  700.     /*
  701.     BltBitMapRastPort(headerRP.BitMap,0,0,activeRP,hLeft,hTop,
  702.             hWidth,hHeight,0xc0);
  703.     WaitBlit();*/
  704.  
  705.     ClipBlit(&headerRP,0,0,activeRP,hLeft,hTop,hWidth,hHeight,(ULONG)0xc0);
  706. }
  707. }
  708.  
  709. /*************************************************************
  710. * RegSelect()
  711. *
  712. *       marks a row as being selected.  
  713. *
  714. **************************************************************/
  715. void RegSelect(ULONG row, BOOL towin)
  716. {
  717. BYTE oldmode, oldmask;
  718. ULONG height, top;
  719.  
  720. /* is it currently selected? */
  721. if (selRow == regTopRow + row) return;
  722.  
  723. /* remove old one */
  724. RegDeselect(towin);
  725.  
  726. height = registerRows[row].height - 2;
  727. top = registerRows[row].rpY + 1;
  728.  
  729. /* render it to the actual window first (avoids flicker later) */ 
  730. if (towin) {
  731.     oldmode = activeRP->DrawMode;
  732.     oldmask = activeRP->Mask;
  733.     SetDrMd(activeRP,COMPLEMENT);
  734.     SafeSetWriteMask(activeRP,0x3);
  735.  
  736.     RectFill(activeRP,
  737.             1 + regLeft, top + regTop,
  738.             regWidth - 2 + regLeft,top + height + regTop );
  739.  
  740.     WaitBlit();
  741.  
  742.     SetDrMd(activeRP,oldmode);
  743.     SafeSetWriteMask(activeRP,oldmask);
  744. }
  745.  
  746. /* now render it "for real" so refreshes will see it */
  747. oldmode = workRP.DrawMode;
  748. oldmask = workRP.Mask;
  749. SetDrMd(&workRP,COMPLEMENT);
  750. SafeSetWriteMask(&workRP,0x3);
  751.  
  752. RectFill(&workRP,
  753.         1, top,
  754.         regWidth-2,top + height );
  755.  
  756. WaitBlit();
  757.  
  758. SetDrMd(&workRP,oldmode);
  759. SafeSetWriteMask(&workRP,oldmask);
  760.  
  761. /* remember this selection for later */
  762. selRow = regTopRow + row;
  763. }
  764.  
  765. /*************************************************************
  766. * RegDeselect()
  767. *
  768. *       clears selection of a row.
  769. *
  770. **************************************************************/
  771. void RegDeselect(BOOL towin)
  772. {
  773.  BYTE oldmode, oldmask;
  774.  ULONG height,top, row = selRow;
  775.  
  776.  if (selRow == -1) return;
  777.  selRow = -1;
  778.  
  779.  /* if not visible, skip graphical rendering */
  780.  if (row < regTopRow || row > regTopRow+numRows-1)
  781.         return; 
  782.  
  783.  /* make zero based */
  784.  row -= regTopRow; 
  785.  
  786.  height = registerRows[row].height - 2;
  787.  top = registerRows[row].rpY + 1;
  788.  
  789.  if (towin) {
  790.      oldmode = activeRP->DrawMode;
  791.      oldmask = activeRP->Mask;
  792.     SetDrMd(activeRP,COMPLEMENT);
  793.      SafeSetWriteMask(activeRP,0x3);
  794.  
  795.      RectFill(activeRP,
  796.             1+regLeft, top + regTop,
  797.             regWidth-2+regLeft,top + height + regTop );
  798.  
  799.      WaitBlit();
  800.  
  801.      SetDrMd(activeRP,oldmode);
  802.      SafeSetWriteMask(activeRP,oldmask);
  803.  }
  804.  
  805.  oldmode = workRP.DrawMode;
  806.  oldmask = workRP.Mask;
  807.  SetDrMd(&workRP,COMPLEMENT);
  808.  SafeSetWriteMask(&workRP,0x3);
  809.  
  810.  RectFill(&workRP,
  811.         1,  top,
  812.         regWidth-2,top + height );
  813.  
  814.  WaitBlit();
  815.  
  816.  SetDrMd(&workRP,oldmode);
  817.  SafeSetWriteMask(&workRP,oldmask);         
  818. }
  819.  
  820. /*************************************************************
  821. * RegFreeAll()
  822. *
  823. * Free up ALL register gadget resources (not linked lists).
  824. * A small attempt is done to do this safely (checks for NULL)
  825. *
  826. **************************************************************/
  827. void RegFreeAll(void)
  828. {
  829. int x;
  830.  
  831.  /* free up arrays */
  832.  if (registerRows != NULL) {
  833.         FreeVec(registerRows);
  834.  }
  835.         
  836.  if (regGrid != NULL) {
  837.         FreeVec(regGrid);
  838.  }
  839.         
  840.   
  841.  /*
  842.   * workRP stuff
  843.   */
  844.        
  845.  /* free up bitmap */
  846.  for (x=0;x<depth;x++)
  847.         if (workbuffer.Planes[x] != NULL) {
  848.                  FreeRaster(workbuffer.Planes[x],regWidth+1,regHeight+1);  
  849.         }
  850.         
  851.  /* free TmpRas */
  852.  if (tmprp != NULL) {
  853.         FreeVec(tmprp);
  854.  }
  855.  
  856.  /*
  857.   * headerRP stuff
  858.   */
  859.   
  860.  /* free up bitmap */
  861.  for (x=0;x<depth;x++)
  862.        if (headerbuffer.Planes[x] != NULL) { 
  863.                 FreeRaster(headerbuffer.Planes[x],hWidth+1,hHeight+1);  
  864.         }
  865.         
  866.  /* free TmpRas */
  867.  if (headertmprp != NULL) {
  868.           FreeVec(headertmprp);
  869.  }
  870.  
  871.  /*
  872.   * misc 
  873.   */
  874.   
  875.  /* free font */
  876.  if (regFont != NULL) {
  877.           CloseFont(regFont);
  878.  }
  879.  
  880. }
  881.  
  882. /****************************************************************
  883. * RegHitTest()
  884. *
  885. *       Takes a mouse hit and determines what to do.
  886. *
  887. ****************************************************************/
  888. BOOL RegHitTest(ULONG Micros, ULONG Seconds, ULONG x, ULONG y)
  889. {
  890.  ULONG t,row;
  891.  static LONG lastrow = -1;
  892.  BOOL retval = FALSE;
  893.  static ULONG micros = 0, secs = 0;
  894.  
  895.  
  896.  /* quick clip of register gadget */
  897.  if (x < regLeft || x > regWidth+regLeft ||
  898.      y < regTop  || y > regHeight+regTop)
  899.      
  900.      return (FALSE);
  901.  
  902.  /* calc row */
  903.  y -= regTop;
  904.  row = 0;
  905.  for (t=0;t<numRows-1;t++) {
  906.     if (y > registerRows[t].rpY +registerRows[t].height)
  907.         row++;
  908.  
  909.     else    break;
  910.  }
  911.  
  912.  /* ok, is it a valid row? */
  913.  if (row < regValidRows) {
  914.         RegSelect(row, TRUE);
  915.     RegEditDisable(FALSE);
  916.     
  917.     if (DoubleClick(secs,micros,Seconds,Micros) && lastrow == row)
  918.         retval = TRUE;
  919.  }
  920.  
  921.  micros = Micros;
  922.  secs = Seconds;
  923.  lastrow = row;
  924.  
  925.  AmiMoveSwap();
  926.  return (retval);
  927. }
  928.  
  929. /****************************************************************
  930. * RegClearGrid()
  931. *
  932. *       Clears the register and then draws the grid.
  933. *
  934. *****************************************************************/
  935. void RegClearGrid()
  936. {
  937.  /*SetAPen(&workRP,DETAILPEN);*/
  938.  
  939.  /* fill area with color */
  940. /*
  941.  RectFill(&workRP,0,0,regWidth,regHeight);
  942. */
  943.  SetRast(&workRP,DETAILPEN);
  944.  
  945.  /* draw register grid */        
  946.  RegRenderGrid();
  947. }
  948.  
  949. /**************************************************************
  950. * RegScrollSetup()
  951. *
  952. *    Sets the scroller correctly
  953. ***************************************************************/
  954. void RegScrollSetup(ULONG top,ULONG total,ULONG visible)
  955. {
  956.  GF_SetGadgetAttrs(gui,AC_MainSpecs[GID_REGVSCROL]->gs_Gadget,
  957.     GTSC_Top,top,
  958.     GTSC_Total, total,
  959.     GTSC_Visible,visible,
  960.     TAG_DONE);
  961. }
  962.  
  963. /************************************************************
  964. * RegInsertEntry()
  965. *
  966. *    Add entry to list
  967. *************************************************************/
  968. void RegInsertEntry(UWORD row, filterNode *en)
  969. {
  970.     entryCount++;
  971.  
  972.     if (regValidRows < numRows) {
  973.         if (regTopNode == NULL)
  974.             regTopNode = en;
  975.  
  976.         regValidRows++;
  977.     }
  978.     
  979.     if (row >= regTopRow && row < regTopRow+regValidRows) {
  980.         RegMoveList(&filtered,regTopRow);
  981.         RegRefresh(FALSE);
  982.     }
  983.  
  984.     RegScrollSetup(regTopRow,entryCount,regValidRows);
  985.     RegEditDisable(TRUE);
  986. }
  987.  
  988. /************************************************************
  989. * RegAddEntry()
  990. *
  991. *    Add entry to list
  992. *************************************************************/
  993. void RegAddEntry(filterNode *en)
  994. {
  995.     entryCount++;
  996.  
  997.     if (regValidRows < numRows) {
  998.         RegDeselect(TRUE);
  999.         if (regTopNode == NULL)
  1000.             regTopNode = en;
  1001.  
  1002.         regValidRows++;
  1003.         RegFillRow(en,regValidRows-1);
  1004.     }
  1005.     else {
  1006.         /* remove curr selection */
  1007.         selRow = -1;
  1008.         RegMoveList(&filtered,entryCount-regValidRows);
  1009.         RegRefresh(FALSE);
  1010.     }
  1011.  
  1012.     RegScrollSetup(regTopRow,entryCount,regValidRows);
  1013.     RegRefresh(FALSE);
  1014.     RegEditDisable(TRUE);
  1015. }
  1016.  
  1017. /************************************************************
  1018. * RegKeyScroll()
  1019. *
  1020. *    scrolls selected item on keyboard commands
  1021. *************************************************************/
  1022. void RegKeyScroll(UWORD code)
  1023. {
  1024.  ULONG currRow;
  1025.  
  1026.  if (entryCount == 0)
  1027.     return;
  1028.  
  1029.   /* is the selected area off screen? */
  1030.  if (selRow != -1 && (selRow < regTopRow || selRow >= regTopRow+numRows) ) {
  1031.     RegMoveToSel(&filtered);
  1032.  }
  1033.  
  1034.  currRow = selRow;
  1035.  
  1036.  switch (code) {
  1037.     case UP:
  1038.         if (currRow == 0)
  1039.             return;
  1040.  
  1041.         /* are we not selected? */
  1042.         if (currRow == -1)
  1043.             currRow = regTopRow+1;
  1044.         
  1045.         if (currRow == regTopRow) {
  1046.             selRow = -1;
  1047.             RegScrollListDown();
  1048.             RegRefresh(FALSE);
  1049.         }
  1050.         else RegDeselect(TRUE);
  1051.     
  1052.         currRow--;        
  1053.         RegSelect(currRow-regTopRow, TRUE);
  1054.         break;
  1055.  
  1056.     case SHIFTUP:
  1057.         /* is there a current selection? */
  1058.         if (currRow == -1) {
  1059.             RegSelect(0,TRUE);
  1060.         }
  1061.  
  1062.         /* are we already near the top? */
  1063.         else if (regTopRow < regValidRows) {
  1064.             if (regTopRow == 0)
  1065.                 RegDeselect(TRUE);
  1066.             else    selRow = -1;
  1067.  
  1068.             RegMoveList(&filtered,0);
  1069.             RegRefresh(FALSE);
  1070.             RegSelect(0, TRUE);
  1071.         }
  1072.         
  1073.         /* then just scroll there */
  1074.         else {    
  1075.             selRow = -1;
  1076.             currRow -= regTopRow;
  1077.             RegMoveList(&filtered,regTopRow-regValidRows+1);
  1078.             RegRefresh(FALSE);
  1079.             RegSelect(currRow, TRUE);
  1080.         }
  1081.         break;
  1082.  
  1083.     case CTRLUP:
  1084.         if (currRow == 0) 
  1085.             return;
  1086.  
  1087.         /* remove current selection */
  1088.         if (regTopRow == 0)
  1089.             RegDeselect(TRUE);
  1090.         else {
  1091.             selRow = -1;
  1092.             RegMoveList(&filtered,0);
  1093.             RegRefresh(FALSE);
  1094.         }
  1095.  
  1096.         /* grab top */
  1097.         RegSelect(0, TRUE);
  1098.         break;
  1099.  
  1100.     case DOWN:
  1101.         if (currRow == entryCount-1) {
  1102.             return;
  1103.         }
  1104.  
  1105.         /* are we selected? */
  1106.         if (currRow == -1) {
  1107.             currRow = regTopRow-1;
  1108.         }
  1109.         
  1110.         /* scroll down or jump down */
  1111.         if (currRow == regTopRow + regValidRows - 1) {
  1112.             selRow = -1;
  1113.             RegScrollListUp();
  1114.             RegRefresh(FALSE);
  1115.         }
  1116.         else {
  1117.             RegDeselect(TRUE);
  1118.         }
  1119.  
  1120.         WaitBlit();
  1121.         currRow++;    
  1122.         RegSelect(currRow-regTopRow, TRUE);
  1123.         break;
  1124.  
  1125.     case SHIFTDOWN:
  1126.         /* is there a current selection? */
  1127.         if (currRow == -1) {
  1128.             RegSelect(0, TRUE);
  1129.         }
  1130.  
  1131.         /* are there not enough entries to page down? */
  1132.         else if (entryCount - (regTopRow + regValidRows-1) <= regValidRows) {
  1133.             if (regTopRow == entryCount-regValidRows)
  1134.                 RegDeselect(TRUE);
  1135.             else selRow = -1;
  1136.  
  1137.             RegMoveList(&filtered,entryCount-regValidRows);
  1138.             RegRefresh(FALSE);
  1139.             RegSelect(regValidRows-1, TRUE);
  1140.         }
  1141.  
  1142.         /* just scroll there */
  1143.         else {    
  1144.             selRow = -1;
  1145.             currRow -= regTopRow;
  1146.             RegMoveList(&filtered,regTopRow+regValidRows-1);
  1147.             RegRefresh(FALSE);
  1148.             RegSelect(currRow, TRUE);
  1149.         }
  1150.         break;
  1151.  
  1152.     case CTRLDOWN:
  1153.         if (selRow == entryCount-1)
  1154.             return;
  1155.  
  1156.         /* remove curr selection */
  1157.         if (regTopRow == entryCount - regValidRows) 
  1158.             RegDeselect(TRUE);
  1159.         else {
  1160.             selRow = -1;
  1161.             /*RegMoveList(&filtered,entryCount-regValidRows); */
  1162.             RegLastPage();
  1163.             RegRefresh(FALSE);
  1164.         }
  1165.  
  1166.  
  1167.         /* grab bottom */
  1168.         RegSelect(regValidRows-1, TRUE);
  1169.         break;
  1170.  }
  1171.  
  1172.  RegScrollSetup(regTopRow, entryCount, regValidRows);
  1173.  RegEditDisable(FALSE);
  1174. }
  1175.  
  1176. /************************************************************
  1177. * void RegEditDisable()
  1178. *
  1179. *    Enable/disable the edit gadget
  1180. *************************************************************/
  1181. void RegEditDisable(BOOL ok)
  1182. {
  1183.  /*
  1184.  if (editDisable != ok) 
  1185.     AmiDisableSel(ok);
  1186.       editDisable = ok;
  1187.  }
  1188.  */
  1189.  
  1190.  AmiDisableSel(ok);
  1191. }
  1192.  
  1193. /************************************************************
  1194. * RegRedrawRow()
  1195. *
  1196. *    Updates alternate row
  1197. *************************************************************/
  1198. void RegRedrawRow(filterNode *en)
  1199. {
  1200.  ULONG height,top,row;
  1201.  UBYTE oldmode, oldmask;
  1202.  
  1203.  row = DataFindNode((struct List *)&filtered,(struct Node *)en);
  1204.  if (row < regTopRow || row >= regTopRow + numRows)
  1205.     return;
  1206.  
  1207.  row -= regTopRow;
  1208.  height = registerRows[row].height - 2;
  1209.  top = registerRows[row].rpY + 1;
  1210.  
  1211.  SetAPen(&workRP,DETAILPEN);
  1212.  
  1213.  /* erase row */
  1214.  RectFill(&workRP,
  1215.         1,  top,
  1216.         regWidth-2,top + height );
  1217.  
  1218.  WaitBlit();
  1219.  
  1220.  /* fill in the row */
  1221.  RegFillRow(en,row);
  1222.  
  1223.  /* now redraw the grid */
  1224.  RegRenderGrid();
  1225.  
  1226.  /* now select locally */
  1227.  oldmode = workRP.DrawMode;
  1228.  oldmask = workRP.Mask;
  1229.  
  1230.  /* update display */
  1231.  RegRefresh(FALSE);
  1232. }
  1233.  
  1234. /************************************************************
  1235. * RegRedrawSel()
  1236. *
  1237. *    Updates the selected row
  1238. *************************************************************/
  1239. void RegRedrawSel(filterNode *fn)
  1240. {
  1241.  int x;
  1242.  ULONG height,top,row;
  1243.  UBYTE oldmode, oldmask;
  1244.  
  1245.  row = selRow-regTopRow;
  1246.  height = registerRows[row].height - 2;
  1247.  top = registerRows[row].rpY + 1;
  1248.  
  1249.  SetAPen(&workRP,DETAILPEN);
  1250.  
  1251.  /* erase row */
  1252.  RectFill(&workRP,
  1253.         1,  top,
  1254.         regWidth-2,top + height );
  1255.  
  1256.  WaitBlit();
  1257.  
  1258.  /* fill in the row */
  1259.  for (x=0;x<4;x++)
  1260.     fn->printChars[x]= -1;
  1261.  RegFillRow(fn,row);
  1262.  
  1263.  /* now redraw the grid */
  1264.  RegRenderGrid();
  1265.  
  1266.  /* now select locally */
  1267.  oldmode = workRP.DrawMode;
  1268.  oldmask = workRP.Mask;
  1269.  SetDrMd(&workRP,COMPLEMENT);
  1270.  SafeSetWriteMask(&workRP,0x3);
  1271.  
  1272.  RectFill(&workRP,
  1273.         1,  top,
  1274.         regWidth-2,top + height );
  1275.  
  1276.  SetDrMd(&workRP,oldmode);
  1277.  SafeSetWriteMask(&workRP,oldmask);
  1278.  
  1279.  /* update display */
  1280.  RegRefresh(FALSE);
  1281. }
  1282.  
  1283. /************************************************************
  1284. * RegMoveList()
  1285. *
  1286. *    Moves visible list area to new top
  1287. *************************************************************/
  1288. void RegMoveList(struct MinList *filters, UWORD top)
  1289. {
  1290.  ULONG x, row;
  1291.  filterNode *ft = (filterNode *)filters->mlh_Head;
  1292.  
  1293.  /* empty list? */
  1294.  if (filters->mlh_TailPred == filters) {
  1295.     RegClearGrid();
  1296.     RegRenderGrid();
  1297.     return;
  1298.  }
  1299.  
  1300. #if 0
  1301.  /* are we already there? */
  1302.  if (top == regTopRow) 
  1303.     return;
  1304. #endif
  1305.  
  1306.  if (top > entryCount - regValidRows) {
  1307.     /*printf("WHOA! top = %d\n",top);*/
  1308.     return;
  1309.  }
  1310.  
  1311.  /* deselect item */
  1312.  row = selRow;
  1313.  selRow = -1;
  1314.  
  1315.  /* obtain new top */
  1316.  for (x=0;x<top;x++) 
  1317.     ft = (filterNode *)ft->node.mln_Succ;
  1318.  
  1319.  regTopRow = top;
  1320.  regTopNode = ft;
  1321.  
  1322.  /* now render */
  1323.  RegClearGrid();
  1324.  for (x=0;x<regValidRows; x++) {
  1325.     RegFillRow(ft,x);
  1326.     ft = (filterNode *)ft->node.mln_Succ;
  1327.  }
  1328.  RegRenderGrid();
  1329.  
  1330.  /* select item again*/
  1331.  if (row >= regTopRow && row <= regTopRow + regValidRows-1) {
  1332.     /*printf("selecting!\n");*/
  1333.     RegSelect(row-regTopRow, FALSE);
  1334.   }
  1335.  else selRow = row;
  1336. }
  1337.  
  1338. /************************************************************
  1339. * RegScrollListUp()
  1340. *
  1341. *    quick move of register up by size of one row 
  1342. *************************************************************/
  1343. void RegScrollListUp(void)
  1344. {
  1345.  WORD x;
  1346.  filterNode *filt;
  1347.  
  1348.  regTopRow++;
  1349.  
  1350.  filt=regTopNode = (filterNode *)regTopNode->node.mln_Succ;
  1351.   
  1352.  RegClearGrid();
  1353.  for (x=0;x < regValidRows; x++) {
  1354.     RegFillRow(filt,x);
  1355.     WaitBlit();
  1356.     filt = (filterNode *)filt->node.mln_Succ;
  1357.  }
  1358.  RegRenderGrid();
  1359.  
  1360. }
  1361.  
  1362. /************************************************************
  1363. * RegScrollListDown()
  1364. *
  1365. *    Quick scrolling of window down one
  1366. *************************************************************/
  1367. void RegScrollListDown(void)
  1368. {
  1369.  WORD x;
  1370.  filterNode *filt;
  1371.  
  1372.  /* are we at the top? */
  1373.  if (regTopRow == 0)
  1374.     return; 
  1375.  
  1376.  regTopRow--;
  1377.  filt=regTopNode = (filterNode *)regTopNode->node.mln_Pred;
  1378.  
  1379.  /* render */
  1380.  RegClearGrid();
  1381.  for (x=0;x <regValidRows; x++) {
  1382.     RegFillRow(filt,x);
  1383.     filt = (filterNode *)filt->node.mln_Succ;
  1384.  }
  1385.  RegRenderGrid();
  1386.  
  1387. }
  1388.  
  1389. /************************************************************
  1390. * RegFillRow()
  1391. *
  1392. *    Fill row with node data
  1393. *************************************************************/
  1394. void RegFillRow(filterNode *fn, WORD row)
  1395. {
  1396.  entryNode *en = fn->entry;
  1397.  char checktype[CHECKSIZE];
  1398.  char datestr[DATESIZE];
  1399.  char amntstr[AMNTSIZE];
  1400.  char textpen;
  1401.  long tempprint = -1;;
  1402.  
  1403.  /* now assumes row is blank */
  1404.  if (en->flags & VOIDED)
  1405.     textpen = SHINEPEN;
  1406.  else textpen = BLOCKPEN;
  1407.  
  1408.  /* fill in type */
  1409.  if (en->type != CHECKTYPE)
  1410.      RegRenderCell(row,0,regTypeArray[en->type],textpen,®PrintChars[en->type],FALSE);
  1411.  else {
  1412.     sprintf(checktype,"%06d",en->check);
  1413.     RegRenderCell(row,0,checktype,textpen, &fn->printChars[0],FALSE);
  1414.  }
  1415.  
  1416.  /* fill in date */
  1417.  DataBuildRegDate(&en->date,datestr);
  1418.  RegRenderCell(row,1,datestr,textpen, &fn->printChars[1],FALSE);
  1419.  
  1420.  /* fill in name */
  1421.  RegRenderCell(row,2,en->name,textpen, &fn->printChars[2],FALSE);
  1422.  
  1423.  /* memo? */
  1424.  if (showMemo)
  1425.     RegRenderCell(row,2,en->memo,textpen,&tempprint,TRUE);
  1426.     
  1427.  /* voided? */
  1428.  if (en->flags & VOIDED)
  1429.      RegRenderCell(row,3,"V", textpen, ®PrintFlags[0],FALSE);
  1430.  
  1431.  /* Cleared/tax deductible?? */
  1432.  if (en->flags & CLEARED)
  1433.     RegRenderCell(row,4,"C",textpen, ®PrintFlags[1],FALSE);
  1434.  
  1435.  if (en->flags & TAXDEDUCT)
  1436.     RegRenderCell(row,5,"T",textpen, ®PrintFlags[2],FALSE);
  1437.  
  1438.  /* amount? */
  1439.  DataBuildAmnt(TRUE, &en->amount,amntstr);
  1440.  
  1441.  if (en->type == DEPOSITTYPE && !(en->flags & VOIDED) )
  1442.     textpen=TEXTPEN;
  1443.  
  1444.  /* right justify this val */
  1445.  RegRenderCellFlush(row,6,amntstr,textpen, &fn->printChars[3]);
  1446.  WaitBlit();
  1447. }
  1448.  
  1449. /********************************************************
  1450. * RegLastPage()
  1451. *
  1452. *    Shows last page of register
  1453. *********************************************************/
  1454. void RegLastPage(void)
  1455. {
  1456.  WORD x;
  1457.  filterNode *filt;
  1458.  
  1459. #if 0
  1460.  /* test to see if we have too few entries */
  1461.  if (entryCount <= regValidRows) {
  1462.     RegMoveList(&filtered,0);
  1463.     return;
  1464.  }
  1465. #endif
  1466.  
  1467.  /* clear display */
  1468.  RegClearGrid();
  1469.  
  1470.  /* work from bottom */
  1471.  if (filtered.mlh_TailPred != &filtered) {
  1472.      filt = (filterNode *)filtered.mlh_TailPred;
  1473.     for (x=regValidRows;x > 0; x--) {
  1474.         RegFillRow(filt,x-1);
  1475.         regTopNode = filt;
  1476.         filt = (filterNode *)filt->node.mln_Pred;
  1477.      }
  1478.  
  1479.       regTopRow = entryCount - regValidRows;
  1480.  }
  1481.  
  1482.  RegRenderGrid();
  1483. }
  1484.  
  1485. /********************************************************
  1486. * RegRemoveSel()
  1487. *
  1488. *    Remove the filter entry of selected row,
  1489. *    redraw register
  1490. *********************************************************/
  1491. void RegRemoveSel(void)
  1492. {
  1493.  /*entryCount--;*/
  1494.  if (entryCount < regValidRows) {
  1495.     regValidRows--;
  1496.     selRow = -1;
  1497.     RegLastPage();
  1498.  }
  1499.  else {
  1500.     /* should we not move up? */
  1501.     if (regTopRow + regValidRows > entryCount)
  1502.         regTopRow--;
  1503.  
  1504.      selRow = -1;
  1505.      RegMoveList(&filtered,regTopRow);
  1506.  }
  1507.  
  1508.  RegRefresh(FALSE);
  1509.  RegScrollSetup(regTopRow, entryCount, regValidRows);
  1510.  RegEditDisable(TRUE);
  1511. }
  1512.  
  1513. /********************************************************
  1514. * RegNewFilter()
  1515. *
  1516. *     Resets the filter in the register
  1517. *********************************************************/
  1518. void RegNewFilter(void)
  1519. {
  1520.  selRow = -1;
  1521.  regTopRow = 0;
  1522.  if (entryCount < numRows)
  1523.     regValidRows = entryCount;
  1524.  else regValidRows = numRows;
  1525.  
  1526.  RegLastPage();
  1527.  RegRefresh(FALSE);
  1528.  RegEditDisable(TRUE);
  1529.  RegScrollSetup(regTopRow, entryCount, regValidRows);
  1530. }
  1531.  
  1532. /*********************************************************
  1533. * RegResetOffsets()
  1534. *
  1535. *    Reset the printlength offsets
  1536. **********************************************************/
  1537. void RegResetOffsets(int type)
  1538. {
  1539.  filterNode *filt = NULL;
  1540.  
  1541.  while ( (filt = (filterNode *)DataGetNext((struct List *)&filtered,
  1542.     (struct Node *)filt)) != NULL) {
  1543.         filt->printChars[type] = -1;
  1544.  }
  1545. }
  1546.  
  1547. /*********************************************************
  1548. * RegRedrawFilter()
  1549. *
  1550. *    Resets filter, but maintains selected state if needed
  1551. **********************************************************/
  1552. void RegRedrawFilter(ULONG filtentries)
  1553. {
  1554.  /* handle any unexpected new entries too */
  1555.  if (filtentries > 0) {
  1556.     entryCount += filtentries;
  1557.     if (regValidRows < numRows) {
  1558.         if (numRows-regValidRows <= filtentries)
  1559.             regValidRows = numRows;
  1560.         else    regValidRows += filtentries;
  1561.     }
  1562.  }
  1563.  
  1564.  if (selRow != -1)
  1565.     RegMoveToSel(&filtered);
  1566.  else     RegNewFilter();
  1567. }
  1568.  
  1569. /************************************************************
  1570. * RegMoveToSel()
  1571. *
  1572. *    Moves visible list area to show selected item in center
  1573. *************************************************************/
  1574. void RegMoveToSel(struct MinList *filters)
  1575. {
  1576.  ULONG top;
  1577.  
  1578.  /* empty list? */
  1579.  if (filters->mlh_TailPred == filters) {
  1580.     RegClearGrid();
  1581.     RegRenderGrid();
  1582.     return;
  1583.  }
  1584.  
  1585.  if (selRow == -1)
  1586.     return;
  1587.  
  1588.  /* calculate new top */
  1589.  if (selRow < numRows)
  1590.     top = 0;             /* on first page */
  1591.  else if (selRow > entryCount - numRows)
  1592.     top = entryCount - numRows;    /* on last page */
  1593.  else if (selRow >= regTopRow && selRow < regTopRow+numRows)
  1594.     top = regTopRow;
  1595.  else top = selRow - numRows/2;        /* put sel in middle */
  1596.  
  1597.  RegMoveList(filters,top);
  1598.  RegScrollSetup(regTopRow, entryCount, regValidRows);
  1599.  RegRefresh(FALSE);
  1600. }
  1601.