HTML2PDF_myPdf::getH() - Code Metrics - iNextrix/ASTPP - Measure and Improve Code Quality continuously with Scrutinizer

HTML2PDF_myPdf::getH() A
last analyzed 2017-06-12 08:08 UTC

↳ Parent: HTML2PDF_myPdf
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0
<?php
/**
 * HTML2PDF Librairy - myPdf class
 *
 * HTML => PDF convertor
 * distributed under the LGPL License
 *
 * @author    Laurent MINGUET <[email protected]>
 * @version   4.03
 */

require_once(dirname(__FILE__).'/tcpdfConfig.php');
require_once(dirname(__FILE__).'/../_tcpdf_'.HTML2PDF_USED_TCPDF_VERSION.'/tcpdf.php');

class HTML2PDF_myPdf extends TCPDF
{
    protected $_footerParam = array();
    protected $_transf      = array();
    protected $_myLastPageGroup = null;
    protected $_myLastPageGroupNb = 0;

    // used to make a radius with bezier : (4/3 * (sqrt(2) - 1))
    const MY_ARC = 0.5522847498;

    // nb of segment to build a arc with bezier curv
    const ARC_NB_SEGMENT = 8;

    /**
     * class constructor
     *
     * @param string  $orientation page orientation, same as TCPDF
     * @param string  $unit        User measure unit, same as TCPDF
     * @param mixed   $format      The format used for pages, same as TCPDF
     * @param boolean $unicode     TRUE means that the input text is unicode (default = true)
     * @param String  $encoding    charset encoding; default is UTF-8
     * @param boolean $diskcache   if TRUE reduce the RAM memory usage by caching temporary data on filesystem (slower).
     * @access public
     */
    public function __construct(
        $orientation = 'P',
        $unit = 'mm',
        $format = 'A4',
        $unicode = true,
        $encoding = 'UTF-8',
        $diskcache = false)
    {
        // call the parent constructor
        parent::__construct($orientation, $unit, $format, $unicode, $encoding, $diskcache);

        // init the specific parameters used by HTML2PDF
        $this->SetCreator(PDF_CREATOR);
        $this->SetAutoPageBreak(false, 0);
        $this->linestyleCap = '2 J';
        $this->setPrintHeader(false);
        $this->jpeg_quality = 90;

        // prepare the automatic footer
        $this->SetMyFooter();

        $this->cMargin = 0;
    }

    /**
     * Set the parameters for the automatic footer
     *
     * @param boolean $page display the page number
     * @param boolean $date display the date
     * @param boolean $hour display the hour
     * @param boolean $form display a warning abour forms
     * @access public
     */
    public function SetMyFooter($page = false, $date = false, $hour = false, $form = false)
    {
        $page    = ($page ? true : false);
        $date    = ($date ? true : false);
        $hour    = ($hour ? true : false);
        $form    = ($form ? true : false);

        $this->_footerParam = array('page' => $page, 'date' => $date, 'hour' => $hour, 'form' => $form);
    }

    /**
     * This function is call automatically by TCPDF at the end of a page
     * It takes no parameters
     *
     * @access public
     */
    public function Footer()
    {
        // prepare the text from the tranlated text
        $txt = '';
        if ($this->_footerParam['form']) {
            $txt = (HTML2PDF_locale::get('pdf05'));
        }
        if ($this->_footerParam['date'] && $this->_footerParam['hour']) {
            $txt .= ($txt ? ' - ' : '').(HTML2PDF_locale::get('pdf03'));
        }
        if ($this->_footerParam['date'] && ! $this->_footerParam['hour']) {
            $txt .= ($txt ? ' - ' : '').(HTML2PDF_locale::get('pdf01'));
        }
        if ( ! $this->_footerParam['date'] && $this->_footerParam['hour']) {
            $txt .= ($txt ? ' - ' : '').(HTML2PDF_locale::get('pdf02'));
        }
        if ($this->_footerParam['page']) {
            $txt .= ($txt ? ' - ' : '').(HTML2PDF_locale::get('pdf04'));
        }

        if (strlen($txt) > 0) {
            // replace some values
            $toReplace = array(
                '[[date_d]]'  => date('d'),
                '[[date_m]]'  => date('m'),
                '[[date_y]]'  => date('Y'),
                '[[date_h]]'  => date('H'),
                '[[date_i]]'  => date('i'),
                '[[date_s]]'  => date('s'),
                '[[page_cu]]' => $this->getMyNumPage(),
                '[[page_nb]]' => $this->getMyAliasNbPages(),
            );
            $txt = str_replace(array_keys($toReplace), array_values($toReplace), $txt);

            // draw the footer
            parent::SetY(-11);
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
            $this->SetFont('helvetica', 'I', 8);
            $this->Cell(0, 10, $txt, 0, 0, 'R');
        }
    }

     /**
     * after cloning a object, we does not want to clone all the front informations
     * because it take a lot a time and a lot of memory => we use reference
     *
     * @param &HTML2PDF_myPdf object
     * @param HTML2PDF_myPdf $pdf
     * @access public
     */
    public function cloneFontFrom(&$pdf)
    {
        $this->fonts            = &$pdf->getFonts();
        $this->FontFiles        = &$pdf->getFontFiles();
        $this->diffs            = &$pdf->getDiffs();
        $this->fontlist         = &$pdf->getFontList();
        $this->numfonts         = &$pdf->getNumFonts();
        $this->fontkeys         = &$pdf->getFontKeys();
        $this->font_obj_ids     = &$pdf->getFontObjIds();
        $this->annotation_fonts = &$pdf->getAnnotFonts();
    }

    /**
     * multiple public accessor for some private attributs
     * used only by cloneFontFrom
     *
     * @return &array

     * @access public
     */
    public function &getFonts()
    {
        return $this->fonts;
    }
    public function &getFontFiles()
    {
        return $this->FontFiles;
    }
    public function &getDiffs()
    {
        return $this->diffs;
    }
    public function &getFontList()
    {
        return $this->fontlist;
    }
    public function &getNumFonts()
    {
        return $this->numfonts;
    }
    public function &getFontKeys()
    {
        return $this->fontkeys;
    }
    public function &getFontObjIds()
    {
        return $this->font_obj_ids;
    }
    public function &getAnnotFonts()
    {
        return $this->annotation_fonts;
    }

