/public_html/vendors/fpdf/fpdf.php

Large files files are truncated, but you can click here to view the full file

<?php

/*******************************************************************************

* Software: FPDF                                                               *

* Version:  1.52(modified)                                                     *

* Date:     2003-12-30                                                         *

* Author:   Olivier PLATHEY                                                    *

* License:  Freeware                                                           *

*                                                                              *

* You may use, modify and redistribute this software as you wish.              *

*******************************************************************************/



// Modified by Renato A.C. [html2fpdf.sf.net]

// (look for 'EDITEI' in the code)



if(!class_exists('FPDF'))

{

    define('FPDF_VERSION','1.52');



    class FPDF

    {

        //Private properties

        var $DisplayPreferences=''; //EDITEI - added

        var $outlines=array(); //EDITEI - added

        var $OutlineRoot; //EDITEI - added

        var $flowingBlockAttr; //EDITEI - added

        var $page;               //current page number

        var $n;                  //current object number

        var $offsets;            //array of object offsets

        var $buffer;             //buffer holding in-memory PDF

        var $pages;              //array containing pages

        var $state;              //current document state

        var $compress;           //compression flag

        var $DefOrientation;     //default orientation

        var $CurOrientation;     //current orientation

        var $OrientationChanges; //array indicating orientation changes

        var $k;                  //scale factor (number of points in user unit)

        var $fwPt,$fhPt;         //dimensions of page format in points

        var $fw,$fh;             //dimensions of page format in user unit

        var $wPt,$hPt;           //current dimensions of page in points

        var $w,$h;               //current dimensions of page in user unit

        var $lMargin;            //left margin

        var $tMargin;            //top margin

        var $rMargin;            //right margin

        var $bMargin;            //page break margin

        var $cMargin;            //cell margin

        var $x,$y;               //current position in user unit for cell positioning

        var $lasth;              //height of last cell printed

        var $LineWidth;          //line width in user unit

        var $CoreFonts;          //array of standard font names

        var $fonts;              //array of used fonts

        var $FontFiles;          //array of font files

        var $diffs;              //array of encoding differences

        var $images;             //array of used images

        var $PageLinks;          //array of links in pages

        var $links;              //array of internal links

        var $FontFamily;         //current font family

        var $FontStyle;          //current font style

        var $underline;          //underlining flag

        var $CurrentFont;        //current font info

        var $FontSizePt;         //current font size in points

        var $FontSize;           //current font size in user unit

        var $DrawColor;          //commands for drawing color

        var $FillColor;          //commands for filling color

        var $TextColor;          //commands for text color

        var $ColorFlag;          //indicates whether fill and text colors are different

        var $ws;                 //word spacing

        var $AutoPageBreak;      //automatic page breaking

        var $PageBreakTrigger;   //threshold used to trigger page breaks

        var $InFooter;           //flag set when processing footer

        var $ZoomMode;           //zoom display mode

        var $LayoutMode;         //layout display mode

        var $title;              //title

        var $subject;            //subject

        var $author;             //author

        var $keywords;           //keywords

        var $creator;            //creator

        var $AliasNbPages;       //alias for total number of pages



/*******************************************************************************

*                                                                              *

*                               Public methods                                 *

*                                                                              *

*******************************************************************************/

        function FPDF($w=null,$orientation='P',$unit='mm',$format='A4')

        {

            //Some checks

            $this->_dochecks();

            //Initialization of properties

            $this->page=0;

            $this->n=2;

            $this->buffer='';

            $this->pages=array();

            $this->OrientationChanges=array();

            $this->state=0;

            $this->fonts=array();

            $this->FontFiles=array();

            $this->diffs=array();

            $this->images=array();

            $this->links=array();

            $this->InFooter=false;

            $this->lasth=0;

            $this->FontFamily='';

            $this->FontStyle='';

            $this->FontSizePt=12;

            $this->underline=false;

            $this->DrawColor='0 G';

            $this->FillColor='0 g';

            $this->TextColor='0 g';

            $this->ColorFlag=false;

            $this->ws=0;

            //Standard fonts

            $this->CoreFonts=array('courier'=>'Courier','courierB'=>'Courier-Bold','courierI'=>'Courier-Oblique','courierBI'=>'Courier-BoldOblique',

                'helvetica'=>'Helvetica','helveticaB'=>'Helvetica-Bold','helveticaI'=>'Helvetica-Oblique','helveticaBI'=>'Helvetica-BoldOblique',

                'times'=>'Times-Roman','timesB'=>'Times-Bold','timesI'=>'Times-Italic','timesBI'=>'Times-BoldItalic',

                'symbol'=>'Symbol','zapfdingbats'=>'ZapfDingbats');

            //Scale factor

            if($unit=='pt')	$this->k=1;

            elseif($unit=='mm')	$this->k=72/25.4;

            elseif($unit=='cm')	$this->k=72/2.54;

            elseif($unit=='in')	$this->k=72;

            else $this->Error('Incorrect unit: '.$unit);

            //Page format

            if(is_string($format))

            {

                $format=strtolower($format);

                if($format=='a3')	$format=array(841.89,1190.55);

                elseif($format=='a4')	$format=array(595.28,841.89);

                elseif($format=='a5')	$format=array(420.94,595.28);

                elseif($format=='letter')	$format=array(612,792);

                elseif($format=='legal') $format=array(612,1008);

                else $this->Error('Unknown page format: '.$format);

                $this->fwPt=$format[0];

                $this->fhPt=$format[1];

            }

            else

            {

                $this->fwPt=$format[0]*$this->k;

                $this->fhPt=$format[1]*$this->k;

            }

            $this->fw=$this->fwPt/$this->k;

            $this->fh=$this->fhPt/$this->k;

            //Page orientation

            $orientation=strtolower($orientation);

            if($orientation=='p' or $orientation=='portrait')

            {

                $this->DefOrientation='P';

                $this->wPt=$this->fwPt;

                $this->hPt=$this->fhPt;

            }

            elseif($orientation=='l' or $orientation=='landscape')

            {

                $this->DefOrientation='L';

                $this->wPt=$this->fhPt;

                $this->hPt=$this->fwPt;

            }

            else $this->Error('Incorrect orientation: '.$orientation);

            $this->CurOrientation=$this->DefOrientation;

            $this->w=$this->wPt/$this->k;

            $this->h=$this->hPt/$this->k;

            //Page margins (1 cm)

            $margin=28.35/$this->k;

            $this->SetMargins($margin,$margin);

            //Interior cell margin (1 mm)

            $this->cMargin=$margin/10;

            //Line width (0.2 mm)

            $this->LineWidth=.567/$this->k;

            //Automatic page break

            $this->SetAutoPageBreak(true,2*$margin);

            //Full width display mode

            $this->SetDisplayMode('fullwidth');

            //Compression

            $this->SetCompression(true);

        }



        function SetMargins($left,$top,$right=-1)

        {

            //Set left, top and right margins

            $this->lMargin=$left;

            $this->tMargin=$top;

            if($right==-1) $right=$left;

            $this->rMargin=$right;

        }



        function SetLeftMargin($margin)

        {

            //Set left margin

            $this->lMargin=$margin;

            if($this->page>0 and $this->x<$margin) $this->x=$margin;

        }



        function SetTopMargin($margin)

        {

            //Set top margin

            $this->tMargin=$margin;

        }



        function SetRightMargin($margin)

        {

            //Set right margin

            $this->rMargin=$margin;

        }



        function SetAutoPageBreak($auto,$margin=0)

        {

            //Set auto page break mode and triggering margin

            $this->AutoPageBreak=$auto;

            $this->bMargin=$margin;

            //debug($margin);

           // debug($this->h);

            $this->PageBreakTrigger=$this->h-$margin;

        }



        function SetDisplayMode($zoom,$layout='continuous')

        {

            //Set display mode in viewer

            if($zoom=='fullpage' or $zoom=='fullwidth' or $zoom=='real' or $zoom=='default' or !is_string($zoom))

            $this->ZoomMode=$zoom;

            else

            $this->Error('Incorrect zoom display mode: '.$zoom);

            if($layout=='single' or $layout=='continuous' or $layout=='two' or $layout=='default')

            $this->LayoutMode=$layout;

            else

            $this->Error('Incorrect layout display mode: '.$layout);

        }



        function SetCompression($compress)

        {

            //Set page compression

            if(function_exists('gzcompress'))	$this->compress=$compress;

            else $this->compress=false;

        }



        function SetTitle($title)

        {

            //Title of document

            $this->title=$title;

        }



        function SetSubject($subject)

        {

            //Subject of document

            $this->subject=$subject;

        }



        function SetAuthor($author)

        {

            //Author of document

            $this->author=$author;

        }



        function SetKeywords($keywords)

        {

            //Keywords of document

            $this->keywords=$keywords;

        }



        function SetCreator($creator)

        {

            //Creator of document

            $this->creator=$creator;

        }



        function AliasNbPages($alias='{nb}')

        {

            //Define an alias for total number of pages

            $this->AliasNbPages=$alias;

        }



        function Error($msg)

        {

            //Fatal error

            die('<B>FPDF error: </B>'.$msg);

        }



        function Open()

        {

            //Begin document

            if($this->state==0)	$this->_begindoc();

        }



        function Close()

        {

            //Terminate document

            if($this->state==3)	return;

            if($this->page==0) $this->AddPage();

            //Page footer

            $this->InFooter=true;

            $this->Footer();

            $this->InFooter=false;

            //Close page

            $this->_endpage();

            //Close document

            $this->_enddoc();

        }



        function AddPage($orientation='')

        {

            //Start a new page

            if($this->state==0) $this->Open();

            $family=$this->FontFamily;

            $style=$this->FontStyle.($this->underline ? 'U' : '');

            $size=$this->FontSizePt;

            $lw=$this->LineWidth;

            $dc=$this->DrawColor;

            $fc=$this->FillColor;

            $tc=$this->TextColor;

            $cf=$this->ColorFlag;

            if($this->page>0)

            {

                //Page footer

                $this->InFooter=true;

                $this->Footer();

                $this->InFooter=false;

                //Close page

                $this->_endpage();

            }

            //Start new page

            $this->_beginpage($orientation);

            //Set line cap style to square

            $this->_out('2 J');

            //Set line width

            $this->LineWidth=$lw;

            $this->_out(sprintf('%.2f w',$lw*$this->k));

            //Set font

            if($family)	$this->SetFont($family,$style,$size);

            //Set colors

            $this->DrawColor=$dc;

            if($dc!='0 G') $this->_out($dc);

            $this->FillColor=$fc;

            if($fc!='0 g') $this->_out($fc);

            $this->TextColor=$tc;

            $this->ColorFlag=$cf;

            //Page header

            $this->Header();

            //Restore line width

            if($this->LineWidth!=$lw)

            {

                $this->LineWidth=$lw;

                $this->_out(sprintf('%.2f w',$lw*$this->k));

            }

            //Restore font

            if($family)	$this->SetFont($family,$style,$size);

            //Restore colors

            if($this->DrawColor!=$dc)

            {

                $this->DrawColor=$dc;

                $this->_out($dc);

            }

            if($this->FillColor!=$fc)

            {

                $this->FillColor=$fc;

                $this->_out($fc);

            }

            $this->TextColor=$tc;

            $this->ColorFlag=$cf;

        }



        function Header()

        {

            //To be implemented in your own inherited class

        }



        function Footer()

        {

            //To be implemented in your own inherited class

        }



        function PageNo()

        {

            //Get current page number

            return $this->page;

        }



        function SetDrawColor($r,$g=-1,$b=-1)

        {

            //Set color for all stroking operations

            if(($r==0 and $g==0 and $b==0) or $g==-1)	$this->DrawColor=sprintf('%.3f G',$r/255);

            else $this->DrawColor=sprintf('%.3f %.3f %.3f RG',$r/255,$g/255,$b/255);

            if($this->page>0)	$this->_out($this->DrawColor);

        }



        function SetFillColor($r,$g=-1,$b=-1)

        {

            //Set color for all filling operations

            if(($r==0 and $g==0 and $b==0) or $g==-1)	$this->FillColor=sprintf('%.3f g',$r/255);

            else$this->FillColor=sprintf('%.3f %.3f %.3f rg',$r/255,$g/255,$b/255);

            $this->ColorFlag = ($this->FillColor != $this->TextColor);

            if($this->page>0)	$this->_out($this->FillColor);

        }



        function SetTextColor($r,$g=-1,$b=-1)

        {

            //Set color for text

            if(($r==0 and $g==0 and $b==0) or $g==-1)	$this->TextColor=sprintf('%.3f g',$r/255);

            else $this->TextColor=sprintf('%.3f %.3f %.3f rg',$r/255,$g/255,$b/255);

            $this->ColorFlag = ($this->FillColor != $this->TextColor);

        }



        function GetStringWidth($s)

        {

            //Get width of a string in the current font

            $s=(string)$s;

            $cw=&$this->CurrentFont['cw'];

            $w=0;

            $l=strlen($s);

            for($i=0;$i<$l;$i++) $w+=$cw[$s{$i}];

            return $w*$this->FontSize/1000;

        }



        function SetLineWidth($width)

        {

            //Set line width

            $this->LineWidth=$width;

            if($this->page>0)	$this->_out(sprintf('%.2f w',$width*$this->k));

        }



        function Line($x1,$y1,$x2,$y2)

        {

            //Draw a line

            $this->_out(sprintf('%.2f %.2f m %.2f %.2f l S',$x1*$this->k,($this->h-$y1)*$this->k,$x2*$this->k,($this->h-$y2)*$this->k));

        }



        function Rect($x,$y,$w,$h,$style='')

        {

            //Draw a rectangle

            if($style=='F')	$op='f';

            elseif($style=='FD' or $style=='DF') $op='B';

            else $op='S';

            $this->_out(sprintf('%.2f %.2f %.2f %.2f re %s',$x*$this->k,($this->h-$y)*$this->k,$w*$this->k,-$h*$this->k,$op));

        }



        function AddFont($family,$style='',$file='')

        {

            //Add a TrueType or Type1 font

            $family=strtolower($family);

            if($family=='arial') $family='helvetica';

            $style=strtoupper($style);

            if($style=='IB') $style='BI';

            if(isset($this->fonts[$family.$style]))	$this->Error('Font already added: '.$family.' '.$style);

            if($file=='')	$file=str_replace(' ','',$family).strtolower($style).'.php';

            if(defined('FPDF_FONTPATH')) $file=FPDF_FONTPATH.$file;

            //debug($file);

            include($file);

            if(!isset($name))	$this->Error('Could not include font definition file');

            $i=count($this->fonts)+1;

            $this->fonts[$family.$style]=array('i'=>$i,'type'=>$type,'name'=>$name,'desc'=>$desc,'up'=>$up,'ut'=>$ut,'cw'=>$cw,'enc'=>$enc,'file'=>$file);

            if($diff)

            {

                //Search existing encodings

                $d=0;

                $nb=count($this->diffs);

                for($i=1;$i<=$nb;$i++)

                if($this->diffs[$i]==$diff)

                {

                    $d=$i;

                    break;

                }

                if($d==0)

                {

                    $d=$nb+1;

                    $this->diffs[$d]=$diff;

                }

                $this->fonts[$family.$style]['diff']=$d;

            }

            if($file)

            {

                if($type=='TrueType')	$this->FontFiles[$file]=array('length1'=>$originalsize);

                else $this->FontFiles[$file]=array('length1'=>$size1,'length2'=>$size2);

            }

        }



        function SetFont($family,$style='',$size=0)

        {

            //Select a font; size given in points

            global $fpdf_charwidths;



            $family=strtolower($family);

            if($family=='')	$family=$this->FontFamily;

            //EDITEI - now understands: monospace,serif,sans [serif]

            if($family=='monospace') $family='courier';

            if($family=='serif') $family='times';

            if($family=='sans') $family='arial';

            if($family=='arial') $family='helvetica';

            elseif($family=='symbol' or $family=='zapfdingbats') $style='';

            $style=strtoupper($style);

            if(is_int(strpos($style,'U')))

            {

                $this->underline=true;

                $style=str_replace('U','',$style);

            }

            else $this->underline=false;

            if ($style=='IB') $style='BI';

            if ($size==0) $size=$this->FontSizePt;

            //Test if font is already selected

            if($this->FontFamily==$family and $this->FontStyle==$style and $this->FontSizePt==$size) return;

            //Test if used for the first time

            $fontkey=$family.$style;

            if(!isset($this->fonts[$fontkey]))

            {

                //Check if one of the standard fonts

                if(isset($this->CoreFonts[$fontkey]))

                {

                    if(!isset($fpdf_charwidths[$fontkey]))

                    {

                        //Load metric file

                        $file=$family;

                        if($family=='times' or $family=='helvetica') $file.=strtolower($style);

                        $file.='.php';

                        if(defined('FPDF_FONTPATH')) $file=FPDF_FONTPATH.$file;

                        include($file);

                        if(!isset($fpdf_charwidths[$fontkey])) $this->Error('Could not include font metric file');

                    }

                    $i=count($this->fonts)+1;

                    $this->fonts[$fontkey]=array('i'=>$i,'type'=>'core','name'=>$this->CoreFonts[$fontkey],'up'=>-100,'ut'=>50,'cw'=>$fpdf_charwidths[$fontkey]);

                }

                else $this->Error('Undefined font: '.$family.' '.$style);

            }

            //Select it

            $this->FontFamily=$family;

            $this->FontStyle=$style;

            $this->FontSizePt=$size;

            $this->FontSize=$size/$this->k;

            $this->CurrentFont=&$this->fonts[$fontkey];

            if($this->page>0)

            $this->_out(sprintf('BT /F%d %.2f Tf ET',$this->CurrentFont['i'],$this->FontSizePt));

        }



        function SetFontSize($size)

        {

            //Set font size in points

            if($this->FontSizePt==$size) return;

            $this->FontSizePt=$size;

            $this->FontSize=$size/$this->k;

            if($this->page>0)

            $this->_out(sprintf('BT /F%d %.2f Tf ET',$this->CurrentFont['i'],$this->FontSizePt));

        }



        function AddLink()

        {

            //Create a new internal link

            $n=count($this->links)+1;

            $this->links[$n]=array(0,0);

            return $n;

        }



        function SetLink($link,$y=0,$page=-1)

        {

            //Set destination of internal link

            if($y==-1) $y=$this->y;

            if($page==-1)	$page=$this->page;

            $this->links[$link]=array($page,$y);

        }



        function Link($x,$y,$w,$h,$link)

        {

            //Put a link on the page

            $this->PageLinks[$this->page][]=array($x*$this->k,$this->hPt-$y*$this->k,$w*$this->k,$h*$this->k,$link);

        }



        function Text($x,$y,$txt)

        {

            //Output a string

            $s=sprintf('BT %.2f %.2f Td (%s) Tj ET',$x*$this->k,($this->h-$y)*$this->k,$this->_escape($txt));

            if($this->underline and $txt!='')	$s.=' '.$this->_dounderline($x,$y,$txt);

            if($this->ColorFlag) $s='q '.$this->TextColor.' '.$s.' Q';

            $this->_out($s);

        }



        function AcceptPageBreak()

        {

            //Accept automatic page break or not

            return $this->AutoPageBreak;

        }



        function Cell($w,$h=0,$txt='',$border=0,$ln=0,$align='',$fill=0,$link='',$currentx=0) //EDITEI

        {

            //Output a cell

            //debug($this->y+$h);

            //debug($this->PageBreakTrigger);

            $k=$this->k;

            if($this->y+$h>$this->PageBreakTrigger and !$this->InFooter and $this->AcceptPageBreak())

            {

                

                //Automatic page break

                $x=$this->x;//Current X position

                $ws=$this->ws;//Word Spacing

                if($ws>0)

                {

                    $this->ws=0;

                    $this->_out('0 Tw');

                }

                

                $this->AddPage($this->CurOrientation);

                $this->x=$x;

                if($ws>0)

                {

                    $this->ws=$ws;

                    $this->_out(sprintf('%.3f Tw',$ws*$k));

                }

            }

            if($w==0) $w = $this->w-$this->rMargin-$this->x;

            $s='';

            if($fill==1 or $border==1)

            {

                if ($fill==1) $op=($border==1) ? 'B' : 'f';

                else $op='S';

                //$op='S';//DEBUG

                $s=sprintf('%.2f %.2f %.2f %.2f re %s ',$this->x*$k,($this->h-$this->y)*$k,$w*$k,-$h*$k,$op);

            }

            if(is_string($border))

            {

                $x=$this->x;

                $y=$this->y;

                if(is_int(strpos($border,'L')))

                $s.=sprintf('%.2f %.2f m %.2f %.2f l S ',$x*$k,($this->h-$y)*$k,$x*$k,($this->h-($y+$h))*$k);

                if(is_int(strpos($border,'T')))

                $s.=sprintf('%.2f %.2f m %.2f %.2f l S ',$x*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-$y)*$k);

                if(is_int(strpos($border,'R')))

                $s.=sprintf('%.2f %.2f m %.2f %.2f l S ',($x+$w)*$k,($this->h-$y)*$k,($x+$w)*$k,($this->h-($y+$h))*$k);

                if(is_int(strpos($border,'B')))

                $s.=sprintf('%.2f %.2f m %.2f %.2f l S ',$x*$k,($this->h-($y+$h))*$k,($x+$w)*$k,($this->h-($y+$h))*$k);

            }

            if($txt!='')

            {

                if($align=='R')	$dx=$w-$this->cMargin-$this->GetStringWidth($txt);

                elseif($align=='C')	$dx=($w-$this->GetStringWidth($txt))/2;

                elseif($align=='L' or $align=='J') $dx=$this->cMargin;

                else $dx = 0;

                if($this->ColorFlag) $s.='q '.$this->TextColor.' ';

                $txt2=str_replace(')','\\)',str_replace('(','\\(',str_replace('\\','\\\\',$txt)));

                //Check whether we are going to outline text or not

                if($this->outline_on)

                {

                    $s.=' '.sprintf('%.2f w',$this->LineWidth*$this->k).' ';

                    $s.=" $this->DrawColor ";

                    $s.=" 2 Tr ";

                }

                //Superscript and Subscript Y coordinate adjustment

                $adjusty = 0;

                if($this->SUB) $adjusty = 1;

                if($this->SUP) $adjusty = -1;

                //End of coordinate adjustment

                $s.=sprintf('BT %.2f %.2f Td (%s) Tj ET',($this->x+$dx)*$k,($this->h-(($this->y+$adjusty)+.5*$h+.3*$this->FontSize))*$k,$txt2); //EDITEI

                if($this->underline)

                $s.=' '.$this->_dounderline($this->x+$dx,$this->y+.5*$h+.3*$this->FontSize+$adjusty,$txt2);

                //Superscript and Subscript Y coordinate adjustment (now for striked-through texts)

                $adjusty = 1.6;

                if($this->SUB) $adjusty = 3.05;

                if($this->SUP) $adjusty = 1.1;

                //End of coordinate adjustment

                if($this->strike) //EDITEI

                $s.=' '.$this->_dounderline($this->x+$dx,$this->y+$adjusty,$txt);

                if($this->ColorFlag) $s.=' Q';

                if($link!='') $this->Link($this->x+$dx,$this->y+.5*$h-.5*$this->FontSize,$this->GetStringWidth($txt),$this->FontSize,$link);

            }

            if($s) $this->_out($s);

            $this->lasth=$h;

            if( strpos($txt,"\n") !== false) $ln=1; //EDITEI - cell now recognizes \n! << comes from <BR> tag

            if($ln>0)

            {

                //Go to next line

                $this->y += $h;

                if($ln==1) //EDITEI

                {

                    //Move to next line

                    if ($currentx != 0) $this->x=$currentx;

                    else $this->x=$this->lMargin;

                }

            }

            else $this->x+=$w;

        }



        //EDITEI

        function MultiCell($w,$h,$txt,$border=0,$align='J',$fill=0,$link='')

        {

            //Output text with automatic or explicit line breaks

            $cw=&$this->CurrentFont['cw'];

            if($w==0)	$w=$this->w-$this->rMargin-$this->x;

            $wmax=($w-2*$this->cMargin)*1000/$this->FontSize;

            $s=str_replace("\r",'',$txt);

            $nb=strlen($s);

            if($nb>0 and $s[$nb-1]=="\n")	$nb--;

            $b=0;

            if($border)

            {

                if($border==1)

                {

                    $border='LTRB';

                    $b='LRT';

                    $b2='LR';

                }

                else

                {

                    $b2='';

                    if(is_int(strpos($border,'L')))	$b2.='L';

                    if(is_int(strpos($border,'R')))	$b2.='R';

                    $b=is_int(strpos($border,'T')) ? $b2.'T' : $b2;

                }

            }

            $sep=-1;

            $i=0;

            $j=0;

            $l=0;

            $ns=0;

            $nl=1;

            while($i<$nb)

            {

                //Get next character

                $c=$s{$i};

                if($c=="\n")

                {

                    //Explicit line break

                    if($this->ws>0)

                    {

                        $this->ws=0;

                        $this->_out('0 Tw');

                    }

                    $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill,$link);

                    $i++;

                    $sep=-1;

                    $j=$i;

                    $l=0;

                    $ns=0;

                    $nl++;

                    if($border and $nl==2) $b=$b2;

                    continue;

                }

                if($c==' ')

                {

                    $sep=$i;

                    $ls=$l;

                    $ns++;

                }

                $l+=$cw[$c];

                if($l>$wmax)

                {

                    //Automatic line break

                    if($sep==-1)

                    {

                        if($i==$j) $i++;

                        if($this->ws>0)

                        {

                            $this->ws=0;

                            $this->_out('0 Tw');

                        }

                        $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill,$link);

                    }

                    else

                    {

                        if($align=='J')

                        {

                            $this->ws=($ns>1) ? ($wmax-$ls)/1000*$this->FontSize/($ns-1) : 0;

                            $this->_out(sprintf('%.3f Tw',$this->ws*$this->k));

                        }

                        $this->Cell($w,$h,substr($s,$j,$sep-$j),$b,2,$align,$fill,$link);

                        $i=$sep+1;

                    }

                    $sep=-1;

                    $j=$i;

                    $l=0;

                    $ns=0;

                    $nl++;

                    if($border and $nl==2) $b=$b2;

                }

                else $i++;

            }

            //Last chunk

            if($this->ws>0)

            {

                $this->ws=0;

                $this->_out('0 Tw');

            }

            if($border and is_int(strpos($border,'B')))	$b.='B';

            $this->Cell($w,$h,substr($s,$j,$i-$j),$b,2,$align,$fill,$link);

            $this->x=$this->lMargin;

        }



        function Write($h,$txt,$currentx=0,$link='') //EDITEI

        {

            //Output text in flowing mode

            $cw=&$this->CurrentFont['cw'];

            $w=$this->w-$this->rMargin-$this->x;

            $wmax=($w-2*$this->cMargin)*1000/$this->FontSize;

            $s=str_replace("\r",'',$txt);

            $nb=strlen($s);

            $sep=-1;

            $i=0;

            $j=0;

            $l=0;

            $nl=1;

            while($i<$nb)

            {

                //Get next character

                $c=$s{$i};

                if($c=="\n")

                {

                    //Explicit line break

                    $this->Cell($w,$h,substr($s,$j,$i-$j),0,2,'',0,$link);

                    $i++;

                    $sep=-1;

                    $j=$i;

                    $l=0;

                    if($nl==1)

                    {

                        if ($currentx != 0) $this->x=$currentx;//EDITEI

                        else $this->x=$this->lMargin;

                        $w=$this->w-$this->rMargin-$this->x;

                        $wmax=($w-2*$this->cMargin)*1000/$this->FontSize;

                    }

                    $nl++;

                    continue;

                }

                if($c == ' ') $sep=$i;

                $l += $cw[$c];

                if($l > $wmax)

                {

                    //Automatic line break

                    if($sep==-1)

                    {

                        if($this->x > $this->lMargin)

                        {

                            //Move to next line

                            if ($currentx != 0) $this->x=$currentx;//EDITEI

                            else $this->x=$this->lMargin;

                            $this->y+=$h;

                            $w=$this->w-$this->rMargin-$this->x;

                            $wmax=($w-2*$this->cMargin)*1000/$this->FontSize;

                            $i++;

                            $nl++;

                            continue;

                        }

                        if($i==$j) $i++;

                        $this->Cell($w,$h,substr($s,$j,$i-$j),0,2,'',0,$link);

                    }

                    else

                    {

                        $this->Cell($w,$h,substr($s,$j,$sep-$j),0,2,'',0,$link);

                        $i=$sep+1;

                    }

                    $sep=-1;

                    $j=$i;

                    $l=0;

                    if($nl==1)

                    {

                        if ($currentx != 0) $this->x=$currentx;//EDITEI

                        else $this->x=$this->lMargin;

                        $w=$this->w-$this->rMargin-$this->x;

                        $wmax=($w-2*$this->cMargin)*1000/$this->FontSize;

                    }

                    $nl++;

                }

                else $i++;

            }

            //Last chunk

            if($i!=$j) $this->Cell($l/1000*$this->FontSize,$h,substr($s,$j),0,0,'',0,$link);

        }



        //-------------------------FLOWING BLOCK------------------------------------//

        //EDITEI some things (added/changed)                                        //

        //The following functions were originally written by Damon Kohler           //

        //--------------------------------------------------------------------------//



        function saveFont()

        {

            $saved = array();

            $saved[ 'family' ] = $this->FontFamily;

            $saved[ 'style' ] = $this->FontStyle;

            $saved[ 'sizePt' ] = $this->FontSizePt;

            $saved[ 'size' ] = $this->FontSize;

            $saved[ 'curr' ] =& $this->CurrentFont;

            $saved[ 'color' ] = $this->TextColor; //EDITEI

            $saved[ 'bgcolor' ] = $this->FillColor; //EDITEI

            $saved[ 'HREF' ] = $this->HREF; //EDITEI

            $saved[ 'underline' ] = $this->underline; //EDITEI

            $saved[ 'strike' ] = $this->strike; //EDITEI

            $saved[ 'SUP' ] = $this->SUP; //EDITEI

            $saved[ 'SUB' ] = $this->SUB; //EDITEI

            $saved[ 'linewidth' ] = $this->LineWidth; //EDITEI

            $saved[ 'drawcolor' ] = $this->DrawColor; //EDITEI

            $saved[ 'is_outline' ] = $this->outline_on; //EDITEI



            return $saved;

        }



        function restoreFont( $saved )

        {

            $this->FontFamily = $saved[ 'family' ];

            $this->FontStyle = $saved[ 'style' ];

            $this->FontSizePt = $saved[ 'sizePt' ];

            $this->FontSize = $saved[ 'size' ];

            $this->CurrentFont =& $saved[ 'curr' ];

            $this->TextColor = $saved[ 'color' ]; //EDITEI

            $this->FillColor = $saved[ 'bgcolor' ]; //EDITEI

            $this->ColorFlag = ($this->FillColor != $this->TextColor); //Restore ColorFlag as well

            $this->HREF = $saved[ 'HREF' ]; //EDITEI

            $this->underline = $saved[ 'underline' ]; //EDITEI

            $this->strike = $saved[ 'strike' ]; //EDITEI

            $this->SUP = $saved[ 'SUP' ]; //EDITEI

            $this->SUB = $saved[ 'SUB' ]; //EDITEI

            $this->LineWidth = $saved[ 'linewidth' ]; //EDITEI

            $this->DrawColor = $saved[ 'drawcolor' ]; //EDITEI

            $this->outline_on = $saved[ 'is_outline' ]; //EDITEI



            if( $this->page > 0)

            $this->_out( sprintf( 'BT /F%d %.2f Tf ET', $this->CurrentFont[ 'i' ], $this->FontSizePt ) );

        }



        function newFlowingBlock( $w, $h, $b = 0, $a = 'J', $f = 0 , $is_table = false )

        {

            // cell width in points

            if ($is_table)  $this->flowingBlockAttr[ 'width' ] = ($w * $this->k);

            else $this->flowingBlockAttr[ 'width' ] = ($w * $this->k) - (2*$this->cMargin*$this->k);

            // line height in user units

            $this->flowingBlockAttr[ 'is_table' ] = $is_table;

            $this->flowingBlockAttr[ 'height' ] = $h;

            $this->flowingBlockAttr[ 'lineCount' ] = 0;

            $this->flowingBlockAttr[ 'border' ] = $b;

            $this->flowingBlockAttr[ 'align' ] = $a;

            $this->flowingBlockAttr[ 'fill' ] = $f;

            $this->flowingBlockAttr[ 'font' ] = array();

            $this->flowingBlockAttr[ 'content' ] = array();

            $this->flowingBlockAttr[ 'contentWidth' ] = 0;

        }



        function finishFlowingBlock($outofblock=false)

        {

            if (!$outofblock) $currentx = $this->x; //EDITEI - in order to make the Cell method work better

            //prints out the last chunk

            $is_table = $this->flowingBlockAttr[ 'is_table' ];

            $maxWidth =& $this->flowingBlockAttr[ 'width' ];

            $lineHeight =& $this->flowingBlockAttr[ 'height' ];

            $border =& $this->flowingBlockAttr[ 'border' ];

            $align =& $this->flowingBlockAttr[ 'align' ];

            $fill =& $this->flowingBlockAttr[ 'fill' ];

            $content =& $this->flowingBlockAttr[ 'content' ];

            $font =& $this->flowingBlockAttr[ 'font' ];

            $contentWidth =& $this->flowingBlockAttr[ 'contentWidth' ];

            $lineCount =& $this->flowingBlockAttr[ 'lineCount' ];



            // set normal spacing

            $this->_out( sprintf( '%.3f Tw', 0 ) );

            $this->ws = 0;



            // the amount of space taken up so far in user units

            $usedWidth = 0;



            // Print out each chunk

            //EDITEI - Print content according to alignment

            $empty = $maxWidth - $contentWidth;

            $empty /= $this->k;

            $b = ''; //do not use borders

            $arraysize = count($content);

            $margins = (2*$this->cMargin);

            if ($outofblock)

            {

                $align = 'C';

                $empty = 0;

                $margins = $this->cMargin;

            }

            switch($align)

            {

                case 'R':

                foreach ( $content as $k => $chunk )

                {

                    $this->restoreFont( $font[ $k ] );

                    $stringWidth = $this->GetStringWidth( $chunk ) + ( $this->ws * substr_count( $chunk, ' ' ) / $this->k );

                    // determine which borders should be used

                    $b = '';

                    if ( $lineCount == 1 && is_int( strpos( $border, 'T' ) ) ) $b .= 'T';

                    if ( $k == count( $content ) - 1 && is_int( strpos( $border, 'R' ) ) ) $b .= 'R';



                    if ($k == $arraysize-1 and !$outofblock) $skipln = 1;

                    else $skipln = 0;



                    if ($arraysize == 1) $this->Cell( $stringWidth + $margins + $empty, $lineHeight, $chunk, $b, $skipln, $align, $fill, $this->HREF , $currentx ); //mono-style line

                    elseif ($k == 0) $this->Cell( $stringWidth + ($margins/2) + $empty, $lineHeight, $chunk, $b, 0, 'R', $fill, $this->HREF );//first part

                    elseif ($k == $arraysize-1 ) $this->Cell( $stringWidth + ($margins/2), $lineHeight, $chunk, $b, $skipln, '', $fill, $this->HREF, $currentx );//last part

                    else $this->Cell( $stringWidth , $lineHeight, $chunk, $b, 0, '', $fill, $this->HREF );//middle part

                }

                break;

                case 'L':

                case 'J':

                foreach ( $content as $k => $chunk )

                {

                    $this->restoreFont( $font[ $k ] );

                    $stringWidth = $this->GetStringWidth( $chunk ) + ( $this->ws * substr_count( $chunk, ' ' ) / $this->k );

                    // determine which borders should be used

                    $b = '';

                    if ( $lineCount == 1 && is_int( strpos( $border, 'T' ) ) ) $b .= 'T';

                    if ( $k == 0 && is_int( strpos( $border, 'L' ) ) ) $b .= 'L';



                    if ($k == $arraysize-1 and !$outofblock) $skipln = 1;

                    else $skipln = 0;



                    if (!$is_table and !$outofblock and !$fill and $align=='L' and $k == 0) {$align='';$margins=0;} //Remove margins in this special (though often) case



                    if ($arraysize == 1) $this->Cell( $stringWidth + $margins + $empty, $lineHeight, $chunk, $b, $skipln, $align, $fill, $this->HREF , $currentx ); //mono-style line

                    elseif ($k == 0) $this->Cell( $stringWidth + ($margins/2), $lineHeight, $chunk, $b, $skipln, $align, $fill, $this->HREF );//first part

                    elseif ($k == $arraysize-1 ) $this->Cell( $stringWidth + ($margins/2) + $empty, $lineHeight, $chunk, $b, $skipln, '', $fill, $this->HREF, $currentx );//last part

                    else $this->Cell( $stringWidth , $lineHeight, $chunk, $b, $skipln, '', $fill, $this->HREF );//middle part

                }

                break;

                case 'C':

                foreach ( $content as $k => $chunk )

                {

                    $this->restoreFont( $font[ $k ] );

                    $stringWidth = $this->GetStringWidth( $chunk ) + ( $this->ws * substr_count( $chunk, ' ' ) / $this->k );

                    // determine which borders should be used

                    $b = '';

                    if ( $lineCount == 1 && is_int( strpos( $border, 'T' ) ) ) $b .= 'T';



                    if ($k == $arraysize-1 and !$outofblock) $skipln = 1;

                    else $skipln = 0;



                    if ($arraysize == 1) $this->Cell( $stringWidth + $margins + $empty, $lineHeight, $chunk, $b, $skipln, $align, $fill, $this->HREF , $currentx ); //mono-style line

                    elseif ($k == 0) $this->Cell( $stringWidth + ($margins/2) + ($empty/2), $lineHeight, $chunk, $b, 0, 'R', $fill, $this->HREF );//first part

                    elseif ($k == $arraysize-1 ) $this->Cell( $stringWidth + ($margins/2) + ($empty/2), $lineHeight, $chunk, $b, $skipln, 'L', $fill, $this->HREF, $currentx );//last part

                    else $this->Cell( $stringWidth , $lineHeight, $chunk, $b, 0, '', $fill, $this->HREF );//middle part

                }

                break;

                default: break;

            }

        }



        function WriteFlowingBlock( $s , $outofblock = false )

        {

            if (!$outofblock) $currentx = $this->x; //EDITEI - in order to make the Cell method work better

            $is_table = $this->flowingBlockAttr[ 'is_table' ];

            // width of all the content so far in points

            $contentWidth =& $this->flowingBlockAttr[ 'contentWidth' ];

            // cell width in points

            $maxWidth =& $this->flowingBlockAttr[ 'width' ];

            $lineCount =& $this->flowingBlockAttr[ 'lineCount' ];

            // line height in user units

            $lineHeight =& $this->flowingBlockAttr[ 'height' ];

            $border =& $this->flowingBlockAttr[ 'border' ];

            $align =& $this->flowingBlockAttr[ 'align' ];

            $fill =& $this->flowingBlockAttr[ 'fill' ];

            $content =& $this->flowingBlockAttr[ 'content' ];

            $font =& $this->flowingBlockAttr[ 'font' ];



            $font[] = $this->saveFont();

            $content[] = '';



            $currContent =& $content[ count( $content ) - 1 ];



            // where the line should be cutoff if it is to be justified

            $cutoffWidth = $contentWidth;



            // for every character in the string

            for ( $i = 0; $i < strlen( $s ); $i++ )

            {

                // extract the current character

                $c = $s{$i};

                // get the width of the character in points

                $cw = $this->CurrentFont[ 'cw' ][ $c ] * ( $this->FontSizePt / 1000 );



                if ( $c == ' ' )

                {

                    $currContent .= ' ';

                    $cutoffWidth = $contentWidth;

                    $contentWidth += $cw;

                    continue;

                }

                // try adding another char

                if ( $contentWidth + $cw > $maxWidth )

                {

                    // it won't fit, output what we already have

                    $lineCount++;

                    //Readjust MaxSize in order to use the whole page width

                    if ($outofblock and ($lineCount == 1) ) $maxWidth = $this->pgwidth * $this->k;

                    // contains any content that didn't make it into this print

                    $savedContent = '';

                    $savedFont = array();

                    // first, cut off and save any partial words at the end of the string

                    $words = explode( ' ', $currContent );



                    // if it looks like we didn't finish any words for this chunk

                    if ( count( $words ) == 1 )

                    {

                        // save and crop off the content currently on the stack

                        $savedContent = array_pop( $content );

                        $savedFont = array_pop( $font );



                        // trim any trailing spaces off the last bit of content

                        $currContent =& $content[ count( $content ) - 1 ];

                        $currContent = rtrim( $currContent );

                    }

                    else // otherwise, we need to find which bit to cut off

                    {

                        $lastContent = '';

                        for ( $w = 0; $w < count( $words ) - 1; $w++) $lastContent .= "{$words[ $w ]} ";



                        $savedContent = $words[ count( $words ) - 1 ];

                        $savedFont = $this->saveFont();

                        // replace the current content with the cropped version

                        $currContent = rtrim( $lastContent );

                    }

                    // update $contentWidth and $cutoffWidth since they changed with cropping

                    $contentWidth = 0;

                    

                    foreach ( $content as $k => $chunk )

                    {

                          $this->restoreFont( $font[ $k ] );

                          $contentWidth += $this->GetStringWidth( $chunk ) * $this->k;

                    }

                    $cutoffWidth = $contentWidth;

                    // if it's justified, we need to find the char spacing

                    if( $align == 'J' )

                    {

                        // count how many spaces there are in the entire content string

                        $numSpaces = 0;

                        foreach ( $content as $chunk ) $numSpaces += substr_count( $chunk, ' ' );

                        // if there's more than one space, find word spacing in points

                        if ( $numSpaces > 0 ) $this->ws = ( $maxWidth - $cutoffWidth ) / $numSpaces;

                        else $this->ws = 0;

                        $this->_out( sprintf( '%.3f Tw', $this->ws ) );

                    }

                    // otherwise, we want normal spacing

                    else $this->_out( sprintf( '%.3f Tw', 0 ) );



                    //EDITEI - Print content according to alignment

                    if (!isset($numSpaces)) $numSpaces = 0;

                    $contentWidth -= ($this->ws*$numSpaces);

                    $empty = $maxWidth - $contentWidth - 2*($this->ws*$numSpaces);

                    $empty /= $this->k;

                    $b = ''; //do not use borders

           /*'If' below used in order to fix "first-line of other page with justify on" bug*/

                    if($this->y+$this->divheight>$this->PageBreakTrigger and !$this->InFooter and $this->AcceptPageBreak())

                    {

                        $bak_x=$this->x;//Current X position

                        $ws=$this->ws;//Word Spacing

                        if($ws>0)

                        {

                            $this->ws=0;

                            $this->_out('0 Tw');

                        }

                        debug('calling add Page');

                        $this->AddPage($this->CurOrientation);

                        $this->x=$bak_x;

                        if($ws>0)

                        {

                            $this->ws=$ws;

                            $this->_out(sprintf('%.3f Tw',$ws));

                        }

                    }

                    $arraysize = count($content);

                    $margins = (2*$this->cMargin);

                    if ($outofblock)

                    {

                        $align = 'C';

                        $empty = 0;

                        $margins = $this->cMargin;

                    }

                    switch($align)

                    {

                        case 'R':

                        foreach ( $content as $k => $chunk )

                        {

                            $this->restoreFont( $font[ $k ] );

                            $stringWidth = $this->GetStringWidth( $chunk ) + ( …