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