    /**
     * Verify that a Font is already loaded
     *
     * @param string Font Key
     * @return boolean
     * @access public
     */
    public function isLoadedFont($fontKey)
    {
        if (isset($this->fonts[$fontKey])) {
            return true;
        }

        if (isset($this->CoreFonts[$fontKey])) {
            return true;
        }

        return false;
    }

    /**
     * Get the Word Spacing
     *
     * @access public
     * @return float word spacing
     */
    public function getWordSpacing()
    {
        return $this->ws;
    }

    /**
     * set the Word Spacing
     *
     * @param float word spacing
     * @access public
     */
    public function setWordSpacing($ws = 0.)
    {
        $this->ws = $ws;
        $this->_out(sprintf('%.3F Tw', $ws * $this->k));
    }

    /**
     * start to use a rectangular Cliping Path with radius corners
     *
     * @param float $x (top left corner)
     * @param float $y (top left corner)
     * @param float $w (x+w  = botom rigth corner)
     * @param float $h (y+h = botom rigth corner)
     * @param array $cornerTL radius of the Top Left corner
     * @param array $cornerTR radius of the Top Right corner
     * @param array $cornerBL radius of the Bottom Left corner
     * @param array $cornerBR radius of the Bottom Right corner
     * @access public
     */
    public function clippingPathStart(
        $x = null,
        $y = null,
        $w = null,
        $h = null,
        $cornerTL = null,
        $cornerTR = null,
        $cornerBL = null,
        $cornerBR = null)
    {
        // init the path
        $path = '';

        // if we have the position and the size of the rectangle, we can proceed
        if ($x !== null && $y !== null && $w !== null && $h !== null) {
            // the positions of the rectangle's corners
            $x1 = $x * $this->k;
            $y1 = ($this->h - $y) * $this->k;

            $x2 = ($x + $w) * $this->k;
            $y2 = ($this->h - $y) * $this->k;

            $x3 = ($x + $w) * $this->k;
            $y3 = ($this->h - $y - $h) * $this->k;

            $x4 = $x * $this->k;
            $y4 = ($this->h - $y - $h) * $this->k;

            // if we have at least one radius corner, then we proceed to a specific path, else it is just a rectangle
            if ($cornerTL || $cornerTR || $cornerBL || $cornerBR) {
                // prepare the radius values
                if ($cornerTL) {
                    $cornerTL[0] = $cornerTL[0] * $this->k;
                    $cornerTL[1] = -$cornerTL[1] * $this->k;
                }
                if ($cornerTR) {
                    $cornerTR[0] = $cornerTR[0] * $this->k;
                    $cornerTR[1] = -$cornerTR[1] * $this->k;
                }
                if ($cornerBL) {
                    $cornerBL[0] = $cornerBL[0] * $this->k;
                    $cornerBL[1] = -$cornerBL[1] * $this->k;
                }
                if ($cornerBR) {
                    $cornerBR[0] = $cornerBR[0] * $this->k;
                    $cornerBR[1] = -$cornerBR[1] * $this->k;
                }

                // if TL radius then specific start else (X1,Y1)
                if ($cornerTL) {
                    $path .= sprintf('%.2F %.2F m ', $x1 + $cornerTL[0], $y1);
                } else {
                    $path .= sprintf('%.2F %.2F m ', $x1, $y1);
                }

                // if TR radius then line + arc, else line to (X2,Y2)
                if ($cornerTR) {
                    $xt1 = ($x2 - $cornerTR[0]) + $cornerTR[0] * self::MY_ARC;
                    $yt1 = ($y2 + $cornerTR[1]) - $cornerTR[1];
                    $xt2 = ($x2 - $cornerTR[0]) + $cornerTR[0];
                    $yt2 = ($y2 + $cornerTR[1]) - $cornerTR[1] * self::MY_ARC;

                    $path .= sprintf('%.2F %.2F l ', $x2 - $cornerTR[0], $y2);
                    $path .= sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c ', $xt1, $yt1, $xt2, $yt2, $x2, $y2 + $cornerTR[1]);
                } else {
                    $path .= sprintf('%.2F %.2F l ', $x2, $y2);
                }

                // if BR radius then line + arc, else line to (X3, Y3)
                if ($cornerBR) {
                    $xt1 = ($x3 - $cornerBR[0]) + $cornerBR[0];
                    $yt1 = ($y3 - $cornerBR[1]) + $cornerBR[1] * self::MY_ARC;
                    $xt2 = ($x3 - $cornerBR[0]) + $cornerBR[0] * self::MY_ARC;
                    $yt2 = ($y3 - $cornerBR[1]) + $cornerBR[1];

                    $path .= sprintf('%.2F %.2F l ', $x3, $y3 - $cornerBR[1]);
                    $path .= sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c ', $xt1, $yt1, $xt2, $yt2, $x3 - $cornerBR[0], $y3);
                } else {
                    $path .= sprintf('%.2F %.2F l ', $x3, $y3);
                }

                // if BL radius then line + arc, else line to (X4, Y4)
                if ($cornerBL) {
                    $xt1 = ($x4 + $cornerBL[0]) - $cornerBL[0] * self::MY_ARC;
                    $yt1 = ($y4 - $cornerBL[1]) + $cornerBL[1];
                    $xt2 = ($x4 + $cornerBL[0]) - $cornerBL[0];
                    $yt2 = ($y4 - $cornerBL[1]) + $cornerBL[1] * self::MY_ARC;

                    $path .= sprintf('%.2F %.2F l ', $x4 + $cornerBL[0], $y4);
                    $path .= sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c ', $xt1, $yt1, $xt2, $yt2, $x4, $y4 - $cornerBL[1]);
                } else {
                    $path .= sprintf('%.2F %.2F l ', $x4, $y4);
                }

                // if RL radius then line + arc
                if ($cornerTL) {
                    $xt1 = ($x1 + $cornerTL[0]) - $cornerTL[0];
                    $yt1 = ($y1 + $cornerTL[1]) - $cornerTL[1] * self::MY_ARC;
                    $xt2 = ($x1 + $cornerTL[0]) - $cornerTL[0] * self::MY_ARC;
                    $yt2 = ($y1 + $cornerTL[1]) - $cornerTL[1];

                    $path .= sprintf('%.2F %.2F l ', $x1, $y1 + $cornerTL[1]);
                    $path .= sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c ', $xt1, $yt1, $xt2, $yt2, $x1 + $cornerTL[0], $y1);
                }
            } else {
                $path .= sprintf('%.2F %.2F m ', $x1, $y1);
                $path .= sprintf('%.2F %.2F l ', $x2, $y2);
                $path .= sprintf('%.2F %.2F l ', $x3, $y3);
                $path .= sprintf('%.2F %.2F l ', $x4, $y4);
            }

            // close the path
            $path .= ' h W n';
        }

        // using the path as a clipping path
        $this->_out('q '.$path.' ');
    }

