lib/MLIB/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 o PNG 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      * @param array  $param Parametros de la libreria.
 291      *
 292      * @return void
 293      * @access public
 294      */
 295     function addImage($archivo, $X, $Y, $pag = null, $formato = null,
 296             $transformacion = null, $param = array()) {
 297         $x = $X;
 298         $y = $Y;
 299         if(is_null($transformacion))
 300             $transformacion = $this->getOrientation($pag);
 301         switch (strtolower($transformacion)) {
 302             case 'portrait':
 303                 $X = $this->_portraitX($x,$y);
 304                 $Y = $this->_portraitY($x,$y);
 305                 break;
 306             case 'landscape':
 307                 $X = $this->_landscapeX($x,$y);
 308                 $Y = $this->_landscapeY($x,$y);
 309                 $param['rotation'] = 90;
 310                 break;
 311         }
 312         $formato = strtolower($formato);
 313         $fh = fopen($archivo, "r");
 314         $filedata = fread($fh, filesize($archivo));
 315         fclose($fh);
 316         switch ($formato) {
 317             case 'jpg':
 318                 $image = $this->_pdf->jfif_embed($filedata);
 319                 break;
 320             case 'png':
 321                 $image = $this->_pdf->png_embed($filedata);
 322                 break;
 323         }
 324         $this->_pdf->image_place($image, $Y, $X, $this->refPage($pag), $param);
 325     }
 326
 327     /**
 328      * Funcion que wrappea una linea.
 329      *
 330      * @param strgin $texto Texto que quiere wrappearse.
 331      * @param int    $l_max Largo maximo del texto.
 332      * @param array  $attr  Atributos del texto.
 333      *
 334      * @return string
 335      * @access public
 336      */
 337     function wrapLine($texto, $l_max, $attr) {
 338         //El if lo estoy haciendo porque en la funcion wordwrap de la libreria
 339         //externa no tienen en cuenta que te pueden pasar un texto vacio a
 340         //wrapear -> Amerita un mail a los autores.
 341         if ($texto) {
 342             return $this->_pdf->wrap_line ($texto, $l_max, $attr);
 343         }
 344         else {
 345             return '';
 346         }
 347     }
 348
 349     /**
 350      * Funcion que wrappea una linea.
 351      *
 352      * @param strgin $texto Texto que quiere wrappearse.
 353      * @param int    $l_max Largo maximo del texto.
 354      * @param array  $attr  Atributos del texto.
 355      *
 356      * @return string
 357      * @access public
 358      */
 359     function wordWrap($texto, $l_max, $attr) {
 360         //El if lo estoy haciendo porque en la funcion wordwrap de la libreria
 361         //externa no tienen en cuenta que te pueden pasar un texto vacio a
 362         //wrapear -> Amerita un mail a los autores.
 363         if ($texto) {
 364             return $this->_pdf->word_wrap ($texto, $l_max, $attr);
 365         }
 366         else {
 367             return array();
 368         }
 369     }
 370
 371     /**
 372      * Funcion que calcula cuanto va a ocupar cierto texto segun su formato en
 373      * una pagina.
 374      *
 375      * @param strgin $texto Texto que quiere medirse.
 376      * @param array  $attr  Atributos del texto.
 377      *
 378      * @return int
 379      * @access public
 380      */
 381     function strlen($texto, $attr = '') {
 382         return $this->_pdf->strlen($texto, $attr);
 383     }
 384
 385     /**
 386      * Funcion que devuelve la cantidad de paginas que contiene el documento.
 387      *
 388      * @return int
 389      * @access public
 390      */
 391     function countPages() {
 392         return count($this->_paginas);
 393     }
 394
 395     /**
 396      * Funcion que devuelve el numero de la pagina actual.
 397      *
 398      * @param mixed $id Identificador de la pagina.
 399      *
 400      * @return int
 401      * @access public
 402      */
 403     function numPage($id = null) {
 404         $id = ($id) ? $id : $this->_pagina_actual;
 405         return (array_search($id, $this->_paginas)) + 1;
 406     }
 407
 408     /**
 409      * Funcion que devuelve la referencia de una pagina vitual. Si no se pasa
 410      * nada utilizo la actual.
 411      *
 412      * @param int $pag Numero de pagina.
 413      *
 414      * @return int
 415      * @access public
 416      */
 417     function refPage($pag = null) {
 418         return $pag ? $this->_paginas[$pag - 1] :
 419             $this->_pagina_actual;
 420     }
 421
 422     /**
 423      * Funcion que devuelve el array de paginas
 424      *
 425      * @return array
 426      * @access public
 427      */
 428     function getPages() {
 429         return $this->_paginas;
 430     }
 431
 432     /**
 433      * Funcion que devuelve el ancho de la pagina.
 434      *
 435      * @param  string $orientacion Orientacion de la pagina.
 436      *
 437      * @return int
 438      * @access public
 439      */
 440     function getWidth($pagina = null, $orientacion = null)
 441     {
 442         if(is_null($orientacion))
 443             $orientacion = $this->getOrientation($pagina);
 444         switch (strtolower($orientacion)) {
 445             case 'landscape':
 446                 $width = $this->_config['Yf'] - $this->_config['Yi'];
 447                 break;
 448             default:
 449                 $width = $this->_config['Xf'] - $this->_config['Xi'];
 450         }
 451         return $width;
 452
 453     }
 454
 455     /**
 456      * Funcion que devuelve el alto de la pagina.
 457      *
 458      * @param  string $orientacion Orientacion de la pagina.
 459      *
 460      * @return int
 461      * @access public
 462      */
 463     function getHeight($pagina = null, $orientacion = null)
 464     {
 465         if(is_null($orientacion))
 466             $orientacion = $this->getOrientation($pagina);
 467         switch (strtolower($orientacion)) {
 468             case 'landscape':
 469                 $height = $this->_config['Xf'] - $this->_config['Xi'];
 470                 break;
 471             default:
 472                 $height = $this->_config['Yf'] - $this->_config['Yi'];
 473         }
 474         return $height;
 475     }
 476
 477     /**
 478      * Funcion que devuelve la rotacion y traslacion para landscape. Variable X.
 479      *
 480      * @param int $x X
 481      * @param int $y Y
 482      *
 483      * @return int
 484      * @access protected
 485      */
 486     function _landscapeX($x, $y)
 487     {
 488         return -$y + $this->_config['Xf'];
 489     }
 490
 491     /**
 492      * Funcion que devuelve la rotacion y traslacion para landscape. Variable Y.
 493      *
 494      * @param int $x X
 495      * @param int $y Y
 496      *
 497      * @return int
 498      * @access protected
 499      */
 500     function _landscapeY($x, $y)
 501     {
 502         return $x + $this->_config['Yi'];
 503     }
 504
 505     /**
 506      * Funcion que devuelve la traslacion para portrait. Variable X.
 507      *
 508      * @param int $x X
 509      * @param int $y Y
 510      *
 511      * @return int
 512      * @access protected
 513      */
 514     function _portraitX($x, $y)
 515     {
 516         return $x + $this->_config['Xi'];
 517     }
 518
 519     /**
 520      * Funcion que devuelve la traslacion para portrait. Variable Y.
 521      *
 522      * @param int $x X
 523      * @param int $y Y
 524      *
 525      * @return int
 526      * @access protected
 527      */
 528     function _portraitY($x, $y)
 529     {
 530         return $y + $this->_config['Yi'];
 531     }
 532
 533     /**
 534      * Funcion que devuelve el tamaño de una imagen.
 535      *
 536      * @param $oid Object id
 537      */
 538     function getImageSize($oid) {
 539         return $this->get_image_size($oid);
 540     }
 541 }
 542 ?>