lib/MECON/PDF.php

   1 <?php /* vim: set binary expandtab tabstop=4 shiftwidth=4 textwidth=80:
   2 -------------------------------------------------------------------------------
   3                              Ministerio de Economía
   4                                     meconlib
   5 -------------------------------------------------------------------------------
   6 This file is part of meconlib.
   7
   8 meconlib is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2 of the License, or (at your option)
  11 any later version.
  12
  13 meconlib is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License; if not,
  18 write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  19 Boston, MA  02111-1307  USA
  20 -------------------------------------------------------------------------------
  21 Creado: Fri Oct 24 16:12:31 2003
  22 Autor:  Gonzalo Merayo <gmeray@mecon.gov.ar>
  23 -------------------------------------------------------------------------------
  24 $Id$
  25 -----------------------------------------------------------------------------*/
  26
  27 require_once 'MECON/PDF/external/phppdflib.class.php';
  28
  29 /**
  30  * Liberia base para el manejo de pdf's.
  31  */
  32 class MECON_PDF {
  33
  34     /**
  35      * Orientacion (portrait o landscape).
  36      * @var sting $orientacion
  37      * @access public
  38      */
  39     var $orientacion = "portrait";
  40
  41     /**
  42      *
  43      *  Orientacion cambiada, indica la orientacion de la pagina cuando es
  44      *  distinto al comun
  45      *  @var array $orientacion_distinta
  46      *  @access protected
  47      */
  48     var $_orientacion_distinta = array();
  49
  50     /**
  51      * Configuracion
  52      * @var arary $config
  53      * @access protected
  54      */
  55      var $_config = array ();
  56
  57     /**
  58      * Libreria externa.
  59      * @var    int $pdf
  60      * @access private
  61      */
  62     var $_pdf;
  63
  64     /**
  65      * Identificacion de la pagina actual
  66      * @var    int $pagina_actual
  67      * @access private
  68      */
  69     var $_pagina_actual;
  70
  71     /**
  72      * Array de paginas.
  73      * @var array $paginas
  74      * @access private
  75      */
  76     var $_paginas = array();
  77
  78     /**
  79      * Class constructor.
  80      *
  81      * @param string $tam Tipo de hoja
  82      * @param string $ori Orientacion de las hojaz (portrait o landscape).
  83      *
  84      * @return void
  85      * @access public
  86      */
  87     function MECON_PDF($tam = "a4", $ori = "portrait")
  88     {
  89         $this->orientacion = $ori;
  90         $this->_pdf = new pdffile;
  91         $this->_config = include 'MECON/PDF/medidas.php';
  92         $this->_config = $this->_config[$tam];
  93     }
  94
  95     /**
  96      * Permite agregar nuevas paginas al pdf que se esta armando.
  97      *
  98      * @param  string $pagina Tipo de pagina que se va a utilizar.
  99      *
 100      * @return void
 101      * @access public
 102      */
 103     function newPage($pagina = "a4", $orientacion = null)
 104     {
 105         $this->_pagina_actual = $this->_pdf->new_page($pagina);
 106         $this->_paginas[] = $this->_pagina_actual;
 107         if(!is_null($orientacion) && $orientacion != $this->orientacion)
 108           $this->_orientacion_distinta[$this->numPage()] = $orientacion;
 109     }
 110
 111     /**
 112      *  Funcion que retorna la orientacion de la pagina indicada
 113      *   Si no se indica, la orientacion de la ultima pagina
 114      *  @access public
 115      *  @return int
 116      */
 117     function getOrientation($pagina = null)
 118     {
 119       if(is_null($pagina))
 120         $pagina = $this->numPage();
 121       if(isset($this->_orientacion_distinta[$pagina]))
 122         $o = $this->_orientacion_distinta[$pagina];
 123       else $o = $this->orientacion;
 124       return $o;
 125     }
 126
 127     /**
 128      * Funcion que genera el archivo y prepara los headers para que se envie.
 129      *
 130      * @return void
 131      * @access public
 132      */
 133     function display()
 134     {
 135         header("Content-Disposition: filename=Doc.pdf");
 136         header("Content-Type: application/pdf");
 137         $temp = $this->toPDF();
 138         header('Content-Length: ' . strlen($temp));
 139         echo $temp;
 140     }
 141
 142     /**
 143      * Funcion que devuelve el PDF.
 144      *
 145      * @return string
 146      * @access public
 147      */
 148     function toPDF() {
 149         return $this->_pdf->generate();
 150     }
 151
 152     /**
 153      * Funcion que permite agregar texto a una pagina.
 154      *
 155      * @param int $X $X
 156      * @param int $Y $Y
 157      * @param string $texto $texto
 158      * @param int $estilo $estilo
 159      * @param int $pag Numero de pagina virtual.
 160      * @param string $transformacion Indica la orientacion de la pagina.
 161      *
 162      * @return void
 163      * @access public
 164      */
 165     function addText($X, $Y, $texto, $estilo = '', $pag = null, $transformacion
 166     = null)    {
 167         //@TODO Ver si $texto es un objeto
 168
 169         $x = $X;
 170         $y = $Y;
 171         if(is_null($transformacion))
 172             $transformacion = $this->getOrientation($pag);
 173         switch (strtolower($transformacion)) {
 174             case 'portrait':
 175                 $X = $this->_portraitX($x,$y);
 176                 $Y = $this->_portraitY($x,$y);
 177                 break;
 178             case 'landscape':
 179                 $X = $this->_landscapeX($x,$y);
 180                 $Y = $this->_landscapeY($x,$y);
 181                 @$estilo['rotation'] += 90;
 182                 break;
 183         }
 184         $this->_pdf->draw_text($X, $Y, $texto, $this->refPage($pag), $estilo);
 185     }
 186
 187     /**
 188      * Funcion que permite agregar un rectangulo a una pagina.
 189      *
 190      * @param int $Xi $Xi
 191      * @param int $Yi $Yi
 192      * @param int $Xf $Xf
 193      * @param int $Yf $Yf
 194      * @param long $estilo $estilo
 195      * @param int $pag Numero de pagina virtual.
 196      * @param string $transformacion Indica la orientacion de la pagina.
 197      *
 198      * @return void
 199      * @access public
 200      */
 201     function addRectangle($Xi, $Yi, $Xf, $Yf, $estilo = '', $pag = null,
 202             $transformacion = null)
 203     {
 204         $xi = $Xi;
 205         $yi = $Yi;
 206         $xf = $Xf;
 207         $yf = $Yf;
 208         if(is_null($transformacion))
 209             $transformacion = $this->getOrientation($pag);
 210         switch (strtolower($transformacion)) {
 211             case 'portrait':
 212                 $Xi = $this->_portraitX($xi,$yi);
 213                 $Yi = $this->_portraitY($xi,$yi);
 214                 $Xf = $this->_portraitX($xf,$yf);
 215                 $Yf = $this->_portraitY($xf,$yf);
 216                 break;
 217             case 'landscape':
 218                 $Xi = $this->_landscapeX($xi,$yi);
 219                 $Yi = $this->_landscapeY($xi,$yi);
 220                 $Xf = $this->_landscapeX($xf,$yf);
 221                 $Yf = $this->_landscapeY($xf,$yf);
 222                 break;
 223         }
 224         $this->_pdf->draw_rectangle($Yi, $Xi, $Yf, $Xf, $this->refPage($pag), $estilo);
 225     }
 226
 227     /**
 228      * Funcion que permite agregar una linea a una pagina.
 229      *
 230      * @param int $Xi $Xi
 231      * @param int $Yi $Yi
 232      * @param int $Xf $Xf
 233      * @param int $Yf $Yf
 234      * @param int $estilo $estilo
 235      * @param int $pag Numero de pagina virtual.
 236      * @param string $transformacion Indica la orientacion de la pagina.
 237      *
 238      * @return void
 239      * @access public
 240      */
 241     function addLine($Xi, $Yi, $Xf, $Yf, $estilo = '', $pag = null,
 242             $transformacion = null)
 243     {
 244         $xi = $Xi;
 245         $yi = $Yi;
 246         $xf = $Xf;
 247         $yf = $Yf;
 248         if(is_null($transformacion))
 249             $transformacion = $this->getOrientation($pag);
 250         switch (strtolower($transformacion)) {
 251             case 'portrait':
 252                 $Xi = $this->_portraitX($xi,$yi);
 253                 $Yi = $this->_portraitY($xi,$yi);
 254                 $Xf = $this->_portraitX($xf,$yf);
 255                 $Yf = $this->_portraitY($xf,$yf);
 256                 break;
 257             case 'landscape':
 258                 $Xi = $this->_landscapeX($xi,$yi);
 259                 $Yi = $this->_landscapeY($xi,$yi);
 260                 $Xf = $this->_landscapeX($xf,$yf);
 261                 $Yf = $this->_landscapeY($xf,$yf);
 262                 break;
 263         }
 264        $this->_pdf->draw_line(array($Xi,$Xf),array($Yi,$Yf),
 265                 $this->refPage($pag),$estilo);
 266     }
 267
 268     /**
 269      * Funcion que permite agregar una imagen JPG a una pagina.
 270      *
 271      * @param string $archivo Path completo del archivo imagen.
 272      * @param int    $X Posicion Horizontal.
 273      * @param int    $Y Posixion vertical.
 274      * @param int    $pag Numero de pagina virtual.
 275      * @param string $formato Formato del archivo (Extension).
 276      * @param string $transformacion Indica la orientacion de la pagina.
 277      *
 278      * @return void
 279      * @access public
 280      */
 281     function addImage($archivo, $X, $Y, $pag = null, $formato = null,
 282             $transformacion = null) {
 283         $x = $X;
 284         $y = $Y;
 285         if(is_null($transformacion))
 286             $transformacion = $this->getOrientation($pag);
 287         switch (strtolower($transformacion)) {
 288             case 'portrait':
 289                 $X = $this->_portraitX($x,$y);
 290                 $Y = $this->_portraitY($x,$y);
 291                 break;
 292             case 'landscape':
 293                 $X = $this->_landscapeX($x,$y);
 294                 $Y = $this->_landscapeY($x,$y);
 295                 break;
 296         }
 297         $formato = strtolower($formato);
 298         switch ($formato) {
 299             case 'jpg':
 300                 $fh = fopen($archivo, "r");
 301                 $filedata = fread($fh, filesize($archivo));
 302                 fclose($fh);
 303                 $image = $this->_pdf->jfif_embed($filedata);
 304                 $this->_pdf->image_place($image, $Y, $X,
 305                         $this->refPage($pag));
 306                 break;
 307         }
 308     }
 309
 310     /**
 311      * Funcion que wrappea una linea.
 312      *
 313      * @param strgin $texto Texto que quiere wrappearse.
 314      * @param int    $l_max Largo maximo del texto.
 315      * @param array  $attr  Atributos del texto.
 316      *
 317      * @return string
 318      * @access public
 319      */
 320     function wrapLine($texto, $l_max, $attr) {
 321         return $this->_pdf->wrap_line ($texto, $l_max, $attr);
 322     }
 323
 324     /**
 325      * Funcion que wrappea una linea.
 326      *
 327      * @param strgin $texto Texto que quiere wrappearse.
 328      * @param int    $l_max Largo maximo del texto.
 329      * @param array  $attr  Atributos del texto.
 330      *
 331      * @return string
 332      * @access public
 333      */
 334     function wordWrap($texto, $l_max, $attr) {
 335         return $this->_pdf->word_wrap ($texto, $l_max, $attr);
 336     }
 337
 338     /**
 339      * Funcion que calcula cuanto va a ocupar cierto texto segun su formato en
 340      * una pagina.
 341      *
 342      * @param strgin $texto Texto que quiere medirse.
 343      * @param array  $attr  Atributos del texto.
 344      *
 345      * @return int
 346      * @access public
 347      */
 348     function strlen($texto, $attr = '') {
 349         return $this->_pdf->strlen($texto, $attr);
 350     }
 351
 352     /**
 353      * Funcion que devuelve la cantidad de paginas que contiene el documento.
 354      *
 355      * @return int
 356      * @access public
 357      */
 358     function countPages() {
 359         return count($this->_paginas);
 360     }
 361
 362     /**
 363      * Funcion que devuelve el numero de la pagina actual.
 364      *
 365      * @param mixed $id Identificador de la pagina.
 366      *
 367      * @return int
 368      * @access public
 369      */
 370     function numPage($id = null) {
 371         $id = ($id) ? $id : $this->_pagina_actual;
 372         return (array_search($id, $this->_paginas)) + 1;
 373     }
 374
 375     /**
 376      * Funcion que devuelve la referencia de una pagina vitual. Si no se pasa
 377      * nada utilizo la actual.
 378      *
 379      * @param int $pag Numero de pagina.
 380      *
 381      * @return int
 382      * @access public
 383      */
 384     function refPage($pag = null) {
 385         return $pag ? $this->_paginas[$pag - 1] :
 386             $this->_pagina_actual;
 387     }
 388
 389     /**
 390      * Funcion que devuelve el array de paginas
 391      *
 392      * @return array
 393      * @access public
 394      */
 395     function getPages() {
 396         return $this->_paginas;
 397     }
 398
 399     /**
 400      * Funcion que devuelve el ancho de la pagina.
 401      *
 402      * @param  string $orientacion Orientacion de la pagina.
 403      *
 404      * @return int
 405      * @access public
 406      */
 407     function getWidth($pagina = null, $orientacion = null)
 408     {
 409         if(is_null($orientacion))
 410             $orientacion = $this->getOrientation($pagina);
 411          switch (strtolower($orientacion)) {
 412             case 'landscape':
 413                 $width = $this->_config['Yf'] - $this->_config['Yi'];
 414                 break;
 415             default:
 416                 $width = $this->_config['Xf'] - $this->_config['Xi'];
 417         }
 418         return $width;
 419
 420     }
 421
 422     /**
 423      * Funcion que devuelve el alto de la pagina.
 424      *
 425      * @param  string $orientacion Orientacion de la pagina.
 426      *
 427      * @return int
 428      * @access public
 429      */
 430     function getHeight($pagina = null, $orientacion = null)
 431     {
 432         if(is_null($orientacion))
 433             $orientacion = $this->getOrientation($pagina);
 434          switch (strtolower($orientacion)) {
 435             case 'landscape':
 436                 $height = $this->_config['Xf'] - $this->_config['Xi'];
 437                 break;
 438             default:
 439                 $height = $this->_config['Yf'] - $this->_config['Yi'];
 440         }
 441         return $height;
 442     }
 443
 444     /**
 445      * Funcion que devuelve la rotacion y traslacion para landscape. Variable X.
 446      *
 447      * @param int $x X
 448      * @param int $y Y
 449      *
 450      * @return int
 451      * @access protected
 452      */
 453     function _landscapeX($x, $y)
 454     {
 455         return -$y + $this->_config['Xf'];
 456     }
 457
 458     /**
 459      * Funcion que devuelve la rotacion y traslacion para landscape. Variable Y.
 460      *
 461      * @param int $x X
 462      * @param int $y Y
 463      *
 464      * @return int
 465      * @access protected
 466      */
 467     function _landscapeY($x, $y)
 468     {
 469         return $x + $this->_config['Yi'];
 470     }
 471
 472     /**
 473      * Funcion que devuelve la traslacion para portrait. Variable X.
 474      *
 475      * @param int $x X
 476      * @param int $y Y
 477      *
 478      * @return int
 479      * @access protected
 480      */
 481     function _portraitX($x, $y)
 482     {
 483         return $x + $this->_config['Xi'];
 484     }
 485
 486     /**
 487      * Funcion que devuelve la traslacion para portrait. Variable Y.
 488      *
 489      * @param int $x X
 490      * @param int $y Y
 491      *
 492      * @return int
 493      * @access protected
 494      */
 495     function _portraitY($x, $y)
 496     {
 497         return $y + $this->_config['Yi'];
 498     }
 499 }
 500 ?>