    /**
     * stop to use the Cliping Path
     *
     * @access public
     */
    public function clippingPathStop()
    {
        $this->_out(' Q');
    }

    /**
     * draw a filled corner of a border with a external and a internal radius
     *         /--------+ ext2
     *        /         |
     *       /  /-------+ int2
     *      /  /
     *      | /
     *      | |
     *      | |
     * ext1 +-+ int1        + cen
     *
     * @param float $ext1X
     * @param float $ext1Y
     * @param float $ext2X
     * @param float $ext2Y
     * @param float $int1X
     * @param float $int1Y
     * @param float $int2X
     * @param float $int2Y
     * @param float $cenX
     * @param float $cenY
     * @access public
     */
    public function drawCurve($ext1X, $ext1Y, $ext2X, $ext2Y, $int1X, $int1Y, $int2X, $int2Y, $cenX, $cenY)
    {
        // prepare the coordinates
        $ext1X = $ext1X * $this->k;
        $ext2X = $ext2X * $this->k;
        $int1X = $int1X * $this->k;
        $int2X = $int2X * $this->k;
        $cenX  = $cenX * $this->k;

        $ext1Y = ($this->h - $ext1Y) * $this->k;
        $ext2Y = ($this->h - $ext2Y) * $this->k;
        $int1Y = ($this->h - $int1Y) * $this->k;
        $int2Y = ($this->h - $int2Y) * $this->k;
        $cenY  = ($this->h - $cenY) * $this->k;

        // init the curve
        $path = '';

        if ($ext1X - $cenX != 0) {
            $xt1 = $cenX + ($ext1X - $cenX);
            $yt1 = $cenY + ($ext2Y - $cenY) * self::MY_ARC;
            $xt2 = $cenX + ($ext1X - $cenX) * self::MY_ARC;
            $yt2 = $cenY + ($ext2Y - $cenY);
        } else {
            $xt1 = $cenX + ($ext2X - $cenX) * self::MY_ARC;
            $yt1 = $cenY + ($ext1Y - $cenY);
            $xt2 = $cenX + ($ext2X - $cenX);
            $yt2 = $cenY + ($ext1Y - $cenY) * self::MY_ARC;
        }
        $path .= sprintf('%.2F %.2F m ', $ext1X, $ext1Y);
        $path .= sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c ', $xt1, $yt1, $xt2, $yt2, $ext2X, $ext2Y);

        if ($int1X - $cenX != 0) {
            $xt1 = $cenX + ($int1X - $cenX) * self::MY_ARC;
            $yt1 = $cenY + ($int2Y - $cenY);
            $xt2 = $cenX + ($int1X - $cenX);
            $yt2 = $cenY + ($int2Y - $cenY) * self::MY_ARC;
        } else {
            $xt1 = $cenX + ($int2X - $cenX);
            $yt1 = $cenY + ($int1Y - $cenY) * self::MY_ARC;
            $xt2 = $cenX + ($int2X - $cenX) * self::MY_ARC;
            $yt2 = $cenY + ($int1Y - $cenY);
        }
        $path .= sprintf('%.2F %.2F l ', $int2X, $int2Y);
        $path .= sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c ', $xt1, $yt1, $xt2, $yt2, $int1X, $int1Y);

        // draw the curve
        $this->_out($path.'f');
    }

    /**
     * draw a filled corner of a border with only a external radius
     *         /--+ ext2
     *        /   |
     *       /    |
     *      /     |
     *      |     |
     *      |     |
     *      |     |
     * ext1 +-----+ int      + cen
     *
     * @param float $ext1X
     * @param float $ext1Y
     * @param float $ext2X
     * @param float $ext2Y
     * @param float $intX
     * @param float $intY
     * @param float $cenX
     * @param float $cenY
     * @access public
     */
    public function drawCorner($ext1X, $ext1Y, $ext2X, $ext2Y, $intX, $intY, $cenX, $cenY)
    {
        // prepare the coordinates
        $ext1X = $ext1X * $this->k;
        $ext2X = $ext2X * $this->k;
        $intX  = $intX * $this->k;
        $cenX  = $cenX * $this->k;

        $ext1Y = ($this->h - $ext1Y) * $this->k;
        $ext2Y = ($this->h - $ext2Y) * $this->k;
        $intY  = ($this->h - $intY) * $this->k;
        $cenY  = ($this->h - $cenY) * $this->k;

        // init the curve
        $path = '';

        if ($ext1X - $cenX != 0) {
            $xt1 = $cenX + ($ext1X - $cenX);
            $yt1 = $cenY + ($ext2Y - $cenY) * self::MY_ARC;
            $xt2 = $cenX + ($ext1X - $cenX) * self::MY_ARC;
            $yt2 = $cenY + ($ext2Y - $cenY);
        } else {
            $xt1 = $cenX + ($ext2X - $cenX) * self::MY_ARC;
            $yt1 = $cenY + ($ext1Y - $cenY);
            $xt2 = $cenX + ($ext2X - $cenX);
            $yt2 = $cenY + ($ext1Y - $cenY) * self::MY_ARC;
        }
        $path .= sprintf('%.2F %.2F m ', $ext1X, $ext1Y);
        $path .= sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c ', $xt1, $yt1, $xt2, $yt2, $ext2X, $ext2Y);
        $path .= sprintf('%.2F %.2F l ', $intX, $intY);
        $path .= sprintf('%.2F %.2F l ', $ext1X, $ext1Y);

        // draw the curve
        $this->_out($path.'f');
    }

