home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 April / CMCD0404.ISO / Software / Freeware / Programare / dotproject / lib / ezpdf / class.ezpdf.php next >
PHP Script  |  2004-01-29  |  57KB  |  1,579 lines
  1. <?php
  2. /*
  3. * Description:    Functions for generating PDF reports
  4. *
  5. * Author:        Wayne Munro, R&OS Ltd, http://www.ros.co.nz/pdf
  6. *
  7. * Updated by:    Paul A. Harouff, P.E. <pharouff@jvpengineers.com>
  8. *
  9. * Date:            2003/08/09
  10. *
  11. * License:        GPL
  12. *
  13. * CHANGE LOG
  14. *
  15. * version 009.1
  16. * - In function ezTable, changed $options['options'] to $options['col_options'] and
  17. *     corrected lines where incorrectly referenced as $options['cols']. Corrected
  18. *     documentation where incorrectly stated to pass column names in array.
  19. *     ezTable assumes column names are 0, 1, 2 ... for maxWidth calculations.
  20. *
  21. *
  22. * TO DO LIST
  23. *
  24. *
  25. */
  26. require_once( $AppUI->getLibraryClass( 'ezpdf/class.pdf') );
  27.  
  28. class Cezpdf extends Cpdf {
  29. //==============================================================================
  30. // this class will take the basic interaction facilities of the Cpdf class
  31. // and make more useful functions so that the user does not have to 
  32. // know all the ins and outs of pdf presentation to produce something pretty.
  33. //
  34. // IMPORTANT NOTE
  35. // there is no warranty, implied or otherwise with this software.
  36. // 
  37. // version 009 (versioning is linked to class.pdf.php)
  38. //
  39. // released under a public domain licence.
  40. //
  41. // Wayne Munro, R&OS Ltd, http://www.ros.co.nz/pdf
  42. //==============================================================================
  43.  
  44. var $ez=array('fontSize'=>10); // used for storing most of the page configuration parameters
  45. var $y; // this is the current vertical positon on the page of the writing point, very important
  46. var $ezPages=array(); // keep an array of the ids of the pages, making it easy to go back and add page numbers etc.
  47. var $ezPageCount=0;
  48.  
  49. // ------------------------------------------------------------------------------
  50.  
  51. function Cezpdf($paper='a4',$orientation='portrait'){
  52.     // Assuming that people don't want to specify the paper size using the absolute coordinates
  53.     // allow a couple of options:
  54.     // orientation can be 'portrait' or 'landscape'
  55.     // or, to actually set the coordinates, then pass an array in as the first parameter.
  56.     // the defaults are as shown.
  57.     // 
  58.     // -------------------------
  59.     // 2002-07-24 - Nicola Asuni (info@tecnick.com):
  60.     // Added new page formats (45 standard ISO paper formats and 4 american common formats)
  61.     // paper cordinates are calculated in this way: (inches * 72) where 1 inch = 2.54 cm
  62.     // 
  63.     // Now you may also pass a 2 values array containing the page width and height in centimeters
  64.     // -------------------------
  65.  
  66.     if (!is_array($paper)){
  67.         switch (strtoupper($paper)){
  68.             case '4A0': {$size = array(0,0,4767.87,6740.79); break;}
  69.             case '2A0': {$size = array(0,0,3370.39,4767.87); break;}
  70.             case 'A0': {$size = array(0,0,2383.94,3370.39); break;}
  71.             case 'A1': {$size = array(0,0,1683.78,2383.94); break;}
  72.             case 'A2': {$size = array(0,0,1190.55,1683.78); break;}
  73.             case 'A3': {$size = array(0,0,841.89,1190.55); break;}
  74.             case 'A4': default: {$size = array(0,0,595.28,841.89); break;}
  75.             case 'A5': {$size = array(0,0,419.53,595.28); break;}
  76.             case 'A6': {$size = array(0,0,297.64,419.53); break;}
  77.             case 'A7': {$size = array(0,0,209.76,297.64); break;}
  78.             case 'A8': {$size = array(0,0,147.40,209.76); break;}
  79.             case 'A9': {$size = array(0,0,104.88,147.40); break;}
  80.             case 'A10': {$size = array(0,0,73.70,104.88); break;}
  81.             case 'B0': {$size = array(0,0,2834.65,4008.19); break;}
  82.             case 'B1': {$size = array(0,0,2004.09,2834.65); break;}
  83.             case 'B2': {$size = array(0,0,1417.32,2004.09); break;}
  84.             case 'B3': {$size = array(0,0,1000.63,1417.32); break;}
  85.             case 'B4': {$size = array(0,0,708.66,1000.63); break;}
  86.             case 'B5': {$size = array(0,0,498.90,708.66); break;}
  87.             case 'B6': {$size = array(0,0,354.33,498.90); break;}
  88.             case 'B7': {$size = array(0,0,249.45,354.33); break;}
  89.             case 'B8': {$size = array(0,0,175.75,249.45); break;}
  90.             case 'B9': {$size = array(0,0,124.72,175.75); break;}
  91.             case 'B10': {$size = array(0,0,87.87,124.72); break;}
  92.             case 'C0': {$size = array(0,0,2599.37,3676.54); break;}
  93.             case 'C1': {$size = array(0,0,1836.85,2599.37); break;}
  94.             case 'C2': {$size = array(0,0,1298.27,1836.85); break;}
  95.             case 'C3': {$size = array(0,0,918.43,1298.27); break;}
  96.             case 'C4': {$size = array(0,0,649.13,918.43); break;}
  97.             case 'C5': {$size = array(0,0,459.21,649.13); break;}
  98.             case 'C6': {$size = array(0,0,323.15,459.21); break;}
  99.             case 'C7': {$size = array(0,0,229.61,323.15); break;}
  100.             case 'C8': {$size = array(0,0,161.57,229.61); break;}
  101.             case 'C9': {$size = array(0,0,113.39,161.57); break;}
  102.             case 'C10': {$size = array(0,0,79.37,113.39); break;}
  103.             case 'RA0': {$size = array(0,0,2437.80,3458.27); break;}
  104.             case 'RA1': {$size = array(0,0,1729.13,2437.80); break;}
  105.             case 'RA2': {$size = array(0,0,1218.90,1729.13); break;}
  106.             case 'RA3': {$size = array(0,0,864.57,1218.90); break;}
  107.             case 'RA4': {$size = array(0,0,609.45,864.57); break;}
  108.             case 'SRA0': {$size = array(0,0,2551.18,3628.35); break;}
  109.             case 'SRA1': {$size = array(0,0,1814.17,2551.18); break;}
  110.             case 'SRA2': {$size = array(0,0,1275.59,1814.17); break;}
  111.             case 'SRA3': {$size = array(0,0,907.09,1275.59); break;}
  112.             case 'SRA4': {$size = array(0,0,637.80,907.09); break;}
  113.             case 'LETTER': {$size = array(0,0,612.00,792.00); break;}
  114.             case 'LEGAL': {$size = array(0,0,612.00,1008.00); break;}
  115.             case 'EXECUTIVE': {$size = array(0,0,521.86,756.00); break;}
  116.             case 'FOLIO': {$size = array(0,0,612.00,936.00); break;}
  117.         }
  118.         switch (strtolower($orientation)){
  119.             case 'landscape':
  120.                 $a=$size[3];
  121.                 $size[3]=$size[2];
  122.                 $size[2]=$a;
  123.                 break;
  124.         }
  125.     } else {
  126.         if (count($paper)>2) {
  127.             // then an array was sent it to set the size
  128.             $size = $paper;
  129.         }
  130.         else { //size in centimeters has been passed
  131.             $size[0] = 0;
  132.             $size[1] = 0;
  133.             $size[2] = ( $paper[0] / 2.54 ) * 72;
  134.             $size[3] = ( $paper[1] / 2.54 ) * 72;
  135.         }
  136.     }
  137.     $this->Cpdf($size);
  138.     $this->ez['pageWidth']=$size[2];
  139.     $this->ez['pageHeight']=$size[3];
  140.     
  141.     // also set the margins to some reasonable defaults
  142.     $this->ez['topMargin']=30;
  143.     $this->ez['bottomMargin']=30;
  144.     $this->ez['leftMargin']=30;
  145.     $this->ez['rightMargin']=30;
  146.     
  147.     // set the current writing position to the top of the first page
  148.     $this->y = $this->ez['pageHeight']-$this->ez['topMargin'];
  149.     // and get the ID of the page that was created during the instancing process.
  150.     $this->ezPages[1]=$this->getFirstPageId();
  151.     $this->ezPageCount=1;
  152. }
  153.  
  154. // ------------------------------------------------------------------------------
  155. // 2002-07-24: Nicola Asuni (info@tecnick.com)
  156. // Set Margins in centimeters
  157. function ezSetCmMargins($top,$bottom,$left,$right){
  158.     $top = ( $top / 2.54 ) * 72;
  159.     $bottom = ( $bottom / 2.54 ) * 72;
  160.     $left = ( $left / 2.54 ) * 72;
  161.     $right = ( $right / 2.54 ) * 72;
  162.     $this->ezSetMargins($top,$bottom,$left,$right);
  163. }
  164. // ------------------------------------------------------------------------------
  165.  
  166.  
  167. function ezColumnsStart($options=array()){
  168.   // start from the current y-position, make the set number of columne
  169.   if (isset($this->ez['columns']) && $this->ez['columns']==1){
  170.     // if we are already in a column mode then just return.
  171.     return;
  172.   }
  173.   $def=array('gap'=>10,'num'=>2);
  174.   foreach($def as $k=>$v){
  175.     if (!isset($options[$k])){
  176.       $options[$k]=$v;
  177.     }
  178.   }
  179.   // setup the columns
  180.   $this->ez['columns']=array('on'=>1,'colNum'=>1);
  181.  
  182.   // store the current margins
  183.   $this->ez['columns']['margins']=array(
  184.      $this->ez['leftMargin']
  185.     ,$this->ez['rightMargin']
  186.     ,$this->ez['topMargin']
  187.     ,$this->ez['bottomMargin']
  188.   );
  189.   // and store the settings for the columns
  190.   $this->ez['columns']['options']=$options;
  191.   // then reset the margins to suit the new columns
  192.   // safe enough to assume the first column here, but start from the current y-position
  193.   $this->ez['topMargin']=$this->ez['pageHeight']-$this->y;
  194.   $width=($this->ez['pageWidth']-$this->ez['leftMargin']-$this->ez['rightMargin']-($options['num']-1)*$options['gap'])/$options['num'];
  195.   $this->ez['columns']['width']=$width;
  196.   $this->ez['rightMargin']=$this->ez['pageWidth']-$this->ez['leftMargin']-$width;
  197.   
  198. }
  199. // ------------------------------------------------------------------------------
  200. function ezColumnsStop(){
  201.   if (isset($this->ez['columns']) && $this->ez['columns']['on']==1){
  202.     $this->ez['columns']['on']=0;
  203.     $this->ez['leftMargin']=$this->ez['columns']['margins'][0];
  204.     $this->ez['rightMargin']=$this->ez['columns']['margins'][1];
  205.     $this->ez['topMargin']=$this->ez['columns']['margins'][2];
  206.     $this->ez['bottomMargin']=$this->ez['columns']['margins'][3];
  207.   }
  208. }
  209. // ------------------------------------------------------------------------------
  210. function ezInsertMode($status=1,$pageNum=1,$pos='before'){
  211.   // puts the document into insert mode. new pages are inserted until this is re-called with status=0
  212.   // by default pages wil be inserted at the start of the document
  213.   switch($status){
  214.     case '1':
  215.       if (isset($this->ezPages[$pageNum])){
  216.         $this->ez['insertMode']=1;
  217.         $this->ez['insertOptions']=array('id'=>$this->ezPages[$pageNum],'pos'=>$pos);
  218.       }
  219.       break;
  220.     case '0':
  221.       $this->ez['insertMode']=0;
  222.       break;
  223.   }
  224. }
  225. // ------------------------------------------------------------------------------
  226.  
  227. function ezNewPage(){
  228.   $pageRequired=1;
  229.   if (isset($this->ez['columns']) && $this->ez['columns']['on']==1){
  230.     // check if this is just going to a new column
  231.     // increment the column number
  232. //echo 'HERE<br>';
  233.     $this->ez['columns']['colNum']++;
  234. //echo $this->ez['columns']['colNum'].'<br>';
  235.     if ($this->ez['columns']['colNum'] <= $this->ez['columns']['options']['num']){
  236.       // then just reset to the top of the next column
  237.       $pageRequired=0;
  238.     } else {
  239.       $this->ez['columns']['colNum']=1;
  240.       $this->ez['topMargin']=$this->ez['columns']['margins'][2];
  241.     }
  242.  
  243.     $width = $this->ez['columns']['width'];
  244.     $this->ez['leftMargin']=$this->ez['columns']['margins'][0]+($this->ez['columns']['colNum']-1)*($this->ez['columns']['options']['gap']+$width);
  245.     $this->ez['rightMargin']=$this->ez['pageWidth']-$this->ez['leftMargin']-$width;
  246.   }
  247. //echo 'left='.$this->ez['leftMargin'].'   right='.$this->ez['rightMargin'].'<br>';
  248.  
  249.   if ($pageRequired){
  250.     // make a new page, setting the writing point back to the top
  251.     $this->y = $this->ez['pageHeight']-$this->ez['topMargin'];
  252.     // make the new page with a call to the basic class.
  253.     $this->ezPageCount++;
  254.     if (isset($this->ez['insertMode']) && $this->ez['insertMode']==1){
  255.       $id = $this->ezPages[$this->ezPageCount] = $this->newPage(1,$this->ez['insertOptions']['id'],$this->ez['insertOptions']['pos']);
  256.       // then manipulate the insert options so that inserted pages follow each other
  257.       $this->ez['insertOptions']['id']=$id;
  258.       $this->ez['insertOptions']['pos']='after';
  259.     } else {
  260.       $this->ezPages[$this->ezPageCount] = $this->newPage();
  261.     }
  262.   } else {
  263.     $this->y = $this->ez['pageHeight']-$this->ez['topMargin'];
  264.   }
  265. }
  266.  
  267. // ------------------------------------------------------------------------------
  268.  
  269. function ezSetMargins($top,$bottom,$left,$right){
  270.   // sets the margins to new values
  271.   $this->ez['topMargin']=$top;
  272.   $this->ez['bottomMargin']=$bottom;
  273.   $this->ez['leftMargin']=$left;
  274.   $this->ez['rightMargin']=$right;
  275.   // check to see if this means that the current writing position is outside the 
  276.   // writable area
  277.   if ($this->y > $this->ez['pageHeight']-$top){
  278.     // then move y down
  279.     $this->y = $this->ez['pageHeight']-$top;
  280.   }
  281.   if ( $this->y < $bottom){
  282.     // then make a new page
  283.     $this->ezNewPage();
  284.   }
  285. }  
  286.  
  287. // ------------------------------------------------------------------------------
  288.  
  289. function ezGetCurrentPageNumber(){
  290.   // return the strict numbering (1,2,3,4..) number of the current page
  291.   return $this->ezPageCount;
  292. }
  293.  
  294. // ------------------------------------------------------------------------------
  295.  
  296. function ezStartPageNumbers($x,$y,$size,$pos='left',$pattern='{PAGENUM} of {TOTALPAGENUM}',$num=''){
  297.   // put page numbers on the pages from here.
  298.   // place then on the 'pos' side of the coordinates (x,y).
  299.   // pos can be 'left' or 'right'
  300.   // use the given 'pattern' for display, where (PAGENUM} and {TOTALPAGENUM} are replaced
  301.   // as required.
  302.   // if $num is set, then make the first page this number, the number of total pages will
  303.   // be adjusted to account for this.
  304.   // Adjust this function so that each time you 'start' page numbers then you effectively start a different batch
  305.   // return the number of the batch, so that they can be stopped in a different order if required.
  306.   if (!$pos || !strlen($pos)){
  307.     $pos='left';
  308.   }
  309.   if (!$pattern || !strlen($pattern)){
  310.     $pattern='{PAGENUM} of {TOTALPAGENUM}';
  311.   }
  312.   if (!isset($this->ez['pageNumbering'])){
  313.     $this->ez['pageNumbering']=array();
  314.   }
  315.   $i = count($this->ez['pageNumbering']);
  316.   $this->ez['pageNumbering'][$i][$this->ezPageCount]=array('x'=>$x,'y'=>$y,'pos'=>$pos,'pattern'=>$pattern,'num'=>$num,'size'=>$size);
  317.   return $i;
  318. }
  319.  
  320. // ------------------------------------------------------------------------------
  321.  
  322. function ezWhatPageNumber($pageNum,$i=0){
  323.   // given a particular generic page number (ie, document numbered sequentially from beginning),
  324.   // return the page number under a particular page numbering scheme ($i)
  325.   $num=0;
  326.   $start=1;
  327.   $startNum=1;
  328.   if (!isset($this->ez['pageNumbering']))
  329.   {
  330.     $this->addMessage('WARNING: page numbering called for and wasn\'t started with ezStartPageNumbers');
  331.     return 0;
  332.   }
  333.   foreach($this->ez['pageNumbering'][$i] as $k=>$v){
  334.     if ($k<=$pageNum){
  335.       if (is_array($v)){
  336.         // start block
  337.         if (strlen($v['num'])){
  338.           // a start was specified
  339.           $start=$v['num'];
  340.           $startNum=$k;
  341.           $num=$pageNum-$startNum+$start;
  342.         }
  343.       } else {
  344.         // stop block
  345.         $num=0;
  346.       }
  347.     }
  348.   }
  349.   return $num;
  350. }
  351.  
  352. // ------------------------------------------------------------------------------
  353.  
  354. function ezStopPageNumbers($stopTotal=0,$next=0,$i=0){
  355.   // if stopTotal=1 then the totalling of pages for this number will stop too
  356.   // if $next=1, then do this page, but not the next, else do not do this page either
  357.   // if $i is set, then stop that particular pagenumbering sequence.
  358.   if (!isset($this->ez['pageNumbering'])){
  359.     $this->ez['pageNumbering']=array();
  360.   }
  361.   if ($next && isset($this->ez['pageNumbering'][$i][$this->ezPageCount]) && is_array($this->ez['pageNumbering'][$i][$this->ezPageCount])){
  362.     // then this has only just been started, this will over-write the start, and nothing will appear
  363.     // add a special command to the start block, telling it to stop as well
  364.     if ($stopTotal){
  365.       $this->ez['pageNumbering'][$i][$this->ezPageCount]['stoptn']=1;
  366.     } else {
  367.       $this->ez['pageNumbering'][$i][$this->ezPageCount]['stopn']=1;
  368.     }
  369.   } else {
  370.     if ($stopTotal){
  371.       $this->ez['pageNumbering'][$i][$this->ezPageCount]='stopt';
  372.     } else {
  373.       $this->ez['pageNumbering'][$i][$this->ezPageCount]='stop';
  374.     }
  375.     if ($next){
  376.       $this->ez['pageNumbering'][$i][$this->ezPageCount].='n';
  377.     }
  378.   }
  379. }
  380.  
  381. // ------------------------------------------------------------------------------
  382.  
  383. function ezPRVTpageNumberSearch($lbl,&$tmp){
  384.   foreach($tmp as $i=>$v){
  385.     if (is_array($v)){
  386.       if (isset($v[$lbl])){
  387.         return $i;
  388.       }
  389.     } else {
  390.       if ($v==$lbl){
  391.         return $i;
  392.       }
  393.     }
  394.   }
  395.   return 0;
  396. }
  397.  
  398. // ------------------------------------------------------------------------------
  399.  
  400. function ezPRVTaddPageNumbers(){
  401.   // this will go through the pageNumbering array and add the page numbers are required
  402.   if (isset($this->ez['pageNumbering'])){
  403.     $totalPages1 = $this->ezPageCount;
  404.     $tmp1=$this->ez['pageNumbering'];
  405.     $status=0;
  406.     foreach($tmp1 as $i=>$tmp){
  407.       // do each of the page numbering systems
  408.       // firstly, find the total pages for this one
  409.       $k = $this->ezPRVTpageNumberSearch('stopt',$tmp);
  410.       if ($k && $k>0){
  411.         $totalPages = $k-1;
  412.       } else {
  413.         $l = $this->ezPRVTpageNumberSearch('stoptn',$tmp);
  414.         if ($l && $l>0){
  415.           $totalPages = $l;
  416.         } else {
  417.           $totalPages = $totalPages1;
  418.         }
  419.       }
  420.       foreach ($this->ezPages as $pageNum=>$id){
  421.         if (isset($tmp[$pageNum])){
  422.           if (is_array($tmp[$pageNum])){
  423.             // then this must be starting page numbers
  424.             $status=1;
  425.             $info = $tmp[$pageNum];
  426.             $info['dnum']=$info['num']-$pageNum;
  427.             // also check for the special case of the numbering stopping and starting on the same page
  428.             if (isset($info['stopn']) || isset($info['stoptn']) ){
  429.               $status=2;
  430.             }
  431.           } else if ($tmp[$pageNum]=='stop' || $tmp[$pageNum]=='stopt'){
  432.             // then we are stopping page numbers
  433.             $status=0;
  434.           } else if ($status==1 && ($tmp[$pageNum]=='stoptn' || $tmp[$pageNum]=='stopn')){
  435.             // then we are stopping page numbers
  436.             $status=2;
  437.           }
  438.         }
  439.         if ($status){
  440.           // then add the page numbering to this page
  441.           if (strlen($info['num'])){
  442.             $num=$pageNum+$info['dnum'];
  443.           } else {
  444.             $num=$pageNum;
  445.           }
  446.           $total = $totalPages+$num-$pageNum;
  447.           $pat = str_replace('{PAGENUM}',$num,$info['pattern']);
  448.           $pat = str_replace('{TOTALPAGENUM}',$total,$pat);
  449.           $this->reopenObject($id);
  450.           switch($info['pos']){
  451.             case 'right':
  452.               $this->addText($info['x'],$info['y'],$info['size'],$pat);
  453.               break;
  454.             default:
  455.               $w=$this->getTextWidth($info['size'],$pat);
  456.               $this->addText($info['x']-$w,$info['y'],$info['size'],$pat);
  457.               break;
  458.           }
  459.           $this->closeObject();
  460.         }
  461.         if ($status==2){
  462.           $status=0;
  463.         }
  464.       }
  465.     }
  466.   }
  467. }
  468.  
  469. // ------------------------------------------------------------------------------
  470.  
  471. function ezPRVTcleanUp(){
  472.   $this->ezPRVTaddPageNumbers();
  473. }
  474.  
  475. // ------------------------------------------------------------------------------
  476.  
  477. function ezStream($options=''){
  478.   $this->ezPRVTcleanUp();
  479.   $this->stream($options);
  480. }
  481.  
  482. // ------------------------------------------------------------------------------
  483.  
  484. function ezOutput($options=0){
  485.   $this->ezPRVTcleanUp();
  486.   return $this->output($options);
  487. }
  488.  
  489. // ------------------------------------------------------------------------------
  490.  
  491. function ezSetY($y){
  492.   // used to change the vertical position of the writing point.
  493.   $this->y = $y;
  494.   if ( $this->y < $this->ez['bottomMargin']){
  495.     // then make a new page
  496.     $this->ezNewPage();
  497.   }
  498. }
  499.  
  500. // ------------------------------------------------------------------------------
  501.  
  502. function ezSetDy($dy,$mod=''){
  503.   // used to change the vertical position of the writing point.
  504.   // changes up by a positive increment, so enter a negative number to go
  505.   // down the page
  506.   // if $mod is set to 'makeSpace' and a new page is forced, then the pointed will be moved 
  507.   // down on the new page, this will allow space to be reserved for graphics etc.
  508.   $this->y += $dy;
  509.   if ( $this->y < $this->ez['bottomMargin']){
  510.     // then make a new page
  511.     $this->ezNewPage();
  512.     if ($mod=='makeSpace'){
  513.       $this->y += $dy;
  514.     }
  515.   }
  516. }
  517.  
  518. // ------------------------------------------------------------------------------
  519.  
  520. function ezPrvtTableDrawLines($pos,$gap,$x0,$x1,$y0,$y1,$y2,$col,$inner,$outer,$opt=1){
  521.   $x0=1000;
  522.   $x1=0;
  523.   $this->setStrokeColor($col[0],$col[1],$col[2]);
  524.   $cnt=0;
  525.   $n = count($pos);
  526.   foreach($pos as $x){
  527.     $cnt++;
  528.     if ($cnt==1 || $cnt==$n){
  529.       $this->setLineStyle($outer);
  530.     } else {
  531.       $this->setLineStyle($inner);
  532.     }
  533.     $this->line($x-$gap/2,$y0,$x-$gap/2,$y2);
  534.     if ($x>$x1){ $x1=$x; };
  535.     if ($x<$x0){ $x0=$x; };
  536.   }
  537.   $this->setLineStyle($outer);
  538.   $this->line($x0-$gap/2-$outer/2,$y0,$x1-$gap/2+$outer/2,$y0);
  539.   // only do the second line if it is different to the first, AND each row does not have
  540.   // a line on it.
  541.   if ($y0!=$y1 && $opt<2){
  542.     $this->line($x0-$gap/2,$y1,$x1-$gap/2,$y1);
  543.   }
  544.   $this->line($x0-$gap/2-$outer/2,$y2,$x1-$gap/2+$outer/2,$y2);
  545. }
  546.  
  547. // ------------------------------------------------------------------------------
  548.  
  549. function ezPrvtTableColumnHeadings($cols,$pos,$maxWidth,$height,$decender,$gap,$size,&$y,$optionsAll=array()){
  550.   // uses ezText to add the text, and returns the height taken by the largest heading
  551.   // this page will move the headings to a new page if they will not fit completely on this one
  552.   // transaction support will be used to implement this
  553.  
  554.   if (isset($optionsAll['cols'])){
  555.     $options = $optionsAll['cols'];
  556.   } else {
  557.     $options = array();
  558.   }
  559.   
  560.   $mx=0;
  561.   $startPage = $this->ezPageCount;
  562.   $secondGo=0;
  563.  
  564.   // $y is the position at which the top of the table should start, so the base
  565.   // of the first text, is $y-$height-$gap-$decender, but ezText starts by dropping $height
  566.   
  567.   // the return from this function is the total cell height, including gaps, and $y is adjusted
  568.   // to be the postion of the bottom line
  569.   
  570.   // begin the transaction
  571.   $this->transaction('start');
  572.   $ok=0;
  573. //  $y-=$gap-$decender;
  574.   $y-=$gap;
  575.   while ($ok==0){
  576.     foreach($cols as $colName=>$colHeading){
  577.       $this->ezSetY($y);
  578.       if (isset($options[$colName]) && isset($options[$colName]['justification'])){
  579.         $justification = $options[$colName]['justification'];
  580.       } else {
  581.         $justification = 'left';
  582.       }
  583.       $this->ezText($colHeading,$size,array('aleft'=> $pos[$colName],'aright'=>($maxWidth[$colName]+$pos[$colName]),'justification'=>$justification));
  584.       $dy = $y-$this->y;
  585.       if ($dy>$mx){
  586.         $mx=$dy;
  587.       }
  588.     }
  589.     $y = $y - $mx - $gap + $decender;
  590. //    $y -= $mx-$gap+$decender;
  591.     
  592.     // now, if this has moved to a new page, then abort the transaction, move to a new page, and put it there
  593.     // do not check on the second time around, to avoid an infinite loop
  594.     if ($this->ezPageCount != $startPage && $secondGo==0){
  595.       $this->transaction('rewind');
  596.       $this->ezNewPage();
  597.       $y = $this->y - $gap-$decender;
  598.       $ok=0;
  599.       $secondGo=1;
  600. //      $y = $store_y;
  601.       $mx=0;
  602.  
  603.     } else {
  604.       $this->transaction('commit');
  605.       $ok=1;
  606.     }
  607.   }
  608.  
  609.   return $mx+$gap*2-$decender;
  610. }
  611.  
  612. // ------------------------------------------------------------------------------
  613.  
  614. function ezPrvtGetTextWidth($size,$text){
  615.   // will calculate the maximum width, taking into account that the text may be broken
  616.   // by line breaks.
  617.   $mx=0;
  618.   $lines = explode("\n",$text);
  619.   foreach ($lines as $line){
  620.     $w = $this->getTextWidth($size,$line);
  621.     if ($w>$mx){
  622.       $mx=$w;
  623.     }
  624.   }
  625.   return $mx;
  626. }
  627.  
  628. // ------------------------------------------------------------------------------
  629.  
  630. function ezTable(&$data,$cols='',$title='',$options=''){
  631.   // add a table of information to the pdf document
  632.   // $data is a two dimensional array
  633.   // $cols (optional) is an associative array, the keys are the names of the columns from $data
  634.   // to be presented (and in that order), the values are the titles to be given to the columns
  635.   // $title (optional) is the title to be put on the top of the table
  636.   //
  637.   // $options is an associative array which can contain:
  638.   // 'showLines'=> 0,1,2, default is 1 (show outside and top lines only), 2=> lines on each row
  639.   // 'showHeadings' => 0 or 1
  640.   // 'shaded'=> 0,1,2,3 default is 1 (1->alternate lines are shaded, 0->no shading, 2-> both shaded, second uses shadeCol2)
  641.   // 'shadeCol' => (r,g,b) array, defining the colour of the shading, default is (0.8,0.8,0.8)
  642.   // 'shadeCol2' => (r,g,b) array, defining the colour of the shading of the other blocks, default is (0.7,0.7,0.7)
  643.   // 'fontSize' => 10
  644.   // 'textCol' => (r,g,b) array, text colour
  645.   // 'titleFontSize' => 12
  646.   // 'rowGap' => 2 , the space added at the top and bottom of each row, between the text and the lines
  647.   // 'colGap' => 5 , the space on the left and right sides of each cell
  648.   // 'lineCol' => (r,g,b) array, defining the colour of the lines, default, black.
  649.   // 'xPos' => 'left','right','center','centre',or coordinate, reference coordinate in the x-direction
  650.   // 'xOrientation' => 'left','right','center','centre', position of the table w.r.t 'xPos' 
  651.   // 'width'=> <number> which will specify the width of the table, if it turns out to not be this
  652.   //    wide, then it will stretch the table to fit, if it is wider then each cell will be made
  653.   //    proportionalty smaller, and the content may have to wrap.
  654.   // 'maxWidth'=> <number> similar to 'width', but will only make table smaller than it wants to be
  655.   // 'col_options' => array( array('justification'=>'left','width'=>100,'link'=>linkDataName), array(...), ...)
  656.   //             allow the setting of other paramaters for the individual columns
  657.   // 'minRowSpace'=> the minimum space between the bottom of each row and the bottom margin, in which a new row will be started
  658.   //                  if it is less, then a new page would be started, default=-100
  659.   // 'innerLineThickness'=>1
  660.   // 'outerLineThickness'=>1
  661.   // 'splitRows'=>0, 0 or 1, whether or not to allow the rows to be split across page boundaries
  662.   // 'protectRows'=>number, the number of rows to hold with the heading on page, ie, if there less than this number of
  663.   //                rows on the page, then move the whole lot onto the next page, default=1
  664.   //
  665.   // note that the user will have had to make a font selection already or this will not 
  666.   // produce a valid pdf file.
  667.   
  668.   if (!is_array($data)){
  669.     return;
  670.   }
  671.   
  672.   if (!is_array($cols)){
  673.     // take the columns from the first row of the data set
  674.     reset($data);
  675.     list($k,$v)=each($data);
  676.     if (!is_array($v)){
  677.       return;
  678.     }
  679.     $cols=array();
  680.     foreach($v as $k1=>$v1){
  681.       $cols[$k1]=$k1;
  682.     }
  683.   }
  684.   
  685.   if (!is_array($options)){
  686.     $options=array();
  687.   }
  688.  
  689.   $defaults = array(
  690.     'shaded'=>1,'showLines'=>1,'shadeCol'=>array(0.8,0.8,0.8),'shadeCol2'=>array(0.7,0.7,0.7),'fontSize'=>10,'titleFontSize'=>12
  691.     ,'titleGap'=>5,'lineCol'=>array(0,0,0),'gap'=>5,'xPos'=>'centre','xOrientation'=>'centre'
  692.     ,'showHeadings'=>1,'textCol'=>array(0,0,0),'width'=>0,'maxWidth'=>0,'col_options'=>array(),'minRowSpace'=>-100,'rowGap'=>2,'colGap'=>5
  693.     ,'innerLineThickness'=>1,'outerLineThickness'=>1,'splitRows'=>0,'protectRows'=>1
  694.     );
  695.  
  696.   foreach($defaults as $key=>$value){
  697.     if (is_array($value)){
  698.       if (!isset($options[$key]) || !is_array($options[$key])){
  699.         $options[$key]=$value;
  700.       }
  701.     } else {
  702.       if (!isset($options[$key])){
  703.         $options[$key]=$value;
  704.       }
  705.     }
  706.   }
  707.   $options['gap']=2*$options['colGap'];
  708.   
  709.   $middle = ($this->ez['pageWidth']-$this->ez['rightMargin'])/2+($this->ez['leftMargin'])/2;
  710.   // figure out the maximum widths of the text within each column
  711.   $maxWidth=array();
  712.   foreach($cols as $colName=>$colHeading){
  713.     $maxWidth[$colName]=0;
  714.   }
  715.   // find the maximum cell widths based on the data
  716.   foreach($data as $row){
  717.     foreach($cols as $colName=>$colHeading){
  718.       $w = $this->ezPrvtGetTextWidth($options['fontSize'],(string)$row[$colName])*1.01;
  719.       if ($w > $maxWidth[$colName]){
  720.         $maxWidth[$colName]=$w;
  721.       }
  722.     }
  723.   }
  724.   // and the maximum widths to fit in the headings
  725.   foreach($cols as $colName=>$colTitle){
  726.     $w = $this->ezPrvtGetTextWidth($options['fontSize'],(string)$colTitle)*1.01;
  727.     if ($w > $maxWidth[$colName]){
  728.       $maxWidth[$colName]=$w;
  729.     }
  730.   }
  731.   
  732.   // calculate the start positions of each of the columns
  733.   $pos=array();
  734.   $x=0;
  735.   $t=$x;
  736.   $adjustmentWidth=0;
  737.   $setWidth=0;
  738.   foreach($maxWidth as $colName => $w){
  739.     $pos[$colName]=$t;
  740.     // if the column width has been specified then set that here, also total the
  741.     // width avaliable for adjustment
  742.     if (isset($options['col_options'][$colName]) && isset($options['col_options'][$colName]['width']) && $options['col_options'][$colName]['width']>0){
  743.       $t=$t+$options['col_options'][$colName]['width'];
  744.       $maxWidth[$colName] = $options['col_options'][$colName]['width']-$options['gap'];
  745.       $setWidth += $options['col_options'][$colName]['width'];
  746.     } else {
  747.       $t=$t+$w+$options['gap'];
  748.       $adjustmentWidth += $w;
  749.       $setWidth += $options['gap'];
  750.     }
  751.   }
  752.   $pos['_end_']=$t;
  753.  
  754.   // if maxWidth is specified, and the table is too wide, and the width has not been set,
  755.   // then set the width.
  756.   if ($options['width']==0 && $options['maxWidth'] && ($t-$x)>$options['maxWidth']){
  757.     // then need to make this one smaller
  758.     $options['width']=$options['maxWidth'];
  759.   }
  760.  
  761.   if ($options['width'] && $adjustmentWidth>0 && $setWidth<$options['width']){
  762.     // first find the current widths of the columns involved in this mystery
  763.     $cols0 = array();
  764.     $cols1 = array();
  765.     $xq=0;
  766.     $presentWidth=0;
  767.     $last='';
  768.     foreach($pos as $colName=>$p){
  769.       if (!isset($options['col_options'][$last]) || !isset($options['col_options'][$last]['width']) || $options['col_options'][$last]['width']<=0){
  770.         if (strlen($last)){
  771.           $cols0[$last]=$p-$xq -$options['gap'];
  772.           $presentWidth += ($p-$xq - $options['gap']);
  773.         }
  774.       } else {
  775.         $cols1[$last]=$p-$xq;
  776.       }
  777.       $last=$colName;
  778.       $xq=$p;
  779.     }
  780.     // $cols0 contains the widths of all the columns which are not set
  781.     $neededWidth = $options['width']-$setWidth;
  782.     // if needed width is negative then add it equally to each column, else get more tricky
  783.     if ($presentWidth<$neededWidth){
  784.       foreach($cols0 as $colName=>$w){
  785.         $cols0[$colName]+= ($neededWidth-$presentWidth)/count($cols0);
  786.       }
  787.     } else {
  788.     
  789.       $cnt=0;
  790.       while ($presentWidth>$neededWidth && $cnt<100){
  791.         $cnt++; // insurance policy
  792.         // find the widest columns, and the next to widest width
  793.         $aWidest = array();
  794.         $nWidest=0;
  795.         $widest=0;
  796.         foreach($cols0 as $colName=>$w){
  797.           if ($w>$widest){
  798.             $aWidest=array($colName);
  799.             $nWidest = $widest;
  800.             $widest=$w;
  801.           } else if ($w==$widest){
  802.             $aWidest[]=$colName;
  803.           }
  804.         }
  805.         // then figure out what the width of the widest columns would have to be to take up all the slack
  806.         $newWidestWidth = $widest - ($presentWidth-$neededWidth)/count($aWidest);
  807.         if ($newWidestWidth > $nWidest){
  808.           // then there is space to set them to this
  809.           foreach($aWidest as $colName){
  810.             $cols0[$colName] = $newWidestWidth;
  811.           }
  812.           $presentWidth=$neededWidth;
  813.         } else {
  814.           // there is not space, reduce the size of the widest ones down to the next size down, and we
  815.           // will go round again
  816.           foreach($aWidest as $colName){
  817.             $cols0[$colName] = $nWidest;
  818.           }
  819.           $presentWidth=$presentWidth-($widest-$nWidest)*count($aWidest);
  820.         }
  821.       }
  822.     }
  823.     // $cols0 now contains the new widths of the constrained columns.
  824.     // now need to update the $pos and $maxWidth arrays
  825.     $xq=0;
  826.     foreach($pos as $colName=>$p){
  827.       $pos[$colName]=$xq;
  828.       if (!isset($options['col_options'][$colName]) || !isset($options['col_options'][$colName]['width']) || $options['col_options'][$colName]['width']<=0){
  829.         if (isset($cols0[$colName])){
  830.           $xq += $cols0[$colName] + $options['gap'];
  831.           $maxWidth[$colName]=$cols0[$colName];
  832.         }
  833.       } else {
  834.         if (isset($cols1[$colName])){
  835.           $xq += $cols1[$colName];
  836.         }
  837.       }
  838.     }
  839.  
  840.     $t=$x+$options['width'];
  841.     $pos['_end_']=$t;
  842.   }
  843.  
  844.   // now adjust the table to the correct location across the page
  845.   switch ($options['xPos']){
  846.     case 'left':
  847.       $xref = $this->ez['leftMargin'];
  848.       break;
  849.     case 'right':
  850.       $xref = $this->ez['pageWidth'] - $this->ez['rightMargin'];
  851.       break;
  852.     case 'centre':
  853.     case 'center':
  854.       $xref = $middle;
  855.       break;
  856.     default:
  857.       $xref = $options['xPos'];
  858.       break;
  859.   }
  860.   switch ($options['xOrientation']){
  861.     case 'left':
  862.       $dx = $xref-$t;
  863.       break;
  864.     case 'right':
  865.       $dx = $xref;
  866.       break;
  867.     case 'centre':
  868.     case 'center':
  869.       $dx = $xref-$t/2;
  870.       break;
  871.   }
  872.  
  873.  
  874.   foreach($pos as $k=>$v){
  875.     $pos[$k]=$v+$dx;
  876.   }
  877.   $x0=$x+$dx;
  878.   $x1=$t+$dx;
  879.  
  880.   $baseLeftMargin = $this->ez['leftMargin'];
  881.   $basePos = $pos;
  882.   $baseX0 = $x0;
  883.   $baseX1 = $x1;
  884.   
  885.   // ok, just about ready to make me a table
  886.   $this->setColor($options['textCol'][0],$options['textCol'][1],$options['textCol'][2]);
  887.   $this->setStrokeColor($options['shadeCol'][0],$options['shadeCol'][1],$options['shadeCol'][2]);
  888.  
  889.   $middle = ($x1+$x0)/2;
  890.  
  891.   // start a transaction which will be used to regress the table, if there are not enough rows protected
  892.   if ($options['protectRows']>0){
  893.     $this->transaction('start');
  894.     $movedOnce=0;
  895.   }
  896.   $abortTable = 1;
  897.   while ($abortTable){
  898.   $abortTable=0;
  899.  
  900.   $dm = $this->ez['leftMargin']-$baseLeftMargin;
  901.   foreach($basePos as $k=>$v){
  902.     $pos[$k]=$v+$dm;
  903.   }
  904.   $x0=$baseX0+$dm;
  905.   $x1=$baseX1+$dm;
  906.   $middle = ($x1+$x0)/2;
  907.  
  908.  
  909.   // if the title is set, then do that
  910.   if (strlen($title)){
  911.     $w = $this->getTextWidth($options['titleFontSize'],$title);
  912.     $this->y -= $this->getFontHeight($options['titleFontSize']);
  913.     if ($this->y < $this->ez['bottomMargin']){
  914.       $this->ezNewPage();
  915.         // margins may have changed on the newpage
  916.         $dm = $this->ez['leftMargin']-$baseLeftMargin;
  917.         foreach($basePos as $k=>$v){
  918.           $pos[$k]=$v+$dm;
  919.         }
  920.         $x0=$baseX0+$dm;
  921.         $x1=$baseX1+$dm;
  922.         $middle = ($x1+$x0)/2;
  923.       $this->y -= $this->getFontHeight($options['titleFontSize']);
  924.     }
  925.     $this->addText($middle-$w/2,$this->y,$options['titleFontSize'],$title);
  926.     $this->y -= $options['titleGap'];
  927.   }
  928.  
  929.         // margins may have changed on the newpage
  930.         $dm = $this->ez['leftMargin']-$baseLeftMargin;
  931.         foreach($basePos as $k=>$v){
  932.           $pos[$k]=$v+$dm;
  933.         }
  934.         $x0=$baseX0+$dm;
  935.         $x1=$baseX1+$dm;
  936.   
  937.   $y=$this->y; // to simplify the code a bit
  938.   
  939.   // make the table
  940.   $height = $this->getFontHeight($options['fontSize']);
  941.   $decender = $this->getFontDecender($options['fontSize']);
  942.  
  943.   
  944.   
  945.   $y0=$y+$decender;
  946.   $dy=0;
  947.   if ($options['showHeadings']){
  948.     // this function will move the start of the table to a new page if it does not fit on this one
  949.     $headingHeight = $this->ezPrvtTableColumnHeadings($cols,$pos,$maxWidth,$height,$decender,$options['rowGap'],$options['fontSize'],$y,$options);
  950.     $y0 = $y+$headingHeight;
  951.     $y1 = $y;
  952.  
  953.  
  954.     $dm = $this->ez['leftMargin']-$baseLeftMargin;
  955.     foreach($basePos as $k=>$v){
  956.       $pos[$k]=$v+$dm;
  957.     }
  958.     $x0=$baseX0+$dm;
  959.     $x1=$baseX1+$dm;
  960.  
  961.   } else {
  962.     $y1 = $y0;
  963.   }
  964.   $firstLine=1;
  965.  
  966.   
  967.   // open an object here so that the text can be put in over the shading
  968.   if ($options['shaded']){
  969.     $this->saveState();
  970.     $textObjectId = $this->openObject();
  971.     $this->closeObject();
  972.     $this->addObject($textObjectId);
  973.     $this->reopenObject($textObjectId);
  974.   }
  975.   
  976.   $cnt=0;
  977.   $newPage=0;
  978.   foreach($data as $row){
  979.     $cnt++;
  980.     // the transaction support will be used to prevent rows being split
  981.     if ($options['splitRows']==0){
  982.       $pageStart = $this->ezPageCount;
  983.       if (isset($this->ez['columns']) && $this->ez['columns']['on']==1){
  984.         $columnStart = $this->ez['columns']['colNum'];
  985.       }
  986.       $this->transaction('start');
  987.       $row_orig = $row;
  988.       $y_orig = $y;
  989.       $y0_orig = $y0;
  990.       $y1_orig = $y1;
  991.     }
  992.     $ok=0;
  993.     $secondTurn=0;
  994.     while(!$abortTable && $ok == 0){
  995.  
  996.     $mx=0;
  997.     $newRow=1;
  998.     while(!$abortTable && ($newPage || $newRow)){
  999.       
  1000.       $y-=$height;
  1001.       if ($newPage || $y<$this->ez['bottomMargin'] || (isset($options['minRowSpace']) && $y<($this->ez['bottomMargin']+$options['minRowSpace'])) ){
  1002.         // check that enough rows are with the heading
  1003.         if ($options['protectRows']>0 && $movedOnce==0 && $cnt<=$options['protectRows']){
  1004.           // then we need to move the whole table onto the next page
  1005.           $movedOnce = 1;
  1006.           $abortTable = 1;
  1007.         }
  1008.       
  1009.         $y2=$y-$mx+2*$height+$decender-$newRow*$height;
  1010.         if ($options['showLines']){
  1011.           if (!$options['showHeadings']){
  1012.             $y0=$y1;
  1013.           }
  1014.           $this->ezPrvtTableDrawLines($pos,$options['gap'],$x0,$x1,$y0,$y1,$y2,$options['lineCol'],$options['innerLineThickness'],$options['outerLineThickness'],$options['showLines']);
  1015.         }
  1016.         if ($options['shaded']){
  1017.           $this->closeObject();
  1018.           $this->restoreState();
  1019.         }
  1020.         $this->ezNewPage();
  1021.         // and the margins may have changed, this is due to the possibility of the columns being turned on
  1022.         // as the columns are managed by manipulating the margins
  1023.  
  1024.         $dm = $this->ez['leftMargin']-$baseLeftMargin;
  1025.         foreach($basePos as $k=>$v){
  1026.           $pos[$k]=$v+$dm;
  1027.         }
  1028. //        $x0=$x0+$dm;
  1029. //        $x1=$x1+$dm;
  1030.         $x0=$baseX0+$dm;
  1031.         $x1=$baseX1+$dm;
  1032.   
  1033.         if ($options['shaded']){
  1034.           $this->saveState();
  1035.           $textObjectId = $this->openObject();
  1036.           $this->closeObject();
  1037.           $this->addObject($textObjectId);
  1038.           $this->reopenObject($textObjectId);
  1039.         }
  1040.         $this->setColor($options['textCol'][0],$options['textCol'][1],$options['textCol'][2],1);
  1041.         $y = $this->ez['pageHeight']-$this->ez['topMargin'];
  1042.         $y0=$y+$decender;
  1043.         $mx=0;
  1044.         if ($options['showHeadings']){
  1045.           $this->ezPrvtTableColumnHeadings($cols,$pos,$maxWidth,$height,$decender,$options['rowGap'],$options['fontSize'],$y,$options);
  1046.           $y1=$y;
  1047.         } else {
  1048.           $y1=$y0;
  1049.         }
  1050.         $firstLine=1;
  1051.         $y -= $height;
  1052.       }
  1053.       $newRow=0;
  1054.       // write the actual data
  1055.       // if these cells need to be split over a page, then $newPage will be set, and the remaining
  1056.       // text will be placed in $leftOvers
  1057.       $newPage=0;
  1058.       $leftOvers=array();
  1059.  
  1060.       foreach($cols as $colName=>$colTitle){
  1061.         $this->ezSetY($y+$height);
  1062.         $colNewPage=0;
  1063.         if (isset($row[$colName])){
  1064.           if (isset($options['col_options'][$colName]) && isset($options['col_options'][$colName]['link']) && strlen($options['col_options'][$colName]['link'])){
  1065.             
  1066.             $lines = explode("\n",$row[$colName]);
  1067.             if (isset($row[$options['col_options'][$colName]['link']]) && strlen($row[$options['col_options'][$colName]['link']])){
  1068.               foreach($lines as $k=>$v){
  1069.                 $lines[$k]='<c:alink:'.$row[$options['col_options'][$colName]['link']].'>'.$v.'</c:alink>';
  1070.               }
  1071.             }
  1072.           } else {
  1073.             $lines = explode("\n",$row[$colName]);
  1074.           }
  1075.         } else {
  1076.           $lines = array();
  1077.         }
  1078.         $this->y -= $options['rowGap'];
  1079.         foreach ($lines as $line){
  1080.           $line = $this->ezProcessText($line);
  1081.           $start=1;
  1082.  
  1083.           while (strlen($line) || $start){
  1084.             $start=0;
  1085.             if (!$colNewPage){
  1086.               $this->y=$this->y-$height;
  1087.             }
  1088.             if ($this->y < $this->ez['bottomMargin']){
  1089.   //            $this->ezNewPage();
  1090.               $newPage=1;  // whether a new page is required for any of the columns
  1091.               $colNewPage=1; // whether a new page is required for this column
  1092.             }
  1093.             if ($colNewPage){
  1094.               if (isset($leftOvers[$colName])){
  1095.                 $leftOvers[$colName].="\n".$line;
  1096.               } else {
  1097.                 $leftOvers[$colName] = $line;
  1098.               }
  1099.               $line='';
  1100.             } else {
  1101.               if (isset($options['col_options'][$colName]) && isset($options['col_options'][$colName]['justification']) ){
  1102.                 $just = $options['col_options'][$colName]['justification'];
  1103.               } else {
  1104.                 $just='left';
  1105.               }
  1106.  
  1107.               $line=$this->addTextWrap($pos[$colName],$this->y,$maxWidth[$colName],$options['fontSize'],$line,$just);
  1108.             }
  1109.           }
  1110.         }
  1111.   
  1112.         $dy=$y+$height-$this->y+$options['rowGap'];
  1113.         if ($dy-$height*$newPage>$mx){
  1114.           $mx=$dy-$height*$newPage;
  1115.         }
  1116.       }
  1117.       // set $row to $leftOvers so that they will be processed onto the new page
  1118.       $row = $leftOvers;
  1119.       // now add the shading underneath
  1120.       if ($options['shaded'] && $cnt%2==0){
  1121.         $this->closeObject();
  1122.         $this->setColor($options['shadeCol'][0],$options['shadeCol'][1],$options['shadeCol'][2],1);
  1123.         $this->filledRectangle($x0-$options['gap']/2,$y+$decender+$height-$mx,$x1-$x0,$mx);
  1124.         $this->reopenObject($textObjectId);
  1125.       }
  1126.  
  1127.       if ($options['shaded']==2 && $cnt%2==1){
  1128.         $this->closeObject();
  1129.         $this->setColor($options['shadeCol2'][0],$options['shadeCol2'][1],$options['shadeCol2'][2],1);
  1130.         $this->filledRectangle($x0-$options['gap']/2,$y+$decender+$height-$mx,$x1-$x0,$mx);
  1131.         $this->reopenObject($textObjectId);
  1132.       }
  1133.  
  1134.       if ($options['showLines']>1){
  1135.         // then draw a line on the top of each block
  1136. //        $this->closeObject();
  1137.         $this->saveState();
  1138.         $this->setStrokeColor($options['lineCol'][0],$options['lineCol'][1],$options['lineCol'][2],1);
  1139. //        $this->line($x0-$options['gap']/2,$y+$decender+$height-$mx,$x1-$x0,$mx);
  1140.         if ($firstLine){
  1141.           $this->setLineStyle($options['outerLineThickness']);
  1142.           $firstLine=0;
  1143.         } else {
  1144.           $this->setLineStyle($options['innerLineThickness']);
  1145.         }
  1146.         $this->line($x0-$options['gap']/2,$y+$decender+$height,$x1-$options['gap']/2,$y+$decender+$height);
  1147.         $this->restoreState();
  1148. //        $this->reopenObject($textObjectId);
  1149.       }
  1150.     } // end of while 
  1151.     $y=$y-$mx+$height;
  1152.     
  1153.     // checking row split over pages
  1154.     if ($options['splitRows']==0){
  1155.       if ( ( ($this->ezPageCount != $pageStart) || (isset($this->ez['columns']) && $this->ez['columns']['on']==1 && $columnStart != $this->ez['columns']['colNum'] ))  && $secondTurn==0){
  1156.         // then we need to go back and try that again !
  1157.         $newPage=1;
  1158.         $secondTurn=1;
  1159.         $this->transaction('rewind');
  1160.         $row = $row_orig;
  1161.         $y = $y_orig;
  1162.         $y0 = $y0_orig;
  1163.         $y1 = $y1_orig;
  1164.         $ok=0;
  1165.  
  1166.         $dm = $this->ez['leftMargin']-$baseLeftMargin;
  1167.         foreach($basePos as $k=>$v){
  1168.           $pos[$k]=$v+$dm;
  1169.         }
  1170.         $x0=$baseX0+$dm;
  1171.         $x1=$baseX1+$dm;
  1172.  
  1173.       } else {
  1174.         $this->transaction('commit');
  1175.         $ok=1;
  1176.       }
  1177.     } else {
  1178.       $ok=1;  // don't go round the loop if splitting rows is allowed
  1179.     }
  1180.     
  1181.     }  // end of while to check for row splitting
  1182.     if ($abortTable){
  1183.       if ($ok==0){
  1184.         $this->transaction('abort');
  1185.       }
  1186.       // only the outer transaction should be operational
  1187.       $this->transaction('rewind');
  1188.       $this->ezNewPage();
  1189.       break;
  1190.     }
  1191.     
  1192.   } // end of foreach ($data as $row)
  1193.   
  1194.   } // end of while ($abortTable)
  1195.  
  1196.   // table has been put on the page, the rows guarded as required, commit.
  1197.   $this->transaction('commit');
  1198.  
  1199.   $y2=$y+$decender;
  1200.   if ($options['showLines']){
  1201.     if (!$options['showHeadings']){
  1202.       $y0=$y1;
  1203.     }
  1204.     $this->ezPrvtTableDrawLines($pos,$options['gap'],$x0,$x1,$y0,$y1,$y2,$options['lineCol'],$options['innerLineThickness'],$options['outerLineThickness'],$options['showLines']);
  1205.   }
  1206.  
  1207.   // close the object for drawing the text on top
  1208.   if ($options['shaded']){
  1209.     $this->closeObject();
  1210.     $this->restoreState();
  1211.   }
  1212.   
  1213.   $this->y=$y;
  1214.   return $y;
  1215. }
  1216.  
  1217. // ------------------------------------------------------------------------------
  1218. function ezProcessText($text){
  1219.   // this function will intially be used to implement underlining support, but could be used for a range of other
  1220.   // purposes
  1221.   $search = array('<u>','<U>','</u>','</U>');
  1222.   $replace = array('<c:uline>','<c:uline>','</c:uline>','</c:uline>');
  1223.   return str_replace($search,$replace,$text);
  1224. }
  1225.  
  1226. // ------------------------------------------------------------------------------
  1227.  
  1228. function ezText($text,$size=0,$options=array(),$test=0){
  1229.   // this will add a string of text to the document, starting at the current drawing
  1230.   // position.
  1231.   // it will wrap to keep within the margins, including optional offsets from the left
  1232.   // and the right, if $size is not specified, then it will be the last one used, or
  1233.   // the default value (12 I think).
  1234.   // the text will go to the start of the next line when a return code "\n" is found.
  1235.   // possible options are:
  1236.   // 'left'=> number, gap to leave from the left margin
  1237.   // 'right'=> number, gap to leave from the right margin
  1238.   // 'aleft'=> number, absolute left position (overrides 'left')
  1239.   // 'aright'=> number, absolute right position (overrides 'right')
  1240.   // 'justification' => 'left','right','center','centre','full'
  1241.  
  1242.   // only set one of the next two items (leading overrides spacing)
  1243.   // 'leading' => number, defines the total height taken by the line, independent of the font height.
  1244.   // 'spacing' => a real number, though usually set to one of 1, 1.5, 2 (line spacing as used in word processing)
  1245.   
  1246.   // if $test is set then this should just check if the text is going to flow onto a new page or not, returning true or false
  1247.   
  1248.   // apply the filtering which will make the underlining function.
  1249.   $text = $this->ezProcessText($text);
  1250.   
  1251.   $newPage=false;
  1252.   $store_y = $this->y;
  1253.   
  1254.   if (is_array($options) && isset($options['aleft'])){
  1255.     $left=$options['aleft'];
  1256.   } else {
  1257.     $left = $this->ez['leftMargin'] + ((is_array($options) && isset($options['left']))?$options['left']:0);
  1258.   }
  1259.   if (is_array($options) && isset($options['aright'])){
  1260.     $right=$options['aright'];
  1261.   } else {
  1262.     $right = $this->ez['pageWidth'] - $this->ez['rightMargin'] - ((is_array($options) && isset($options['right']))?$options['right']:0);
  1263.   }
  1264.   if ($size<=0){
  1265.     $size = $this->ez['fontSize'];
  1266.   } else {
  1267.     $this->ez['fontSize']=$size;
  1268.   }
  1269.   
  1270.   if (is_array($options) && isset($options['justification'])){
  1271.     $just = $options['justification'];
  1272.   } else {
  1273.     $just = 'left';
  1274.   }
  1275.   
  1276.   // modifications to give leading and spacing based on those given by Craig Heydenburg 1/1/02
  1277.   if (is_array($options) && isset($options['leading'])) { ## use leading instead of spacing
  1278.     $height = $options['leading'];
  1279.     } else if (is_array($options) && isset($options['spacing'])) {
  1280.     $height = $this->getFontHeight($size) * $options['spacing'];
  1281.     } else {
  1282.         $height = $this->getFontHeight($size);
  1283.     }
  1284.  
  1285.   
  1286.   $lines = explode("\n",$text);
  1287.   foreach ($lines as $line){
  1288.     $start=1;
  1289.     while (strlen($line) || $start){
  1290.       $start=0;
  1291.       $this->y=$this->y-$height;
  1292.       if ($this->y < $this->ez['bottomMargin']){
  1293.         if ($test){
  1294.           $newPage=true;
  1295.         } else {
  1296.           $this->ezNewPage();
  1297.           // and then re-calc the left and right, in case they have changed due to columns
  1298.         }
  1299.       }
  1300.       if (is_array($options) && isset($options['aleft'])){
  1301.         $left=$options['aleft'];
  1302.       } else {
  1303.         $left = $this->ez['leftMargin'] + ((is_array($options) && isset($options['left']))?$options['left']:0);
  1304.       }
  1305.       if (is_array($options) && isset($options['aright'])){
  1306.         $right=$options['aright'];
  1307.       } else {
  1308.         $right = $this->ez['pageWidth'] - $this->ez['rightMargin'] - ((is_array($options) && isset($options['right']))?$options['right']:0);
  1309.       }
  1310.       $line=$this->addTextWrap($left,$this->y,$right-$left,$size,$line,$just,0,$test);
  1311.     }
  1312.   }
  1313.  
  1314.   if ($test){
  1315.     $this->y=$store_y;
  1316.     return $newPage;
  1317.   } else {
  1318.     return $this->y;
  1319.   }
  1320. }
  1321.  
  1322. // ------------------------------------------------------------------------------
  1323.  
  1324. function ezImage($image,$pad = 5,$width = 0,$resize = 'full',$just = 'center',$border = ''){
  1325.     //beta ezimage function
  1326.     if (stristr($image,'://'))//copy to temp file
  1327.     {
  1328.         $fp = @fopen($image,"rb");
  1329.         while(!feof($fp))
  1330.            {
  1331.                   $cont.= fread($fp,1024);
  1332.            }
  1333.            fclose($fp);
  1334.         $image = tempnam ("/tmp", "php-pdf");
  1335.         $fp2 = @fopen($image,"w");
  1336.            fwrite($fp2,$cont);
  1337.           fclose($fp2);
  1338.         $temp = true;
  1339.     }
  1340.  
  1341.     if (!(file_exists($image))) return false; //return immediately if image file does not exist
  1342.     $imageInfo = getimagesize($image);
  1343.     switch ($imageInfo[2]){
  1344.         case 2:
  1345.             $type = "jpeg";
  1346.             break;
  1347.         case 3:
  1348.             $type = "png";
  1349.             break;
  1350.         default:
  1351.             return false; //return if file is not jpg or png
  1352.     }
  1353.     if ($width == 0) $width = $imageInfo[0]; //set width
  1354.     $ratio = $imageInfo[0]/$imageInfo[1];
  1355.  
  1356.     //get maximum width of image
  1357.     if (isset($this->ez['columns']) && $this->ez['columns']['on'] == 1)
  1358.     {
  1359.         $bigwidth = $this->ez['columns']['width'] - ($pad * 2);
  1360.     }
  1361.     else
  1362.     {
  1363.         $bigwidth = $this->ez['pageWidth'] - ($pad * 2);
  1364.     }
  1365.     //fix width if larger than maximum or if $resize=full
  1366.     if ($resize == 'full' || $resize == 'width' || $width > $bigwidth)
  1367.     {
  1368.         $width = $bigwidth;
  1369.  
  1370.     }
  1371.  
  1372.     $height = ($width/$ratio); //set height
  1373.  
  1374.     //fix size if runs off page
  1375.     if ($height > ($this->y - $this->ez['bottomMargin'] - ($pad * 2)))
  1376.     {
  1377.         if ($resize != 'full')
  1378.         {
  1379.             $this->ezNewPage();
  1380.         }
  1381.         else
  1382.         {
  1383.             $height = ($this->y - $this->ez['bottomMargin'] - ($pad * 2)); //shrink height
  1384.             $width = ($height*$ratio); //fix width
  1385.         }
  1386.     }
  1387.  
  1388.     //fix x-offset if image smaller than bigwidth
  1389.     if ($width < $bigwidth)
  1390.     {
  1391.         //center if justification=center
  1392.         if ($just == 'center')
  1393.         {
  1394.             $offset = ($bigwidth - $width) / 2;
  1395.         }
  1396.         //move to right if justification=right
  1397.         if ($just == 'right')
  1398.         {
  1399.             $offset = ($bigwidth - $width);
  1400.         }
  1401.         //leave at left if justification=left
  1402.         if ($just == 'left')
  1403.         {
  1404.             $offset = 0;
  1405.         }
  1406.     }
  1407.  
  1408.  
  1409.     //call appropriate function
  1410.     if ($type == "jpeg"){
  1411.         $this->addJpegFromFile($image,$this->ez['leftMargin'] + $pad + $offset, $this->y + $this->getFontHeight($this->ez['fontSize']) - $pad - $height,$width);
  1412.     }
  1413.  
  1414.     if ($type == "png"){
  1415.         $this->addPngFromFile($image,$this->ez['leftMargin'] + $pad + $offset, $this->y + $this->getFontHeight($this->ez['fontSize']) - $pad - $height,$width);
  1416.     }
  1417.     //draw border
  1418.     if ($border != '')
  1419.     {
  1420.     if (!(isset($border['color'])))
  1421.     {
  1422.         $border['color']['red'] = .5;
  1423.         $border['color']['blue'] = .5;
  1424.         $border['color']['green'] = .5;
  1425.     }
  1426.     if (!(isset($border['width']))) $border['width'] = 1;
  1427.     if (!(isset($border['cap']))) $border['cap'] = 'round';
  1428.     if (!(isset($border['join']))) $border['join'] = 'round';
  1429.     
  1430.  
  1431.     $this->setStrokeColor($border['color']['red'],$border['color']['green'],$border['color']['blue']);
  1432.     $this->setLineStyle($border['width'],$border['cap'],$border['join']);
  1433.     $this->rectangle($this->ez['leftMargin'] + $pad + $offset, $this->y + $this->getFontHeight($this->ez['fontSize']) - $pad - $height,$width,$height);
  1434.  
  1435.     }
  1436.     // move y below image
  1437.     $this->y = $this->y - $pad - $height;
  1438.     //remove tempfile for remote images
  1439.     if ($temp == true) unlink($image);
  1440.  
  1441. }
  1442. // ------------------------------------------------------------------------------
  1443.  
  1444. // note that templating code is still considered developmental - have not really figured
  1445. // out a good way of doing this yet.
  1446. function loadTemplate($templateFile){
  1447.   // this function will load the requested template ($file includes full or relative pathname)
  1448.   // the code for the template will be modified to make it name safe, and then stored in 
  1449.   // an array for later use
  1450.   // The id of the template will be returned for the user to operate on it later
  1451.   if (!file_exists($templateFile)){
  1452.     return -1;
  1453.   }
  1454.  
  1455.   $code = implode('',file($templateFile));
  1456.   if (!strlen($code)){
  1457.     return;
  1458.   }
  1459.  
  1460.   $code = trim($code);
  1461.   if (substr($code,0,5)=='<?php'){
  1462.     $code = substr($code,5);
  1463.   }
  1464.   if (substr($code,-2)=='?>'){
  1465.     $code = substr($code,0,strlen($code)-2);
  1466.   }
  1467.   if (isset($this->ez['numTemplates'])){
  1468.     $newNum = $this->ez['numTemplates'];
  1469.     $this->ez['numTemplates']++;
  1470.   } else {
  1471.     $newNum=0;
  1472.     $this->ez['numTemplates']=1;
  1473.     $this->ez['templates']=array();
  1474.   }
  1475.  
  1476.   $this->ez['templates'][$newNum]['code']=$code;
  1477.  
  1478.   return $newNum;
  1479. }
  1480.  
  1481. // ------------------------------------------------------------------------------
  1482.  
  1483. function execTemplate($id,$data=array(),$options=array()){
  1484.   // execute the given template on the current document.
  1485.   if (!isset($this->ez['templates'][$id])){
  1486.     return;
  1487.   }
  1488.   eval($this->ez['templates'][$id]['code']);
  1489. }
  1490.  
  1491. // ------------------------------------------------------------------------------
  1492. function ilink($info){
  1493.   $this->alink($info,1);
  1494. }
  1495.  
  1496. function alink($info,$internal=0){
  1497.   // a callback function to support the formation of clickable links within the document
  1498.   $lineFactor=0.05; // the thickness of the line as a proportion of the height. also the drop of the line.
  1499.   switch($info['status']){
  1500.     case 'start':
  1501.     case 'sol':
  1502.       // the beginning of the link
  1503.       // this should contain the URl for the link as the 'p' entry, and will also contain the value of 'nCallback'
  1504.       if (!isset($this->ez['links'])){
  1505.         $this->ez['links']=array();
  1506.       }
  1507.       $i = $info['nCallback'];
  1508.       $this->ez['links'][$i] = array('x'=>$info['x'],'y'=>$info['y'],'angle'=>$info['angle'],'decender'=>$info['decender'],'height'=>$info['height'],'url'=>$info['p']);
  1509.       if ($internal==0){
  1510.         $this->saveState();
  1511.         $this->setColor(0,0,1);
  1512.         $this->setStrokeColor(0,0,1);
  1513.         $thick = $info['height']*$lineFactor;
  1514.         $this->setLineStyle($thick);
  1515.       }
  1516.       break;
  1517.     case 'end':
  1518.     case 'eol':
  1519.       // the end of the link
  1520.       // assume that it is the most recent opening which has closed
  1521.       $i = $info['nCallback'];
  1522.       $start = $this->ez['links'][$i];
  1523.       // add underlining
  1524.       if ($internal){
  1525.         $this->addInternalLink($start['url'],$start['x'],$start['y']+$start['decender'],$info['x'],$start['y']+$start['decender']+$start['height']);
  1526.       } else {
  1527.         $a = deg2rad((float)$start['angle']-90.0);
  1528.         $drop = $start['height']*$lineFactor*1.5;
  1529.         $dropx = cos($a)*$drop;
  1530.         $dropy = -sin($a)*$drop;
  1531.         $this->line($start['x']-$dropx,$start['y']-$dropy,$info['x']-$dropx,$info['y']-$dropy);
  1532.         $this->addLink($start['url'],$start['x'],$start['y']+$start['decender'],$info['x'],$start['y']+$start['decender']+$start['height']);
  1533.         $this->restoreState();
  1534.       }
  1535.       break;
  1536.   }
  1537. }
  1538.  
  1539. // ------------------------------------------------------------------------------
  1540.  
  1541. function uline($info){
  1542.   // a callback function to support underlining
  1543.   $lineFactor=0.05; // the thickness of the line as a proportion of the height. also the drop of the line.
  1544.   switch($info['status']){
  1545.     case 'start':
  1546.     case 'sol':
  1547.     
  1548.       // the beginning of the underline zone
  1549.       if (!isset($this->ez['links'])){
  1550.         $this->ez['links']=array();
  1551.       }
  1552.       $i = $info['nCallback'];
  1553.       $this->ez['links'][$i] = array('x'=>$info['x'],'y'=>$info['y'],'angle'=>$info['angle'],'decender'=>$info['decender'],'height'=>$info['height']);
  1554.       $this->saveState();
  1555.       $thick = $info['height']*$lineFactor;
  1556.       $this->setLineStyle($thick);
  1557.       break;
  1558.     case 'end':
  1559.     case 'eol':
  1560.       // the end of the link
  1561.       // assume that it is the most recent opening which has closed
  1562.       $i = $info['nCallback'];
  1563.       $start = $this->ez['links'][$i];
  1564.       // add underlining
  1565.       $a = deg2rad((float)$start['angle']-90.0);
  1566.       $drop = $start['height']*$lineFactor*1.5;
  1567.       $dropx = cos($a)*$drop;
  1568.       $dropy = -sin($a)*$drop;
  1569.       $this->line($start['x']-$dropx,$start['y']-$dropy,$info['x']-$dropx,$info['y']-$dropy);
  1570.       $this->restoreState();
  1571.       break;
  1572.   }
  1573. }
  1574.  
  1575. // ------------------------------------------------------------------------------
  1576.  
  1577. }
  1578. ?>
  1579.