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         return $this->_pdf->wrap_line ($texto, $l_max, $attr);
 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 wordWrap($texto, $l_max, $attr) {
 338         return $this->_pdf->word_wrap ($texto, $l_max, $attr);
 339     }
 340
 341     /**
 342      * Funcion que calcula cuanto va a ocupar cierto texto segun su formato en
 343      * una pagina.
 344      *
 345      * @param strgin $texto Texto que quiere medirse.
 346      * @param array  $attr  Atributos del texto.
 347      *
 348      * @return int
 349      * @access public
 350      */
 351     function strlen($texto, $attr = '') {
 352         return $this->_pdf->strlen($texto, $attr);
 353     }
 354
 355     /**
 356      * Funcion que devuelve la cantidad de paginas que contiene el documento.
 357      *
 358      * @return int
 359      * @access public
 360      */
 361     function countPages() {
 362         return count($this->_paginas);
 363     }
 364
 365     /**
 366      * Funcion que devuelve el numero de la pagina actual.
 367      *
 368      * @param mixed $id Identificador de la pagina.
 369      *
 370      * @return int
 371      * @access public
 372      */
 373     function numPage($id = null) {
 374         $id = ($id) ? $id : $this->_pagina_actual;
 375         return (array_search($id, $this->_paginas)) + 1;
 376     }
 377
 378     /**
 379      * Funcion que devuelve la referencia de una pagina vitual. Si no se pasa
 380      * nada utilizo la actual.
 381      *
 382      * @param int $pag Numero de pagina.
 383      *
 384      * @return int
 385      * @access public
 386      */
 387     function refPage($pag = null) {
 388         return $pag ? $this->_paginas[$pag - 1] :
 389             $this->_pagina_actual;
 390     }
 391
 392     /**
 393      * Funcion que devuelve el array de paginas
 394      *
 395      * @return array
 396      * @access public
 397      */
 398     function getPages() {
 399         return $this->_paginas;
 400     }
 401
 402     /**
 403      * Funcion que devuelve el ancho de la pagina.
 404      *
 405      * @param  string $orientacion Orientacion de la pagina.
 406      *
 407      * @return int
 408      * @access public
 409      */
 410     function getWidth($pagina = null, $orientacion = null)
 411     {
 412         if(is_null($orientacion))
 413             $orientacion = $this->getOrientation($pagina);
 414         switch (strtolower($orientacion)) {
 415             case 'landscape':
 416                 $width = $this->_config['Yf'] - $this->_config['Yi'];
 417                 break;
 418             default:
 419                 $width = $this->_config['Xf'] - $this->_config['Xi'];
 420         }
 421         return $width;
 422
 423     }
 424
 425     /**
 426      * Funcion que devuelve el alto de la pagina.
 427      *
 428      * @param  string $orientacion Orientacion de la pagina.
 429      *
 430      * @return int
 431      * @access public
 432      */
 433     function getHeight($pagina = null, $orientacion = null)
 434     {
 435         if(is_null($orientacion))
 436             $orientacion = $this->getOrientation($pagina);
 437         switch (strtolower($orientacion)) {
 438             case 'landscape':
 439                 $height = $this->_config['Xf'] - $this->_config['Xi'];
 440                 break;
 441             default:
 442                 $height = $this->_config['Yf'] - $this->_config['Yi'];
 443         }
 444         return $height;
 445     }
 446
 447     /**
 448      * Funcion que devuelve la rotacion y traslacion para landscape. Variable X.
 449      *
 450      * @param int $x X
 451      * @param int $y Y
 452      *
 453      * @return int
 454      * @access protected
 455      */
 456     function _landscapeX($x, $y)
 457     {
 458         return -$y + $this->_config['Xf'];
 459     }
 460
 461     /**
 462      * Funcion que devuelve la rotacion y traslacion para landscape. Variable Y.
 463      *
 464      * @param int $x X
 465      * @param int $y Y
 466      *
 467      * @return int
 468      * @access protected
 469      */
 470     function _landscapeY($x, $y)
 471     {
 472         return $x + $this->_config['Yi'];
 473     }
 474
 475     /**
 476      * Funcion que devuelve la traslacion para portrait. Variable X.
 477      *
 478      * @param int $x X
 479      * @param int $y Y
 480      *
 481      * @return int
 482      * @access protected
 483      */
 484     function _portraitX($x, $y)
 485     {
 486         return $x + $this->_config['Xi'];
 487     }
 488
 489     /**
 490      * Funcion que devuelve la traslacion para portrait. Variable Y.
 491      *
 492      * @param int $x X
 493      * @param int $y Y
 494      *
 495      * @return int
 496      * @access protected
 497      */
 498     function _portraitY($x, $y)
 499     {
 500         return $y + $this->_config['Yi'];
 501     }
 502 }
 503 ?>