    /**
     * Start a transformation
     *
     * @access public
     */
    public function startTransform()
    {
        $this->_out('q');
    }

    /**
     * Stop a transformation
     *
     * @access public
     */
    public function stopTransform()
    {
        $this->_out('Q');
    }

    /**
     * add a Translate transformation
     *
     * @access public
     */
    public function setTranslate($xT, $yT)
    {
        // Matrix for Translate
        $tm[0] = 1;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        $tm[1] = 0;
        $tm[2] = 0;
        $tm[3] = 1;
        $tm[4] = $xT * $this->k;
        $tm[5] = -$yT * $this->k;

        // apply the Transform Matric
        $this->_out(sprintf('%.3F %.3F %.3F %.3F %.3F %.3F cm', $tm[0], $tm[1], $tm[2], $tm[3], $tm[4], $tm[5]));
    }

    /**
     * add a Rotate transformation
     *
     * @param float $angle
     * @access public
     */
    public function setRotation($angle, $xC = null, $yC = null)
    {
        // if no center, rotate around the current posiition
        if ($xC === null) $xC = $this->x;
        if ($yC === null) $yC = $this->y;

        // prepare the coordinate
        $yC = ($this->h - $yC) * $this->k;
        $xC *= $this->k;

        // Matrix for Rotate
        $tm[0] = cos(deg2rad($angle));
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        $tm[1] = sin(deg2rad($angle));
        $tm[2] = -$tm[1];
        $tm[3] = $tm[0];
        $tm[4] = $xC + $tm[1] * $yC - $tm[0] * $xC;
        $tm[5] = $yC - $tm[0] * $yC - $tm[1] * $xC;

        // apply the Transform Matric
        $this->_out(sprintf('%.3F %.3F %.3F %.3F %.3F %.3F cm', $tm[0], $tm[1], $tm[2], $tm[3], $tm[4], $tm[5]));
    }

    /**
     * we redifine the original SetX method, because we don't want the automatic treatment.
     * It is HTML2PDF that make the treatment
     *
     * @param float   $x
     * @param boolean $rtloff NOT USED
     * @access public
     */
    public function SetX($x, $rtloff = false)
    {
        $this->x = $x;
    }

    /**
     * we redifine the original SetY method, because we don't want the automatic treatment.
     * It is HTML2PDF that make the treatment
     *
     * @param float   $y
     * @param boolean $resetx Reset the X position
     * @param boolean $rtloff NOT USED
     * @access public
     */
    public function SetY($y, $resetx = true, $rtloff = false)
    {
        if ($resetx)
            $this->x = $this->lMargin;

        $this->y = $y;
    }

    /**
     * we redifine the original SetXY method, because we don't want the automatic treatment.
     * It is HTML2PDF that make the treatment
     *
     * @param integer $x
     * @param integer $y
     * @param boolean $rtloff NOT USED
     * @access public
     */
    public function SetXY($x, $y, $rtloff = false)
    {
        $this->x = $x;
        $this->y = $y;
    }

    /**
     * multiple public accessor because HTML2PDF need to use TCPDF without being a extend of it
     *
     * @param  mixed
     * @return mixed
     * @access public
     */
    public function getK()
    {
        return $this->k;
    }

    /**
     * @return double
     */
    public function getW()
    {
        return $this->w;
    }

    /**
     * @return double
     */
    public function getH()
    {
        return $this->h;
    }
    public function getlMargin()
    {
        return $this->lMargin;
    }

    /**
     * @return double
     */
    public function getrMargin()
    {
        return $this->rMargin;
    }

    /**
     * @return double
     */
    public function gettMargin()
    {
        return $this->tMargin;
    }
    public function getbMargin()
    {
        return $this->bMargin;
    }
    public function setbMargin($v)
    {
        $this->bMargin = $v;
    }

    /**
     * SVG - Convert a SVG Style in PDF Style
     *
     * @param  array  $styles SVG Style
     * @return string PDF style
     * @access public
     */
    public function svgSetStyle($styles)
    {
        // init the PDF style
        $style = '';

        // Style : fill
        if ($styles['fill']) {
            $this->setFillColorArray($styles['fill']);
            $style .= 'F';
        }

        // Style : stroke
        if ($styles['stroke'] && $styles['stroke-width']) {
            $this->SetDrawColorArray($styles['stroke']);
            $this->SetLineWidth($styles['stroke-width']);
            $style .= 'D';
        }

        // Style : opacity
        if ($styles['fill-opacity']) {
            $this->SetAlpha($styles['fill-opacity']);
        }

        return $style;
    }

    /**
     * SVG - make a Rectangle
     *
     * @param float $x
     * @param float $y
     * @param float $w
     * @param float $h
     * @param string $style PDF Style
     * @access public
     */
    public function svgRect($x, $y, $w, $h, $style)
    {
        // prepare the 4 corners
        $x1 = $x;
        $x2 = $x + $w;
        $x3 = $x + $w;
        $x4 = $x;

        $y1 = $y;
        $y2 = $y;
        $y3 = $y + $h;
        $y4 = $y + $h;

        // get the Closing operator from the PDF Style
        if ($style == 'F') $op = 'f';
        elseif ($style == 'FD' || $style == 'DF') $op = 'B';
        else $op = 'S';

        // drawing
        $this->_Point($x1, $y1, true);
        $this->_Line($x2, $y2, true);
        $this->_Line($x3, $y3, true);
        $this->_Line($x4, $y4, true);
        $this->_Line($x1, $y1, true);
        $this->_out($op);
    }

