home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 5 / 05.iso / a / a031 / template.exe / REPORT.COD < prev    next >
Encoding:
Text File  |  1992-03-10  |  71.6 KB  |  2,898 lines
  1. //
  2. // Module Name: REPORT.COD
  3. // Description: Define report program structure.
  4. //
  5. Report (.frg) Program Template
  6. ------------------------------
  7. $Version: $
  8. Copyright (c) 1991 Borland International, Inc.
  9. {
  10.  include "report.def";
  11.  include "builtin.def";
  12.  
  13.  if getenv("dtl_debug") then
  14.    debug(2)
  15.    breakpoint( pick_debug )
  16.  endif
  17.  
  18.  var  bnl_formname,     // Name of BNL file to newframe if argument() has value
  19.       arg_list;
  20.  
  21.  arg_list = argument()
  22.  if arg_list != "" then
  23.    bnl_formname = token( ",", arg_list, 1 )
  24.    if !newframe( bnl_formname ) then
  25.      return -1;
  26.    endif
  27.  endif
  28.  
  29. //
  30. // Enum string constants for international translation
  31. //
  32. enum
  33.     wrong_class = "Can't use REPORT.GEN on non-report objects.  ",
  34.     demo_string  = "dBASE IV SAMPLE REPORT - FOR EVALUATION PURPOSES ONLY",
  35.     increase_page = "Increase the page length for this report.",
  36.     demo_version = 0;
  37.  
  38. enum    FIRST_GEN = 2;
  39.  
  40. enum    CHARACTER_TYPE = 67,
  41.         DATE_TYPE,
  42.         FLOAT_TYPE = 70,
  43.         LOGICAL_TYPE = 76,
  44.         MEMO_TYPE,
  45.         NUMERIC_TYPE = 78;
  46.  
  47. enum    AVERAGE_OP = 0,
  48.         COUNT_OP = 1,
  49.         MAX_OP,
  50.         MIN_OP,
  51.         SUM_OP,
  52.         STD_DEV_OP,
  53.         VARIANCE_OP;
  54.  
  55.     if frame_class != report then
  56.         pause(wrong_class + any_key)
  57.         return 0
  58.     endif
  59.  
  60. var
  61. // temporary variables
  62.     count,x,a,i,ni,j,k,temp,temp2,
  63. // global variables
  64.      rptname,   // Report name
  65.  default_drive, // dBASE default drive
  66.      isfirst,   // first system memvar? (handles commas)
  67.      isnew,     // is this a new band?
  68.      isopen,    // is the band open?
  69.      priv_vars, // system memvars list
  70.     priv_vars2, // if FLD_EXPRESSION is broken into 2 strings
  71.      bandedit,  // word wrap off or on
  72.      bandgrp,   // GROUP id for bands
  73.      bandhgt,   // band row position plus height plus one
  74.      bandlen2,  // length of page header (0 if band is closed)
  75.   bandspacing2, // spacing on page header band
  76.      bandlen50, // length of detail band        "
  77.    bandspacing, // spacing on detail band
  78.      bandlen98, // length of page footer        "
  79.  bandspacing98, // spacing on footer band
  80.      bandtype,  // type of band ie. page footer, report intro, etc.
  81.  band_previous, // previous bandtype
  82.      length,    // length of field or text
  83.      maxgrp,    // maximum number of bands
  84.      isrepo,    // is there report intro/summary bands
  85.      maxrow,    // maximum row
  86.      nextrow,   // next row when looking ahead ie. ++<cursor>
  87. current_column, // current text or field plus length
  88.      bsrv,      // beginning of band suppress repeated value
  89.      xsrv,      // current suppress repeated value var
  90.      xsum,      // current "noname" summary field
  91.      xxsum,     // subset of either an average, std. deviation or variance
  92.      samerow,   // flag set for items occuring on the same row
  93.      bandrow,   // band row plus one
  94.  first_combine, // text or field is the first in the chain of combined data
  95.      combine,   // combine fields flag
  96.  suppress_line, // if the text "Page no." appears first on the line
  97.   previous_row, // previous elements' row
  98.     pre_type,   // previous element type was field or text
  99.     next_type,
  100.    inner_loop,  // elements inside the band encountered
  101.   optl_heading, // flag to test whether optional heading has been output
  102. is_rintro_open, // is the Report Intro band open
  103.  is_rsumm_open, // is the Report Summary band open
  104. number_of_open_group_intros,   // none open, Grphead procedure is suppressed
  105. number_of_open_group_summarys, // none open, Grpfoot procedure is suppressed
  106. is_page_header_open, // if Page Header band is open
  107. number_of_reset_on_page, // summary fields reset on page
  108. number_of_fld_suppress,  // suppressed fields
  109. intro_band_one_height,   // footer widow checking for
  110. intro_band_two_height,   // dBASE III PLUS reports
  111. number_of_word_wrap_bands,
  112. number_of_group_calc_fields,
  113. number_of_group_footer_fields,
  114. number_of_group_intro_each,
  115. current_group_footer_field,
  116. number_of_begin_new_pages,
  117. retain_previous,
  118. external_define,
  119. blankable_row,
  120. left_delimiter,
  121. right_delimiter,
  122. delimit_flag,
  123. ruler_flag,
  124. previous_indent,
  125. previous_lmargin,
  126. previous_rmargin,
  127. previous_tabs,
  128. line_one_length
  129. ;
  130.     default_drive = STRSET(_defdrive)
  131.     rptname = FRAME_PATH + NAME
  132.     if not FILEOK(rptname) then
  133.         if FILEDRIVE(NAME) || !default_drive then
  134.             rptname=NAME
  135.         else
  136.             rptname=default_drive + ":" + NAME
  137.         endif
  138.     endif
  139.  
  140.     if not CREATE(rptname+".FRG") then
  141.         PAUSE(fileroot(rptname)+".FRG"+read_only+any_key)
  142.         return 0
  143.     endif
  144.  
  145.     pre_pass();
  146.  
  147. // variable initializations
  148.     bandrow=0
  149.     bsrv=0
  150.     combine=0
  151.     current_column=0
  152.     first_combine=1
  153.     isopen=0
  154.     maxrow=0
  155.     nextrow=0
  156.     optl_heading=0
  157.     previous_row=0
  158.     left_delimiter="\""
  159.     right_delimiter="\""
  160.     delimit_flag=0
  161.     samerow=0
  162.     xsrv=0
  163.     xsum=0
  164.     xxsum=0
  165.     isrepo=0
  166.     is_rintro_open=0
  167.     bandlen2=0
  168.     is_page_header_open=0
  169.     bandlen50=0
  170.     current_group_footer_field=0
  171.     number_of_begin_new_pages=0
  172.     number_of_group_footer_fields=0
  173.     number_of_group_intro_each=0
  174.     number_of_open_group_intros=0
  175.     number_of_open_group_summarys=0
  176.     number_of_word_wrap_bands=0
  177.     bandlen98=0
  178.     bandspacing=0
  179.     bandspacing98=0
  180.     is_rsumm_open=0
  181.     intro_band_one_height=0
  182.     intro_band_two_height=0
  183.     ruler_flag=1
  184.     line_one_length=0;  }
  185. * Program............: {rptname}.FRG
  186. * Date...............: {LTRIM(SUBSTR(DATE(),1,8))}
  187. * Versions...........: dBASE IV, Report {db_version_no}
  188. *
  189. * Notes:
  190. * ------
  191. * Prior to running this procedure with the DO command
  192. * it is necessary use LOCATE because the CONTINUE
  193. * statement is in the main loop.
  194. *
  195. *-- Parameters
  196. PARAMETERS gl_noeject, gl_plain, gl_summary, gc_heading, gc_extra
  197. ** The first three parameters are of type Logical.
  198. ** The fourth parameter is a string.  The fifth is extra.
  199. {
  200.     if dBASE_III_PLUS == FIRST_GEN then
  201.         a=", _plength, _ploffset";
  202.     else
  203.         a="";
  204.     endif
  205. }
  206. PRIVATE _peject{a}, _wrap
  207.  
  208. *-- Test for no records found
  209. IF EOF() .OR. .NOT. FOUND()
  210.    RETURN
  211. ENDIF
  212.  
  213. *-- turn word wrap mode off
  214. _wrap=.F.
  215.  
  216. {       report_setup();
  217. }
  218. IF _plength < {tb_margin(bandlen2,bandspacing2)} \
  219. + {tb_margin(bandlen98,bandspacing98)} + 2
  220.    SET DEVICE TO SCREEN
  221.    DEFINE WINDOW gw_report FROM 7,17 TO 11,62 DOUBLE
  222.    ACTIVATE WINDOW gw_report
  223.    @ 0,1 SAY "{increase_page}"
  224.    @ 2,1 SAY "{any_key}"
  225.    x=INKEY(0)
  226.    DEACTIVATE WINDOW gw_report
  227.    RELEASE WINDOW gw_report
  228.    RETURN
  229. ENDIF
  230.  
  231. _plineno=0          && set lines to zero
  232. {   if dBASE_III_PLUS == FIRST_GEN then  }
  233.  
  234. *-- dBASE III PLUS report setup
  235. {
  236.     case PRINT_NEW_PAGE of
  237.     0: a="\"AFTER\""
  238.     1: a="\"BEFORE\""
  239.     2: a="\"BOTH\""
  240.     3: a="\"NONE\""
  241.     endcase
  242. }
  243. _peject={a}
  244. _plength={PRINT_PAGE_LENGTH}
  245. _ploffset={(!PRINT_LEFT_OFFSET) ? 0 : PRINT_LEFT_OFFSET}
  246.  
  247. *-- PLAIN option to screen only
  248. IF gl_plain
  249.    IF SET("PRINT") = "OFF" .AND. SET("ALTERNATE") = "OFF"
  250.       gl_noeject=.T.
  251.    ENDIF
  252. ENDIF
  253.  
  254. {   endif   }
  255. *-- NOEJECT parameter
  256. IF gl_noeject
  257.    IF _peject="BEFORE"
  258.       _peject="NONE"
  259.    ENDIF
  260.    IF _peject="BOTH"
  261.       _peject="AFTER"
  262.    ENDIF
  263. ENDIF
  264.  
  265. *-- Set-up environment
  266. ON ESCAPE DO Prnabort
  267. IF SET("TALK")="ON"
  268.    SET TALK OFF
  269.    gc_talk="ON"
  270. ELSE
  271.    gc_talk="OFF"
  272. ENDIF
  273. gc_space=SET("SPACE")
  274. SET SPACE OFF
  275. gc_time=TIME()      && system time for predefined field
  276. gd_date=DATE()      && system date  "    "    "     "
  277. gl_fandl=.F.        && first and last page flag
  278. {       if number_of_group_intro_each then }
  279. gl_intros=.F.       && flag for group intros on each page
  280. {       endif   }
  281. gl_prntflg=.T.      && Continue printing flag
  282. gl_widow=.T.        && flag for checking widow bands
  283. gn_length=LEN(gc_heading)  && store length of the HEADING
  284. gn_level=2          && current band being processed
  285. gn_page=_pageno     && grab current page number
  286. gn_pspace=_pspacing && get current print spacing
  287.  
  288. {   init_group_footer_vars();
  289.     init_calculated_vars(); }
  290.  
  291. *-- Set up procedure for page break
  292. gn_atline=_plength - {tb_margin(bandlen98,bandspacing98)}
  293. ON PAGE AT LINE gn_atline EJECT PAGE
  294.  
  295. *-- Print Report
  296.  
  297. PRINTJOB
  298.  
  299. {   if number_of_begin_new_pages then   }
  300. gl_newpage=.T.      && ok to begin band on new page
  301.  
  302. {   endif
  303.     init_group_break_vars()
  304.     init_summary_vars()
  305.     init_suppress_repeated_value_vars()
  306.     assign_calculated_vars()
  307.     assign_summary_vars()
  308.     if isrepo && is_rintro_open && not FRAME_PAGEHEADINGS then  }
  309. DO Rintro
  310.  
  311. *-- reset page number in case report intro spanned two pages
  312. _pageno=gn_page
  313.  
  314. {   endif   }
  315. IF gl_plain
  316.    ON PAGE AT LINE gn_atline DO Pgplain
  317. ELSE
  318.    ON PAGE AT LINE gn_atline DO Pgfoot
  319. ENDIF
  320.  
  321. {   if has_headers() then   }
  322. DO Pghead
  323.  
  324. {   endif   }
  325. gl_fandl=.T.        && first physical page started
  326.  
  327. {   if isrepo && is_rintro_open && FRAME_PAGEHEADINGS then  }
  328. DO Rintro
  329. {       if number_of_begin_new_pages then   }
  330. gl_newpage=.F.
  331. {       endif  }
  332.  
  333. {   endif
  334.     if number_of_open_group_intros then }
  335. DO Grphead
  336. {       if number_of_group_intro_each then }
  337. gl_intros=.F.
  338. {       endif   }
  339.  
  340. {   endif   }
  341. *-- File Loop
  342. DO WHILE FOUND() .AND. .NOT. EOF() .AND. gl_prntflg
  343. {   lmarg(4)
  344. //
  345. // If there are group bands
  346. // set up the CASE structure to test
  347. // the group band values
  348. //
  349.     if (number_of_open_group_intros || number_of_open_group_summarys) then }
  350. DO CASE
  351. {       build_case_statement(); }
  352. OTHERWISE
  353.    gn_level=0
  354. ENDCASE
  355. *-- test whether an expression didn't match
  356. IF gn_level <> 0
  357. {       if number_of_open_group_summarys then   }
  358.    DO Grpfoot WITH 100-gn_level
  359. {       endif   }
  360.    DO Grpinit
  361. ENDIF
  362. {       if number_of_open_group_intros then }
  363. *-- Repeat group intros
  364. IF gn_level <> 0
  365.    DO Grphead
  366. ENDIF
  367. {       endif
  368.         if number_of_group_intro_each then }
  369. gl_intros=.F.
  370. {       endif
  371.     endif   }
  372. gn_level=0
  373. {   if bandlen50 then   }
  374. *-- Detail lines
  375. IF gl_summary
  376.    DO Upd_Vars
  377. ELSE
  378.    DO __Detail
  379. ENDIF
  380. {   else    }
  381. DO Upd_Vars
  382. {   endif}
  383. gl_widow=.T.         && enable widow checking
  384. CONTINUE
  385. {   if number_of_open_group_intros || number_of_open_group_summarys then
  386.         increment_group_by_record_vars()
  387.     endif
  388.     lmarg(1);   }
  389. ENDDO
  390.  
  391. IF gl_prntflg
  392. //
  393. // If there are group bands
  394. //
  395. {   if maxgrp > 3 then  }
  396.    gn_level=3
  397. {       if number_of_open_group_summarys then   }
  398.    DO Grpfoot WITH 97
  399. {       endif
  400.     endif   }
  401. //
  402. // Report summary
  403. //
  404. {   if isrepo && is_rsumm_open then }
  405.    DO Rsumm
  406. {   endif
  407.     if bandlen98 then
  408.         if !is_rsumm_open then  }
  409.    gl_fandl=.F.     && last page finished
  410. {       endif   }
  411.    IF _plineno <= gn_atline
  412.       EJECT PAGE
  413.    ENDIF
  414. {   endif   }
  415. ELSE
  416. {   if isrepo && is_rsumm_open then
  417.         if maxgrp > 3 then  }
  418.    gn_level=3
  419. {       endif   }
  420.    DO Rsumm
  421. {   endif   }
  422.    DO Reset
  423.    RETURN
  424. ENDIF
  425.  
  426. ON PAGE
  427.  
  428. ENDPRINTJOB
  429.  
  430. DO Reset
  431. RETURN
  432. * EOP: {rptname}.FRG
  433. {   output_proc_gheight();  }
  434.  
  435. *-- Update summary fields and/or calculated fields.
  436. PROCEDURE Upd_Vars
  437. {   update_summary_and_calc_vars(); }
  438. RETURN
  439. * EOP: Upd_Vars
  440.  
  441. *-- Set flag to get out of DO WHILE loop when escape is pressed.
  442. PROCEDURE Prnabort
  443. gl_prntflg=.F.
  444. RETURN
  445. * EOP: Prnabort
  446.  
  447. {   if number_of_open_group_intros
  448.      || number_of_open_group_summarys then }
  449. *-- Reset group break variables.  Reinit summary
  450. *-- fields with reset set to a particular group band.
  451. PROCEDURE Grpinit
  452. {       reinit_group_variables(); }
  453. RETURN
  454. * EOP: Grpinit
  455.  
  456. {   endif
  457.     if number_of_reset_on_page || number_of_fld_suppress then   }
  458. *-- Reset summary fields (on page) and suppress repeated values.
  459. PROCEDURE Pageinit
  460. {       reinit_page_variables(); }
  461. RETURN
  462. * EOP: Pageinit
  463.  
  464. {   endif
  465.     if (number_of_open_group_intros
  466.      || number_of_open_group_summarys) then
  467.         output_group_calls();
  468.     endif
  469.     if external_define then
  470.         fileerase(rptname+".grp");
  471.         APPEND(rptname+".FRG");
  472.     endif
  473.     output_band_procs();    }
  474.  
  475. *-- Process page break when PLAIN option is used.
  476. PROCEDURE Pgplain
  477. PRIVATE _box
  478. EJECT PAGE
  479. {   if number_of_reset_on_page
  480.     || number_of_fld_suppress then  }
  481. IF gl_fandl
  482.    DO Pageinit
  483. ENDIF
  484. {   endif   }
  485. RETURN
  486. * EOP: Pgplain
  487.  
  488. *-- Reset dBASE environment prior to calling report
  489. PROCEDURE Reset
  490. SET SPACE &gc_space.
  491. SET TALK &gc_talk.
  492. ON ESCAPE
  493. ON PAGE
  494. RETURN
  495. * EOP: Reset
  496.  
  497. {
  498. return 0;
  499. //--------------------------------
  500. // End of main template procedure
  501. // User defined functions follow
  502. //--------------------------------
  503. define output_band_procs()
  504. //
  505. // Main loop which outputs the procedures for all the bands
  506. // and the contents of each band (also setup code).
  507. //
  508.     bandtype=99
  509. //
  510.     foreach ELEMENT ecursor
  511.         inner_loop=0
  512.         pre_type=0
  513.         next_type=0
  514. //
  515. // List type is a BAND?
  516. //
  517.         if ELEMENT_TYPE == @Band_Element then
  518.             begin_new_band(ecursor)
  519.             loop
  520.         else
  521.             ++count;
  522.         endif
  523.  
  524. do while ELEMENT_TYPE != @Band_Element && !eoc(ecursor)
  525.   inner_loop=1;
  526. //
  527.   if ELEMENT_TYPE == @Fld_Element then
  528.     if FLD_SUPPRESS then
  529.       ++xsrv;
  530.     endif
  531.  
  532.     retain_previous=0;
  533.     if GROUP > 50 then
  534.       retain_previous=retain_previous_value(ecursor)
  535.     endif
  536.     if retain_previous then
  537.       ++current_group_footer_field;
  538.     endif
  539.  
  540.     if !FLD_FIELDNAME && FLD_FIELDTYPE == Summ_data then
  541.       ++xsum;
  542.     endif
  543.   endif
  544. //
  545.   if FLD_HIDDEN || not isopen goto noprint endif
  546. //
  547. // Text or Field item begins on new row
  548. //
  549.   if ELEMENT_TYPE == @Text_Element || ELEMENT_TYPE == @Fld_Element then
  550.     if !pre_type || previous_row != Row_Positn then
  551.       samerow=0;
  552.       combine=0;
  553.       first_combine=1;
  554.     endif
  555.   endif
  556. //
  557.   if !optl_heading
  558.    && Row_Positn > bandrow+1
  559.    && bandtype == Page_Header then
  560.     if maxrow < bandrow+1 then }
  561. ?
  562.  
  563. {       ++maxrow;
  564.     endif   }
  565. *-- Print HEADING parameter - no items on line one
  566. IF .NOT. gl_plain
  567.    ?? gc_heading FUNCTION "I;V"+LTRIM(STR(_rmargin - _lmargin))
  568. ENDIF
  569.  
  570. {   optl_heading=1;
  571.   endif
  572. //
  573. // Output carriage returns for dBASE report
  574. //
  575.   if !bandedit then
  576. nextline1:
  577.     if maxrow < Row_Positn then }
  578. ?
  579. {     ++maxrow;
  580.       goto nextline1;
  581.     endif
  582.   else
  583.     if blankable_row && previous_row < Row_Positn then
  584.       blankable_row=0;
  585.       lmarg(1); }
  586. ENDIF
  587. {   endif
  588.     if (previous_row < Row_Positn) && (ELEMENT_TYPE == @Fld_Element
  589.     || ELEMENT_TYPE == @Text_Element) then
  590.       blankable_row=check4blank(ecursor);
  591.       if blankable_row then
  592.         if conditional_if_for_blank_line(ecursor) then
  593.           isnew=1;
  594.           lmarg(4);
  595.         endif
  596.       endif
  597.     endif
  598.     maxrow=Row_Positn;
  599.   endif
  600. //
  601. // Insert heading code for items on line one
  602. //
  603.     if line_one_length
  604.      && dBASE_III_PLUS != FIRST_GEN
  605.      && bandtype == Page_Header
  606.      && Row_Positn == bandrow+1 then    }
  607. *-- Print HEADING parameter - if it doesn't fit on line one
  608. *-- Value added to gn_length is the last column on line one times two
  609. IF .NOT. gl_plain .AND. gn_length + {line_one_length * 2} > ln_width
  610.    ?? gc_heading FUNCTION "I;V"+LTRIM(STR(ln_width))
  611.    ?
  612.    ll_heading = .F.
  613. ENDIF
  614.  
  615. {       line_one_length=0;
  616.     endif
  617. //
  618.   pre_type=0;
  619.   next_type=0;
  620.   ++ecursor;
  621.   nextrow=Row_Positn;
  622.   if ELEMENT_TYPE == @Text_Element
  623.   || ELEMENT_TYPE == @Fld_Element then
  624.     next_type=1;
  625.   endif
  626.   --ecursor;
  627. //
  628.   case ELEMENT_TYPE of
  629.   @Text_Element:
  630. //
  631.     x=Col_Positn;
  632.     i=LEN(Text_Item);
  633.     ni=0;
  634.     pre_type=1;
  635.     if i == 237 then
  636.       foreach Text_Item fcursor in ecursor
  637.         if ni then
  638.           i=i+LEN(Text_Item);
  639.           temp=Text_Item;
  640.         endif
  641.         ++ni;
  642.       next
  643.     endif
  644.     current_column=x+i;
  645.     set_combine_flag(ecursor);
  646.     ++ecursor;
  647.     if (bandtype == Page_Header || bandtype == Page_Footer)
  648.       && ELEMENT_TYPE == @Fld_Element
  649.       && nextrow == maxrow then
  650.         if FLD_FIELDTYPE == Pred_data
  651.             && FLD_PREDEFINE == 3 then
  652.           --ecursor;
  653.           if SUBSTR(UPPER(Text_Item),1,4) == "PAGE" then
  654.             if previous_row == Row_Positn then
  655.                suppress_line=2;
  656.             else
  657.                suppress_line=1;
  658.             endif
  659.           endif
  660.           ++ecursor;
  661.           if suppress_line == 1 then
  662.             ++ecursor;
  663.             if !eoc(ecursor) && Row_Positn == nextrow then
  664.               suppress_line=2;
  665.             endif
  666.             --ecursor;
  667.           endif
  668.         endif
  669.     endif
  670.     --ecursor;
  671. //
  672.     if suppress_line == 1 &&
  673.      (bandtype == Page_Header || bandtype == Page_Footer) then
  674.        plainopt(ecursor);
  675.     endif
  676.     if isnew then
  677.       isnew=0;  }
  678. ?? \
  679. {   else
  680.       if samerow then}
  681.  \
  682. {     else}
  683. ?? \
  684. {     endif
  685.     endif
  686.     if substr(Text_Item,1,1) == "\"" then
  687.       left_delimiter = "["
  688.       right_delimiter = "]"
  689.       delimit_flag = 1
  690.     endif
  691.     if suppress_line == 2 then}
  692. IIF(gl_plain,'' , \
  693. {   endif
  694.     if i > 70 then}
  695. ;
  696. {     separate(Text_Item);
  697.       if ni then}
  698. + {left_delimiter}{temp}{right_delimiter};
  699. {     endif
  700.     else}
  701. {left_delimiter}{Text_Item}{right_delimiter} \
  702. {   endif
  703.     if suppress_line == 2 then}
  704. ) \
  705. {     suppress_line=0;
  706.     endif
  707.     if delimit_flag then
  708.       left_delimiter="\""
  709.       right_delimiter="\""
  710.       delimit_flag=0
  711.     endif
  712.   @Box_Element:}
  713. DEFINE BOX FROM {(!BOX_LEFT) ? 0 : BOX_LEFT} TO \
  714. {((!BOX_LEFT) ? 0 : BOX_LEFT)+BOX_WIDTH-1} \
  715. HEIGHT {BOX_HEIGHT} \
  716. {   case BOX_TYPE of
  717.     0: // Single}
  718. SINGLE
  719. {   1: // Double}
  720. DOUBLE
  721. {   2: // Defined}
  722. CHR({BOX_SPECIAL_CHAR})
  723. {   endcase
  724.   @Page_Element:}
  725. EJECT PAGE
  726. { @Para_Element:}
  727. ?
  728. { @Ruler_Element:
  729. //
  730.     ++ecursor;
  731.     if ELEMENT_TYPE == @Para_Element then
  732.       loop
  733.     endif
  734.     --ecursor;
  735.     a=((!RULER_LEFTM) ? 0 : RULER_LEFTM);
  736.     x=((!RULER_INDENT) ? 0 : RULER_INDENT);
  737.     if x && x > 255 then
  738.       x = x - 65536;
  739.     endif
  740.     i=0;
  741.     if ruler_flag || (a != previous_lmargin && x != previous_indent) then
  742.       if a + previous_indent < 0 then
  743.         if x >= 0 then   }
  744. _indent={x}
  745. {         i=1;
  746.         else    }
  747. _indent=0
  748. {       endif
  749.       endif     }
  750. _lmargin={a}
  751. {     if !i then    }
  752. _indent={x}
  753. {     endif
  754.       previous_indent=x;
  755.       previous_lmargin=a;
  756.     else
  757.       if x != previous_indent then  }
  758. _indent={x}
  759. {       previous_indent=x;
  760.       endif
  761.       if a != previous_lmargin then }
  762. _lmargin={a}
  763. {       previous_lmargin=a;
  764.       endif
  765.     endif
  766.     a=RULER_RIGHTM;
  767.     if ruler_flag || a != previous_rmargin then }
  768. _rmargin={a}
  769. {     previous_rmargin=a;
  770.     endif}
  771. _pcolno={previous_lmargin+x }
  772. {   a=RULER_TABS;
  773.     if ruler_flag || a != previous_tabs then    }
  774. _tabs=\
  775. {     if LEN(a) > 70 then}
  776. ;
  777. {       separate(a);}
  778.  
  779. {     else}
  780. "{a}"
  781. {     endif
  782.       previous_tabs=a;
  783.     endif
  784.     ruler_flag=0;
  785. }
  786. { @Fld_Element:
  787. //
  788.     x=Col_Positn;
  789.     i=FLD_REPWIDTH;
  790.     ni=0;
  791.     pre_type=1;
  792.     if i > 237 then
  793.       foreach FLD_TEMPLATE fcursor in ecursor
  794.         if ni then
  795.           temp2=FLD_TEMPLATE;
  796.         endif
  797.         ++ni;
  798.       next
  799.     endif
  800.     current_column=x+i;
  801. //
  802.     set_combine_flag(ecursor)
  803. //
  804.     k=0;
  805.     x=0;
  806.     priv_vars2="";
  807.     if dBASE_III_PLUS == FIRST_GEN && FLD_VALUE_TYPE == CHARACTER_TYPE &&
  808.     (FLD_FIELDTYPE == Tabl_data || FLD_FIELDTYPE == Calc_data) then
  809.       priv_vars="TRIM(";
  810.       x=1;
  811.     else
  812.       priv_vars="";
  813.     endif
  814.   if retain_previous then
  815.       priv_vars="r_foot"+str(current_group_footer_field);
  816.   else
  817.     case FLD_FIELDTYPE of
  818.     Tabl_data:
  819. // With ALIAS
  820. //      priv_vars=priv_vars+upper_first(FLD_FILENAME)+"->"+
  821. //                          upper_first(FLD_FIELDNAME);
  822. // Without ALIAS
  823.       priv_vars=priv_vars+upper_first(FLD_FIELDNAME);
  824.     Calc_data:
  825.       if FLD_FIELDNAME then
  826.         priv_vars=priv_vars+lower(FLD_FIELDNAME);
  827.       else
  828.         foreach FLD_EXPRESSION fcursor in ecursor
  829.           if k then
  830.             priv_vars2=FLD_EXPRESSION;
  831.           endif
  832.           ++k;
  833.         next
  834.         if (UPPER(SUBSTR(LTRIM(FLD_EXPRESSION),1,5))) != "TRIM(" then
  835.           priv_vars=priv_vars+FLD_EXPRESSION;
  836.         else
  837.           priv_vars=FLD_EXPRESSION;
  838.           x=0;
  839.         endif
  840.       endif
  841.     Pred_data: ;
  842.       case FLD_PREDEFINE of
  843.       0: // Date
  844.         priv_vars="gd_date";
  845.       1: // Time
  846.         priv_vars="gc_time";
  847.       2: // Recno
  848.         priv_vars="RECNO()";
  849.       3: // Pageno
  850.         priv_vars="_pageno";
  851.       endcase
  852.     Summ_data:
  853.       if !FLD_FIELDNAME then
  854.         priv_vars="r_msum"+STR(xsum);
  855.       else
  856.         priv_vars=lower(FLD_FIELDNAME);
  857.       endif
  858.     endcase
  859.   endif
  860.     if x then
  861.       priv_vars2=priv_vars2+")";
  862.     endif
  863.     if !suppress_line &&
  864.     (bandtype == Page_Header || bandtype == Page_Footer) then
  865.       plainopt(ecursor);
  866.     endif
  867. //
  868. // For output of suppress repeated value memo fields
  869. //
  870.     if FLD_SUPPRESS && FLD_VALUE_TYPE == MEMO_TYPE then  }
  871.  
  872. lf_temp={suppress_repeated_values(ecursor);}
  873. {     isnew=1;
  874.     endif
  875.     if isnew then
  876.       isnew=0;  }
  877. ?? \
  878. {   else
  879.       if samerow then}
  880.  \
  881. {     else}
  882. ?? \
  883. {     endif
  884.     endif
  885.     if FLD_SUPPRESS && FLD_VALUE_TYPE == MEMO_TYPE then  }
  886. &lf_temp. \
  887. {   else
  888.       suppress_repeated_values(ecursor);
  889.     endif
  890.  
  891.     j=0;
  892.     if FLD_PICFUN then
  893.       temp=FLD_PICFUN;
  894.       j=AT("V",temp) | AT("H",temp);
  895.       if not j then}
  896. FUNCTION "{FLD_PICFUN}" \
  897. {     else
  898.         if not AT("H",temp) then
  899.           if j < LEN(FLD_PICFUN) then
  900.             temp=SUBSTR(temp,1,j)+STR(i)+SUBSTR(temp,j+1);
  901.           else
  902.             temp=temp+STR(i);
  903.           endif
  904.         endif}
  905. FUNCTION "{temp}" \
  906. {     endif
  907.     endif
  908.     temp=FLD_TEMPLATE+temp2;
  909.     if FLD_VALUE_TYPE == CHARACTER_TYPE then
  910.       if FLD_LENGTH == FLD_REPWIDTH && temp == REPLICATE("X",FLD_LENGTH) then
  911.         j=FLD_LENGTH;
  912.       endif
  913.     endif
  914.     if not j then
  915. //
  916. // test for invalid picture templates
  917. //
  918.       if temp && (FLD_FIELDTYPE != Pred_data || FLD_PREDEFINE != 1) &&
  919.       FLD_VALUE_TYPE != DATE_TYPE then
  920.         if i > 70 then}
  921. PICTURE ;
  922. {         separate(temp);
  923.         else}
  924. PICTURE "{FLD_TEMPLATE}" \
  925. {       endif
  926.       endif
  927.     endif
  928.   endcase
  929. //
  930. // Style of output ie. BOLD, UNDERLINE and ITALICS.
  931. //
  932.   if FLD_STYLE then}
  933. STYLE "\
  934. {   if Bold & FLD_STYLE then}
  935. B\
  936. {   endif
  937.     if Italic & FLD_STYLE then}
  938. I\
  939. {   endif
  940.     if Underline & FLD_STYLE then}
  941. U\
  942. {   endif
  943.     if Superscript & FLD_STYLE then}
  944. R\
  945. {   endif
  946.     if Subscript & FLD_STYLE then}
  947. L\
  948. {   endif
  949.     if User_Font & FLD_STYLE then
  950.       if  1 & FLD_STYLE then}1{endif}\
  951. {     if  2 & FLD_STYLE then}2{endif}\
  952. {     if  4 & FLD_STYLE then}3{endif}\
  953. {     if  8 & FLD_STYLE then}4{endif}\
  954. {     if 16 & FLD_STYLE then}5{endif}\
  955. {   endif}
  956. " \
  957. { endif
  958. //
  959. // List type is TEXT or FIELD?
  960. //
  961.   if (ELEMENT_TYPE == @Text_Element || ELEMENT_TYPE == @Fld_Element) then
  962. //
  963. // not a word wrap band?
  964. //
  965.     if !bandedit && first_combine then  }
  966. AT {Col_Positn}\
  967. {   endif
  968.     if Row_Positn != nextrow then   }
  969.  
  970. {     isnew=1;
  971.     else
  972.       if FLD_SUPPRESS && bsrv != xsrv then    }
  973. ,
  974. {       isnew=1;
  975.       else
  976.         if next_type && Row_Positn == nextrow then
  977.           ++samerow;
  978.           if samerow > 7 then  // Break ?? command every 8 expressions}
  979. ,
  980. {           isnew=1;
  981.             samerow=1;
  982.           else    }
  983. ,;
  984. {         endif
  985.         else    }
  986.  
  987. {         isnew=1;
  988.         endif
  989.       endif
  990.     endif
  991. //
  992.     if FLD_SUPPRESS && bsrv != xsrv then
  993.         assign_suppress_var(ecursor);
  994.     endif
  995. //
  996.     if first_combine && combine then
  997.       first_combine=0;
  998.     endif
  999.     if !combine && !first_combine then
  1000.       first_combine=1;
  1001.     endif
  1002. //
  1003.   endif
  1004. //
  1005.   if !optl_heading && bandtype == Page_Header then
  1006.     if maxrow == bandrow+1 && nextrow > bandrow+1 then
  1007.         output_optional_heading()
  1008.     endif
  1009.   endif
  1010. //
  1011.   if bandtype == Page_Header || bandtype == Page_Footer then
  1012.     x=0;
  1013.     if previous_row < maxrow && nextrow > maxrow &&
  1014.     FLD_FIELDTYPE == Pred_data &&
  1015.     (!FLD_PREDEFINE || FLD_PREDEFINE == 3) then
  1016.       x=1;
  1017.     endif
  1018.     if x || (suppress_line && nextrow > maxrow) then
  1019.       if suppress_line && nextrow > maxrow then suppress_line=0; endif
  1020. //
  1021.       if optl_heading && nextrow > maxrow && bandtype != Page_Footer then}
  1022. ?
  1023. {       ++maxrow;
  1024.         isnew=1;
  1025.       endif
  1026.       lmarg(1);}
  1027. ENDIF
  1028. {   endif
  1029.   endif
  1030. noprint:
  1031.   x=0;
  1032.   if ELEMENT_TYPE != @Ruler_Element then
  1033.     previous_row=Row_Positn;
  1034.   endif
  1035.   ++ecursor;
  1036. enddo
  1037. if inner_loop then --ecursor; endif
  1038. next ecursor;
  1039. //
  1040. // Output carriage returns for dBASE report to handle blank lines
  1041. //
  1042. nextline3:
  1043. if maxrow < bandhgt then
  1044.   if isopen then}
  1045. ?
  1046. { endif
  1047.   ++maxrow;
  1048.   goto nextline3;
  1049. endif
  1050. if bandtype == Report_Summary && is_rsumm_open then
  1051. }
  1052. gl_fandl=.F.
  1053. ?
  1054. RETURN
  1055. * EOP: Rsumm
  1056. {
  1057. endif
  1058. if bandtype == Page_Footer then
  1059.   finish_page_footer();
  1060. endif
  1061. return;
  1062. enddef
  1063.  
  1064. define upper_first(string)
  1065.         // Takes and returns a string with first letter upper case
  1066.         return upper( substr( string,1,1)) + lower( substr( string,2))
  1067. enddef
  1068.  
  1069. define separate(string);
  1070. //
  1071. // Separates strings longer than 70 so that printed output
  1072. // of the report does not cause truncation or line wrap.
  1073. //
  1074.     var x,y,length;
  1075.     x=1
  1076.     length=LEN(string)
  1077. moreleft:
  1078.     if x <= length then
  1079.         if x != 1 then  }
  1080. + \
  1081. {       endif
  1082.         if x+70 <= length then
  1083.             y=70
  1084.         else
  1085.             y=length-x+1
  1086.         endif;  }
  1087. {left_delimiter}{SUBSTR(string,x,y)}{right_delimiter};
  1088. {       x=x+70
  1089.         goto moreleft;
  1090.     endif
  1091.     return
  1092. enddef
  1093.  
  1094. define retain_previous_value(cursor)
  1095. //
  1096. // Test whether a footer field needs to ...
  1097. //
  1098.     var result;
  1099.     result=0;
  1100.     case cursor.FLD_FIELDTYPE of
  1101.     Tabl_data: result=1
  1102.     Pred_data:
  1103.         if cursor.FLD_PREDEFINE == 2 then
  1104.             result=1
  1105.         endif
  1106.     endcase
  1107.     return result
  1108. enddef
  1109.  
  1110. define set_combine_flag(cursor)
  1111. //
  1112. // Determine whether field and or text are touching.
  1113. // If they are, a trim is performed on the field.
  1114. //
  1115.     ++cursor;
  1116.     if cursor.ELEMENT_TYPE == @Text_Element
  1117.      || cursor.ELEMENT_TYPE == @Fld_Element then
  1118.         if current_column == cursor.Col_Positn
  1119.          && maxrow == cursor.Row_Positn then
  1120.             combine=1;
  1121.         else
  1122.             combine=0;
  1123.         endif
  1124.     endif
  1125.     --cursor;
  1126. enddef
  1127.  
  1128. define assign_suppress_var(cursor)}
  1129. IF .NOT. (r_msrv{xsrv} = \
  1130. //
  1131. {     if !cursor.FLD_FIELDNAME then
  1132.         if cursor.FLD_FIELDTYPE == Calc_data then}
  1133. {extend(cursor,@FLD_EXPRESSION)}
  1134. {       endif
  1135.         if cursor.FLD_FIELDTYPE == Summ_data then}
  1136. r_msum{xsum}\
  1137. {       endif
  1138.       else
  1139.         if cursor.FLD_VALUE_TYPE == MEMO_TYPE then}
  1140. LEFT({upper_first(cursor.FLD_FIELDNAME)},254)\
  1141. {       else
  1142.           if cursor.FLD_FIELDTYPE == Tabl_data then
  1143. upper_first(cursor.FLD_FIELDNAME)}
  1144. {         else
  1145. lower(cursor.FLD_FIELDNAME)}
  1146. {         endif
  1147.         endif
  1148.       endif}
  1149. )
  1150. {     if !cursor.FLD_FIELDNAME then}
  1151.    r_msrv{xsrv}=\
  1152. {       if cursor.FLD_FIELDTYPE == Calc_data then}
  1153. {extend(cursor,@FLD_EXPRESSION)}
  1154.  
  1155. {       endif
  1156.         if cursor.FLD_FIELDTYPE == Summ_data then}
  1157. r_msum{xsum}
  1158. {       endif
  1159.       else}
  1160.    r_msrv{xsrv}=\
  1161. {       if cursor.FLD_FIELDTYPE == Tabl_data then
  1162. upper_first(cursor.FLD_FIELDNAME)}
  1163.  
  1164. {       else
  1165. lower(cursor.FLD_FIELDNAME)}
  1166.  
  1167. {       endif
  1168.       endif}
  1169. ENDIF
  1170. {
  1171.     return;
  1172. enddef
  1173.  
  1174. define suppress_repeated_values(cursor)
  1175. //
  1176. // Suppress repeated values
  1177. //
  1178.     if cursor.FLD_SUPPRESS then}
  1179. IIF(\
  1180. //
  1181. // Date field?
  1182. //
  1183. {       if cursor.FLD_VALUE_TYPE == DATE_TYPE then}
  1184. DTOS(r_msrv{xsrv}) \
  1185. {       else}
  1186. r_msrv{xsrv} \
  1187. {       endif}
  1188. <> \
  1189. //
  1190. // Date field?
  1191. //
  1192. {       if cursor.FLD_VALUE_TYPE == DATE_TYPE then}
  1193. DTOS({priv_vars}{priv_vars2})\
  1194. {       else}
  1195. //
  1196. // Memo field?
  1197. //
  1198. {           if cursor.FLD_VALUE_TYPE == MEMO_TYPE then}
  1199. LEFT({priv_vars},254)\
  1200. {           else}
  1201. {priv_vars}{priv_vars2}
  1202. {           endif}
  1203. {       endif}
  1204. //
  1205. // Memo field?
  1206. //
  1207. {       if cursor.FLD_VALUE_TYPE == MEMO_TYPE then}
  1208. ,[{priv_vars}],[""])
  1209. {       else}
  1210. ,{priv_vars}{priv_vars2},"") \
  1211. {       endif
  1212.     else
  1213.  priv_vars}{priv_vars2} \
  1214. {   endif
  1215. enddef
  1216.  
  1217. define extend(elk,selno)
  1218.     var result;
  1219.     foreach selno j in elk
  1220.         result = result + j.selno
  1221.     next j
  1222.     return result
  1223. enddef
  1224.  
  1225. define plainopt(cursor)
  1226. //
  1227. // Strictly for Page headers and Page footers, suppresses
  1228. // page numbers and dates when the PLAIN option is used.
  1229. //
  1230.     var temp; temp=0
  1231.     if previous_row < maxrow && nextrow > maxrow
  1232.      && cursor.FLD_FIELDTYPE == Pred_data
  1233.      && (!cursor.FLD_PREDEFINE || cursor.FLD_PREDEFINE == 3) then
  1234.         temp=1
  1235.     endif
  1236.     if temp || suppress_line then   }
  1237. IF .NOT. gl_plain
  1238. {       lmarg(4);
  1239.     else
  1240.         if cursor.FLD_FIELDTYPE == Pred_data &&
  1241.          (!cursor.FLD_PREDEFINE || cursor.FLD_PREDEFINE == 3) then
  1242.             if !cursor.FLD_PREDEFINE then
  1243.                 priv_vars="IIF(gl_plain,'',gd_date)"
  1244.             else
  1245.                 priv_vars="IIF(gl_plain,'',_pageno)"
  1246.             endif
  1247.         endif
  1248.     endif
  1249.     return
  1250. enddef
  1251.  
  1252. define output_optional_heading()
  1253. //
  1254. // Where to place the HEADING parameter in the page header
  1255. //
  1256. }
  1257.  
  1258. *-- Print HEADING parameter - if it fits on line one
  1259. IF \
  1260. {if !suppress_line then}.NOT. gl_plain .AND. {endif}\
  1261. gn_length > 0 .AND. ll_heading
  1262.    ?? " "
  1263.    ?? gc_heading FUNCTION "I;V"+LTRIM(STR(ln_width-(_pcolno*2)))
  1264. ENDIF
  1265. {
  1266.     isnew=1;
  1267.     optl_heading=1;
  1268. enddef
  1269.  
  1270. define begin_new_band(cursor)
  1271. //
  1272. // Code output at the beginning of each band procedure
  1273. //
  1274.     band_previous=bandtype
  1275.     bandtype=cursor.BAND_BANDTYPE
  1276.     samerow=0
  1277.     combine=0
  1278.     first_combine=1
  1279.     ruler_flag=1;
  1280. //
  1281. // Output carriage returns for dBASE report to handle blank lines
  1282. //
  1283. nextline2:
  1284.     if maxrow < bandhgt then
  1285.         if isopen then  }
  1286. ?
  1287. {       endif
  1288.         ++maxrow;
  1289.         goto nextline2;
  1290.     endif
  1291.     if blankable_row then
  1292.         blankable_row=0;
  1293.         lmarg(1);   }
  1294. ENDIF
  1295. {   endif
  1296. //
  1297. // beyond the first band?
  1298. //
  1299.     if band_previous != 99 then
  1300. //
  1301.         if number_of_begin_new_pages && isopen then
  1302.             if band_previous == Group_Intro
  1303.              || band_previous == Detail
  1304.              || band_previous == Group_Summary then }
  1305. gl_newpage=.F.
  1306. {             if band_previous == Group_Intro ||
  1307.                  band_previous == Group_Summary then }
  1308. ?
  1309. {             endif
  1310.            endif
  1311.         endif
  1312.         if band_previous == Page_Header
  1313.          || band_previous == Page_Footer
  1314.          || isopen then
  1315.             case band_previous of
  1316.             Page_Header:
  1317.                 if suppress_line then
  1318.                     suppress_line=0
  1319.                     lmarg(1);   }
  1320. ENDIF
  1321. {               endif   }
  1322. //
  1323. {               if isopen
  1324.                  || (is_rintro_open && FRAME_PAGEHEADINGS)
  1325.                  || number_of_open_group_intros then    }
  1326. RETURN
  1327. * EOP: Pghead
  1328. {               endif
  1329.             Report_Intro:   }
  1330. RETURN
  1331. * EOP: Rintro
  1332. {           Group_Intro:    }
  1333. RETURN
  1334. {           Detail: }
  1335. RETURN
  1336. * EOP: __Detail
  1337. {           Group_Summary:
  1338.                 if dBASE_III_PLUS == FIRST_GEN then }
  1339. IF ln_level < 9{if cursor.GROUP == 96 then}6{else}7{endif}
  1340.    ?
  1341. ENDIF
  1342. {               endif   }
  1343. RETURN
  1344. {           Report_Summary: }
  1345. gl_fandl=.F.        && last page finished
  1346. ?
  1347. RETURN
  1348. * EOP: Rsumm
  1349. {           Page_Footer:
  1350.                 finish_page_footer();
  1351.             endcase
  1352.         endif   }
  1353.  
  1354. {   endif
  1355. //
  1356. // capture band attributes
  1357. // -----------------------
  1358. // bandrow and maxrow for row position
  1359. // bandedit for word wrap band
  1360. // isopen for band open or closed
  1361. //
  1362.     if cursor.Row_Positn then
  1363.         bandhgt=cursor.Row_Positn+cursor.BAND_HEIGHT+1
  1364.         bandrow=cursor.Row_Positn+1
  1365.         maxrow=cursor.Row_Positn+1
  1366.     else
  1367.         bandhgt=cursor.BAND_HEIGHT+1
  1368.         bandrow=1
  1369.         maxrow=1;
  1370.     endif
  1371.  
  1372.     bandedit=cursor.BAND_BANDEDIT
  1373.     bandgrp=cursor.GROUP
  1374.     bsrv=xsrv
  1375.     isnew=1
  1376.     isopen=cursor.BAND_OPENFLG;
  1377. //
  1378.     if cursor.BAND_BANDTYPE == Page_header
  1379.      || cursor.BAND_BANDTYPE == Page_Footer
  1380.      || cursor.BAND_OPENFLG then
  1381.         if cursor.BAND_BANDTYPE then   }
  1382. PROCEDURE \
  1383. {       else
  1384.             if cursor.BAND_OPENFLG
  1385.              || (is_rintro_open && FRAME_PAGEHEADINGS)
  1386.              || number_of_open_group_intros then    }
  1387. PROCEDURE \
  1388. {           endif
  1389.         endif
  1390.         case bandtype of
  1391.         Page_Header:
  1392.             if cursor.BAND_OPENFLG
  1393.              || (is_rintro_open && FRAME_PAGEHEADINGS)
  1394.              || number_of_open_group_intros then    }
  1395. Pghead
  1396. {               if line_one_length then }
  1397. PRIVATE ll_heading, ln_width
  1398. ll_heading = .T.
  1399. ln_width = _rmargin - _lmargin
  1400. {               endif
  1401.             endif
  1402.         Report_Intro:   }
  1403. Rintro
  1404. {       Group_Intro:    }
  1405. Head{cursor.GROUP}
  1406. {           if not cursor.BAND_INTROEACH then  }
  1407. IF gn_level=1
  1408.    RETURN
  1409. ENDIF
  1410. {           endif
  1411.             if dBASE_III_PLUS == FIRST_GEN && cursor.GROUP == 4
  1412.              && intro_band_one_height && intro_band_two_height then
  1413.                 ++bandhgt;
  1414.             else
  1415.                 if number_of_begin_new_pages && isopen then
  1416.                     --bandhgt;
  1417.                 endif
  1418.             endif
  1419.         Detail: }
  1420. __Detail
  1421. {       Group_Summary:  }
  1422. Foot{cursor.GROUP}
  1423. {           if dBASE_III_PLUS == FIRST_GEN then }
  1424. ln_lines=IIF(ln_level < 97, \
  1425. {               case cursor.GROUP of
  1426.                 96: }
  1427. {intro_band_one_height+intro_band_two_height+2}, \
  1428. {intro_band_one_height+intro_band_two_height+1})
  1429. {               95: }
  1430. {intro_band_two_height+2}, \
  1431. {intro_band_two_height+1})
  1432. {               endcase }
  1433. IF _plineno+ln_lines > gn_atline
  1434.    _plineno=gn_atline
  1435.    ?
  1436. ENDIF
  1437. {           else
  1438.                 if number_of_begin_new_pages && isopen then
  1439.                     --bandhgt;
  1440.                 endif
  1441.             endif
  1442.         Report_Summary: }
  1443. Rsumm
  1444. {           --bandhgt;
  1445.         Page_Footer:    }
  1446. Pgfoot
  1447. PRIVATE _box{if isopen}, _pspacing{endif}
  1448. gl_widow=.F.         && disable widow checking
  1449. {           if isopen then  }
  1450. _pspacing=1
  1451. ?
  1452. {           endif
  1453.             if bandhgt then --bandhgt endif
  1454.             if cursor.BAND_OPENFLG && cursor.BAND_HEIGHT then }
  1455. IF .NOT. gl_plain
  1456.    _pspacing=gn_pspace
  1457. {             lmarg(4);
  1458.             endif
  1459.         endcase
  1460.     endif
  1461. //
  1462. // is the band open?
  1463. // make system memvars PRIVATE
  1464. // only if the values change
  1465. //
  1466.     if isopen then
  1467. //
  1468. // BAND_NEWPAGE  - Begin band on new page:  No, Yes|
  1469. //
  1470.         if cursor.BAND_NEWPAGE then    }
  1471. IF .NOT. gl_newpage
  1472.    gl_newpage=.T.
  1473.    EJECT PAGE
  1474. ENDIF
  1475. {       endif
  1476. //
  1477. // BAND_TEXTPITCH - Text pitch for band:  Pica, Elite, Condensed, Default|
  1478. //
  1479.         if cursor.BAND_TEXTPITCH != 3 then }
  1480. IF SET("PRINT") = "ON" .AND. _ppitch <> {text_pitch(cursor.BAND_TEXTPITCH)}
  1481.    PRIVATE _ppitch
  1482.    _ppitch = {text_pitch(cursor.BAND_TEXTPITCH)}
  1483. ENDIF
  1484. {       endif
  1485. //
  1486. // BAND_QUALITY - Quality pitch for band:  Yes, No|
  1487. //
  1488.         if cursor.BAND_QUALITY < 2 then    }
  1489. IF SET("PRINT") = "ON" .AND. {if !cursor.BAND_QUALITY then}.NOT. {endif}_pquality
  1490.    PRIVATE _pquality
  1491.    _pquality = {if cursor.BAND_QUALITY then}.F.{else}.T.{endif}
  1492. ENDIF
  1493. {       endif
  1494. //
  1495. // BAND_SPACING - Default, single, double or triple
  1496. //
  1497.         if cursor.BAND_SPACING then    }
  1498. IF _pspacing <> {cursor.BAND_SPACING}
  1499.    PRIVATE _pspacing
  1500.    _pspacing={cursor.BAND_SPACING}
  1501. ENDIF
  1502. {       endif
  1503. //
  1504. // BAND_BANDEDIT - Wordwrap band:  Yes, No|
  1505. //
  1506.         if number_of_word_wrap_bands then
  1507.             if cursor.BAND_BANDEDIT then   }
  1508. PRIVATE _indent, _lmargin, _rmargin, _tabs
  1509. {           endif   }
  1510. IF {if cursor.BAND_BANDEDIT then}.NOT. {endif}_wrap
  1511.    PRIVATE _wrap
  1512.    _wrap = {if cursor.BAND_BANDEDIT then}.T.{else}.F.{endif}
  1513. ENDIF
  1514. {       endif
  1515. //
  1516.         ni="";
  1517.         if cursor.BAND_BANDTYPE == Detail then
  1518.             if cursor.BAND_HEIGHT then
  1519.                 if !bandspacing then
  1520.                     if cursor.BAND_HEIGHT > 1 then
  1521.                         ni=STR(cursor.BAND_HEIGHT)+" * gn_pspace";
  1522.                     else
  1523.                         ni="gn_pspace";
  1524.                     endif
  1525.                 else
  1526.                     if bandspacing > 1 then
  1527.                         ni=STR(cursor.BAND_HEIGHT * cursor.BAND_SPACING);
  1528.                     else
  1529.                         if cursor.BAND_HEIGHT > 1 then
  1530.                             ni=STR(cursor.BAND_HEIGHT);
  1531.                         endif
  1532.                     endif
  1533.                 endif
  1534.                 if ni then  }
  1535. IF {ni} < gn_atline - {tb_margin(bandlen2,bandspacing2)}
  1536.    IF gl_widow .AND. _plineno+{ni} > gn_atline + 1
  1537.       EJECT PAGE
  1538. {                      // kjn added number..open
  1539.                     if number_of_open_group_intros &&
  1540.                        number_of_group_intro_each then }
  1541.       gl_intros=.F.
  1542. {                   endif
  1543.                   lmarg(1);  }
  1544.    ENDIF
  1545. ENDIF
  1546. {               endif
  1547.             endif}
  1548. DO Upd_Vars
  1549. {           if number_of_begin_new_pages then   }
  1550. gl_newpage=.F.
  1551. {           endif
  1552.         endif
  1553.         if cursor.Row_Positn then previous_row=cursor.Row_Positn endif;
  1554.     endif
  1555.     return
  1556. enddef
  1557.  
  1558. define text_pitch(pitch_value)
  1559.     var result;
  1560.     case pitch_value of
  1561.     0: result="\"PICA\""
  1562.     1: result="\"ELITE\""
  1563.     2: result="\"CONDENSED\""
  1564.     3: result="\"DEFAULT\""
  1565.     endcase
  1566.     return result
  1567. enddef
  1568.  
  1569. define check4blank(incursor);
  1570. //
  1571. // This function determines whether or not a line is "blankable".
  1572. // A flag is set if the line contains text made up of only spaces
  1573. // or a numeric with a function Z which prints nothing for zero values
  1574. // or a character field.  It is only called for word wrap bands.
  1575. //
  1576.     var blank_line,fld_flag,j,k,previous_row,temp;
  1577.     k=incursor;
  1578.     blank_line=1;
  1579.     fld_flag=0;
  1580.     previous_row=k.Row_Positn;
  1581.  
  1582.     do while !eoc(k);
  1583.       if k.Row_Positn > previous_row then
  1584.         blank_line=fld_flag;
  1585.         exit;
  1586.       endif
  1587.       if blank_line then
  1588.         if k.FLD_VALUE_TYPE == 78 then
  1589.           if not AT("Z",k.FLD_PICFUN) then
  1590.             blank_line=0;
  1591.           else
  1592.             ++fld_flag;
  1593.           endif
  1594.         else
  1595.           if k.Text_Item then
  1596.             j=LEN(k.Text_Item);
  1597.             temp = k.Text_Item;
  1598.             if j == 237 then
  1599.               foreach Text_Item fcursor in k
  1600.                 j=j+LEN(fcursor.Text_Item);
  1601.                 temp = temp + fcursor.Text_Item;
  1602.               next
  1603.             endif
  1604.             if space(j) != temp then
  1605.               blank_line=0;
  1606.             endif
  1607.           else
  1608.             if k.ELEMENT_TYPE == @Fld_Element then
  1609.               if k.FLD_VALUE_TYPE != 67 then
  1610.                 blank_line=0;
  1611.               else
  1612.                 ++fld_flag;
  1613.               endif
  1614.             endif
  1615.           endif
  1616.         endif
  1617.       endif
  1618.       if !blank_line then
  1619.         exit;
  1620.       endif
  1621.       ++k;
  1622.     enddo
  1623.   return blank_line;
  1624. enddef
  1625.  
  1626. define conditional_if_for_blank_line(incursor);
  1627. //
  1628. // A dBASE IF statement is output for lines tested by check4blank()
  1629. // to test whether the printed line will contain only spaces.
  1630. //
  1631.     var field_flag, line_format, item_num, current_row, cursor2;
  1632.        cursor2=incursor;
  1633.        current_row=cursor2.Row_Positn;
  1634.        item_num=1;
  1635. }
  1636. *-- Test for blank line
  1637. PRIVATE tot_length
  1638. tot_length=0
  1639. tot_length=tot_length+LEN(TRIM( \
  1640. {
  1641.        do while !eoc(cursor2) && cursor2.Row_Positn == current_row}
  1642. {        if cursor2.ELEMENT_TYPE == @Fld_element then
  1643.            if field_flag then   }\
  1644. )) \
  1645. {            if line_format then    }
  1646.  
  1647. tot_length=tot_length+\
  1648. {              item_num=1;
  1649.              else
  1650.                if ++item_num <= 16 then   }\
  1651. + ;
  1652. {              else }
  1653.  
  1654. tot_length=tot_length+\
  1655. {                item_num=1;
  1656.                endif
  1657.              endif  }
  1658. LEN(TRIM( \
  1659. {          else
  1660.              field_flag=1;
  1661.            endif
  1662.          endif
  1663.          if cursor2.FLD_VALUE_TYPE == 78 then}
  1664. TRANSFORM(\
  1665. {          line_format = putfld(cursor2);}
  1666. ,"\
  1667. {          if cursor2.FLD_PICFUN then}
  1668. @{cursor2.FLD_PICFUN} \
  1669. {          endif}
  1670. {cursor2.FLD_TEMPLATE}") \
  1671. {//
  1672.          else
  1673.            if cursor2.ELEMENT_TYPE == @Fld_element then
  1674.              line_format = putfld(cursor2);
  1675.            endif
  1676.          endif
  1677.          ++cursor2;
  1678.        enddo}
  1679. ))
  1680. IF tot_length > 0
  1681. {  return 1;
  1682. enddef
  1683.  
  1684. define putfld(cursor);
  1685. //
  1686. // Subfunction of conditional_if_for_blank_line(), this places
  1687. // the individual fields on the same line as the IF statement.
  1688. //
  1689.     var retval,value,value2;
  1690.     retval=0;
  1691.     value=cursor.FLD_FIELDTYPE;
  1692.     case value of
  1693.     Tabl_data:
  1694.         if cursor.FLD_VALUE_TYPE == 77 then }
  1695. MLINE({upper_first(cursor.FLD_FIELDNAME)},1)\
  1696. {       else    }
  1697. {upper_first(cursor.FLD_FIELDNAME)}\
  1698. {       endif
  1699.     Calc_data:  }
  1700. {       if cursor.FLD_FIELDNAME then    }
  1701. {lower(cursor.FLD_FIELDNAME)}\
  1702. {       else
  1703.             foreach FLD_EXPRESSION exp in cursor    }
  1704. {FLD_EXPRESSION}\
  1705. {           next    }
  1706.  ;
  1707. {         retval=1;
  1708.         endif   }
  1709. {   Pred_data:
  1710.         value2=cursor.FLD_PREDEFINE;
  1711.         case value2 of
  1712.         0: // Date  }
  1713. gd_date\
  1714. {       1: // Time  }
  1715. gc_time\
  1716. {       2: // Recno }
  1717. RECNO()\
  1718. {       3: // Pageno}
  1719. _pageno\
  1720. {       endcase }
  1721. {   endcase }
  1722.  \
  1723. {   return retval;
  1724. enddef
  1725.  
  1726. define output_group_calls()
  1727.  
  1728.         if number_of_open_group_intros then }
  1729. *-- Process Group Intro bands during group breaks
  1730. PROCEDURE Grphead
  1731. IF EOF()
  1732.    RETURN
  1733. ENDIF
  1734. PRIVATE _pspacing
  1735. {           if bandspacing then }
  1736. _pspacing={bandspacing}
  1737. {           else    }
  1738. _pspacing=gn_pspace
  1739. {           endif   }
  1740. {       endif
  1741.         if dBASE_III_PLUS == FIRST_GEN
  1742.          && !number_of_open_group_summarys then   }
  1743. IF gn_level > 3
  1744.    ?
  1745. ENDIF
  1746. {       endif
  1747.         if number_of_open_group_intros then }
  1748. IF gn_level = 0
  1749.    gn_level=50
  1750. ENDIF
  1751. {       endif
  1752.         check4widows()
  1753.         if external_define then
  1754.             textopen(rptname+".grp")
  1755.         endif
  1756.         foreach BAND_ELEMENT k
  1757.             case BAND_BANDTYPE of
  1758.             Group_Intro:
  1759.                 if BAND_OPENFLG then    }
  1760. IF gn_level <= {GROUP}{if BAND_INTROEACH then} .OR. gl_intros{endif}
  1761.    DO Head{GROUP}
  1762. ENDIF
  1763. {               endif
  1764.             Detail:
  1765.                 if number_of_open_group_intros then }
  1766. gn_level=0
  1767. RETURN
  1768. * EOP: Grphead.PRG
  1769.  
  1770. {               endif
  1771.                 if number_of_open_group_summarys then   }
  1772. *-- Process Group Summary bands during group breaks
  1773. PROCEDURE Grpfoot
  1774. PARAMETER ln_level
  1775. {               endif
  1776.             Group_Summary:
  1777.                 if external_define then
  1778.                     textspos(0);
  1779.                     temp2=STR(GROUP)+": ";
  1780.                     if (temp = find_string(temp2) ) then }
  1781. IF ln_level >= {GROUP}
  1782. {                       lmarg(4);
  1783.     substr(temp,5)  }
  1784.  
  1785. {                       do while (temp = find_string(temp2) )    }
  1786. {   substr(temp,5)  }
  1787.  
  1788. {                       enddo
  1789.                         lmarg(0);   }
  1790. ENDIF
  1791. {                   endif
  1792.                 endif
  1793.                 if BAND_OPENFLG then    }
  1794. IF ln_level >= {GROUP}
  1795.    DO Foot{GROUP}
  1796. ENDIF
  1797. {               endif
  1798.             Page_Footer:
  1799.                 if number_of_open_group_summarys then   }
  1800. RETURN
  1801. * EOP: Grpfoot.PRG
  1802.  
  1803. {               endif
  1804.                 exit;
  1805.             endcase
  1806.         next k;
  1807.         if external_define then
  1808.             textclose()
  1809.         endif
  1810. enddef
  1811.  
  1812. define find_string(string)
  1813. //
  1814. // Assume the text file is open and rewound.  Matches are
  1815. // done on exact equality.  Returns entire string.
  1816. //
  1817.     var length,retval,temp; length=len(string); retval="";
  1818.  
  1819.     do while ( temp = textgetl() ) != EOF
  1820.         if string == substr(temp,1,length) then
  1821.             retval = temp;
  1822.             exit
  1823.         endif
  1824.     enddo
  1825.  
  1826.     return retval;
  1827. enddef
  1828.  
  1829. define check4widows()
  1830. //
  1831. // Check for possible widow band for group intros (includes detail length)
  1832. //
  1833.     foreach BAND_ELEMENT cursor
  1834.         if cursor.BAND_BANDTYPE == Group_Intro && cursor.BAND_OPENFLG then
  1835. //
  1836.             ni="";
  1837.             if !cursor.BAND_SPACING && !bandspacing then
  1838.                 ni=" * gn_pspace";
  1839.             else
  1840.                 if !cursor.BAND_SPACING && bandspacing > 1 then
  1841.                     ni=" * "+str(bandspacing);
  1842.                 else
  1843.                     if cursor.BAND_SPACING > 1 then
  1844.                         ni=" * "+str(cursor.BAND_SPACING);
  1845.                     endif
  1846.                 endif
  1847.             endif
  1848.             if cursor.BAND_HEIGHT > 1 then
  1849.                 a=str(cursor.BAND_HEIGHT)+ni+" ";
  1850.             else
  1851.                 if ni then
  1852.                     a=substr(ni,4)+" ";
  1853.                 else
  1854.                     a="";
  1855.                 endif
  1856.             endif   }
  1857. IF gn_level = {GROUP}
  1858. {           lmarg(4);
  1859.             if a then   }
  1860. IF {a} < gn_atline
  1861. {               lmarg(7);
  1862.             endif   }
  1863. IF (gl_widow .AND. _plineno+Gheight({cursor.GROUP}) > gn_atline + 1)\
  1864. {           if cursor.BAND_HEIGHT then}
  1865.  ;
  1866. .OR. (gl_widow .AND. _plineno+\
  1867. {               if cursor.BAND_HEIGHT > 1 then}
  1868. {cursor.BAND_HEIGHT}{ni}\
  1869. {               else
  1870.                     if !cursor.BAND_SPACING then
  1871.                         if ni then}
  1872. {SUBSTR(ni,4)}\
  1873. {                       else}
  1874. 1\
  1875. {                       endif
  1876.                     else}
  1877. {cursor.BAND_SPACING}\
  1878. {                   endif
  1879.                 endif}
  1880.  > gn_atline)
  1881. {           else}
  1882.  
  1883. {           endif}
  1884.    EJECT PAGE
  1885. ENDIF
  1886. {           if a then
  1887.                 lmarg(4);   }
  1888. ENDIF
  1889. {           endif
  1890.             lmarg(1);   }
  1891. ENDIF
  1892. {       endif
  1893.     next
  1894.     return
  1895. enddef
  1896.  
  1897. define reinit_page_variables()
  1898. //
  1899. // Summary fields set to Reset every page are assigned starting values.
  1900. //
  1901.     i=0
  1902.     x=0;
  1903.     foreach FLD_ELEMENT k
  1904.         if FLD_SUPPRESS then    }
  1905. r_msrv{++x}={init_not_value(k)}{logical_expression(k)}
  1906. {       endif
  1907.         if FLD_FIELDTYPE == Summ_data then
  1908.             if !FLD_FIELDNAME then
  1909.                 ++i
  1910.             endif
  1911.             if FLD_RESET == Each_Page then
  1912.                 if !FLD_FIELDNAME then
  1913.                     priv_vars="r_msum"+STR(i)
  1914.                 else
  1915.                     priv_vars=lower(FLD_FIELDNAME)
  1916.                 endif
  1917.                 sub_init_summary_vars(k)
  1918.             else
  1919.                 if FLD_OPERATION > SUM_OP then
  1920.                     xxsum = xxsum + 4
  1921.                 else
  1922.                     if FLD_OPERATION == AVERAGE_OP then
  1923.                         xxsum = xxsum + 2
  1924.                     endif
  1925.                 endif
  1926.             endif
  1927.         endif
  1928.     next k;
  1929.     xxsum=0
  1930.     return
  1931. enddef
  1932.  
  1933. define reinit_group_variables()
  1934. //
  1935. // Group break and summary fields are setup for next grouping.
  1936. //
  1937.     i=0
  1938.     x=0
  1939.     foreach FLD_ELEMENT k
  1940. //
  1941. // Summary field and reset on group?
  1942. //
  1943.         if FLD_FIELDTYPE == Summ_data then
  1944.             if !FLD_FIELDNAME then
  1945.                 ++x
  1946.             endif
  1947.             if FLD_RESET > Each_Group then
  1948.                 if i && i != FLD_RESET then
  1949.                     i=0
  1950.                     lmarg(1);   }
  1951. ENDIF
  1952. {               endif
  1953.                 if i != FLD_RESET then    }
  1954. IF gn_level <= {FLD_RESET}
  1955. {                   i=FLD_RESET
  1956.                     lmarg(4)
  1957.                 endif
  1958.                 if !FLD_FIELDNAME then
  1959.                     priv_vars="r_msum"+STR(x)
  1960.                 else
  1961.                     priv_vars=lower(FLD_FIELDNAME)
  1962.                 endif
  1963.                 sub_init_summary_vars(k)
  1964.             else
  1965.                 if FLD_OPERATION > SUM_OP then
  1966.                     xxsum = xxsum + 4
  1967.                 else
  1968.                     if FLD_OPERATION == AVERAGE_OP then
  1969.                         xxsum = xxsum + 2
  1970.                     endif
  1971.                 endif
  1972.             endif
  1973.         endif
  1974.     next k;
  1975.     xxsum=0
  1976.     if i then
  1977.         i=0
  1978.         lmarg(1);   }
  1979. ENDIF
  1980. {   endif
  1981.     foreach BAND_ELEMENT k
  1982.         if BAND_BANDTYPE == Group_Intro then    }
  1983. //
  1984. // Reset Group break vars on group intro bands
  1985. //
  1986. IF gn_level <= {GROUP}
  1987.    r_mvar{GROUP}={group_break_type(k)}
  1988. ENDIF
  1989. {       else
  1990.             if BAND_BANDTYPE > Group_Intro then
  1991.                 exit
  1992.             endif
  1993.         endif
  1994.     next k;
  1995.     return
  1996. enddef
  1997.  
  1998. define update_summary_and_calc_vars()
  1999. //
  2000. // This function is currently based on a calc all scenario.
  2001. // Which means all calculations happen in a left to right and
  2002. // top to bottom based on position in the report design surface.
  2003. //
  2004.     var temp;
  2005.     x=1
  2006.     xsum=0
  2007.     xxsum=0
  2008.     if external_define then
  2009.        textopen(rptname+".grp")
  2010.     endif
  2011.     foreach FLD_ELEMENT k
  2012.         case k.FLD_FIELDTYPE of
  2013. //
  2014. // Initialize named calculated fields for all bands
  2015. //
  2016.         Calc_data:
  2017.             if k.FLD_FIELDNAME && k.GROUP != 3 then}
  2018. {lower(k.FLD_FIELDNAME)}={
  2019.                 foreach FLD_EXPRESSION j in k
  2020.                     j.FLD_EXPRESSION}
  2021. {               next}
  2022.  
  2023. {           endif
  2024. //
  2025. // Summary fields
  2026. //
  2027.         Summ_data:
  2028.             if !FLD_FIELDNAME then
  2029.                 ++xsum
  2030.                 priv_vars="r_msum"+STR(xsum)
  2031.             else
  2032.                 priv_vars=lower(FLD_FIELDNAME);
  2033.             endif
  2034.             if external_define then
  2035.                 textspos(0);
  2036.                 if upd_find_string(priv_vars+"=") then
  2037.                     loop
  2038.                 endif
  2039.             endif
  2040.             case FLD_OPERATION of
  2041.             AVERAGE_OP: }
  2042. *-- Average
  2043. r_sum{++xxsum}=r_sum{xxsum}+1{tabto(40)}&& count
  2044. r_sum{++xxsum}=r_sum{xxsum}+{FLD_SUMFIELD}{tabto(40)}&& sum
  2045. {priv_vars}=r_sum{xxsum}/r_sum{xxsum-1}{tabto(40)}&& average
  2046. {           COUNT_OP:   }
  2047. *-- Count
  2048. {priv_vars}={priv_vars}+1
  2049. {           MAX_OP:     }
  2050. *-- Max
  2051. IF {FLD_SUMFIELD} > {priv_vars}
  2052.    {priv_vars}={FLD_SUMFIELD}
  2053. ENDIF
  2054. {           MIN_OP:     }
  2055. *-- Min
  2056. IF {FLD_SUMFIELD} < {priv_vars}
  2057.    {priv_vars}={FLD_SUMFIELD}
  2058. ENDIF
  2059. {           SUM_OP:     }
  2060. *-- Sum
  2061. {priv_vars}={priv_vars}+{FLD_SUMFIELD}
  2062. {           otherwise: // STD or VAR
  2063.                 if FLD_OPERATION == STD_DEV_OP then  }
  2064. *-- Std deviation
  2065. {               else    }
  2066. *-- Variance
  2067. {               endif   }
  2068. r_sum{++xxsum}=r_sum{xxsum}+{FLD_SUMFIELD}^2\
  2069. {tabto(40)}&& sum of squares
  2070. r_sum{++xxsum}=r_sum{xxsum}+{FLD_SUMFIELD}\
  2071. {tabto(40)}&& sum
  2072. r_sum{++xxsum}=r_sum{xxsum}+1\
  2073. {tabto(40)}&& count
  2074. r_sum{++xxsum}=r_sum{xxsum-2}/r_sum{xxsum-1}\
  2075. {tabto(40)}&& average
  2076. *-- variance
  2077. {priv_vars}=\
  2078. (r_sum{xxsum-3}+r_sum{xxsum-1}*(r_sum{xxsum}^2);
  2079.    -(2*r_sum{xxsum}*r_sum{xxsum-2}))/r_sum{xxsum-1}
  2080. {               if FLD_OPERATION == STD_DEV_OP then  }
  2081. {priv_vars}=SQRT({priv_vars})\
  2082. {tabto(40)}&& std deviation
  2083. {               endif
  2084.             endcase;
  2085.         otherwise:
  2086. //
  2087. // footer fields
  2088. //
  2089. // When a group break occurs the record pointer is positioned
  2090. // on the next group.  Therefore, it is neccessary to capture
  2091. // the values of the previous record into temporary variables.
  2092. //
  2093.             if GROUP > 50 then
  2094.                 retain_previous=0;
  2095.                 case k.FLD_FIELDTYPE of
  2096.                 Tabl_data: retain_previous=1;
  2097.                 Pred_data:
  2098.                         if k.FLD_PREDEFINE == 2 then
  2099.                             retain_previous=1;
  2100.                         endif
  2101.                 endcase
  2102.                 if retain_previous then
  2103.                     case FLD_FIELDTYPE of
  2104.                     Tabl_data:
  2105.                         temp = substr(FLD_FIELDNAME,1,1) +
  2106.                             lower(substr(FLD_FIELDNAME,2))
  2107.                     Pred_data:
  2108.                         temp = "RECNO()"
  2109.                     endcase;}
  2110. r_foot{x}={temp}
  2111. {                   ++x;
  2112.                 endif
  2113.             endif
  2114.         endcase
  2115.     next k;
  2116.     if external_define then
  2117.        textclose()
  2118.     endif
  2119.     xsum=0
  2120.     xxsum=0
  2121.     return
  2122. enddef
  2123.  
  2124. define upd_find_string(string)
  2125. //
  2126. // Assume the text file is open and rewound.  Matches are
  2127. // done on exact equality.  Determines whether string is found.
  2128. //
  2129.     var length,retval,temp; length=len(string); retval="";
  2130.  
  2131.     do while ( temp = textgetl() ) != EOF
  2132.         if string == substr(temp,5,length) then
  2133.             retval = "1";
  2134.             exit
  2135.         endif
  2136.     enddo
  2137.  
  2138.     return retval;
  2139. enddef
  2140.  
  2141. define output_proc_gheight()
  2142.     x=0
  2143.     foreach BAND_ELEMENT k
  2144.         if BAND_BANDTYPE > Group_Intro then
  2145.             exit
  2146.         endif
  2147.         if BAND_BANDTYPE == Group_Intro && BAND_OPENFLG then
  2148.             if !x then  }
  2149.  
  2150. *-- Determine height of group bands and detail band for widow checking
  2151. FUNCTION Gheight
  2152. PARAMETER Group_Band
  2153. retval=0              && return value
  2154. {           endif   }
  2155. IF Group_Band <= {GROUP}
  2156.    retval = retval +\
  2157. {           if BAND_HEIGHT > 1 then }
  2158.  {BAND_HEIGHT}\
  2159. {           endif
  2160.             if !BAND_SPACING && !bandspacing then
  2161.                 if BAND_HEIGHT > 1 then } *{endif}\
  2162.  gn_pspace
  2163. {           else
  2164.                 if !BAND_SPACING && bandspacing > 1 then
  2165.                     if BAND_HEIGHT > 1 then } *{endif}\
  2166.  {bandspacing}
  2167. {               else
  2168.                     if BAND_SPACING > 1 then
  2169.                         if BAND_HEIGHT > 1 then } *{endif}\
  2170.  {BAND_SPACING}
  2171. {                   else
  2172.                         if BAND_HEIGHT < 2 then }
  2173.  {BAND_HEIGHT}\
  2174. {                       endif   }
  2175.  
  2176. {                   endif
  2177.                 endif
  2178.             endif   }
  2179. ENDIF
  2180. {           ++x
  2181.         endif
  2182.     next k;
  2183.     if x then
  2184.         if bandlen50 then   }
  2185. *-- add height of detail band
  2186. retval = retval + \
  2187. {           if !bandspacing then    }
  2188. {               if bandlen50 > 1 then   }
  2189. {bandlen50} * \
  2190. {               endif   }
  2191. gn_pspace
  2192. {           else
  2193.                 if bandspacing > 1 then }
  2194. {bandspacing*bandlen50}
  2195.  
  2196. {               else}
  2197. {bandlen50}
  2198.  
  2199. {               endif
  2200.             endif
  2201.         endif   }
  2202. RETURN retval
  2203. * EOP: Gheight
  2204. {   endif
  2205.     return
  2206. enddef
  2207.  
  2208. define increment_group_by_record_vars()
  2209.     foreach BAND_ELEMENT k
  2210.         if BAND_BANDTYPE == Group_Intro then
  2211. //
  2212. // increment any group by record count vars.
  2213. //
  2214.             if BAND_GROUP_REC then  }
  2215. r_mvar{GROUP}=r_mvar{GROUP}+1
  2216. {           endif
  2217.         else
  2218.             if BAND_BANDTYPE > Group_Intro then
  2219.                 exit
  2220.             endif
  2221.         endif
  2222.     next k;
  2223.     return
  2224. enddef
  2225.  
  2226. define tb_margin(bandhgt,bandspc)
  2227.     var retval;
  2228. // Band set to default spacing
  2229.     if !bandspc then
  2230.  
  2231. // Detail band set to default
  2232.         if !bandspacing then
  2233.  
  2234. // Band height greater than 1
  2235.             if bandhgt > 1 then
  2236.                 retval="(_pspacing * "+STR(bandhgt)+" + 1)"
  2237.             else
  2238.                 if bandhgt then
  2239.                     retval="(_pspacing + 1)"
  2240.                 else
  2241.                     retval=1
  2242.                 endif
  2243.             endif
  2244.  
  2245. // Detail band is not default
  2246.         else
  2247.             retval=bandspacing * bandhgt +1
  2248.         endif
  2249.  
  2250. // Band is not default
  2251.     else
  2252.         retval=bandspc * bandhgt +1
  2253.     endif
  2254.     return retval
  2255. enddef
  2256.  
  2257. define build_case_statement()
  2258.     foreach BAND_ELEMENT k
  2259.         if BAND_BANDTYPE == Group_Intro then
  2260. //
  2261. // Group by field
  2262. //
  2263.             if BAND_GFIELD then }
  2264. CASE \
  2265. {               if at(">",BAND_GFIELD) then // Check for ALIAS
  2266. substr(BAND_GFIELD,at(">",BAND_GFIELD)+1)   }
  2267. {               else
  2268. BAND_GFIELD }
  2269. {               endif   }
  2270.  <> r_mvar{GROUP}
  2271. {           endif
  2272. //
  2273. // Group by expression
  2274. //
  2275.             if BAND_EXPRESSION then }
  2276. CASE (\
  2277. {               foreach BAND_EXPRESSION fcursor in k
  2278. BAND_EXPRESSION }
  2279. {               next    }
  2280. ) <> r_mvar{GROUP}
  2281. {           endif
  2282. //
  2283. // Group by record count
  2284. //
  2285.             if BAND_GROUP_REC then  }
  2286. CASE r_mvar{GROUP} > {BAND_GROUP_REC}
  2287. {           endif   }
  2288.    gn_level={GROUP}
  2289. {       endif
  2290.     next k;
  2291.     return
  2292. enddef
  2293.  
  2294. define init_group_footer_vars()
  2295.     x=0
  2296.     if number_of_group_footer_fields then
  2297.         x=1;    }
  2298. *-- Initialize group footer field variables
  2299. {       do while x <= number_of_group_footer_fields }
  2300. r_foot{x}=.F.
  2301. {           ++x;
  2302.         enddo   }
  2303.  
  2304. {   endif
  2305.     return
  2306. enddef
  2307.  
  2308. define init_calculated_vars()
  2309. //
  2310. // Initialize calculated fields.  This is neccesary since summary,
  2311. // calculated or group break variables might reference the field.
  2312. //
  2313.     x=0
  2314.     foreach FLD_ELEMENT k
  2315. //
  2316. // Reset Summary (on page) and Suppress repeated values
  2317. //
  2318.         if FLD_FIELDTYPE == Summ_data && FLD_RESET == 1 then
  2319.             ++number_of_reset_on_page
  2320.         endif
  2321.         if FLD_SUPPRESS then
  2322.             ++number_of_fld_suppress
  2323.         endif
  2324. //
  2325. // only if there is a fieldname assigned to the calculated field
  2326. //
  2327.         if FLD_FIELDTYPE == Calc_data && FLD_FIELDNAME then
  2328.             if !x then  }
  2329. *-- Initialize calculated variables.
  2330. {           endif
  2331. lower(FLD_FIELDNAME)}={get_init_val(FLD_VALUE_TYPE)}
  2332. {           ++x
  2333.         endif
  2334.     next k;
  2335.     return
  2336. enddef
  2337.  
  2338. define get_init_val(valtype)
  2339. //
  2340. // Called by init_calculated_vars()
  2341. //
  2342.     var result;
  2343.     case valtype of
  2344.     DATE_TYPE: result="CTOD(\"  /  /  \")"
  2345.     FLOAT_TYPE: result="FLOAT(0)"
  2346.     LOGICAL_TYPE: result=".F."
  2347.     NUMERIC_TYPE: result="0"
  2348.     otherwise: result="\"\""
  2349.     endcase
  2350.     return result
  2351. enddef
  2352.  
  2353. define init_group_break_vars()
  2354.     x=1  // to obtain number of group bands
  2355.     number_of_open_group_intros=0
  2356.  
  2357.     foreach BAND_ELEMENT k
  2358.         if BAND_BANDTYPE == Group_Intro then
  2359.             if x == 1 then  }
  2360. *-- Initialize group break vars.
  2361. {           endif
  2362.             if BAND_OPENFLG then
  2363.                 ++number_of_open_group_intros
  2364.             endif;  }
  2365. //
  2366. r_mvar{GROUP}={group_break_type(k)}
  2367. {           ++x
  2368.         endif
  2369.         if BAND_BANDTYPE == Detail then
  2370.             exit
  2371.         endif
  2372.     next k;
  2373.     maxgrp=x+2
  2374.     if x > 1 then   }
  2375.  
  2376. {   endif
  2377.     return
  2378. enddef
  2379.  
  2380. define group_break_type(cursor)
  2381. //
  2382. // Depending on type of group break e.g. Expression, Field or Record count
  2383. // assign the beginning value to the group break variable.
  2384. //
  2385.     var result;
  2386.     case cursor.BAND_GROUPTYPE of
  2387.     1: // by field
  2388.         if at(">",cursor.BAND_GFIELD) then  // Check for ALIAS
  2389.             result = substr(cursor.BAND_GFIELD,at(">",cursor.BAND_GFIELD)+1)
  2390.         else
  2391.             result = cursor.BAND_GFIELD
  2392.         endif
  2393.     3: // by record count
  2394.         result = "1"
  2395.     otherwise: // by expression
  2396.         foreach BAND_EXPRESSION j in cursor
  2397.             result = result + j.BAND_EXPRESSION
  2398.         next
  2399.     endcase
  2400.     return result
  2401. enddef
  2402.  
  2403. define init_summary_vars()
  2404. //
  2405. // Initialize summary fields, similar to calculated fields, it is
  2406. // necessary to assign "unrelated" starting values to these fields.
  2407. //
  2408.     x=0
  2409.     foreach FLD_ELEMENT k
  2410.         if FLD_FIELDTYPE == Summ_data then
  2411.             if !x then  }
  2412. *-- Initialize summary variables.
  2413. {           endif
  2414.             ++x
  2415.             if !FLD_FIELDNAME then
  2416.                 ++xsum
  2417.                 priv_vars="r_msum"+STR(xsum)
  2418.             else
  2419.                 priv_vars=lower(FLD_FIELDNAME)
  2420.             endif
  2421.             sub_init_summary_vars(k)
  2422.         endif
  2423.     next k;
  2424.     xsum=0
  2425.     xxsum=0
  2426.     if x then  }
  2427.  
  2428. {   endif
  2429.     return
  2430. enddef
  2431.  
  2432. define sub_init_summary_vars(cursor)
  2433. //
  2434. // Called by init_summary_vars() and reinit_group/page_variables()
  2435. // Set summary variables to starting values for next grouping.
  2436. //
  2437.     if cursor.FLD_OPERATION > SUM_OP then   }
  2438. STORE 0 TO r_sum{++xxsum},r_sum{++xxsum},\
  2439. r_sum{++xxsum},r_sum{++xxsum},{priv_vars}
  2440. {   else
  2441.         case cursor.FLD_OPERATION of
  2442.         AVERAGE_OP: }
  2443. STORE 0 TO r_sum{++xxsum},r_sum{++xxsum},{priv_vars}
  2444. {       COUNT_OP:   }
  2445. {priv_vars}=0
  2446. {       otherwise: // Min, Max or Sum
  2447.             if cursor.FLD_OPERATION == MIN_OP ||
  2448.                cursor.FLD_OPERATION == MAX_OP then
  2449.                 // ptr 63167 added MAX_OP}
  2450. {priv_vars}={cursor.FLD_SUMFIELD}
  2451. {           else    }
  2452. {priv_vars}=0
  2453. {           endif
  2454.         endcase
  2455.     endif
  2456.     return
  2457. enddef
  2458.  
  2459. define init_suppress_repeated_value_vars()
  2460.     x=0  // to offset each suppress repeated value variable
  2461. //
  2462.     foreach FLD_ELEMENT k
  2463. //
  2464. // suppress repeated values?
  2465. //
  2466.         if FLD_SUPPRESS then
  2467.             if !x then  }
  2468. *-- Initialize suppress repeated value variables.
  2469. {           endif   }
  2470. r_msrv{++x}={init_not_value(k)}{logical_expression(k)}
  2471. {       endif
  2472.     next k;
  2473.     if x then   }
  2474.  
  2475. {   endif
  2476.     return
  2477. enddef
  2478.  
  2479. define init_not_value(elk)
  2480. //
  2481. // Used assign a reverse value to suppress repeated value variables.
  2482. // Needed to print the first in the list of suppresed values.
  2483. //
  2484.     var result;
  2485.     case elk.FLD_VALUE_TYPE of
  2486.     DATE_TYPE: result ="CTOD(\"  /  /  \")"
  2487.     FLOAT_TYPE: result="FLOAT(0)"
  2488.     LOGICAL_TYPE: result=".NOT. "
  2489.     NUMERIC_TYPE: result="0"
  2490.     otherwise: result="\"\""
  2491.     endcase
  2492.     return result
  2493. enddef
  2494.  
  2495. define logical_expression(elk)
  2496. //
  2497. // If suppressed variable is of logical type the expression is returned
  2498. //
  2499.     var result;
  2500.     if elk.FLD_VALUE_TYPE != LOGICAL_TYPE then return "" endif
  2501.     if elk.FLD_FIELDNAME then
  2502.         if FLD_FIELDTYPE == Tabl_data then
  2503.             result=upper_first(elk.FLD_FIELDNAME)
  2504.         else
  2505.             result=lower(elk.FLD_FIELDNAME)
  2506.         endif
  2507.     else
  2508.         result=extend(elk,@FLD_EXPRESSION)
  2509.     endif
  2510.     return result
  2511. enddef
  2512.  
  2513. define assign_calculated_vars()
  2514. //
  2515. // Now the starting values for calculated fields are assigned.
  2516. // It could be a table, calculated or summary field (or any combination).
  2517. //
  2518.     x=0
  2519.     foreach FLD_ELEMENT k
  2520. //
  2521. // only if there is a fieldname assigned to the calculated field
  2522. //
  2523.         if FLD_FIELDTYPE == Calc_data && FLD_FIELDNAME then
  2524.             if !x then  }
  2525. *-- Assign initial values to calculated variables.
  2526. {           endif}
  2527. {lower(FLD_FIELDNAME)}={
  2528.                 foreach FLD_EXPRESSION j in k
  2529.                     j.FLD_EXPRESSION}
  2530. {               next}
  2531.  
  2532. {           ++x
  2533.         endif
  2534.     next k;
  2535.     if x then   }
  2536.  
  2537. {   endif
  2538.     return
  2539. enddef
  2540.  
  2541. define assign_summary_vars()
  2542. //
  2543. // This is synonymous with assign_calculated_vars.
  2544. //
  2545.     x=0
  2546.     foreach FLD_ELEMENT k
  2547.         if FLD_FIELDTYPE == Summ_data then
  2548.             if !FLD_FIELDNAME then
  2549.                 ++xsum
  2550.             endif
  2551.             if FLD_OPERATION == MAX_OP || FLD_OPERATION == MIN_OP then
  2552.                 if !x then  }
  2553. *-- Initialize min/max summary variables again,
  2554. *-- in case it's based on a calculated field.
  2555. {               endif
  2556.                 ++x
  2557.                 if !FLD_FIELDNAME then
  2558.                     priv_vars="r_msum"+STR(xsum)
  2559.                 else
  2560.                     priv_vars=lower(FLD_FIELDNAME)
  2561.                 endif;  }
  2562. {priv_vars}={FLD_SUMFIELD}
  2563. {           endif
  2564.         endif
  2565.     next k;
  2566.     xsum=0
  2567.     if x then   }
  2568.  
  2569. {   endif
  2570.     return
  2571. enddef
  2572.  
  2573. define finish_page_footer()
  2574. //
  2575. // Complete the bottom portion of the Page Footer band
  2576. //
  2577.     if suppress_line then
  2578.         suppress_line=0
  2579.         lmarg(1);   }
  2580. ENDIF
  2581. {   endif
  2582.     if isopen && bandhgt+1 then
  2583.       lmarg(1);  }
  2584. ENDIF
  2585. {   endif
  2586.     if demo_version then    }
  2587. ? "{demo_string}" FUNCTION "IV"+LTRIM(STR(_rmargin-_lmargin))
  2588. {   endif   }
  2589. EJECT PAGE
  2590. {   if number_of_group_intro_each then }
  2591. gl_intros=.T.
  2592. {   endif   }
  2593. {   if number_of_begin_new_pages then   }
  2594. gl_newpage=.T.
  2595. {   endif   }
  2596. *-- is the page number greater than the ending page
  2597. IF _pageno > _pepage
  2598.    GOTO BOTTOM
  2599.    SKIP
  2600.    gn_level=0
  2601. ENDIF
  2602. {   if number_of_reset_on_page || number_of_fld_suppress then   }
  2603. IF gl_fandl
  2604.    DO Pageinit
  2605. ENDIF
  2606. {   endif
  2607.     if has_headers() then
  2608.         if bandspacing then
  2609.             temp = bandspacing
  2610.         else
  2611.             temp = "gn_pspace"
  2612.         endif;  }
  2613. IF .NOT. gl_plain .AND. gl_fandl
  2614.    _pspacing={temp}
  2615.    DO Pghead
  2616. {     if number_of_group_intro_each then }
  2617.    IF gl_intros .AND. gn_level = 0
  2618.      DO GrpHead
  2619.      gl_newpage = .F.
  2620.      gl_intros = .F.
  2621.    ENDIF
  2622. {     endif   }
  2623. ENDIF
  2624. {   endif   }
  2625. RETURN
  2626. * EOP: Pgfoot
  2627. {   return
  2628. enddef
  2629.  
  2630. define has_headers()
  2631.     if is_page_header_open
  2632.      || (is_rintro_open && FRAME_PAGEHEADINGS)
  2633.      || number_of_open_group_intros then
  2634.         return 1
  2635.     else
  2636.         return 0
  2637.     endif
  2638. enddef
  2639.  
  2640. define pre_pass()
  2641. //
  2642. // Two passes are made thru the fields.  The first pass outputs a
  2643. // list of calculated fields to be used for lookup.  The next pass
  2644. // examines the "field to summarize on" attribute of summary fields
  2645. // and makes a list of those which reference the calc. fields.
  2646. //
  2647.     var xsum,xxsum,subgroup;
  2648.     external_define=0
  2649.     xsum=0
  2650.     xxsum=0
  2651.     number_of_group_calc_fields=0;
  2652.  
  2653.     create(rptname+".ord");
  2654.  
  2655.     foreach FLD_ELEMENT k
  2656.         if k.FLD_FIELDNAME && k.FLD_FIELDTYPE == Calc_data
  2657.         && k.GROUP > 3 && k.GROUP != 50 && k.GROUP < 97 then }
  2658. {k.FLD_FIELDNAME} = {if k.GROUP > 50 then k.GROUP else 100-k.GROUP endif}
  2659. {           ++number_of_group_calc_fields;
  2660.         endif
  2661.     next
  2662.     if number_of_group_calc_fields then
  2663.         create(rptname+".grp");
  2664.         textopen(rptname+".ord");
  2665.  
  2666.         foreach FLD_ELEMENT k
  2667.             if k.FLD_FIELDTYPE == Summ_data then
  2668.                 textspos(0);
  2669.                 if not ( subgroup=
  2670.                   pre_pass_find_string(k.FLD_SUMFIELD+" = ") ) then
  2671.                     subgroup = 50;
  2672.                 endif
  2673.                 if k.FLD_FIELDNAME then
  2674.                     priv_vars=lower(k.FLD_FIELDNAME);
  2675.                 else
  2676.                     ++xsum
  2677.                     priv_vars="r_msum"+STR(xsum);
  2678.                 endif
  2679.                 if subgroup != 50 then
  2680.                     if !external_define then
  2681.                         external_define=1;
  2682.                     endif
  2683.                     pre_pass_summary_field(k,subgroup);
  2684.                 endif
  2685.             endif
  2686.         next
  2687.  
  2688.         textclose();
  2689.     endif
  2690.     append(rptname+".FRG");
  2691.     fileerase(rptname+".ord");
  2692.     if not external_define then
  2693.         fileerase(rptname+".grp");
  2694.     endif
  2695.     return;
  2696. enddef
  2697.  
  2698. define pre_pass_find_string(string)
  2699. //
  2700. // Assume the text file is open and rewound.  Matches are
  2701. // done on exact equality, returns the right portion of the string.
  2702. //
  2703.     var length,retval,temp; length=len(string); retval="";
  2704.  
  2705.     do while ( temp = textgetl() ) != EOF
  2706.         if string == substr(temp,1,length) then
  2707.             retval = substr(temp,length+1);
  2708.             exit
  2709.         endif
  2710.     enddo
  2711.  
  2712.     return retval;
  2713. enddef
  2714.  
  2715. define pre_pass_summary_field(cursor,subgroup)
  2716. //
  2717. // Output a statement for the summary calculation to be included later.
  2718. //
  2719.     case cursor.FLD_OPERATION of
  2720.     AVERAGE_OP: }
  2721. {subgroup}: *-- Average
  2722. {subgroup}: r_sum{++xxsum}=r_sum{xxsum}+1{tabto(40)}&& count
  2723. {subgroup}: r_sum{++xxsum}=r_sum{xxsum}+{cursor.FLD_SUMFIELD}{tabto(40)}&& sum
  2724. {subgroup}: {priv_vars}=r_sum{xxsum}/r_sum{xxsum-1}{tabto(40)}&& average
  2725. {   COUNT_OP:   }
  2726. {subgroup}: *-- Count
  2727. {subgroup}: {priv_vars}={priv_vars}+1
  2728. {   MAX_OP:     }
  2729. {subgroup}: *-- Max
  2730. {subgroup}: IF {cursor.FLD_SUMFIELD} > {priv_vars}
  2731. {subgroup}:    {priv_vars}={cursor.FLD_SUMFIELD}
  2732. {subgroup}: ENDIF
  2733. {   MIN_OP:     }
  2734. {subgroup}: *-- Min
  2735. {subgroup}: IF {cursor.FLD_SUMFIELD} < {priv_vars}
  2736. {subgroup}:    {priv_vars}={cursor.FLD_SUMFIELD}
  2737. {subgroup}: ENDIF
  2738. {   SUM_OP:     }
  2739. {subgroup}: *-- Sum
  2740. {subgroup}: {priv_vars}={priv_vars}+{cursor.FLD_SUMFIELD}
  2741. {   otherwise: // STD or VAR
  2742.         if cursor.FLD_OPERATION == STD_DEV_OP then  }
  2743. {subgroup}: *-- Std deviation
  2744. {       else    }
  2745. {subgroup}: *-- Variance
  2746. {       endif   }
  2747. {subgroup}: r_sum{++xxsum}=r_sum{xxsum}+{cursor.FLD_SUMFIELD}^2\
  2748. {tabto(40)}&& sum of squares
  2749. {subgroup}: r_sum{++xxsum}=r_sum{xxsum}+{cursor.FLD_SUMFIELD}\
  2750. {tabto(40)}&& sum
  2751. {subgroup}: r_sum{++xxsum}=r_sum{xxsum}+1\
  2752. {tabto(40)}&& count
  2753. {subgroup}: r_sum{++xxsum}=r_sum{xxsum-2}/r_sum{xxsum-1}\
  2754. {tabto(40)}&& average
  2755. {subgroup}: *-- variance
  2756. {subgroup}: {priv_vars}=(r_sum{xxsum-3}+r_sum{xxsum-1}*(r_sum{xxsum}^2);
  2757. {subgroup}:    -(2*r_sum{xxsum}*r_sum{xxsum-2}))/r_sum{xxsum-1}
  2758. {       if cursor.FLD_OPERATION == STD_DEV_OP then  }
  2759. {subgroup}: {priv_vars}=SQRT({priv_vars})\
  2760. {tabto(40)}&& std deviation
  2761. {       endif
  2762.     endcase;
  2763. enddef
  2764.  
  2765. define report_setup()
  2766. var cursor, ntemp;
  2767.     foreach BAND_ELEMENT cursor
  2768.  
  2769.         if BAND_BANDEDIT then
  2770.             ++number_of_word_wrap_bands;
  2771.         endif
  2772.  
  2773.         if BAND_NEWPAGE then
  2774.             ++number_of_begin_new_pages;
  2775.         endif
  2776.  
  2777.         case BAND_BANDTYPE of
  2778.         Report_Intro:
  2779.             isrepo=1;
  2780.             if BAND_OPENFLG then
  2781.                 is_rintro_open = 1;
  2782.             endif
  2783.  
  2784.         Page_Header:
  2785.             if BAND_OPENFLG then
  2786.                 is_page_header_open = 1;
  2787.                 bandlen2=BAND_HEIGHT;
  2788.                 if BAND_SPACING then
  2789.                     bandspacing2=BAND_SPACING;
  2790.                 endif
  2791.             else
  2792.                 bandspacing2=1;
  2793.             endif
  2794.  
  2795.         Group_Intro:
  2796.             if dBASE_III_PLUS == FIRST_GEN then
  2797.                 if GROUP == 4 then
  2798.                     intro_band_one_height = BAND_HEIGHT;
  2799.                 endif
  2800.                 if GROUP == 5 then
  2801.                     intro_band_two_height = BAND_HEIGHT;
  2802.                 endif
  2803.             endif
  2804.             if BAND_INTROEACH then
  2805.                 ++number_of_group_intro_each;
  2806.             endif
  2807.  
  2808.         Detail:
  2809.             if BAND_OPENFLG then
  2810.                 bandlen50=BAND_HEIGHT;
  2811.             endif
  2812.             if BAND_SPACING then
  2813.                 bandspacing=BAND_SPACING;
  2814.             endif
  2815.  
  2816.         Group_Summary:
  2817.             if BAND_OPENFLG then
  2818.                 ++number_of_open_group_summarys;
  2819.             endif
  2820.  
  2821.         Page_Footer:
  2822.             if BAND_OPENFLG then
  2823.                 bandlen98=BAND_HEIGHT;
  2824.                 if BAND_SPACING then
  2825.                     bandspacing98=BAND_SPACING;
  2826.                 endif
  2827.             else
  2828.                 bandspacing98=1;
  2829.             endif
  2830.  
  2831.         Report_Summary:
  2832.             if BAND_OPENFLG then
  2833.                 is_rsumm_open = 1;
  2834.             endif
  2835.         endcase
  2836.     next
  2837.     if demo_version then
  2838.         ++bandlen98;
  2839.     endif
  2840.  
  2841.     if number_of_open_group_summarys || is_rsumm_open || bandlen98 then
  2842.         foreach FLD_ELEMENT cursor
  2843.             if GROUP > 50 then
  2844.                 retain_previous=0;
  2845.                 case cursor.FLD_FIELDTYPE of
  2846.                 Tabl_data: retain_previous=1;
  2847.                 Pred_data:
  2848.                         if cursor.FLD_PREDEFINE == 2 then
  2849.                             retain_previous=1;
  2850.                         endif
  2851.                 endcase
  2852.                 if retain_previous then
  2853.                     ++number_of_group_footer_fields;
  2854.                 endif
  2855.             endif
  2856.         next
  2857.     endif
  2858.     cursor = makec(@ELEMENT);
  2859.     ntemp = 1;
  2860.     do while ntemp
  2861.         if cursor.ELEMENT_TYPE == @Band_Element
  2862.          && cursor.BAND_BANDTYPE == Page_header then
  2863.             ntemp = 0;
  2864.         else
  2865.             ++cursor;
  2866.         endif
  2867.     enddo
  2868.     ntemp = ((!cursor.Row_Positn) ? 0 : cursor.Row_Positn)+2;
  2869.     ++cursor;
  2870.     do while cursor.Row_Positn <= ntemp
  2871.         if cursor.Row_Positn == ntemp then
  2872.             line_one_length = ((!cursor.Col_Positn) ? 0 : cursor.Col_Positn);
  2873.             case cursor.ELEMENT_TYPE of
  2874.             @Text_Element:
  2875.                 foreach Text_Item tcursor in cursor
  2876.                     line_one_length += len(Text_Item);
  2877.                 next
  2878.             @Fld_Element:
  2879.                 line_one_length += cursor.FLD_REPWIDTH;
  2880.             @Box_Element:
  2881.                 line_one_length +=
  2882.                  ((!cursor.BOX_LEFT) ? 0 : cursor.BOX_LEFT)
  2883.                  + cursor.BOX_WIDTH-1;
  2884.             endcase
  2885.         else
  2886.             exit
  2887.         endif
  2888.         ++cursor;
  2889.     enddo
  2890.     if line_one_length then
  2891.         ++line_one_length;
  2892.     endif
  2893.     return;
  2894. enddef
  2895.  
  2896. // EOP: REPORT.COD
  2897.  
  2898.