home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic 4 Unleashed / Visual_Basic_4_Unleashed_SAMS_Publishing_1995.iso / repease / rep_rep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-09  |  71.8 KB  |  1,877 lines
  1. /*==============================================================================
  2.    REP_REP.C
  3.    Report Ease: Report Executer Routines.
  4.  
  5.    ReportEase Plus
  6.    Sub Systems, Inc.
  7.    ReportEase Plus, Copyright (c) 1993, Sub Systems, Inc. All Rights Reserved.
  8.    159 Main Street, #8C, Stoneham,  MA 02180 
  9.    (617) 438-8901.
  10.  
  11.    Software License Agreement  (1993)              
  12.    ----------------------------------
  13.    This license agreement allows the purchaser the right to modify the 
  14.    source code to incorporate in their application.
  15.    The target application must not be distributed as a standalone report writer
  16.    or a mail merge product.
  17.    Sub Systems, Inc. reserves the right to prosecute anybody found to be 
  18.    making illegal copies of the executable software or compiling the source
  19.    code for the purpose of selling there after.
  20.  
  21. ===============================================================================*/
  22. #include "windows.h"
  23.  
  24. #if defined (_WIN32)
  25.    #if !defined(WIN32)
  26.      #define WIN32
  27.    #endif
  28. #endif
  29. #if !defined(WIN32) 
  30.   #include "print.h"
  31. #endif
  32.  
  33. #include "stdio.h"
  34. #include "stdlib.h"
  35. #include "ctype.h"
  36. #include "fcntl.h"
  37. #include "io.h"
  38. #include "sys\types.h"
  39. #include "sys\stat.h"
  40. #include "string.h"
  41. #include "dos.h"
  42. #include "math.h"
  43. #include "setjmp.h"
  44.  
  45. #include "rep.h"
  46.  
  47. #define  PREFIX extern
  48. #include "rep1.h"
  49.  
  50. extern BOOL ReportEaseActive;    // TRUE when report ease has been called 
  51.  
  52. /******************************************************************************
  53.     RepInit:
  54.     This routine is called by the user application to initialize a report
  55.     run.  The parameters are passed using the StrRep structure.
  56.     The routine returns a 0 value if the report is successfully initialized.
  57.     Otherwise it returns an error code (see ERR_ in the rew.h file).
  58.  
  59.     This routine uses the input structure parameter (RepArg) to pass the 
  60.     field information to the application routine.  It returns the pointer
  61.     to two arrays:
  62.  
  63.     1.  field: Huge pointer to the field table.  This table contains field information
  64.         about each field used by the form.  The elements of a field
  65.         is defined using the StrField structure.  Your application will need
  66.         to fill in the field data before calling the RepRec routine.
  67.         
  68.         The number of fields in this table is given by the TotalFields variable 
  69.         within the StrRep structure.
  70.           
  71.     2.  SortField: Huge pointer to the sort field table.  This table contains field information
  72.         about each sort field used by the form.  The elements of a field
  73.         is defined using the StrField structure.  Your application should
  74.         sort the records as specified by these fields.
  75.         
  76.         The number of fields in this table is given by the TotalSortFields variable 
  77.         within the StrRep structure.
  78.           
  79.  
  80. *******************************************************************************/     
  81. int WINAPI _export RepInit(struct StrRep far *ArgPtr) 
  82. {
  83.    LPSTR SaveCharPtr;
  84.    int  j,i,select,len,result,HorzWidth,PrtResX,PrtResY;
  85.    int   CompExp[NAME_WIDTH+2],LastSym,FieldIndex,fld,CurField;
  86.    int   SecItem,FirstY,LastY,WrapItem,LastItem,AdjX,AdjY;
  87.    struct StrItem TempItem;
  88.    POINT pt;
  89.  
  90.    // prepare to return an error code
  91.    #if defined (WIN32)
  92.       if (setjmp(FrAbort)==-1) return ErrorCode; // Fatal error return location 
  93.    #else
  94.       if (Catch((LPCATCHBUF)&FrAbort)==-1) return ErrorCode; // Fatal error return location 
  95.    #endif
  96.  
  97.    // check if ReportEase alread active
  98.    if (ReportEaseActive) {
  99.        MessageBox(hFrParentWnd,"Report Ease Already Active!",NULL,MB_OK);
  100.        return ERR_DUPLICATE;
  101.    }
  102.  
  103.    SessionType='R';                     // Report Run session 
  104.    ReportStage=IN_INIT;                 // in initialization 
  105.    RepArg=*ArgPtr;                      // store the argument pointer 
  106.    
  107.    //****************** check if the input file exists ****************
  108.    if (access(RepArg.file,6)==-1) {
  109.       AbortFr("Form File Not Found!",ERR_NO_FILE);
  110.    }
  111.  
  112.    //* Transfer the some input parameter variables to the global area *
  113.    strcpy(FrFileName,ArgPtr->file);    // current report file name 
  114.    FrShowHorBar=TRUE;                  // show horizontal scroll bar 
  115.    FrShowVerBar=TRUE;                  // show vertical scroll bar 
  116.  
  117.    //hFrInst=ArgPtr->hInst;           // uncomment for STATIC linking
  118.    //hFrPrevInst=ArgPtr->hPrevInst;   // uncomment for STATIC linking
  119.  
  120.    hFrWnd=NULL;                        // windows not opened yet 
  121.    hFrParentWnd=ArgPtr->hParentWnd;    // Handle to the parent window 
  122.  
  123.    //***************** Select the output device **********************
  124.    if (ArgPtr->device=='A') {          // ask user for the output device 
  125.       select=CallDialogBox("DeviceParam",DeviceParam,0);
  126.       if (select<0) return ERR_NO_DEVICE;
  127.       if (select==0) ArgPtr->device='S';
  128.       else           ArgPtr->device='P';
  129.    }
  130.  
  131.    if (ArgPtr->device=='S') UseScreen=TRUE;
  132.    else  {
  133.        UseScreen=FALSE;
  134.        FrShowHorBar=FALSE;             // show horizontal scroll bar 
  135.        FrShowVerBar=FALSE;             // show vertical scroll bar 
  136.    }
  137.  
  138.    //***************** Other initialization and file input 
  139.    if (0!=(result=InitFr(RepArg.style,RepArg.x,RepArg.y,RepArg.width,RepArg.height))) return result;
  140.    if (UseScreen) {
  141.       FormHdr.RulerType=RULER_OFF;     // turnoff the ruler
  142.       GetWinDimension();               // recalculate the window dimensions
  143.    }
  144.  
  145.    AllocRepMem();                      // allocate/reallocate arrays 
  146.  
  147.    //****************** accept the dialog fields ***************************
  148.    if (!AcceptDlgField()) {
  149.       ReportStatus=REP_ABORT;          // user cancellation 
  150.       RepExit();                       
  151.       return ERR_SUSPEND;
  152.    }
  153.  
  154.    //****************** initialize the temporary fields ***************************
  155.    for (i=0;i<MAX_TEMP_FIELDS;i++) {
  156.       InitField(&TempField[i]);
  157.       TempField[i].InUse=FALSE;
  158.    }
  159.  
  160.    //***************** Stuff the sort fields *******************************
  161.    for(i=0;i<TotalBreakFields;i++) {      // allocate space for the character sort fields 
  162.       FieldIndex=BreakField[i].SortField; // index into the field table 
  163.       SaveCharPtr=SortField[i].CharData;  // this field already allocated 
  164.       SortField[i]=field[FieldIndex];
  165.       SortField[i].CharData=SaveCharPtr;
  166.    }
  167.  
  168.    //***************** Assign the constant string and dialog fields **********
  169.    for (fld=0;fld<TotalFields;fld++) {
  170.       if (field[fld].type==TYPE_TEXT) field[fld].CharData[0]=0;// initialize 
  171.  
  172.       if (field[fld].source==SRC_CONST) {
  173.           if (field[fld].type==TYPE_TEXT) {
  174.               lstrcpy(field[fld].CharData,&field[fld].name[1]); // exclude the initial quote 
  175.               len=lstrlen(field[fld].CharData);
  176.               if (len>0) field[fld].CharData[len-1]=0;         // exclude the ending quotes 
  177.           }
  178.       }
  179.       else if (field[fld].source==SRC_DLG) {                   // assign fields 
  180.           if (field[fld].type==TYPE_TEXT) {
  181.              lstrcpy(field[fld].CharData,DlgField[field[fld].SysIdx].CharData);
  182.           }
  183.           else {
  184.              field[fld].NumData=DlgField[field[fld].SysIdx].NumData;
  185.              field[fld].DblData=DlgField[field[fld].SysIdx].DblData;
  186.           }
  187.       }
  188.    }
  189.  
  190.    //***************** compile the report selection criteria ****************
  191.    LastSym=CompileExp(FormHdr.SelExp,CompExp);// compile the expression 
  192.  
  193.    if (LastSym!=END_OF_EXP) {                 // error encountered 
  194.       AbortFr("Invalid Report Selection Expression!",ERR_BAD_EXP);
  195.    }
  196.    i=0;
  197.    while(CompExp[i]!=END_OF_EXP) {            // transfer to the structure 
  198.       FormHdr.SelExp[i]=CompExp[i];
  199.       i++;
  200.    }
  201.    FormHdr.SelExp[i]=CompExp[i];
  202.  
  203.    //***************** compile the field expressions *********************
  204.    for (j=0;j<TotalFields;j++) {
  205.       if (field[j].source==SRC_CALC) {
  206.          LastSym=CompileExp(field[j].CalcExp,CompExp);// compile the expression 
  207.  
  208.          if (LastSym!=END_OF_EXP) {       // error encountered 
  209.             AbortFr("Invalid Field Calculation Expression!",ERR_BAD_EXP);
  210.          }
  211.          i=0;
  212.          while(CompExp[i]!=END_OF_EXP) {  // transfer to the structure 
  213.             field[j].CalcExp[i]=CompExp[i];
  214.             i++;
  215.          }
  216.          field[j].CalcExp[i]=CompExp[i];
  217.       }
  218.    }
  219.  
  220.    //***************** compile the section selection expressions *********************
  221.    for (j=0;j<MAX_SECTIONS;j++) {
  222.       if (section[j].InUse) {
  223.          LastSym=CompileExp(section[j].SelExp,CompExp);// compile the expression 
  224.  
  225.          if (LastSym!=END_OF_EXP) {       // error encountered 
  226.             AbortFr("Invalid Section Selection Expression!",ERR_BAD_EXP);
  227.          }
  228.          i=0;
  229.          while(CompExp[i]!=END_OF_EXP) {  // transfer to the structure 
  230.             section[j].SelExp[i]=CompExp[i];
  231.             i++;
  232.          }
  233.          section[j].SelExp[i]=CompExp[i];
  234.       }
  235.    }
  236.  
  237.    //***************** Initialize the user fields ****************************
  238.    for (fld=0;fld<TotalFields;fld++) {
  239.       SaveCharPtr=UserField[fld].CharData; // this field already allocated 
  240.       UserField[fld]=field[fld];
  241.       UserField[fld].CharData=SaveCharPtr;
  242.       if (field[fld].type==TYPE_TEXT) lstrcpy(UserField[fld].CharData,field[fld].CharData);
  243.    }
  244.  
  245.  
  246.    //********************* initialize the section and section items ***********
  247.    for (i=0;i<MAX_SECTIONS;i++) {             // initialize the section pointers 
  248.       if (!section[i].InUse) continue;
  249.  
  250.       SecItem=section[i].ScrItem;             // section position in the item table
  251.       item[SecItem].y=item[SecItem].y+FormHdr.SecBannerHeight;
  252.       item[SecItem].height=item[SecItem].height-FormHdr.SecBannerHeight;
  253.       section[i].FirstItem=SecItem;
  254.       section[i].ItemCount=1;                 // include the section item
  255.       
  256.       // calculate first and last Y position of items within the section
  257.       FirstY=LastY=-1;                        // initialize
  258.       for (j=section[i].FirstItem+1;j<TotalItems;j++) {
  259.          if (item[j].section!=i) break;       // next section begins
  260.          section[i].ItemCount++;
  261.          
  262.          if (item[j].type==GROUP) continue;   // ignore group items
  263.          if (FirstY==-1) FirstY=item[j].y;    // find the first item position
  264.          else if (item[j].y<FirstY) FirstY=item[j].y;
  265.  
  266.          if (item[j].y+item[j].height>LastY) LastY=item[j].y+item[j].height;
  267.       
  268.          // initialize the field variables
  269.          if (item[j].type==FIELD) {
  270.             CurField=item[j].field;
  271.             field[CurField].section=UserField[CurField].section=i;
  272.             if (i<SEC_FTR_LVL9) field[CurField].SumType=UserField[CurField].SumType=SUM_NONE;
  273.          }
  274.       }
  275.       
  276.       // adjust the item Y positions within the section
  277.       if (!(section[i].flags&SFLAG_TRIM_BEFORE)) FirstY=item[SecItem].y;
  278.       if (!(section[i].flags&SFLAG_TRIM_AFTER))  LastY=item[SecItem].y+item[SecItem].height;
  279.       
  280.       if (FirstY==-1 || LastY==-1) {
  281.          section[i].ItemCount=0;
  282.          section[i].height=0;
  283.       }
  284.       else {
  285.          section[i].height=LastY-FirstY;
  286.          for (j=section[i].FirstItem;j<TotalItems;j++) {
  287.             if (item[j].section!=i) break;       // next section begins
  288.             item[j].y-=FirstY;                   // position relative to the section beginning
  289.          }
  290.  
  291.          // set the section item to begin at relative zero
  292.          j=section[i].FirstItem;
  293.          item[j].y=0;                            // set the section beginning to zero
  294.          item[j].height=LastY-FirstY+1;
  295.       }
  296.       
  297.       // move the wrap field at the last position
  298.       if (i==SEC_DETAIL1 && section[i].ItemCount>0) {
  299.          WrapItem=-1;
  300.          LastItem=section[i].FirstItem+section[i].ItemCount-1;
  301.          for (j=section[i].FirstItem;j<=LastItem;j++) {
  302.             if (item[j].type==GROUP || item[j].type==SECTION) continue;   // ignore group items
  303.             
  304.             if (WrapItem!=-1) {     // check any item after the wrap item
  305.                if (item[j].y>=item[WrapItem].y+item[WrapItem].height-DESC_MARGIN) WrapItem=-1;  // discard this wrap item
  306.             }
  307.             
  308.             if (item[j].type!=FIELD) continue;
  309.             CurField=item[j].field;
  310.             if (field[CurField].type==TYPE_TEXT 
  311.              && field[CurField].flags&(FLAG_WRAP|FLAG_WORD_WRAP)) WrapItem=j;
  312.          }
  313.          if (WrapItem!=-1 && WrapItem!=LastItem) { // reloate the wrap item
  314.             HugeMove(&(item[WrapItem]),&TempItem,sizeof(struct StrItem));
  315.             HugeMove(&(item[LastItem]),&(item[WrapItem]),sizeof(struct StrItem));
  316.             HugeMove(&TempItem,&(item[LastItem]),sizeof(struct StrItem));
  317.             WrapItem=LastItem;
  318.          }
  319.          LastWrapItem=WrapItem;
  320.       }
  321.  
  322.    }
  323.    
  324.  
  325.    //***************** other initialization **********************************
  326.    GetSystemDateTime();    // get the system date and time
  327.  
  328.    // initialize month array 
  329.    MonthName[0]="Jan";MonthName[1]="Feb";MonthName[2]="Mar";
  330.    MonthName[3]="Apr";MonthName[4]="May";MonthName[5]="Jun";
  331.    MonthName[6]="Jul";MonthName[7]="Aug";MonthName[8]="Sep";
  332.    MonthName[9]="Oct";MonthName[10]="Nov";MonthName[11]="Dec";
  333.    
  334.    RecCount=0;                            // First rec to be read by the application 
  335.    PageCount=1;                           // first page 
  336.    ScrPage=0;                             // screen page being displayed
  337.    CurX=0;                                // current displacement toward x direction
  338.    CurHeight=0;                           // current Y displacement
  339.    CurCol=0;                              // current column for multiple column sections
  340.    TrialMode=FALSE;                       // trial mode prints trial records 
  341.    hMetaFile=NULL;                        // current screen page in memory meta file
  342.    PageAdvanced=FALSE;                    // set after page is advanced 
  343.    AdvancingPage=FALSE;                   // set during page advance 
  344.    ReportStatus=REP_RESUMED;
  345.  
  346.    //*************** initialize the page variables *******************
  347.    LeftMargin=(int)((FormHdr.LeftMargin)*UNITS_PER_INCH);  // margins logical in units 
  348.    RightMargin=(int)((FormHdr.RightMargin)*UNITS_PER_INCH); 
  349.    TopMargin=(int)((FormHdr.TopMargin)*UNITS_PER_INCH);
  350.    BottomMargin=(int)((FormHdr.BottomMargin)*UNITS_PER_INCH);
  351.  
  352.    PrintWidth=(int)(PrintWidthInches*UNITS_PER_INCH);   // width of the printed area   
  353.  
  354.    // adjust left and top margin for the hidden areas
  355.    Escape(hPrtDC,GETPRINTINGOFFSET,0,NULL,&pt);  // actual offset where printing begins
  356.    PrtResX=GetDeviceCaps(hPrtDC,LOGPIXELSX);     // number of pixels per inch of X direction 
  357.    PrtResY=GetDeviceCaps(hPrtDC,LOGPIXELSY);     // number of pixels per inch of Y direction 
  358.    AdjX=MulDiv(pt.x,UNITS_PER_INCH,PrtResX);     // printing area begin position
  359.    AdjY=MulDiv(pt.y,UNITS_PER_INCH,PrtResY);
  360.  
  361.    LeftMargin-=AdjX;                             // margin relative to printing area
  362.    TopMargin-=AdjY;
  363.    for (i=0;i<TotalItems;i++) item[i].x-=AdjX;   // x relative to printing area
  364.  
  365.    PageHeight=(int)(PrintHeightInches*UNITS_PER_INCH)+TopMargin;  // height of the printed page   
  366.    if (section[SEC_FTR_PAGE].InUse) PrintHeight=PageHeight-section[SEC_FTR_PAGE].height;
  367.    else                             PrintHeight=PageHeight;
  368.  
  369.    if (PrintHeight<=0) {
  370.       MessageBox(hFrWnd,"Page Too Small!",NULL,MB_OK);
  371.       return ERR_PRINTER;
  372.    }
  373.    
  374.  
  375.    //******************** set additional window characteristics ****************
  376.    if (UseScreen) {
  377.       //******************** set the left margin on the screen ****************
  378.       FrWinOrgX=FrWinOrgY=0;
  379.       FrSetViewWindow();        // set the logical window origin 
  380.  
  381.       //******************* set scroll bars **********************************
  382.       HorzWidth=PrintWidth-FrWinWidth;
  383.       if (HorzWidth>0) {
  384.          HorScrollPos=HOR_SCROLL_MIN+(int)((long)FrWinOrgX*(HOR_SCROLL_MAX-HOR_SCROLL_MIN)/HorzWidth);
  385.          if (HorScrollPos>HOR_SCROLL_MAX) HorScrollPos=HOR_SCROLL_MAX;
  386.          SetScrollPos(hFrWnd,SB_HORZ,HorScrollPos,TRUE);
  387.       }
  388.       SetScrollPos(hFrWnd,SB_VERT,VER_SCROLL_MIN,TRUE);
  389.       
  390.       //****************** Create a new meta file **********************
  391.       if (NULL==(hMetaDC=CreateMetaFile(NULL))) AbortFr("Error creating metafile",ERR_NO_FILE);
  392.       ShowScrRepStatus();                             // show screen reporting status
  393.       RepInitMenu(hFrMenu);                           // initialize the menu bar
  394.    }
  395.    
  396.    //***************** Initialize the system fields ****************************
  397.    for (fld=0;fld<TotalFields;fld++) {
  398.       if (field[fld].source==SRC_SYS) {
  399.          StuffSysField(&field[fld]);
  400.          StuffSysField(&UserField[fld]);
  401.       }
  402.    }
  403.  
  404.    //***************** stuff the return fields*******************************
  405.    RepArg.field=UserField;               // field to be filled by the user application 
  406.    RepArg.TotalFields=TotalFields;
  407.    RepArg.SortField=SortField;
  408.    RepArg.TotalSortFields=TotalBreakFields;
  409.    lstrcpy(RepArg.DataSetName,FormHdr.DataSetName);
  410.  
  411.    (*ArgPtr)=RepArg;                      // return the updated structure 
  412.  
  413.    return 0;
  414. }
  415.  
  416. /******************************************************************************
  417.     RepRec:
  418.     This routine is called by the user application to print each record.
  419.     The field data for the record must be passed using the 'field' array
  420.     as returned by the RepInit routine.  
  421.     
  422.     Your application should fill in the data for only the fields of SOURCE 
  423.     type equal to SCR_APPL.  The data in other fields must not be modified in 
  424.     any way.  
  425.     
  426.     Only the following elements in the field structure can be used to pass data:
  427.  
  428.        CharData  (char far *) to pass the character string data.
  429.                  The character data being copied to the CharData pointer
  430.                  should not be larger than the 'width' as specified in 
  431.                  the field structure.  This variable (width) holds the character
  432.                  field width as specified by your application during the
  433.                  form edit process.
  434.  
  435.        NumData   (long) to pass numeric, logical and date data.
  436.                  (date should be passed either as YYMMDD or YYYYMMDD format).
  437.  
  438.        DblData   (double) to pass float numeric data.
  439.  
  440.     No other element of field structure should be modified.
  441. *******************************************************************************/     
  442. int WINAPI _export RepRec() 
  443. {
  444.     int sec,BreakSort;
  445.     struct StrField TempField,huge *SaveField=NULL;
  446.     int LastSym;
  447.     int fld;
  448.  
  449.    // prepare to return an error code
  450.    #if defined (WIN32)
  451.       if (setjmp(FrAbort)==-1) {            // Fatal error return location 
  452.    #else
  453.       if (Catch((LPCATCHBUF)&FrAbort)==-1) { // Fatal error return location 
  454.    #endif
  455.         if (SaveField!=NULL) {
  456.            field=SaveField;
  457.            SaveField=NULL;
  458.         }
  459.         return ErrorCode;
  460.     }
  461.  
  462.     ReportStage=IN_RECORDS;                    // processing records 
  463.  
  464.     //******************** Apply record selection criteria ******************
  465.     EvaluateSystemFields();                    // update system fields 
  466.  
  467.     if (FormHdr.SelExp[0]!=END_OF_EXP) {
  468.         SaveField=field;                       // activate user fields 
  469.         field=UserField;
  470.         
  471.         LastSym=RunExp(FormHdr.SelExp,&TempField,TRUE); // run the expression and return the output in the field 
  472.         
  473.         field=SaveField;                       // activate the original field 
  474.         SaveField=NULL;
  475.  
  476.         if (LastSym!=END_OF_EXP || TempField.type!=TYPE_LOGICAL)  { // error encountered 
  477.            MessageBox(hFrWnd,"Error In Record Filter",NULL,MB_OK);
  478.            return ERR_BAD_EXP;
  479.         }
  480.         if (!(TempField.NumData)) return 0;// record not selected   
  481.     }
  482.  
  483.     //************ calculate the break fields *********
  484.     SaveField=field;                       // activate user fields 
  485.     field=UserField;
  486.     CalculateBreakFields();
  487.     field=SaveField;                       // activate the original field 
  488.     SaveField=NULL;
  489.  
  490.     
  491.     //******************** Initialize for the first record *******************
  492.     if (RecCount==0) InitFirstRec();
  493.  
  494.     //************************ Check for sort breaks ***********************
  495.     BreakSort=PrintSortFooters();
  496.  
  497.     //**************** copy the user field to the global field ***************
  498.     for (fld=0;fld<TotalFields;fld++) {
  499.         if (field[fld].type==TYPE_TEXT)     lstrcpy(field[fld].CharData,UserField[fld].CharData);
  500.         else if (field[fld].type==TYPE_DBL) field[fld].DblData=UserField[fld].DblData;
  501.         else                                field[fld].NumData=UserField[fld].NumData;
  502.     }
  503.  
  504.     //******************* Evaluate the calculation fields ******************
  505.     CalculateFields(0,MAX_SECTIONS-1);     // calculate all fields for all section 
  506.     
  507.     //************************* Print sort headers **************************
  508.     PrintSortHeaders(BreakSort);
  509.     
  510.     //************************* Print the detail sections **********************
  511.     for (sec=SEC_DETAIL1;sec<=SEC_DETAIL9;sec++) PrintSection(sec);
  512.  
  513.     //************************* Do totals ************************************
  514.     for (fld=0;fld<TotalFields;fld++) {
  515.         field[fld].count++;
  516.  
  517.         if (field[fld].SumType==SUM_MAX) {
  518.            if (field[fld].DblData>field[fld].HoldDbl) field[fld].HoldDbl=field[fld].DblData;
  519.            if (field[fld].NumData>field[fld].HoldNum) field[fld].HoldNum=field[fld].NumData;
  520.         }
  521.         else if (field[fld].SumType==SUM_MIN) {
  522.            if (field[fld].DblData<field[fld].HoldDbl) field[fld].HoldDbl=field[fld].DblData;
  523.            if (field[fld].NumData<field[fld].HoldNum) field[fld].HoldNum=field[fld].NumData;
  524.         }
  525.         else {
  526.            field[fld].HoldDbl+=field[fld].DblData;
  527.            field[fld].HoldNum+=field[fld].NumData;
  528.         }
  529.  
  530.     }
  531.     
  532.     if (UseScreen) {
  533.        // show progress
  534.        if ( (RecCount<50 && RecCount%5==0) || RecCount%10==0) ShowScrRepStatus();               // show print progress
  535.        ProcessUserCommands();            // process any pending messages
  536.     }
  537.  
  538.     RecCount++;                          // increment number of records printed 
  539.  
  540.     return 0;
  541. }
  542.  
  543. /*****************************************************************************
  544.     RepExit:
  545. *****************************************************************************/
  546. int WINAPI _export RepExit()
  547. {
  548.     int CurSort,CurSec,FooterSec;
  549.  
  550.    // prepare to return an error code
  551.    #if defined (WIN32)
  552.       if (setjmp(FrAbort)==-1) return ErrorCode; // Fatal error return location 
  553.    #else
  554.       if (Catch((LPCATCHBUF)&FrAbort)==-1) return ErrorCode; // Fatal error return location 
  555.    #endif
  556.  
  557.     if (ReportStatus!=REP_ABORT && RecCount>0) {
  558.         ReportStage=IN_TOTALS;                  // printing totals 
  559.  
  560.         //******************** calculate the footer fields ********************
  561.         CalculateFields(SEC_FTR_LVL9,SEC_FTR_REP);
  562.         
  563.         //******************** print sort footers ******************************
  564.         for (CurSort=(TotalBreakFields-1);CurSort>=0;CurSort--) {
  565.             CurSec=BreakField[CurSort].section;
  566.             FooterSec=SEC_FTR_LVL1-(CurSec-SEC_HDR_LVL1);
  567.             PrintSection(FooterSec);                // print section footer 
  568.         }
  569.  
  570.         PrintSection(SEC_FTR_REP);                  // print the report footers 
  571.  
  572.         CurHeight=PrintHeight;                      // print last page footer 
  573.         PageAdvanced=AdvancingPage=TRUE;
  574.         PrintSection(SEC_FTR_PAGE);
  575.     }
  576.  
  577.     if (ReportStatus!=REP_ABORT) {
  578.         if (UseScreen) {
  579.            ReportStage=IN_EXIT;
  580.            TransferMetaFile();                      // transfer the last metafile page to disk
  581.            RepInitMenu(hFrMenu);                    // redisplay the menu 
  582.            PaintRepScr();                           // show screen 
  583.         }
  584.         else {
  585.            ReportStage=IN_EXIT;
  586.            Escape(hFrDC,NEWFRAME,0,0L,0L);
  587.         }
  588.     }
  589.  
  590.     if (UseScreen && ReportStatus!=REP_ABORT) 
  591.           return 0;                       // do cleanup later
  592.     else  return RepCleanup();            // do cleanup now
  593. }
  594.  
  595. /*****************************************************************************
  596.     RepCleanup:
  597.     Release the report resources
  598. *****************************************************************************/
  599. int RepCleanup()
  600. {
  601.     int i;
  602.     char string[85];
  603.     int fld;
  604.     HMETAFILE hMeta;
  605.  
  606.     //******* release printer window resources *********
  607.     if (!UseScreen) {
  608.         if (RecCount>0) {
  609.             PrintProc(hFrDC,0);                     // show the last status
  610.             Escape(hFrDC,ENDDOC,0,0L,0L);           // end of print job 
  611.             if (hFrWnd) EnableWindow(hFrWnd,TRUE);  // activate the parent window 
  612.             DestroyWindow(hAbortWnd);               // destroy the abort window 
  613.             FreeProcInstance(lpProc);               // free the process instances 
  614.             FreeProcInstance(lpAbortDlg);
  615.         }
  616.         if (ReportStatus!=REP_ABORT) {
  617.            wsprintf(string,"%ld Record(s) Printed",RecCount);
  618.            MessageBox(hFrWnd,string,"Report Over",MB_ICONSTOP);
  619.         }
  620.     }
  621.  
  622.     //*********************** Do cleanup ***********************************
  623.     // free up space taken by the character fields 
  624.     for(fld=0;fld<TotalFields;fld++) {      // allocate space for the character fields 
  625.        if (field[fld].type==TYPE_TEXT && field[fld].CharData!=NULL)         OurFree(field[fld].CharData);
  626.        if (UserField[fld].type==TYPE_TEXT && UserField[fld].CharData!=NULL) OurFree(UserField[fld].CharData);
  627.     }
  628.  
  629.     for(i=0;i<TotalBreakFields;i++) { // allocate space for the character fields 
  630.        if (SortField[i].type==TYPE_TEXT) OurFree(SortField[i].CharData);
  631.     }
  632.  
  633.     //*********** free up addtional global memory blocks ****
  634.     GlobalUnlock(hSortField);
  635.     GlobalFree(hSortField);
  636.  
  637.     GlobalUnlock(hUserField);
  638.     GlobalFree(hUserField);
  639.  
  640.     //*********** free up screen arrays *******************************
  641.     if (UseScreen) {
  642.         GlobalUnlock(hPageLoc);
  643.         GlobalFree(hPageLoc);
  644.  
  645.         OurFree(FileBuf);      // free the file buffer
  646.  
  647.         // close the last metafile device context and delete the memory metafile
  648.         if (hMetaDC && NULL!=(hMeta=CloseMetaFile(hMetaDC))) DeleteMetaFile(hMeta);
  649.  
  650.         unlink(MetaFile);      // delete meta files
  651.         unlink(TempMetaFile);  // delete temporary meta file
  652.         unlink(ScrMetaFile);   // delete screen meta file
  653.         unlink(PrtMetaFile);   // delete selective print file
  654.     }
  655.  
  656.     FrModified=FALSE;
  657.     CloseFr();
  658.  
  659.     return 0;
  660. }
  661.  
  662. /******************************************************************************
  663.     PrintSortFooters:
  664.     Check if sort break has taken places. If so, write the old sort footers.
  665. *******************************************************************************/     
  666. PrintSortFooters()
  667. {
  668.     int CurSort,CurSec,BreakSort,FooterSec;
  669.     int CurField;
  670.  
  671.  
  672.     for (CurSort=0;CurSort<TotalBreakFields;CurSort++) {
  673.         CurField=BreakField[CurSort].CompField;
  674.         
  675.         if (field[CurField].type==TYPE_TEXT && 
  676.               lstrcmp(UserField[CurField].CharData,field[CurField].CharData)!=0) break;
  677.         else if (field[CurField].type==TYPE_DBL && 
  678.               UserField[CurField].DblData!=field[CurField].DblData) break;
  679.         else if (UserField[CurField].NumData!=field[CurField].NumData) break;
  680.     }
  681.     
  682.     if (CurSort==TotalBreakFields) return CurSort;  // no sort breaks 
  683.  
  684.  
  685.     BreakSort=CurSort;
  686.  
  687.     //******************** calculate the footer fields ********************
  688.     CalculateFields(SEC_FTR_LVL9,SEC_FTR_REP);
  689.  
  690.     //***************** write sort section footers ************************
  691.     for (CurSort=(TotalBreakFields-1);CurSort>=BreakSort;CurSort--) {
  692.         CurSec=BreakField[CurSort].section;
  693.         FooterSec=SEC_FTR_LVL1-(CurSec-SEC_HDR_LVL1);
  694.         PrintSection(FooterSec);                 // print section footer 
  695.     }
  696.  
  697.     return BreakSort;
  698. }
  699.  
  700. /******************************************************************************
  701.     PrintSortHeaders:
  702.     This routine prints sort headers for all levels below the specified level.
  703. *******************************************************************************/     
  704. PrintSortHeaders(int BreakSort)
  705. {
  706.     int CurSort,CurSec,FooterSec;
  707.     int fld;
  708.  
  709.     if (BreakSort>=TotalBreakFields) return TRUE;   // no sort breaks 
  710.  
  711.     //***************** write sort section headers ***************************
  712.     for (CurSort=BreakSort;CurSort<TotalBreakFields;CurSort++) {
  713.         CurSec=BreakField[CurSort].section;
  714.         PrintSection(CurSec);              // print section headers 
  715.         
  716.         FooterSec=SEC_FTR_LVL1-(CurSec-SEC_HDR_LVL1);
  717.         
  718.         for(fld=0;fld<TotalFields;fld++) { // clear accumulaters 
  719.            if (field[fld].InUse && field[fld].section==FooterSec) {
  720.                if (!(FLAG_RETAIN&field[fld].flags)) {
  721.                   field[fld].HoldNum=0;
  722.                   field[fld].HoldDbl=0;
  723.                   field[fld].count=0;
  724.                   if (field[fld].SumType==SUM_MIN || field[fld].SumType==SUM_MAX) {
  725.                      field[fld].HoldNum=field[fld].NumData;
  726.                      field[fld].HoldDbl=field[fld].DblData;
  727.                   }
  728.                }
  729.            }
  730.         }
  731.     }    
  732.  
  733.     return TRUE;
  734. }
  735.  
  736. /*****************************************************************************
  737.     EvaluateSystemFields:
  738.     Evaludate system fields
  739. *****************************************************************************/
  740. EvaluateSystemFields()
  741. {
  742.     int fld;
  743.  
  744.     // evaluate system fields ********
  745.     for (fld=0;fld<TotalFields;fld++) {
  746.        if (field[fld].source==SRC_SYS) {
  747.           StuffSysField(&UserField[fld]);
  748.        }
  749.     }
  750.     return TRUE;
  751. }
  752.  
  753. /*****************************************************************************
  754.     CalculateFields:
  755.     Do calculation and assin systems fields 
  756. *****************************************************************************/
  757. CalculateFields(int FirstSec,int LastSec)
  758. {
  759.     int fld,LastSym;
  760.     struct StrField TempField;
  761.  
  762.  
  763.     // evaluate calculated fields ****
  764.     for (fld=0;fld<TotalFields;fld++) {
  765.        if (field[fld].source==SRC_CALC && field[fld].section>=FirstSec && field[fld].section<=LastSec) {
  766.           
  767.           LastSym=RunExp(field[fld].CalcExp,&TempField,TRUE); // run the expression and return the output in the field 
  768.           if (LastSym!=END_OF_EXP)  {      // error encountered 
  769.              wsprintf(msg,"Error In Calculation Field: %s",(LPSTR)(field[fld].name));
  770.              AbortFr(msg,ERR_BAD_EXP);
  771.           }
  772.  
  773.           if (field[fld].type==TYPE_TEXT && field[fld].CharData!=NULL) {
  774.              OurFree(field[fld].CharData);
  775.              field[fld].CharData=NULL;
  776.           }
  777.  
  778.           if      (TempField.type==TYPE_TEXT)  field[fld].CharData=TempField.CharData;
  779.           else if (TempField.type==TYPE_DBL)   field[fld].DblData=TempField.DblData;
  780.           else                                 field[fld].NumData=TempField.NumData;
  781.        }
  782.     }
  783.     
  784.     return TRUE;
  785. } 
  786.  
  787. /*****************************************************************************
  788.     CalculateSecExp:
  789.     Calculate the section selection expression.
  790. *****************************************************************************/
  791. CalculateSecExp(int CurSec)
  792. {
  793.     int LastSym;
  794.     struct StrField TempField;
  795.  
  796.     if (section[CurSec].InUse) {
  797.        if (section[CurSec].SelExp[0]==END_OF_EXP) section[CurSec].selected=TRUE;
  798.        else {
  799.            LastSym=RunExp(section[CurSec].SelExp,&TempField,TRUE); // run the expression and return the output in the field 
  800.            if (LastSym!=END_OF_EXP)  {      // error encountered 
  801.               AbortFr("Error In Section Filter",ERR_BAD_EXP);
  802.            }
  803.            section[CurSec].selected=(int)TempField.NumData;
  804.        }
  805.     }
  806.     else   section[CurSec].selected=FALSE;
  807.  
  808.     return section[CurSec].selected;
  809. }
  810.  
  811. /*****************************************************************************
  812.     CalculateBreakFields:
  813.     Calculation fields used for break comparison
  814. *****************************************************************************/
  815. CalculateBreakFields()
  816. {
  817.     int fld,LastSym;
  818.     struct StrField TempField;
  819.     int i;
  820.  
  821.     for (i=0;i<TotalBreakFields;i++) {
  822.        fld=BreakField[i].CompField;
  823.        if (field[fld].source==SRC_CALC) {
  824.           LastSym=RunExp(field[fld].CalcExp,&TempField,TRUE); // run the expression and return the output in the field 
  825.           if (LastSym!=END_OF_EXP)  {      // error encountered 
  826.              wsprintf(msg,"Error In Break Calculation Field: %s",(LPSTR)(field[fld].name));
  827.              AbortFr(msg,ERR_BAD_EXP);
  828.           }
  829.  
  830.           if (field[fld].type==TYPE_TEXT && field[fld].CharData!=NULL) {
  831.              OurFree(field[fld].CharData);
  832.              field[fld].CharData=NULL;
  833.           }
  834.  
  835.           if      (TempField.type==TYPE_TEXT)  field[fld].CharData=TempField.CharData;
  836.           else if (TempField.type==TYPE_DBL)   field[fld].DblData=TempField.DblData;
  837.           else                                 field[fld].NumData=TempField.NumData;
  838.        }
  839.     }
  840.     
  841.     return TRUE;
  842. } 
  843.  
  844. /*****************************************************************************
  845.     InitFirstRec:
  846.     Do initialization for the first record.
  847. *****************************************************************************/
  848. InitFirstRec()
  849. {
  850.     int i,CurSec;
  851.     int fld;
  852.  
  853.     //***************** copy from user fields ***************************
  854.     for (fld=0;fld<TotalFields;fld++) {
  855.           if (field[fld].type==TYPE_TEXT)     lstrcpy(field[fld].CharData,UserField[fld].CharData);
  856.           else if (field[fld].type==TYPE_DBL) field[fld].DblData=UserField[fld].DblData;
  857.           else                                field[fld].NumData=UserField[fld].NumData;
  858.     }
  859.  
  860.     CalculateFields(0,MAX_SECTIONS-1);   // do calculation for the first record 
  861.     
  862.     //***************** initialize the output device ***************************
  863.     ReportStatus=REP_RESUMED;            // report in progress 
  864.     if (UseScreen) {                     // show the blank screen 
  865.        RepInitMenu(hFrMenu);             // initialize the menu items 
  866.        CurHeight=TopMargin;
  867.     }
  868.     else {
  869.        lpAbortDlg = MakeProcInstance((FARPROC)PrintAbortParam, hFrInst);
  870.        hAbortWnd=CreateDialog(hFrInst,"PrintAbortParam",hFrWnd,(DLGPROC)lpAbortDlg);
  871.        ShowWindow(hAbortWnd,SW_NORMAL);
  872.  
  873.        lpProc = MakeProcInstance((FARPROC)PrintProc, hFrInst);
  874.        SetAbortProc(hFrDC,(ABORTPROC)lpProc);
  875.  
  876.        if (Escape(hFrDC,STARTDOC,strlen(FormHdr.name),FormHdr.name,NULL)<0) {
  877.            AbortFr("Unable to Start the Print Job",ERR_PRINTER);
  878.        }
  879.        
  880.        UpdateWindow(hAbortWnd);
  881.        if (hFrWnd) EnableWindow(hFrWnd,FALSE);  // disable the main window 
  882.  
  883.        FrWinWidth=PrintWidth+LeftMargin+RightMargin; // to enable use of display routines for printing 
  884.  
  885.     }
  886.     
  887.     CurHeight=TopMargin;                        // start printing from the top page
  888.  
  889.     if (RFLAG_TRIAL&FormHdr.flags && !UseScreen) PrintTrial();  // print trial run 
  890.  
  891.     PageAdvanced=TRUE;                   // suppress page advance 
  892.     PrintSection(SEC_HDR_PAGE);          // print page header 
  893.  
  894.     PageAdvanced=TRUE;                   // suppress page advance 
  895.     PrintSection(SEC_HDR_REP);           // print the report header 
  896.  
  897.     for (i=0;i<TotalBreakFields;i++) {   // print group headers 
  898.        CurSec=BreakField[i].section;
  899.        PageAdvanced=TRUE;                // suppress page advance 
  900.        PrintSection(CurSec);
  901.     }
  902.  
  903.     PageAdvanced=TRUE;
  904.  
  905.     return TRUE;
  906. }
  907.  
  908. /*****************************************************************************
  909.     PrintSection:
  910.     This routine prints lines for a specified section.  The routine will
  911.     apply the current record data to the fields found in the section.
  912. *****************************************************************************/
  913. PrintSection(int CurSec)
  914. {
  915.     int   FromItem,ToItem,CurItem;
  916.  
  917.     if (!(section[CurSec].InUse)) return FALSE; // this section not used 
  918.     if (!(CalculateSecExp(CurSec))) return FALSE; // this section not selected 
  919.  
  920.     FromItem=section[CurSec].FirstItem;
  921.     ToItem=FromItem+section[CurSec].ItemCount-1;
  922.  
  923.     if (ToItem<FromItem) return FALSE;
  924.  
  925.     // force to first column when not in the first detail section
  926.     if (CurSec!=SEC_DETAIL1 && CurCol!=0) {
  927.        CurCol=0;
  928.        CurHeight=LastY;                         // update the current y location
  929.     }
  930.  
  931.     // Check for page advance
  932.     if (CurCol==0) {
  933.        if      (SFLAG_PAGE_BEF&(section[CurSec].flags))       AdvancePage(CurSec);
  934.        else if (CurHeight+section[CurSec].height>PrintHeight) AdvancePage(CurSec);
  935.        LastY=CurHeight;                        // track last Y position used for printing
  936.     }
  937.     CurX=CurCol*(item[section[CurSec].ScrItem].width);             // x displacement
  938.     
  939.     // clear the height adjusment field
  940.     for (CurItem=FromItem;CurItem<=ToItem;CurItem++) item[CurItem].HeightAdj=0;
  941.  
  942.     // Print each item
  943.     for (CurItem=FromItem;CurItem<=ToItem;CurItem++) {     // process each line 
  944.         if (item[CurItem].type==GROUP) continue;
  945.         if (item[CurItem].section!=CurSec) continue;
  946.  
  947.         if (UseScreen) PrintItem(hMetaDC,CurItem);
  948.         else           PrintItem(hFrDC,CurItem);
  949.  
  950.         PageAdvanced=FALSE;                                 // new page is dirtied now
  951.     }
  952.  
  953.     // Update printed page height and horizontal column position
  954.     if (CurSec==SEC_DETAIL1) {
  955.        CurCol++;
  956.        if (CurCol>=section[CurSec].columns) {
  957.           if (SFLAG_TRIM_AFTER&(section[CurSec].flags)) CurHeight=LastY;
  958.           else                                          CurHeight+=section[CurSec].height;
  959.           if (CurHeight<LastY) CurHeight=LastY;
  960.  
  961.           CurCol=0;
  962.           if (section[CurSec].columns==1 && SFLAG_PAGE_AFT&(section[CurSec].flags)) CurHeight=PrintHeight+1; // force page break for the next section
  963.        }
  964.     }
  965.     else {
  966.        if (SFLAG_TRIM_AFTER&(section[CurSec].flags)) CurHeight=LastY;
  967.        else                                          CurHeight+=section[CurSec].height;
  968.        if (CurHeight<LastY) CurHeight=LastY;
  969.        
  970.        if (SFLAG_PAGE_AFT&(section[CurSec].flags)) AdvancePage(MAX_SECTIONS);
  971.        CurCol=0;                                            // other sections are single column
  972.     }
  973.  
  974.     return TRUE;
  975. }
  976.  
  977. /*****************************************************************************
  978.     PrintItem:
  979.     Print the specified item at the specified device context.  The item is
  980.     printed relative to the current Y position
  981. *****************************************************************************/
  982. PrintItem(HDC hDC,int CurItem)
  983. {
  984.  
  985.     RECT rect;
  986.     HPEN hPen;
  987.     HBRUSH hBrush;
  988.  
  989.     // build the rectangle
  990.     rect.left=item[CurItem].x+CurX;
  991.     rect.right=item[CurItem].x+CurX+item[CurItem].width;
  992.     rect.top=CurHeight+item[CurItem].y+item[CurItem].HeightAdj;
  993.     rect.bottom=rect.top+item[CurItem].height;
  994.  
  995.     // fill rectangle if needed
  996.     if (item[CurItem].flags&OFLAG_FILL) { // fill rectangle
  997.        if (NULL!=(hBrush=CreateBrushIndirect(&(item[CurItem].brush)))) {
  998.           FillRect(hDC,&rect,hBrush);
  999.           DeleteObject(hBrush);           // delete the temporary brush
  1000.        }
  1001.     }
  1002.  
  1003.     // draw the bounding rectangle
  1004.     if (item[CurItem].OutlineSelect) {// draw rectangle
  1005.        if (NULL!=(hPen=CreatePen(item[CurItem].OutlineStyle,item[CurItem].OutlineWidth,item[CurItem].OutlineColor))) {
  1006.           SelectObject(hDC,hPen);
  1007.           FrDrawOutline(hDC,&rect,item[CurItem].OutlineSelect);
  1008.           SelectObject(hDC,GetStockObject(BLACK_PEN));
  1009.           DeleteObject(hPen);             // delete the temporary pen
  1010.        }
  1011.     }
  1012.  
  1013.     // draw the item interior
  1014.     if (item[CurItem].type==LABEL)        PrintLabel(hDC,CurItem);
  1015.     else if (item[CurItem].type==FIELD)   PrintField(hDC,CurItem);
  1016.     else if (item[CurItem].type==LINE)    PrintLine(hDC,CurItem);
  1017.     else if (item[CurItem].type==PICT)    PrintPicture(hDC,CurItem);
  1018.  
  1019.     return TRUE;
  1020. }
  1021.  
  1022. /******************************************************************************
  1023.     PrintLabel:
  1024.     Print a label to the specified device context
  1025. *******************************************************************************/
  1026. int PrintLabel(HDC hDC, int CurItem)
  1027. {
  1028.     RECT rect;
  1029.     int  LabelWidth,LabelHeight,LabelLen,x,y,flags,font;
  1030.  
  1031.     // build the bounding rectangle
  1032.     rect.left=item[CurItem].x+CurX;
  1033.     rect.right=item[CurItem].x+CurX+item[CurItem].width;
  1034.     rect.top=item[CurItem].y+CurHeight+item[CurItem].HeightAdj;
  1035.     rect.bottom=rect.top+item[CurItem].height;
  1036.  
  1037.     // Get label dimension
  1038.     font=item[CurItem].font;
  1039.     LabelWidth=GetLabelLen(item[CurItem].label,font);
  1040.     LabelHeight=FrFont[font].height;
  1041.     LabelLen=lstrlen(item[CurItem].label);
  1042.  
  1043.     // Get the label position
  1044.     flags=item[CurItem].flags;
  1045.     if      (flags&OFLAG_HLEFT)  x=rect.left+DESC_MARGIN;
  1046.     else if (flags&OFLAG_HRIGHT) x=rect.left+(item[CurItem].width-LabelWidth)-DESC_MARGIN;
  1047.     else {
  1048.        x=rect.left+(item[CurItem].width-LabelWidth)/2; // center
  1049.        if (x<(rect.left+DESC_MARGIN)) x=rect.left+DESC_MARGIN;
  1050.     }
  1051.     if      (flags&OFLAG_VTOP)   y=rect.top;
  1052.     else if (flags&OFLAG_VBOTTOM)y=rect.top+(item[CurItem].height-LabelHeight);
  1053.     else                         y=rect.top+(item[CurItem].height-LabelHeight)/2; // center
  1054.     
  1055.  
  1056.     // Draw the label
  1057.     SetFont(hDC,(BYTE)font);
  1058.     SetTextColor(hDC,item[CurItem].TextColor);
  1059.     SetBkMode(hDC,TRANSPARENT);
  1060.     if (LabelLen>0) TextOut(hDC,x,y,item[CurItem].label,LabelLen);
  1061.  
  1062.     // update the last Y position
  1063.     if (CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj>LastY) 
  1064.        LastY=CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj;
  1065.     
  1066.     return TRUE;
  1067. }
  1068.  
  1069. /******************************************************************************
  1070.     PrintField:
  1071.     Format and print the current field
  1072. *******************************************************************************/
  1073. PrintField(HDC hDC, int CurItem)
  1074. {
  1075.     RECT rect;
  1076.     int i,j,x,y,count,CurField,LabelLen,LabelWidth,LabelHeight,font,flags,
  1077.         SuffixWidth,PosSuffixLen,NegSuffixLen;
  1078.     LPSTR ptr;
  1079.     char string[NAME_WIDTH+1];
  1080.  
  1081.     CurField=item[CurItem].field;    // field associated with the item
  1082.  
  1083.     font=item[CurItem].font;
  1084.  
  1085.     // build the bounding rectangle
  1086.     rect.left=item[CurItem].x+CurX;
  1087.     rect.right=item[CurItem].x+CurX+item[CurItem].width;
  1088.     rect.top=item[CurItem].y+CurHeight+item[CurItem].HeightAdj;
  1089.     rect.bottom=rect.top+item[CurItem].height;
  1090.  
  1091.     // print picture type field
  1092.     if (field[CurField].type==TYPE_PICT) {
  1093.        if (RepArg.DrawPicture) (RepArg.DrawPicture)(hDC,(int)field[CurField].NumData,field[CurField].FileId,field[CurField].FieldId,&rect);
  1094.        return TRUE; 
  1095.     }
  1096.  
  1097.     // print word wrapped field
  1098.     if (field[CurField].type==TYPE_TEXT 
  1099.      && field[CurField].flags&(FLAG_WRAP|FLAG_WORD_WRAP)) return PrintWrapField(hDC,CurItem);
  1100.     
  1101.  
  1102.     // get the formatted data
  1103.     FormatFieldData(&field[CurField],item[CurItem].label);
  1104.     if (field[CurField].type==TYPE_TEXT) {
  1105.        ptr=field[CurField].CharData;    // pointer to the formatted data
  1106.        TruncateText(ptr,item[CurItem].width,font);   // truncate text to fit within the label
  1107.     }
  1108.     else  ptr=item[CurItem].label;
  1109.     LabelLen=lstrlen(ptr);
  1110.  
  1111.     // special numeric field format processing
  1112.     if (field[CurField].type==TYPE_NUM || field[CurField].type==TYPE_DBL) {
  1113.         // check negative sign suffix
  1114.         SuffixWidth=0;
  1115.         NegSuffixLen=lstrlen(field[CurField].NegSignSuffix);
  1116.         if (NegSuffixLen>0 && LabelLen>NegSuffixLen 
  1117.          && lstrstr(&ptr[LabelLen-NegSuffixLen],field[CurField].NegSignSuffix)!=NULL)
  1118.             SuffixWidth=GetLabelLen(field[CurField].NegSignSuffix,font);
  1119.  
  1120.         // check positive sign suffix
  1121.         PosSuffixLen=lstrlen(field[CurField].PosSignSuffix);
  1122.         if (SuffixWidth==0 && PosSuffixLen>0 && LabelLen>PosSuffixLen 
  1123.          && lstrstr(&ptr[LabelLen-PosSuffixLen],field[CurField].PosSignSuffix)!=NULL)
  1124.             SuffixWidth=GetLabelLen(field[CurField].PosSignSuffix,font);
  1125.  
  1126.         // process 'pad with zero' flag
  1127.         if (field[CurField].flags&FLAG_PAD_ZERO) {
  1128.            count=(item[CurItem].width-GetLabelLen(ptr,font)+SuffixWidth)/GetLabelLen("0",font); // number of zeros to insert
  1129.            if (count>0) {
  1130.               for (i=j=0;i<LabelLen;i++,j++) {
  1131.                  // look for first numeric character
  1132.                  if (i==j && (ptr[i]=='.' || ptr[i]==',' || (ptr[i]>='0' && ptr[i]<='9'))) {  // first numeric character found
  1133.                      while (count>0) {
  1134.                         string[j]='0';
  1135.                         j++;
  1136.                         count--;
  1137.                      }
  1138.                  }
  1139.                  string[j]=ptr[i];
  1140.               }
  1141.               string[j]=0;
  1142.               lstrcpy(ptr,string);            // new string
  1143.               LabelLen=lstrlen(ptr);          // new label length
  1144.            }
  1145.         }
  1146.     }
  1147.     else SuffixWidth=0;
  1148.  
  1149.     // Get field dimension
  1150.     LabelWidth=GetLabelLen(ptr,font)-SuffixWidth;
  1151.     LabelHeight=FrFont[font].height;
  1152.  
  1153.     // Get the label position
  1154.     flags=item[CurItem].flags;
  1155.     if      (flags&OFLAG_HLEFT)  x=rect.left+DESC_MARGIN;
  1156.     else if (flags&OFLAG_HRIGHT) x=rect.left+(item[CurItem].width-LabelWidth)-DESC_MARGIN;
  1157.     else {
  1158.          x=rect.left+(item[CurItem].width-LabelWidth)/2; // center
  1159.          if (x<(rect.left+DESC_MARGIN) ) x=rect.left+DESC_MARGIN;
  1160.     }
  1161.     if      (flags&OFLAG_VTOP)   y=rect.top;
  1162.     else if (flags&OFLAG_VBOTTOM)y=rect.top+(item[CurItem].height-LabelHeight);
  1163.     else                         y=rect.top+(item[CurItem].height-LabelHeight)/2; // center
  1164.  
  1165.     
  1166.     // Draw the label
  1167.     SetFont(hDC,(BYTE)font);
  1168.     SetTextColor(hDC,item[CurItem].TextColor);
  1169.     SetBkMode(hDC,TRANSPARENT);
  1170.     if (LabelLen>0) TextOut(hDC,x,y,ptr,LabelLen);
  1171.  
  1172.     // update the last Y position
  1173.     if (CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj>LastY) 
  1174.        LastY=CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj;
  1175.  
  1176.     return TRUE;
  1177. }
  1178.  
  1179. /******************************************************************************
  1180.     PrintWrapField:
  1181.     Format and print a word/wrapped field
  1182. *******************************************************************************/
  1183. PrintWrapField(HDC hDC, int CurItem)
  1184. {
  1185.     RECT rect;
  1186.     int x,y,FirstChar,LastChar,CurField,LabelLen,i,LastItem,CurSec,
  1187.         LabelWidth,LabelHeight,font,flags,FieldHeight,DistanceY;
  1188.     char string[LINE_WIDTH+1];
  1189.     BOOL FlexibleSize,paged=FALSE;
  1190.  
  1191.     CurField=item[CurItem].field;    // field associated with the item
  1192.     FlexibleSize=field[CurField].flags&FLAG_FLEX_SIZE;
  1193.     font=item[CurItem].font;
  1194.     CurSec=item[CurItem].section; 
  1195.     LastItem=section[CurSec].FirstItem+section[CurSec].ItemCount-1;  // Last item in the section
  1196.  
  1197.     // build the bounding rectangle
  1198.     rect.left=item[CurItem].x+CurX;
  1199.     rect.right=item[CurItem].x+CurX+item[CurItem].width;
  1200.     rect.top=item[CurItem].y+CurHeight+item[CurItem].HeightAdj;
  1201.     rect.bottom=rect.top+item[CurItem].height;
  1202.  
  1203.     // get the formatted data
  1204.     FormatFieldData(&field[CurField],item[CurItem].label);
  1205.  
  1206.     // extract lines and print
  1207.     FirstChar=0;
  1208.     y=rect.top;
  1209.     SetFont(hDC,(BYTE)font);
  1210.     SetTextColor(hDC,item[CurItem].TextColor);
  1211.     SetBkMode(hDC,TRANSPARENT);
  1212.  
  1213.     while ((LastChar=ExtractLine(CurItem,string,FirstChar))!=-1) {
  1214.         StrTrim(string);                 // terminate space
  1215.  
  1216.         LabelWidth=GetLabelLen(string,font);
  1217.         LabelHeight=FrFont[font].height;
  1218.         LabelLen=lstrlen(string);
  1219.  
  1220.         // Get the label position
  1221.         flags=item[CurItem].flags;
  1222.         if      (flags&OFLAG_HLEFT)  x=rect.left+DESC_MARGIN;
  1223.         else if (flags&OFLAG_HRIGHT) x=rect.left+(item[CurItem].width-LabelWidth)-DESC_MARGIN;
  1224.         else                         x=rect.left+(item[CurItem].width-LabelWidth)/2; // center
  1225.         
  1226.         // Draw the text field
  1227.         if (LabelLen>0)   TextOut(hDC,x,y,string,LabelLen);
  1228.  
  1229.         y+=LabelHeight;
  1230.         FirstChar=LastChar+1;        // position for the next line
  1231.  
  1232.         // break if wrap rectangle is finished
  1233.         if ((y+LabelHeight>rect.bottom) && !FlexibleSize) break;  // next line can't fit in the item rectangle
  1234.  
  1235.         // break if current page is finished
  1236.         if ((y+LabelHeight>PrintHeight)) {
  1237.            if (CurSec!=SEC_DETAIL1) break;
  1238.  
  1239.            // last break field is allowed to continue to the next page
  1240.            PageAdvanced=FALSE;       // allow page advance now
  1241.            AdvancePage(CurSec);      // advance page
  1242.            y=rect.top=CurHeight;
  1243.            SetFont(hDC,(BYTE)font);  // set fonts again
  1244.            SetTextColor(hDC,item[CurItem].TextColor);
  1245.            SetBkMode(hDC,TRANSPARENT);
  1246.            rect.bottom=rect.top+PrintHeight; // allow full page
  1247.            paged=TRUE;                       // note the page advancement
  1248.         }
  1249.     }
  1250.  
  1251.     // check if Y adjustment for remaining field is needed
  1252.     FieldHeight=y-rect.top;
  1253.     if (FlexibleSize && FieldHeight!=item[CurItem].height) {
  1254.        for (i=CurItem+1;i<=LastItem;i++) {
  1255.           if (item[i].type==SECTION || item[i].type==GROUP) continue;
  1256.           if (item[i].section!=CurSec) continue;
  1257.           if (item[i].y>item[CurItem].y+item[CurItem].height-DESC_MARGIN) {
  1258.              if (paged) {
  1259.                 DistanceY=item[i].y-(item[CurItem].y+item[CurItem].height);  // distance between this item and end of the wrapped current item
  1260.                 item[i].HeightAdj=-item[i].y+FieldHeight+DistanceY;
  1261.              }
  1262.              else       item[i].HeightAdj=item[i].HeightAdj+FieldHeight-item[CurItem].height;
  1263.           }
  1264.        }
  1265.     }
  1266.  
  1267.     // update the last Y position
  1268.     if (y>LastY) LastY=y;
  1269.  
  1270.     return TRUE;
  1271. }
  1272.  
  1273. /******************************************************************************
  1274.     ExtractLine:
  1275.     This routine extract a line that can fit within the specified rectangle
  1276.     width. The extract line is returned using the second argument.  The third
  1277.     argument tells the beginning position within the source string to start
  1278.     using.
  1279.     The routine returns the position of the last character within the source 
  1280.     string.
  1281. *******************************************************************************/
  1282. ExtractLine(int CurItem,LPSTR string,int FirstChar)
  1283. {
  1284.     int i,j,k,font,CurField,DataLen,len,LineWidth;
  1285.     int LastWordSrcIndex,LastWordDstIndex;
  1286.     BOOL WordWrap;
  1287.     LPSTR ptr;
  1288.     char  ParaChar,CurChar;
  1289.     int  far *CharWidth;
  1290.  
  1291.     // initialize variables
  1292.     font=item[CurItem].font;                 // font to print the field
  1293.     CharWidth=FrFont[font].CharWidth;        // character width table
  1294.     CurField=item[CurItem].field;            // current field
  1295.     ptr=field[CurField].CharData;            // field text data pointer
  1296.     DataLen=lstrlen(ptr);                    // text data length
  1297.     ParaChar=field[CurField].ParaChar[0];    // paragraph break character
  1298.     if (field[CurField].flags&FLAG_WORD_WRAP) WordWrap=TRUE;  // Word wrap
  1299.     else                                       WordWrap=FALSE; // character wrap
  1300.  
  1301.     if (FirstChar>=(DataLen-1)) return -1;   // no more characters left
  1302.  
  1303.     // build new string
  1304.     LineWidth=0;                             // unit width of the string
  1305.     j=0;                                     // number of characters in the string
  1306.     i=FirstChar;
  1307.     LastWordSrcIndex=-1;                     // index of the last complete word in the source string
  1308.     LastWordDstIndex=-1;                     // index of the last complete word in the destination string
  1309.  
  1310.     while (TRUE) {
  1311.        if (i==DataLen) break;                // all characters processed
  1312.        if (j>=LINE_WIDTH) break;             // end of buffer
  1313.        
  1314.        CurChar=ptr[i];
  1315.        if (CurChar==ParaChar) {              // paragraph break
  1316.           string[j]=0;                       // terminate the string
  1317.           return i;                          // return the last character index
  1318.        }
  1319.  
  1320.        // translate characters               // cr/lf translation
  1321.        if (CurChar==0xA || CurChar==0xD) {  
  1322.           if (j>0 && string[j-1]==' ') {     // ignore
  1323.              i++;
  1324.              continue;
  1325.           }
  1326.           else CurChar=' ';                  // convert to spaces
  1327.        }
  1328.        else if (CurChar==0x9) {              // translate tab
  1329.           for (k=0;k<TAB_CHAR_LEN-1;k++) {   // expand to multiple spaces
  1330.              CurChar=' ';
  1331.              string[j]=CurChar;
  1332.              LineWidth+=CharWidth[(BYTE)CurChar];
  1333.              j++;
  1334.              if (j>=LINE_WIDTH || LineWidth>=item[CurItem].width) {
  1335.                 j--;
  1336.                 i--;
  1337.                 break;
  1338.              }
  1339.           }
  1340.        }
  1341.        
  1342.        // process a regular character
  1343.        string[j]=CurChar;
  1344.        LineWidth+=CharWidth[(BYTE)CurChar];
  1345.        j++;
  1346.        if (j>=LINE_WIDTH || LineWidth>=item[CurItem].width) {
  1347.           j--;
  1348.           i--;
  1349.           break;
  1350.        }
  1351.        i++;                                  // increment the source index
  1352.  
  1353.        // mark the last complete word
  1354.        if (CurChar==' ') {
  1355.           LastWordSrcIndex=i-1;              // index of the last word in the source string
  1356.           LastWordDstIndex=j-1;
  1357.        }
  1358.     }
  1359.  
  1360.     // cutoff at word boundary
  1361.     if (WordWrap && LastWordSrcIndex>0 && LineWidth>=item[CurItem].width) {
  1362.        i=LastWordSrcIndex;
  1363.        j=LastWordDstIndex;
  1364.     }
  1365.  
  1366.     len=j;
  1367.     string[len]=0;                           // terminate the string
  1368.  
  1369.     return i;                                // last character processed
  1370. }
  1371.  
  1372. /******************************************************************************
  1373.     PrintLine:
  1374.     Print a 'line' type item
  1375. *******************************************************************************/
  1376. PrintLine(HDC hDC, int CurItem)
  1377. {
  1378.     int x1,y1,x2,y2;
  1379.     HPEN hPen,hOldPen;
  1380.  
  1381.     // build the line beginning and ending coordinates
  1382.     if (item[CurItem].LineAngle==ANGLE_HORZ) {        // horizontal line
  1383.        x1=item[CurItem].x+CurX;
  1384.        y1=CurHeight+item[CurItem].y+item[CurItem].HeightAdj+item[CurItem].height/2;
  1385.        x2=x1+item[CurItem].width;
  1386.        y2=y1;
  1387.     }
  1388.     else if (item[CurItem].LineAngle==ANGLE_VERT) {   // vertical line
  1389.        x1=item[CurItem].x+CurX+item[CurItem].width/2;
  1390.        y1=CurHeight+item[CurItem].y+item[CurItem].HeightAdj;
  1391.        x2=x1;
  1392.        y2=y1+item[CurItem].height;
  1393.     }
  1394.     else if (item[CurItem].LineAngle==ANGLE_FDIAG) {  // diagonal line
  1395.        x1=item[CurItem].x+CurX;
  1396.        y1=CurHeight+item[CurItem].y+item[CurItem].HeightAdj;
  1397.        x2=x1+item[CurItem].width;
  1398.        y2=y1+item[CurItem].height;
  1399.     }
  1400.     else {                                            // backword diagonal line
  1401.        x1=item[CurItem].x+CurX;
  1402.        y1=CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj;
  1403.        x2=x1+item[CurItem].width;
  1404.        y2=CurHeight+item[CurItem].y;
  1405.     }
  1406.  
  1407.     // create the line pen
  1408.     if (NULL!=(hPen=CreatePen(item[CurItem].LineStyle,item[CurItem].LineWidth,item[CurItem].LineColor))) {
  1409.        hOldPen=SelectObject(hDC,hPen);
  1410.  
  1411.        // draw the line
  1412.        MoveToEx(hDC,x1,y1,NULL);
  1413.        LineTo(hDC,x2,y2);
  1414.  
  1415.        SelectObject(hDC,hOldPen);
  1416.        DeleteObject(hPen);             // delete the temporary pen
  1417.     }
  1418.  
  1419.     // update the last Y position
  1420.     if (CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj>LastY) 
  1421.        LastY=CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj;
  1422.  
  1423.     return TRUE;
  1424. }
  1425.  
  1426. /******************************************************************************
  1427.     PrintPicture:
  1428.     Draw a picture bitmap
  1429. *******************************************************************************/
  1430. PrintPicture(HDC hDC, int CurItem)
  1431. {
  1432.    int pict;
  1433.    LPBITMAPINFO pInfo;
  1434.    LPSTR pImage;
  1435.  
  1436.    pict=item[CurItem].font;             // index into the font structure
  1437.  
  1438.    // print a device independent bitmap
  1439.    if (NULL!=(pImage=GlobalLock(FrFont[pict].hImage)) 
  1440.     && NULL!=(pInfo=(LPBITMAPINFO)GlobalLock(FrFont[pict].hInfo)) ) { 
  1441.        
  1442.        StretchDIBits(hDC,item[CurItem].x+CurX,CurHeight+item[CurItem].y+item[CurItem].HeightAdj,item[CurItem].width,item[CurItem].height,
  1443.          0,0,(int)pInfo->bmiHeader.biWidth,(int)pInfo->bmiHeader.biHeight,pImage,pInfo,DIB_RGB_COLORS,SRCCOPY);
  1444.  
  1445.        GlobalUnlock(FrFont[pict].hImage);
  1446.        GlobalUnlock(FrFont[pict].hInfo);
  1447.    }
  1448.  
  1449.     // update the last Y position
  1450.     if (CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj>LastY) 
  1451.        LastY=CurHeight+item[CurItem].y+item[CurItem].height+item[CurItem].HeightAdj;
  1452.  
  1453.    return TRUE;
  1454. }
  1455.  
  1456. /******************************************************************************
  1457.     FormatFieldData:
  1458.     This routine format the specified field to the specified width.  It
  1459.     applies all applicable format to this field and returns the formatted
  1460.     string.
  1461. ******************************************************************************/
  1462. FormatFieldData(struct StrField huge *CurField,char far *string)
  1463. {
  1464.     int i,j,type,SumType,len,negative,DecPlaces,digits,DecFound,temp,
  1465.         ZeroValue,LeftSignLen,RightSignLen,CurrencySymLen;
  1466.     char line[LINE_WIDTH+2],mm[3],dd[3],yy[5];
  1467.     unsigned flags;
  1468.     long NumData;
  1469.     double DblData;
  1470.  
  1471.     type=CurField->type;
  1472.     SumType=CurField->SumType;
  1473.     flags=CurField->flags;
  1474.     DecPlaces=CurField->DecPlaces;
  1475.  
  1476.     NumData=0;
  1477.     DblData=0;
  1478.  
  1479.     if  (SumType==SUM_NONE)  {
  1480.         if (type==TYPE_DBL)   DblData=CurField->DblData;
  1481.         else                  NumData=CurField->NumData;
  1482.     }
  1483.     else if (SumType==SUM_COUNT) {
  1484.         if (type==TYPE_DBL)   DblData=CurField->count;
  1485.         else                  NumData=CurField->count;
  1486.         CurField->count=0;
  1487.     }
  1488.     else if (SumType==SUM_AVERAGE) {
  1489.         if (type==TYPE_DBL)   DblData=CurField->HoldDbl;
  1490.         else                  NumData=CurField->HoldNum;
  1491.         if (CurField->count>0) {
  1492.            if (type==TYPE_DBL)   DblData/=(double)CurField->count;
  1493.            else                  NumData/=(long)CurField->count;
  1494.         }
  1495.         CurField->count=0;
  1496.         CurField->HoldDbl=0;
  1497.         CurField->HoldNum=0;
  1498.     }
  1499.     else {
  1500.         if (type==TYPE_DBL)   DblData=CurField->HoldDbl;
  1501.         else                  NumData=CurField->HoldNum;
  1502.         CurField->HoldDbl=0;
  1503.         CurField->HoldNum=0;
  1504.     }
  1505.  
  1506.     //*************** Format Alpha Fields **********************************
  1507.     if (type==TYPE_TEXT) {
  1508.         
  1509.         string=CurField->CharData;
  1510.         len=strlen(string);
  1511.  
  1512.         if (flags&FLAG_CAPS) strupr(string);
  1513.         else if (flags&FLAG_SMALL) strlwr(string);
  1514.         else if (flags&FLAG_FIRST_CAP) {
  1515.            strlwr(string);
  1516.            for (i=0;i<len;i++) {
  1517.               if (i==0 || string[i-1]==' ') string[i]=toupper((string[i]));
  1518.            } 
  1519.         }
  1520.         
  1521.         if (flags&FLAG_TRIM) rTrim(string);
  1522.     }
  1523.  
  1524.     //**************** Format numeric fields ********************************
  1525.     else if (type==TYPE_NUM || type==TYPE_DBL) {
  1526.         negative=ZeroValue=FALSE;
  1527.         if (type==TYPE_NUM) {
  1528.            if (NumData<0) {
  1529.               negative=TRUE;
  1530.               NumData=-NumData;
  1531.            }
  1532.            if (NumData==0) ZeroValue=TRUE;
  1533.            
  1534.            ltoa(NumData,string,10);
  1535.            if (DecPlaces>0) {               // insert a decimal 
  1536.               len=strlen(string);
  1537.               if (DecPlaces>len) {
  1538.                  lPad(string,DecPlaces+1);
  1539.                  string[0]='.';
  1540.                  i=1;
  1541.                  while (string[i]==' ') {
  1542.                     string[i]='0';
  1543.                     i++;
  1544.                  }
  1545.               }
  1546.               else {
  1547.                  lPad(&string[len-DecPlaces],DecPlaces+1);
  1548.                  string[len-DecPlaces]='.';
  1549.               }
  1550.            }
  1551.         }
  1552.         else {                              // if type is equal to doubld 
  1553.            if (DblData<0) {
  1554.               negative=TRUE;
  1555.               DblData=-DblData;
  1556.            }
  1557.            if (DblData==0) ZeroValue=TRUE;
  1558.            
  1559.            DoubleToStr(DblData,DecPlaces,string);
  1560.         }
  1561.         
  1562.         //********************* insert comma characters *******************
  1563.         if (flags&FLAG_COMMA) {             // insert comma 
  1564.            len=strlen(string);
  1565.            for (digits=0;digits<len;digits++) if (string[digits]=='.') break;
  1566.            if (digits>0) {
  1567.               strcpy(line,string);
  1568.               j=0;
  1569.               DecFound=FALSE;
  1570.               for (i=0;i<len;i++,j++) {
  1571.                   if (DecFound) {           // simply copy the remaining digits 
  1572.                      string[j]=line[i];
  1573.                   }
  1574.                   else {                    // before decimal 
  1575.                      if (line[i]=='.') {
  1576.                         string[j]=line[i];
  1577.                         DecFound=TRUE;
  1578.                      }
  1579.                      else {                 // do we need to insert comma 
  1580.                         temp=digits/3;
  1581.                         if (digits==temp*3 && digits>0 && j>0) {// insert comma 
  1582.                            string[j]=',';
  1583.                            j++;
  1584.                         }
  1585.                         string[j]=line[i];
  1586.                         digits--;
  1587.                      }
  1588.                   }
  1589.               }
  1590.               string[j]=0;
  1591.            }
  1592.         }
  1593.         
  1594.  
  1595.         //******************* apply numeric attributes *******************************
  1596.         len=strlen(string);
  1597.         LeftSignLen=lstrlen(CurField->NegSignPrefix);
  1598.         if (lstrlen(CurField->PosSignPrefix)>LeftSignLen) LeftSignLen=lstrlen(CurField->PosSignPrefix);
  1599.         
  1600.         RightSignLen=lstrlen(CurField->NegSignSuffix);
  1601.         if (lstrlen(CurField->PosSignSuffix)>RightSignLen) RightSignLen=lstrlen(CurField->PosSignSuffix);
  1602.  
  1603.         CurrencySymLen=lstrlen(CurField->CurrencySymbol);
  1604.  
  1605.         //******************* insert the currency symbol ********************
  1606.         if (CurrencySymLen>0) {
  1607.            lPad(string,len+CurrencySymLen);
  1608.            for (i=0;i<CurrencySymLen;i++) string[i]=CurField->CurrencySymbol[i];
  1609.            len+=CurrencySymLen;
  1610.         }
  1611.  
  1612.         //******************* insert the left prefix symbol ********************
  1613.         if (LeftSignLen>0) {
  1614.            lPad(string,len+LeftSignLen);
  1615.            
  1616.            if (negative) {
  1617.               for (i=0;i<lstrlen(CurField->NegSignPrefix);i++) string[i]=CurField->NegSignPrefix[i];
  1618.            }
  1619.            else {
  1620.               for (i=0;i<lstrlen(CurField->PosSignPrefix);i++) string[i]=CurField->PosSignPrefix[i];
  1621.            }
  1622.            len+=LeftSignLen;
  1623.         }
  1624.  
  1625.         //******************* insert the right suffiex symbol ********************
  1626.         if (RightSignLen>0) {
  1627.            rPad(string,len+RightSignLen);
  1628.            
  1629.            if (negative) {
  1630.               for (i=0;i<lstrlen(CurField->NegSignSuffix);i++) string[len+i]=CurField->NegSignSuffix[i];
  1631.            }
  1632.            else {
  1633.               for (i=0;i<lstrlen(CurField->PosSignSuffix);i++) string[len+i]=CurField->PosSignSuffix[i];
  1634.            }
  1635.            len+=RightSignLen;
  1636.            rTrim(string);
  1637.         }
  1638.  
  1639.         //******************** length check *********************************
  1640.         if (flags&FLAG_SUP_ZERO && ZeroValue) string[0]=0;
  1641.     }
  1642.  
  1643.     //**************** Format date fields ***********************************
  1644.  
  1645.     else if (type==TYPE_DATE) {
  1646.         if (NumData<991231L) NumData=19000000L+NumData;
  1647.         ltoa(NumData,line,10);
  1648.  
  1649.         strcpy(dd,&line[6]);
  1650.         line[6]=0;
  1651.         strcpy(mm,&line[4]);
  1652.         line[4]=0;
  1653.         strcpy(yy,line);
  1654.         string[0]=0;
  1655.  
  1656.         switch (CurField->DateFormat) {
  1657.            case DT_MMDDYY:
  1658.                strcat(string,mm);
  1659.                lstrcat(string,CurField->DateDelim);
  1660.                strcat(string,dd);
  1661.                lstrcat(string,CurField->DateDelim);
  1662.                strcat(string,&yy[2]);
  1663.                break;
  1664.            case DT_DDMMYY:
  1665.                strcat(string,dd);
  1666.                lstrcat(string,CurField->DateDelim);
  1667.                strcat(string,mm);
  1668.                lstrcat(string,CurField->DateDelim);
  1669.                strcat(string,&yy[2]);
  1670.                break;
  1671.            case DT_MMDDYYYY:
  1672.                strcat(string,mm);
  1673.                lstrcat(string,CurField->DateDelim);
  1674.                strcat(string,dd);
  1675.                lstrcat(string,CurField->DateDelim);
  1676.                strcat(string,yy);
  1677.                break;
  1678.            case DT_MMMDDYYYY:
  1679.                temp=atoi(mm);
  1680.                if (temp<1) temp=1;
  1681.                if (temp>12) temp=12;
  1682.                strcat(string,MonthName[temp-1]);
  1683.                strcat(string," ");
  1684.                if (dd[0]=='0') strcat(string,&dd[1]);
  1685.                else            strcat(string,dd);
  1686.                strcat(string,", ");
  1687.                strcat(string,yy);
  1688.                break;
  1689.            default:
  1690.                ;
  1691.         }
  1692.     }
  1693.     
  1694.     //**************** Format the logical fields *****************************
  1695.  
  1696.     else if (type==TYPE_LOGICAL) {
  1697.         if (NumData) string[0]=CurField->LogicalSymbols[0];
  1698.         else         string[0]=CurField->LogicalSymbols[1];
  1699.         string[1]=0;
  1700.     }
  1701.  
  1702.     return TRUE;
  1703. }
  1704.  
  1705. /*****************************************************************************
  1706.     AcceptDlgField:
  1707.     Accept the values for the dialog fields from the user.  The fields are
  1708.     accept as specified by the PromptOrder variable.
  1709. *****************************************************************************/
  1710. AcceptDlgField()
  1711. {
  1712.     int fld,idx,FieldTable[MAX_DLGS],ord,TotalDlgFields,FieldFlag;
  1713.     int result;
  1714.     char string[NAME_WIDTH+2];
  1715.  
  1716.     // sort the fields in the prompt order 
  1717.     TotalDlgFields=0;
  1718.     for (ord=0;ord<MAX_DLGS;ord++) {
  1719.        for (fld=0;fld<MAX_DLGS;fld++) {
  1720.           if (DlgField[fld].InUse && DlgField[fld].PromptOrder==ord) {
  1721.              FieldTable[TotalDlgFields]=fld;
  1722.              TotalDlgFields++;
  1723.           }
  1724.        }
  1725.     }
  1726.  
  1727.     if (TotalDlgFields==0) return TRUE;   // dialog fields not used 
  1728.  
  1729.     idx=0;
  1730.  
  1731.     while(TRUE) {                         // accept/validate each field 
  1732.        if (idx>=TotalDlgFields) break;    
  1733.        fld=FieldTable[idx];
  1734.  
  1735.        
  1736.        ACCEPT_DATA:
  1737.  
  1738.        DlgIndex=fld;                      // pass information to the dialog box 
  1739.        FieldFlag=idx;
  1740.        if (idx==(TotalDlgFields-1)) FieldFlag=MAX_DLGS;
  1741.        result=CallDialogBox("DlgInputParam",DlgInputParam,(DWORD)FieldFlag);
  1742.        
  1743.        if (!result) {
  1744.           if (idx<=0) return FALSE;
  1745.           idx--;
  1746.           continue;
  1747.        }
  1748.        
  1749.        //***** convert and validate *****************
  1750.        if      (DlgField[fld].type==TYPE_NUM) DlgField[fld].NumData=atol(DlgField[fld].CharData);
  1751.        else if (DlgField[fld].type==TYPE_DBL) DlgField[fld].DblData=atof(DlgField[fld].CharData);
  1752.        else if (DlgField[fld].type==TYPE_LOGICAL) {
  1753.            strupr(DlgField[fld].CharData);
  1754.            StrTrim(DlgField[fld].CharData);
  1755.            if      (strstr("YES,TRUE,Y,1",DlgField[fld].CharData)) DlgField[fld].NumData=1;
  1756.            else if (strstr("NO,FALSE,N,0",DlgField[fld].CharData)) DlgField[fld].NumData=0;
  1757.            else {
  1758.               MessageBox(hFrWnd,"Valid entries: YES,NO,TRUE,FALSE,Y,N,1,0",NULL,MB_OK);
  1759.               goto ACCEPT_DATA;
  1760.            }
  1761.        }
  1762.        else if (DlgField[fld].type==TYPE_DATE) {
  1763.            if (DlgField[fld].CharData[0]!='\"') {   // enclose in quotes 
  1764.              strcpy(string,"\"");
  1765.              strcat(string,DlgField[fld].CharData);
  1766.              strcat(string,"\"");
  1767.            }
  1768.            else strcpy(string,DlgField[fld].CharData);
  1769.  
  1770.            if (!ValidateDate(string,&(DlgField[fld].NumData)) || DlgField[fld].NumData==-1) {
  1771.              MessageBox(hFrWnd,"Invalid Date Format/Value!",NULL,MB_OK);
  1772.              goto ACCEPT_DATA;
  1773.            }
  1774.        }
  1775.  
  1776.        idx++;
  1777.     }
  1778.  
  1779.     return TRUE;
  1780. }
  1781.  
  1782. /*****************************************************************************
  1783.    AllocRepMem:
  1784.    Allocate memory for:
  1785.    This routine adjusts the memory blocks allocated by the AllocFormMem
  1786.    routine and allocates these new objects:
  1787.    1. Sort Fields
  1788. *****************************************************************************/
  1789. AllocRepMem()
  1790. {
  1791.     int i;
  1792.     int FieldIndex,fld;
  1793.  
  1794.     if (UseScreen) {
  1795.        if ( (NULL==(hPageLoc=GlobalAlloc(GMEM_MOVEABLE,(long)(MAX_SCR_PAGES+1)*sizeof(long)))) 
  1796.           || (NULL==(PageLoc=(long far *)GlobalLock(hPageLoc))) ) {
  1797.           AbortFr("Ran Out of Memory (AllocRepMem)",ERR_NO_MEM);
  1798.        }
  1799.        FileBuf=OurAlloc(BUF_SIZE);        // allocate file buffer
  1800.     } 
  1801.     
  1802.     //**** allocate other object arrays *************************************
  1803.     if (  (NULL==(hUserField=GlobalAlloc(GMEM_MOVEABLE,(long)(TotalFields+1)*sizeof(struct StrField)))) 
  1804.        || (NULL==(UserField=(struct StrField huge *)GlobalLock(hUserField)))  
  1805.        || (NULL==(hSortField=GlobalAlloc(GMEM_MOVEABLE,(long)(TotalBreakFields+1)*sizeof(struct StrField)))) 
  1806.        || (NULL==(SortField=(struct StrField huge *)GlobalLock(hSortField))) ){
  1807.        AbortFr("Ran Out of Memory (AllocRepMem(1))",ERR_NO_MEM);
  1808.     }
  1809.  
  1810.     //***** shrink the field array ******************************************
  1811.     GlobalUnlock(hField);
  1812.     if (  (NULL==(hField=GlobalReAlloc(hField,(long)(TotalFields+1)*sizeof(struct StrField),0))) 
  1813.        || (NULL==(field=(struct StrField huge *)GlobalLock(hField)))  ){
  1814.        AbortFr("Ran Out of Memory (AllocRepMem(2))",ERR_NO_MEM);
  1815.     }
  1816.     
  1817.     for(fld=0;fld<TotalFields;fld++) {    // allocate space for the character fields 
  1818.        UserField[fld].type=field[fld].type;
  1819.        
  1820.        if (field[fld].type==TYPE_TEXT) {
  1821.           
  1822.           //***** update the width for the dialog fields **********
  1823.           if (field[fld].source==SRC_DLG) field[fld].width=DlgField[field[fld].SysIdx].width;
  1824.           
  1825.           if (NULL==(field[fld].CharData=OurAlloc(field[fld].width+2))
  1826.            || NULL==(UserField[fld].CharData=OurAlloc(field[fld].width+2)) ) {
  1827.              AbortFr("Ran Out of Memory(2)",ERR_NO_MEM);
  1828.           }
  1829.        }
  1830.     }
  1831.  
  1832.     for(i=0;i<TotalBreakFields;i++) {      // allocate space for the character sort fields 
  1833.        FieldIndex=BreakField[i].SortField; // index into the field table 
  1834.        SortField[i].type=field[FieldIndex].type;
  1835.  
  1836.        if (field[FieldIndex].type==TYPE_TEXT) {
  1837.           if (NULL==(SortField[i].CharData=OurAlloc(field[FieldIndex].width+2))) {
  1838.              AbortFr("Ran Out of Memory(3)",ERR_NO_MEM);
  1839.           }
  1840.        }
  1841.     }
  1842.  
  1843.     return TRUE;
  1844. }
  1845.  
  1846. /******************************************************************************
  1847.     StuffSysField:
  1848.     Build data for the system fields
  1849. *******************************************************************************/     
  1850. StuffSysField(struct StrField huge *field)
  1851. {
  1852.  
  1853.     switch (field->SysIdx) {
  1854.        case SYS_PAGE:
  1855.           field->NumData=PageCount;
  1856.           if (CurHeight>=PrintHeight) (field->NumData)++;
  1857.           break;
  1858.        case SYS_DATE:
  1859.           field->NumData=SystemDate;
  1860.           break;
  1861.        case SYS_TIME:
  1862.           lstrcpy(field->CharData,SystemTime);
  1863.           break;
  1864.        case SYS_REC_COUNT:
  1865.           field->NumData=RecCount+1;
  1866.           break;
  1867.        case SYS_PARA_BREAK:
  1868.           field->CharData[0]=DEF_PARA_BREAK;
  1869.           field->CharData[1]=0;
  1870.           break;
  1871.        default:  
  1872.           ;
  1873.     }
  1874.  
  1875.     return TRUE;
  1876. }
  1877.