    /**
     * SVG - make a Line
     *
     * @param float $x1
     * @param float $y1
     * @param float $x2
     * @param float $y2
     * @access public
     */
    public function svgLine($x1, $y1, $x2, $y2)
    {
        // get the Closing operator
        $op = 'S';

        // drawing
        $this->_Point($x1, $y1, true);
        $this->_Line($x2, $y2, true);
        $this->_out($op);
    }

    /**
     * SVG - make a Ellipse
     *
     * @param float  $x0 x Center
     * @param float  $y0 y Center
     * @param float  $rx x radius
     * @param float  $ry y radius
     * @param string $style PDF Style
     * @access public
     */
    public function svgEllipse($x0, $y0, $rx, $ry, $style)
    {
        // get the Closing operator from the PDF Style
        if ($style == 'F') $op = 'f';
        elseif ($style == 'FD' || $style == 'DF') $op = 'B';
        else $op = 'S';

        // drawing
        $this->_Arc($x0, $y0, $rx, $ry, 0, 2 * M_PI, true, true, true);
        $this->_out($op);
    }

    /**
     * SVG - make a Advanced Polygone
     *
     * @param array  $actions list of actions
     * @param string $style PDF Style
     * @access public
     */
    public function svgPolygone($actions, $style)
    {
        // get the Closing operator from the PDF Style
        if ($style == 'F') $op = 'f';
        elseif ($style == 'FD' || $style == 'DF') $op = 'B';
        else $op = 'S';

        // To save the First action and the last point
        $first = array('', 0, 0);
        $last = array(0, 0, 0, 0);

        foreach ($actions as $action) {
            switch ($action[0])
            {
                // Start the Path
                case 'M':
                case 'm':
                    $first = $action;
                    $x = $action[1]; $y = $action[2]; $xc = $x; $yc = $y;
                    $this->_Point($x, $y, true);
                    break;

                // Close the Path
                case 'Z':
                case 'z':
                    $x = $first[1]; $y = $first[2]; $xc = $x; $yc = $y;
                    $this->_Line($x, $y, true);
                    break;

                // Make a Line (new point)
                case 'L':
                    $x = $action[1]; $y = $action[2]; $xc = $x; $yc = $y;
                    $this->_Line($x, $y, true);
                    break;

                // Make a Line (vector from last point)
                case 'l':
                    $x = $last[0] + $action[1]; $y = $last[1] + $action[2]; $xc = $x; $yc = $y;
                    $this->_Line($x, $y, true);
                    break;

                // Make a Horizontal Line (new point)
                case 'H':
                    $x = $action[1]; $y = $last[1]; $xc = $x; $yc = $y;
                    $this->_Line($x, $y, true);
                    break;

                // Make a Horisontal Line (vector from last point)
                case 'h':
                    $x = $last[0] + $action[1]; $y = $last[1]; $xc = $x; $yc = $y;
                    $this->_Line($x, $y, true);
                    break;

                // Make a Vertical Line (new point)
                case 'V':
                    $x = $last[0]; $y = $action[1]; $xc = $x; $yc = $y;
                    $this->_Line($x, $y, true);
                    break;

                // Make a Vertical Line (vector from last point)
                case 'v':
                    $x = $last[0]; $y = $last[1] + $action[1]; $xc = $x; $yc = $y;
                    $this->_Line($x, $y, true);
                    break;

                // Make a Arc (new point)
                case 'A':
                    $rx = $action[1]; // rx
                    $ry = $action[2]; // ry
                    $a = $action[3]; // deviation angle of the axis X
                    $l = $action[4]; // large-arc-flag
                    $s = $action[5]; // sweep-flag
                    $x1 = $last[0]; // begin x
                    $y1 = $last[1]; // begin y
                    $x2 = $action[6]; // final x
                    $y2 = $action[7]; // final y

                    $this->_Arc2($x1, $y1, $x2, $y2, $rx, $ry, $a, $l, $s, true);
                    $x = $x2; $y = $y2; $xc = $x; $yc = $y;
                    break;

                // Make a Arc (vector from last point)
                case 'a':
                    $rx = $action[1]; // rx
                    $ry = $action[2]; // ry
                    $a = $action[3]; // deviation angle of the axis X
                    $l = $action[4]; // large-arc-flag
                    $s = $action[5]; // sweep-flag
                    $x1 = $last[0]; // begin x
                    $y1 = $last[1]; // begin y
                    $x2 = $last[0] + $action[6]; // final x
                    $y2 = $last[1] + $action[7]; // final y

                    $this->_Arc2($x1, $y1, $x2, $y2, $rx, $ry, $a, $l, $s, true);
                    $x = $x2; $y = $y2; $xc = $x; $yc = $y;
                    break;

                // Make a Bezier Curve (new point)
                case 'C':
                    $x1 = $action[1];
                    $y1 = $action[2];
                    $x2 = $action[3];
                    $y2 = $action[4];
                    $xf = $action[5];
                    $yf = $action[6];
                    $this->_Curve($x1, $y1, $x2, $y2, $xf, $yf, true);
                    $x = $xf; $y = $yf; $xc = $x2; $yc = $y2;
                    break;

                // Make a Bezier Curve (vector from last point)
                case 'c':
                    $x1 = $last[0] + $action[1];
                    $y1 = $last[1] + $action[2];
                    $x2 = $last[0] + $action[3];
                    $y2 = $last[1] + $action[4];
                    $xf = $last[0] + $action[5];
                    $yf = $last[1] + $action[6];
                    $this->_Curve($x1, $y1, $x2, $y2, $xf, $yf, true);
                    $x = $xf; $y = $yf; $xc = $x2; $yc = $y2;
                    break;

                // Unknown Path
                default:
                    throw new HTML2PDF_exception(0, 'SVG Path Error : ['.$action[0].'] unkown');
            }

            // save the last point
            $last = array($x, $y, $xc, $yc);
        }

        // finish the path
        $this->_out($op);
    }

