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