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 protected
  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      * Nombre del archivo resultado para el display.
  80      * @var sting $nombre
  81      * @access private
  82      */
  83     var $_nombre;
  84
  85     /**
  86      * Class constructor.
  87      *
  88      * @param string $tam Tipo de hoja
  89      * @param string $ori Orientacion de las hojas (portrait o landscape).
  90      * @param string $nombre Nombre del archivo PDF.
  91      *
  92      * @return void
  93      * @access public
  94      */
  95     function MECON_PDF($tam = "a4", $ori = "portrait", $nombre = "Doc.pdf")
  96     {
  97         setlocale (LC_ALL, 'en_US');
  98         $this->orientacion = $ori;
  99         $this->_pdf = new pdffile;
 100         $this->_config = include 'MECON/PDF/medidas.php';
 101         $this->_config = $this->_config[$tam];
 102         $this->_nombre = $nombre;
 103     }
 104
 105     /**
 106      * Permite agregar nuevas paginas al pdf que se esta armando.
 107      *
 108      * @param  string $pagina Tipo de pagina que se va a utilizar.
 109      * @param  string $orientacion Orientacion de la pagina en particular.
 110      *
 111      * @return void
 112      * @access public
 113      */
 114     function newPage($pagina = "a4", $orientacion = null)
 115     {
 116         $this->_pagina_actual = $this->_pdf->new_page($pagina);
 117         $this->_paginas[] = $this->_pagina_actual;
 118         if(!is_null($orientacion) && $orientacion != $this->orientacion)
 119             $this->_orientacion_distinta[$this->numPage()] = $orientacion;
 120     }
 121
 122     /**
 123      * Funcion que retorna la orientacion de la pagina indicada.
 124      * Si no se indica, toma la orientacion de la ultima pagina.
 125      *
 126      * @param int $pagina Numero de la pagina.
 127      *
 128      * @access public
 129      * @return int
 130      */
 131     function getOrientation($pagina = null)
 132     {
 133         if(is_null($pagina))
 134             $pagina = $this->numPage();
 135
 136         if(isset($this->_orientacion_distinta[$pagina]))
 137             return $this->_orientacion_distinta[$pagina];
 138         else
 139             return $this->orientacion;
 140     }
 141
 142     /**
 143      * Funcion que genera el archivo y prepara los headers para que se envie.
 144      *
 145      * @return void
 146      * @access public
 147      */
 148     function display()
 149     {
 150         header("Content-Disposition: filename=".$this->_nombre);
 151         header("Content-Type: application/pdf");
 152         $temp = $this->toPDF();
 153         header('Content-Length: ' . strlen($temp));
 154         echo $temp;
 155     }
 156
 157     /**
 158      * Funcion que devuelve el PDF.
 159      *
 160      * @return string
 161      * @access public
 162      */
 163     function toPDF() {
 164         return $this->_pdf->generate();
 165     }
 166
 167     /**
 168      * Funcion que permite agregar texto a una pagina.
 169      *
 170      * @param int $X $X
 171      * @param int $Y $Y
 172      * @param string $texto $texto
 173      * @param int $estilo $estilo
 174      * @param int $pag Numero de pagina virtual.
 175      * @param string $transformacion Indica la orientacion de la pagina.
 176      *
 177      * @return void
 178      * @access public
 179      */
 180     function addText($X, $Y, $texto, $estilo = '', $pag = null, $transformacion
 181     = null)    {
 182         $x = $X;
 183         $y = $Y;
 184         if(is_null($transformacion))
 185             $transformacion = $this->getOrientation($pag);
 186         switch (strtolower($transformacion)) {
 187             case 'portrait':
 188                 $X = $this->_portraitX($x,$y);
 189                 $Y = $this->_portraitY($x,$y);
 190                 break;
 191             case 'landscape':
 192                 $X = $this->_landscapeX($x,$y);
 193                 $Y = $this->_landscapeY($x,$y);
 194                 @$estilo['rotation'] += 90;
 195                 break;
 196         }
 197         $this->_pdf->draw_text($X, $Y, $texto, $this->refPage($pag), $estilo);
 198     }
 199
 200     /**
 201      * Funcion que permite agregar un rectangulo a una pagina.
 202      *
 203      * @param int $Xi $Xi
 204      * @param int $Yi $Yi
 205      * @param int $Xf $Xf
 206      * @param int $Yf $Yf
 207      * @param long $estilo $estilo
 208      * @param int $pag Numero de pagina virtual.
 209      * @param string $transformacion Indica la orientacion de la pagina.
 210      *
 211      * @return void
 212      * @access public
 213      */
 214     function addRectangle($Xi, $Yi, $Xf, $Yf, $estilo = '', $pag = null,
 215             $transformacion = null)
 216     {
 217         $xi = $Xi;
 218         $yi = $Yi;
 219         $xf = $Xf;
 220         $yf = $Yf;
 221         if(is_null($transformacion))
 222             $transformacion = $this->getOrientation($pag);
 223         switch (strtolower($transformacion)) {
 224             case 'portrait':
 225                 $Xi = $this->_portraitX($xi,$yi);
 226                 $Yi = $this->_portraitY($xi,$yi);
 227                 $Xf = $this->_portraitX($xf,$yf);
 228                 $Yf = $this->_portraitY($xf,$yf);
 229                 break;
 230             case 'landscape':
 231                 $Xi = $this->_landscapeX($xi,$yi);
 232                 $Yi = $this->_landscapeY($xi,$yi);
 233                 $Xf = $this->_landscapeX($xf,$yf);
 234                 $Yf = $this->_landscapeY($xf,$yf);
 235                 break;
 236         }
 237         $this->_pdf->draw_rectangle($Yi, $Xi, $Yf, $Xf, $this->refPage($pag), $estilo);
 238     }
 239
 240     /**
 241      * Funcion que permite agregar una linea a una pagina.
 242      *
 243      * @param int $Xi $Xi
 244      * @param int $Yi $Yi
 245      * @param int $Xf $Xf
 246      * @param int $Yf $Yf
 247      * @param int $estilo $estilo
 248      * @param int $pag Numero de pagina virtual.
 249      * @param string $transformacion Indica la orientacion de la pagina.
 250      *
 251      * @return void
 252      * @access public
 253      */
 254     function addLine($Xi, $Yi, $Xf, $Yf, $estilo = '', $pag = null,
 255             $transformacion = null)
 256     {
 257         $xi = $Xi;
 258         $yi = $Yi;
 259         $xf = $Xf;
 260         $yf = $Yf;
 261         if(is_null($transformacion))
 262             $transformacion = $this->getOrientation($pag);
 263         switch (strtolower($transformacion)) {
 264             case 'portrait':
 265                 $Xi = $this->_portraitX($xi,$yi);
 266                 $Yi = $this->_portraitY($xi,$yi);
 267                 $Xf = $this->_portraitX($xf,$yf);
 268                 $Yf = $this->_portraitY($xf,$yf);
 269                 break;
 270             case 'landscape':
 271                 $Xi = $this->_landscapeX($xi,$yi);
 272                 $Yi = $this->_landscapeY($xi,$yi);
 273                 $Xf = $this->_landscapeX($xf,$yf);
 274                 $Yf = $this->_landscapeY($xf,$yf);
 275                 break;
 276         }
 277        $this->_pdf->draw_line(array($Xi,$Xf),array($Yi,$Yf),
 278                 $this->refPage($pag),$estilo);
 279     }
 280
 281     /**
 282      * Funcion que permite agregar una imagen JPG a una pagina.
 283      *
 284      * @param string $archivo Path completo del archivo imagen.
 285      * @param int    $X Posicion Horizontal.
 286      * @param int    $Y Posixion vertical.
 287      * @param int    $pag Numero de pagina virtual.
 288      * @param string $formato Formato del archivo (Extension).
 289      * @param string $transformacion Indica la orientacion de la pagina.
 290      *
 291      * @return void
 292      * @access public
 293      */
 294     function addImage($archivo, $X, $Y, $pag = null, $formato = null,
 295             $transformacion = null) {
 296         $x = $X;
 297         $y = $Y;
 298         if(is_null($transformacion))
 299             $transformacion = $this->getOrientation($pag);
 300         switch (strtolower($transformacion)) {
 301             case 'portrait':
 302                 $X = $this->_portraitX($x,$y);
 303                 $Y = $this->_portraitY($x,$y);
 304                 break;
 305             case 'landscape':
 306                 $X = $this->_landscapeX($x,$y);
 307                 $Y = $this->_landscapeY($x,$y);
 308                 break;
 309         }
 310         $formato = strtolower($formato);
 311         switch ($formato) {
 312             case 'jpg':
 313                 $fh = fopen($archivo, "r");
 314                 $filedata = fread($fh, filesize($archivo));
 315                 fclose($fh);
 316                 $image = $this->_pdf->jfif_embed($filedata);
 317                 $this->_pdf->image_place($image, $Y, $X,
 318                         $this->refPage($pag));
 319                 break;
 320         }
 321     }
 322
 323     /**
 324      * Funcion que wrappea una linea.
 325      *
 326      * @param strgin $texto Texto que quiere wrappearse.
 327      * @param int    $l_max Largo maximo del texto.
 328      * @param array  $attr  Atributos del texto.
 329      *
 330      * @return string
 331      * @access public
 332      */
 333     function wrapLine($texto, $l_max, $attr) {
 334         //El if lo estoy haciendo porque en la funcion wordwrap de la libreria
 335         //externa no tienen en cuenta que te pueden pasar un texto vacio a
 336         //wrapear -> Amerita un mail a los autores.
 337         if ($texto) {
 338             return $this->_pdf->wrap_line ($texto, $l_max, $attr);
 339         }
 340         else {
 341             return '';
 342         }
 343     }
 344
 345     /**
 346      * Funcion que wrappea una linea.
 347      *
 348      * @param strgin $texto Texto que quiere wrappearse.
 349      * @param int    $l_max Largo maximo del texto.
 350      * @param array  $attr  Atributos del texto.
 351      *
 352      * @return string
 353      * @access public
 354      */
 355     function wordWrap($texto, $l_max, $attr) {
 356         //El if lo estoy haciendo porque en la funcion wordwrap de la libreria
 357         //externa no tienen en cuenta que te pueden pasar un texto vacio a
 358         //wrapear -> Amerita un mail a los autores.
 359         if ($texto) {
 360             return $this->_pdf->word_wrap ($texto, $l_max, $attr);
 361         }
 362         else {
 363             return array();
 364         }
 365     }
 366
 367     /**
 368      * Funcion que calcula cuanto va a ocupar cierto texto segun su formato en
 369      * una pagina.
 370      *
 371      * @param strgin $texto Texto que quiere medirse.
 372      * @param array  $attr  Atributos del texto.
 373      *
 374      * @return int
 375      * @access public
 376      */
 377     function strlen($texto, $attr = '') {
 378         return $this->_pdf->strlen($texto, $attr);
 379     }
 380
 381     /**
 382      * Funcion que devuelve la cantidad de paginas que contiene el documento.
 383      *
 384      * @return int
 385      * @access public
 386      */
 387     function countPages() {
 388         return count($this->_paginas);
 389     }
 390
 391     /**
 392      * Funcion que devuelve el numero de la pagina actual.
 393      *
 394      * @param mixed $id Identificador de la pagina.
 395      *
 396      * @return int
 397      * @access public
 398      */
 399     function numPage($id = null) {
 400         $id = ($id) ? $id : $this->_pagina_actual;
 401         return (array_search($id, $this->_paginas)) + 1;
 402     }
 403
 404     /**
 405      * Funcion que devuelve la referencia de una pagina vitual. Si no se pasa
 406      * nada utilizo la actual.
 407      *
 408      * @param int $pag Numero de pagina.
 409      *
 410      * @return int
 411      * @access public
 412      */
 413     function refPage($pag = null) {
 414         return $pag ? $this->_paginas[$pag - 1] :
 415             $this->_pagina_actual;
 416     }
 417
 418     /**
 419      * Funcion que devuelve el array de paginas
 420      *
 421      * @return array
 422      * @access public
 423      */
 424     function getPages() {
 425         return $this->_paginas;
 426     }
 427
 428     /**
 429      * Funcion que devuelve el ancho de la pagina.
 430      *
 431      * @param  string $orientacion Orientacion de la pagina.
 432      *
 433      * @return int
 434      * @access public
 435      */
 436     function getWidth($pagina = null, $orientacion = null)
 437     {
 438         if(is_null($orientacion))
 439             $orientacion = $this->getOrientation($pagina);
 440         switch (strtolower($orientacion)) {
 441             case 'landscape':
 442                 $width = $this->_config['Yf'] - $this->_config['Yi'];
 443                 break;
 444             default:
 445                 $width = $this->_config['Xf'] - $this->_config['Xi'];
 446         }
 447         return $width;
 448
 449     }
 450
 451     /**
 452      * Funcion que devuelve el alto de la pagina.
 453      *
 454      * @param  string $orientacion Orientacion de la pagina.
 455      *
 456      * @return int
 457      * @access public
 458      */
 459     function getHeight($pagina = null, $orientacion = null)
 460     {
 461         if(is_null($orientacion))
 462             $orientacion = $this->getOrientation($pagina);
 463         switch (strtolower($orientacion)) {
 464             case 'landscape':
 465                 $height = $this->_config['Xf'] - $this->_config['Xi'];
 466                 break;
 467             default:
 468                 $height = $this->_config['Yf'] - $this->_config['Yi'];
 469         }
 470         return $height;
 471     }
 472
 473     /**
 474      * Funcion que devuelve la rotacion y traslacion para landscape. Variable X.
 475      *
 476      * @param int $x X
 477      * @param int $y Y
 478      *
 479      * @return int
 480      * @access protected
 481      */
 482     function _landscapeX($x, $y)
 483     {
 484         return -$y + $this->_config['Xf'];
 485     }
 486
 487     /**
 488      * Funcion que devuelve la rotacion y traslacion para landscape. Variable Y.
 489      *
 490      * @param int $x X
 491      * @param int $y Y
 492      *
 493      * @return int
 494      * @access protected
 495      */
 496     function _landscapeY($x, $y)
 497     {
 498         return $x + $this->_config['Yi'];
 499     }
 500
 501     /**
 502      * Funcion que devuelve la traslacion para portrait. Variable X.
 503      *
 504      * @param int $x X
 505      * @param int $y Y
 506      *
 507      * @return int
 508      * @access protected
 509      */
 510     function _portraitX($x, $y)
 511     {
 512         return $x + $this->_config['Xi'];
 513     }
 514
 515     /**
 516      * Funcion que devuelve la traslacion para portrait. Variable Y.
 517      *
 518      * @param int $x X
 519      * @param int $y Y
 520      *
 521      * @return int
 522      * @access protected
 523      */
 524     function _portraitY($x, $y)
 525     {
 526         return $y + $this->_config['Yi'];
 527     }
 528 }
 529 ?>