    /**
     * SVG - go to a point
     *
     * @param float   $x
     * @param float   $y
     * @param boolean $trans apply transformation
     * @access protected
     */
    protected function _Point($x, $y, $trans = false)
    {
        if ($trans) {
        	$this->ptTransform($x, $y);
        }

        $this->_out(sprintf('%.2F %.2F m', $x, $y));
    }

    /**
     * SVG - make a line from the last point to (x,y)
     *
     * @param float   $x
     * @param float   $y
     * @param boolean $trans apply transformation
     * @access protected
     */
    protected function _Line($x, $y, $trans = false)
    {
        if ($trans) {
        	$this->ptTransform($x, $y);
        }

        $this->_out(sprintf('%.2F %.2F l', $x, $y));
    }

    /**
     * SVG - make a bezier curve from the last point to (xf,yf), with the 2 direction points (x1,y1) and (x2,y2)
     *
     * @param float $x1
     * @param float $y1
     * @param float $x2
     * @param float $y2
     * @param float $xf
     * @param float $yf
     * @param boolean $trans apply transformation
     * @access protected
     */
    protected function _Curve($x1, $y1, $x2, $y2, $xf, $yf, $trans = false)
    {
        if ($trans) {
            $this->ptTransform($x1, $y1);
            $this->ptTransform($x2, $y2);
            $this->ptTransform($xf, $yf);
        }
        $this->_out(sprintf('%.2F %.2F %.2F %.2F %.2F %.2F c', $x1, $y1, $x2, $y2, $xf, $yf));
    }

    /**
     * SVG - make a arc with Center, Radius, from angleBegin to angleEnd
     *
     * @param float $xc
     * @param float $yc
     * @param float $rx
     * @param float $ry
     * @param float $angleBegin in radians
     * @param float $angleEnd in radians
     * @param boolean $direction
     * @param boolean $drawFirst, true => add the first point
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param boolean $trans apply transformation
     * @access protected
     */
    protected function _Arc(
        $xc,
        $yc,
        $rx,
        $ry,
        $angleBegin,
        $angleEnd,
        $direction = true,
        $drawFirst = true,
        $trans = false)
    {
        // if we want the no trigo direction : add 2PI to the begin angle, to invert the direction
        if ( ! $direction) $angleBegin += M_PI * 2.;

        // cut in segment to convert in berize curv
        $dt = ($angleEnd - $angleBegin) / self::ARC_NB_SEGMENT;
        $dtm = $dt / 3;

        // center of the arc
        $x0 = $xc; $y0 = $yc;

        // calculing the first point
        $t1 = $angleBegin;
        $a0 = $x0 + ($rx * cos($t1));
        $b0 = $y0 + ($ry * sin($t1));
        $c0 = -$rx * sin($t1);
        $d0 = $ry * cos($t1);

        // if drawFirst => draw the first point
        if ($drawFirst) {
        	$this->_Point($a0, $b0, $trans);
        }

        // foreach segment
        for ($i = 1; $i <= self::ARC_NB_SEGMENT; $i++) {
            // calculing the next point
            $t1 = ($i * $dt) + $angleBegin;
            $a1 = $x0 + ($rx * cos($t1));
            $b1 = $y0 + ($ry * sin($t1));
            $c1 = -$rx * sin($t1);
            $d1 = $ry * cos($t1);

            // make the bezier curv
            $this->_Curve(
                $a0 + ($c0 * $dtm), $b0 + ($d0 * $dtm),
                $a1 - ($c1 * $dtm), $b1 - ($d1 * $dtm),
                $a1, $b1,
                $trans
            );

            // save the point
            $a0 = $a1;
            $b0 = $b1;
            $c0 = $c1;
            $d0 = $d1;
        }
    }

    /**
     * SVG - make a arc from Pt1 to Pt2, with Radius
     *
     * @param float $x1
     * @param float $y1
     * @param float $x2
     * @param float $y2
     * @param float $rx
     * @param float $ry
     * @param float $angle deviation angle of the axis X
     * @param integer $l large-arc-flag
     * @param integer $s sweep-flag
     * @param boolean $trans apply transformation
     * @access protected
     */
    protected function _Arc2($x1, $y1, $x2, $y2, $rx, $ry, $angle = 0., $l = 0, $s = 0, $trans = false)
    {
        // array to stock the parameters
        $v = array();

        // the original values
        $v['x1'] = $x1;
        $v['y1'] = $y1;
        $v['x2'] = $x2;
        $v['y2'] = $y2;
        $v['rx'] = $rx;
        $v['ry'] = $ry;

        // rotate with the deviation angle of the axis X
        $v['xr1'] = $v['x1'] * cos($angle) - $v['y1'] * sin($angle);
        $v['yr1'] = $v['x1'] * sin($angle) + $v['y1'] * cos($angle);
        $v['xr2'] = $v['x2'] * cos($angle) - $v['y2'] * sin($angle);
        $v['yr2'] = $v['x2'] * sin($angle) + $v['y2'] * cos($angle);

        // the normalized vector
        $v['Xr1'] = $v['xr1'] / $v['rx'];
        $v['Yr1'] = $v['yr1'] / $v['ry'];
        $v['Xr2'] = $v['xr2'] / $v['rx'];
        $v['Yr2'] = $v['yr2'] / $v['ry'];
        $v['dXr'] = $v['Xr2'] - $v['Xr1'];
        $v['dYr'] = $v['Yr2'] - $v['Yr1'];
        $v['D'] = $v['dXr'] * $v['dXr'] + $v['dYr'] * $v['dYr'];

        // if |vector| is Null, or if |vector| > 2 : impossible to make a arc => Line
        if ($v['D'] == 0 || $v['D'] > 4) {
            $this->_Line($x2, $y2, $trans);
            return false;
        }

        // convert paramters for make a arc with Center, Radius, from angleBegin to angleEnd
        $v['s1'] = array();
        $v['s1']['t'] = sqrt((4. - $v['D']) / $v['D']);
        $v['s1']['Xr'] = ($v['Xr1'] + $v['Xr2']) / 2. + $v['s1']['t'] * ($v['Yr2'] - $v['Yr1']) / 2.;
        $v['s1']['Yr'] = ($v['Yr1'] + $v['Yr2']) / 2. + $v['s1']['t'] * ($v['Xr1'] - $v['Xr2']) / 2.;
        $v['s1']['xr'] = $v['s1']['Xr'] * $v['rx'];
        $v['s1']['yr'] = $v['s1']['Yr'] * $v['ry'];
        $v['s1']['x'] = $v['s1']['xr'] * cos($angle) + $v['s1']['yr'] * sin($angle);
        $v['s1']['y'] = -$v['s1']['xr'] * sin($angle) + $v['s1']['yr'] * cos($angle);
        $v['s1']['a1'] = atan2($v['y1'] - $v['s1']['y'], $v['x1'] - $v['s1']['x']);
        $v['s1']['a2'] = atan2($v['y2'] - $v['s1']['y'], $v['x2'] - $v['s1']['x']);
        if ($v['s1']['a1'] > $v['s1']['a2']) $v['s1']['a1'] -= 2 * M_PI;

        $v['s2'] = array();
        $v['s2']['t'] = -$v['s1']['t'];
        $v['s2']['Xr'] = ($v['Xr1'] + $v['Xr2']) / 2. + $v['s2']['t'] * ($v['Yr2'] - $v['Yr1']) / 2.;
        $v['s2']['Yr'] = ($v['Yr1'] + $v['Yr2']) / 2. + $v['s2']['t'] * ($v['Xr1'] - $v['Xr2']) / 2.;
        $v['s2']['xr'] = $v['s2']['Xr'] * $v['rx'];
        $v['s2']['yr'] = $v['s2']['Yr'] * $v['ry'];
        $v['s2']['x'] = $v['s2']['xr'] * cos($angle) + $v['s2']['yr'] * sin($angle);
        $v['s2']['y'] = -$v['s2']['xr'] * sin($angle) + $v['s2']['yr'] * cos($angle);
        $v['s2']['a1'] = atan2($v['y1'] - $v['s2']['y'], $v['x1'] - $v['s2']['x']);
        $v['s2']['a2'] = atan2($v['y2'] - $v['s2']['y'], $v['x2'] - $v['s2']['x']);
        if ($v['s2']['a1'] > $v['s2']['a2']) $v['s2']['a1'] -= 2 * M_PI;

        if ( ! $l) {
            if ($s) {
                $xc = $v['s2']['x'];
                $yc = $v['s2']['y'];
                $a1 = $v['s2']['a1'];
                $a2 = $v['s2']['a2'];
                $this->_Arc($xc, $yc, $rx, $ry, $a1, $a2, true, false, $trans);
            } else {
                $xc = $v['s1']['x'];
                $yc = $v['s1']['y'];
                $a1 = $v['s1']['a1'];
                $a2 = $v['s1']['a2'];
                $this->_Arc($xc, $yc, $rx, $ry, $a1, $a2, false, false, $trans);
            }
        } else {
            if ($s) {
                $xc = $v['s1']['x'];
                $yc = $v['s1']['y'];
                $a1 = $v['s1']['a1'];
                $a2 = $v['s1']['a2'];
                $this->_Arc($xc, $yc, $rx, $ry, $a1, $a2, true, false, $trans);
            } else {
                $xc = $v['s2']['x'];
                $yc = $v['s2']['y'];
                $a1 = $v['s2']['a1'];
                $a2 = $v['s2']['a2'];
                $this->_Arc($xc, $yc, $rx, $ry, $a1, $a2, false, false, $trans);
            }
        }
    }

    /**
     * SVG - transform the point (reference)
     *
     * @param float &$x
     * @param float &$y
     * @param boolean $trans true => convert into PDF unit
     * @param double $x
     * @param double $y
     * @return boolean
     * @access public
     */
    public function ptTransform(&$x, &$y, $trans = true)
    {
        // load the last Transfomation Matrix
        $nb = count($this->_transf);
        if ($nb)    $m = $this->_transf[$nb - 1];
        else        $m = array(1, 0, 0, 1, 0, 0);

        // apply the Transformation Matrix
        list($x, $y) = array(($x * $m[0] + $y * $m[2] + $m[4]), ($x * $m[1] + $y * $m[3] + $m[5]));

        // if true => convert into PDF unit
        if ($trans) {
            $x = $x * $this->k;
            $y = ($this->h - $y) * $this->k;
        }

        return true;
    }

    /**
     * SVG - add a transformation Matric
     *
     * @param array $n matrix
     * @access public
     */
    public function doTransform($n = null)
    {
        // get the last Transformation Matrix
        $nb = count($this->_transf);
        if ($nb)    $m = $this->_transf[$nb - 1];
        else        $m = array(1, 0, 0, 1, 0, 0);

        // if no transform, get the Identity Matrix
        if ( ! $n) $n = array(1, 0, 0, 1, 0, 0);

        // create the new Transformation Matrix
        $this->_transf[] = array(
            $m[0] * $n[0] + $m[2] * $n[1],
            $m[1] * $n[0] + $m[3] * $n[1],
            $m[0] * $n[2] + $m[2] * $n[3],
            $m[1] * $n[2] + $m[3] * $n[3],
            $m[0] * $n[4] + $m[2] * $n[5] + $m[4],
            $m[1] * $n[4] + $m[3] * $n[5] + $m[5]
        );
    }

    /**
     * SVG - remove a transformation Matric
     *
     * @access public
     */
    public function undoTransform()
    {
        array_pop($this->_transf);
    }

    /**
     * Convert a HTML2PDF barcode in a TCPDF barcode
     *
     * @param string $code code to print
     * @param string $type type of barcode (see tcpdf/barcodes.php for supported formats)
     * @param int $x x position in user units
     * @param int $y y position in user units
     * @param int $w width in user units
     * @param int $h height in user units
     * @param int $labelFontsize of the Test Label. If false : no Label
     * @param array $color color of the foreground
     * @access public
     */
    public function myBarcode($code, $type, $x, $y, $w, $h, $labelFontsize, $color)
    {
        // the style of the barcode
        $style = array(
            'position' => 'S',
            'text' => ($labelFontsize ? true : false),
            'fgcolor' => $color,
            'bgcolor' => false,
        );

        // build the barcode
        $this->write1DBarcode($code, $type, $x, $y, $w, $h, '', $style, 'N');

        // it Label => add the FontSize to the height
        if ($labelFontsize) $h += ($labelFontsize);

        // return the size of the barcode
        return array($w, $h);
    }

    /**
     * create a automatic Index on a page
     *
     * @param html2pdf $obj           parent object
     * @param string   $titre         Title of the Index Page
     * @param integer  $sizeTitle     Font size for hthe Title
     * @param integer  $sizeBookmark  Font size for the bookmarks
     * @param boolean  $bookmarkTitle Bookmark the Title
     * @param boolean  $displayPage   Display the page number for each bookmark
     * @param integer  $page draw the automatic Index on a specific Page. if null => add a page at the end
     * @param string   $fontName      FontName to use
     * @access public
     */
    public function createIndex(
        &$obj,
        $titre = 'Index',
        $sizeTitle = 20,
        $sizeBookmark = 15,
        $bookmarkTitle = true,
        $displayPage = true,
        $page = null,
        $fontName = 'helvetica')
    {
        // bookmark the Title if wanted
        if ($bookmarkTitle) {
        	$this->Bookmark($titre, 0, -1);
        }

        // display the Title with the good Font size
        $this->SetFont($fontName, '', $sizeTitle);
        $this->Cell(0, 5, $titre, 0, 1, 'C');

        // set the good Font size for the bookmarks
        $this->SetFont($fontName, '', $sizeBookmark);
        $this->Ln(10);

        // get the number of bookmarks
        $size = sizeof($this->outlines);

        // get the size of the "P. xx" cell
        $pageCellSize = $this->GetStringWidth('p. '.$this->outlines[$size - 1]['p']) + 2;

        // Foreach bookmark
        for ($i = 0; $i < $size; $i++) {
            // if we need a new page => add a new page
            if ($this->getY() + $this->FontSize >= ($this->h - $this->bMargin)) {
                $obj->_INDEX_NewPage($page);
                $this->SetFont($fontName, '', $sizeBookmark);
            }

            // Offset of the current level
            $level = $this->outlines[$i]['l'];
            if ($level > 0) $this->Cell($level * 8);

            // Caption (cut to fit on the width page)
            $str = $this->outlines[$i]['t'];
            $strsize = $this->GetStringWidth($str);
            $availableSize = $this->w - $this->lMargin - $this->rMargin - $pageCellSize - ($level * 8) - 4;
            while ($strsize >= $availableSize) {
                $str = substr($str, 0, -1);
                $strsize = $this->GetStringWidth($str);
            }

            // if we want to display the page nmber
            if ($displayPage) {
                // display the Bookmark Caption
                $this->Cell($strsize + 2, $this->FontSize + 2, $str);

                //Filling dots
                $w = $this->w - $this->lMargin - $this->rMargin - $pageCellSize - ($level * 8) - ($strsize + 2);
                $nb = $w / $this->GetStringWidth('.');
                $dots = str_repeat('.', $nb);
                $this->Cell($w, $this->FontSize + 2, $dots, 0, 0, 'R');

                //Page number
                $this->Cell($pageCellSize, $this->FontSize + 2, 'p. '.$this->outlines[$i]['p'], 0, 1, 'R');
            } else {
                // display the Bookmark Caption
                $this->Cell($strsize + 2, $this->FontSize + 2, $str, 0, 1);
            }
        }
    }

    /**
     * Returns the string alias used for the total number of pages.
     *
     * @access public
     * @return string;

     * @see TCPDF::getAliasNbPages(), TCPDF::getPageGroupAlias()
     */
    public function getMyAliasNbPages()
    {
        if ($this->_myLastPageGroupNb == 0) {
            return $this->getAliasNbPages();
        } else {
            $old = $this->currpagegroup;
            $this->currpagegroup = '{nb'.$this->_myLastPageGroupNb.'}';
            $new = $this->getPageGroupAlias();
            $this->currpagegroup = $old;

            return $new;
        }
    }

    /**
     * Returns the current page number.
     *
     * @access public
     * @param  integer $page
     * @return integer;

     */
    public function getMyNumPage($page = null)
    {
        if ($page === null) {
            $page = $this->page;
        }

        if ($this->_myLastPageGroupNb == 0) {
            return $page;
        } else {
            return $page - $this->_myLastPageGroup;
        }
    }

    /**
     * Start a new group of pages
     *
     * @access public
     * @return integer;

     * @see tcpdf::startPageGroup
     */
    public function myStartPageGroup()
    {
        $this->_myLastPageGroup = $this->page - 1;
        $this->_myLastPageGroupNb++;
    }

    /**
     * get $_myLastPageGroup;
     *
     * @access public
     * @return integer $_myLastPageGroup;
     */
    public function getMyLastPageGroup()
    {
        return $this->_myLastPageGroup;
    }

    /**
     * set $_myLastPageGroup;
     *
     * @access public
     * @param integer $myLastPageGroup;
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param integer $myLastPageGroup
     */
    public function setMyLastPageGroup($myLastPageGroup)
    {
        $this->_myLastPageGroup = $myLastPageGroup;
    }

    /**
     * get $_myLastPageGroupNb;
     *
     * @access public
     * @return integer $_myLastPageGroupNb;
     */
    public function getMyLastPageGroupNb()
    {
        return $this->_myLastPageGroupNb;
    }

    /**
     * set $_myLastPageGroupNb;
     *
     * @access public
     * @param integer $myLastPageGroupNb;
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param integer $myLastPageGroupNb
     */
    public function setMyLastPageGroupNb($myLastPageGroupNb)
    {
        $this->_myLastPageGroupNb = $myLastPageGroupNb;
    }
}

iNextrix / ASTPP

HTML2PDF_myPdf::getH() A last analyzed 2017-06-12 08:08 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

HTML2PDF_myPdf::getH() A
last analyzed 2017-06-12 08:08 UTC
