libraries/export/pdf.php

   1 <?php
   2 /* vim: set expandtab sw=4 ts=4 sts=4: */
   3 /**
   4  * Produce a PDF report (export) from a query
   5  *
   6  * @package PhpMyAdmin-Export
   7  * @subpackage PDF
   8  */
   9 if (! defined('PHPMYADMIN')) {
  10     exit;
  11 }
  12
  13 /**
  14  *
  15  */
  16 if (isset($plugin_list)) {
  17     $plugin_list['pdf'] = array(
  18         'text' => __('PDF'),
  19         'extension' => 'pdf',
  20         'mime_type' => 'application/pdf',
  21         'force_file' => true,
  22         'options' => array(
  23             array('type' => 'begin_group', 'name' => 'general_opts'),
  24             array('type' => 'message_only', 'name' => 'explanation', 'text' => __('(Generates a report containing the data of a single table)')),
  25             array('type' => 'text', 'name' => 'report_title', 'text' => __('Report title:')),
  26             array('type' => 'hidden', 'name' => 'structure_or_data'),
  27             array('type' => 'end_group')
  28             ),
  29         'options_text' => __('Options'),
  30         );
  31 } else {
  32
  33     include_once './libraries/PDF.class.php';
  34
  35     /**
  36      * Adapted from a LGPL script by Philip Clarke
  37      * @package PhpMyAdmin-Export
  38      * @subpackage PDF
  39      */
  40     class PMA_Export_PDF extends PMA_PDF
  41     {
  42         var $tablewidths;
  43         var $headerset;
  44
  45         function checkPageBreak($h=0, $y='', $addpage=true) {
  46             if ($this->empty_string($y)) {
  47                 $y = $this->y;
  48             }
  49             $current_page = $this->page;
  50             if ((($y + $h) > $this->PageBreakTrigger) AND (!$this->InFooter) AND ($this->AcceptPageBreak())) {
  51                 if ($addpage) {
  52                     //Automatic page break
  53                     $x = $this->x;
  54                     $this->AddPage($this->CurOrientation);
  55                     $this->y = $this->dataY;
  56                     $oldpage = $this->page - 1;
  57                     if ($this->rtl) {
  58                         if ($this->pagedim[$this->page]['orm'] != $this->pagedim[$oldpage]['orm']) {
  59                             $this->x = $x - ($this->pagedim[$this->page]['orm'] - $this->pagedim[$oldpage]['orm']);
  60                         } else {
  61                             $this->x = $x;
  62                         }
  63                     } else {
  64                         if ($this->pagedim[$this->page]['olm'] != $this->pagedim[$oldpage]['olm']) {
  65                             $this->x = $x + ($this->pagedim[$this->page]['olm'] - $this->pagedim[$oldpage]['olm']);
  66                         } else {
  67                             $this->x = $x;
  68                         }
  69                     }
  70                 }
  71                 return true;
  72             }
  73             if ($current_page != $this->page) {
  74                 // account for columns mode
  75                 return true;
  76             }
  77             return false;
  78         }
  79
  80         function Header()
  81         {
  82             global $maxY;
  83             // Check if header for this page already exists
  84             if (!isset($this->headerset[$this->page])) {
  85                 $fullwidth = 0;
  86                 foreach ($this->tablewidths as $width) {
  87                     $fullwidth += $width;
  88                 }
  89                 $this->SetY(($this->tMargin) - ($this->FontSizePt/$this->k)*3);
  90                 $this->cellFontSize = $this->FontSizePt ;
  91                 $this->SetFont(PMA_PDF_FONT, '', ($this->titleFontSize ? $this->titleFontSize : $this->FontSizePt));
  92                 $this->Cell(0, $this->FontSizePt, $this->titleText, 0, 1, 'C');
  93                 $this->SetFont(PMA_PDF_FONT, '', $this->cellFontSize);
  94                 $this->SetY(($this->tMargin) - ($this->FontSizePt/$this->k)*1.5);
  95                 $this->Cell(0, $this->FontSizePt, __('Database') .': ' .$this->currentDb .',  ' .__('Table') .': ' .$this->currentTable, 0, 1, 'L');
  96                 $l = ($this->lMargin);
  97                 foreach ($this->colTitles as $col => $txt) {
  98                     $this->SetXY($l, ($this->tMargin));
  99                     $this->MultiCell($this->tablewidths[$col], $this->FontSizePt, $txt);
 100                     $l += $this->tablewidths[$col] ;
 101                     $maxY = ($maxY < $this->getY()) ? $this->getY() : $maxY ;
 102                 }
 103                 $this->SetXY($this->lMargin, $this->tMargin);
 104                 $this->setFillColor(200, 200, 200);
 105                 $l = ($this->lMargin);
 106                 foreach ($this->colTitles as $col => $txt) {
 107                     $this->SetXY($l, $this->tMargin);
 108                     $this->cell($this->tablewidths[$col], $maxY-($this->tMargin), '', 1, 0, 'L', 1);
 109                     $this->SetXY($l, $this->tMargin);
 110                     $this->MultiCell($this->tablewidths[$col], $this->FontSizePt, $txt, 0, 'C');
 111                     $l += $this->tablewidths[$col];
 112                 }
 113                 $this->setFillColor(255, 255, 255);
 114                 // set headerset
 115                 $this->headerset[$this->page] = 1;
 116             }
 117
 118             $this->dataY = $maxY;
 119         }
 120
 121         function morepagestable($lineheight=8)
 122         {
 123             // some things to set and 'remember'
 124             $l = $this->lMargin;
 125             $startheight = $h = $this->dataY;
 126             $startpage = $currpage = $this->page;
 127
 128             // calculate the whole width
 129             $fullwidth = 0;
 130             foreach ($this->tablewidths as $width) {
 131                 $fullwidth += $width;
 132             }
 133
 134             // Now let's start to write the table
 135             $row = 0;
 136             $tmpheight = array();
 137             $maxpage = $this->page;
 138
 139             while ($data = PMA_DBI_fetch_row($this->results)) {
 140                 $this->page = $currpage;
 141                 // write the horizontal borders
 142                 $this->Line($l, $h, $fullwidth+$l, $h);
 143                 // write the content and remember the height of the highest col
 144                 foreach ($data as $col => $txt) {
 145                     $this->page = $currpage;
 146                     $this->SetXY($l, $h);
 147                     if ($this->tablewidths[$col] > 0) {
 148                         $this->MultiCell($this->tablewidths[$col], $lineheight, $txt, 0, $this->colAlign[$col]);
 149                         $l += $this->tablewidths[$col];
 150                     }
 151
 152                     if (!isset($tmpheight[$row.'-'.$this->page])) {
 153                         $tmpheight[$row.'-'.$this->page] = 0;
 154                     }
 155                     if ($tmpheight[$row.'-'.$this->page] < $this->GetY()) {
 156                         $tmpheight[$row.'-'.$this->page] = $this->GetY();
 157                     }
 158                     if ($this->page > $maxpage) {
 159                         $maxpage = $this->page;
 160                     }
 161                     unset($data[$col]);
 162                 }
 163
 164                 // get the height we were in the last used page
 165                 $h = $tmpheight[$row.'-'.$maxpage];
 166                 // set the "pointer" to the left margin
 167                 $l = $this->lMargin;
 168                 // set the $currpage to the last page
 169                 $currpage = $maxpage;
 170                 unset($data[$row]);
 171                 $row++;
 172             }
 173             // draw the borders
 174             // we start adding a horizontal line on the last page
 175             $this->page = $maxpage;
 176             $this->Line($l, $h, $fullwidth+$l, $h);
 177             // now we start at the top of the document and walk down
 178             for ($i = $startpage; $i <= $maxpage; $i++) {
 179                 $this->page = $i;
 180                 $l = $this->lMargin;
 181                 $t = ($i == $startpage) ? $startheight : $this->tMargin;
 182                 $lh = ($i == $maxpage) ? $h : $this->h-$this->bMargin;
 183                 $this->Line($l, $t, $l, $lh);
 184                 foreach ($this->tablewidths as $width) {
 185                     $l += $width;
 186                     $this->Line($l, $t, $l, $lh);
 187                 }
 188             }
 189             // set it to the last page, if not it'll cause some problems
 190             $this->page = $maxpage;
 191         }
 192
 193         function setAttributes($attr = array())
 194         {
 195             foreach ($attr as $key => $val) {
 196                 $this->$key = $val ;
 197             }
 198         }
 199
 200         function setTopMargin($topMargin)
 201         {
 202             $this->tMargin = $topMargin;
 203         }
 204
 205         function mysql_report($query)
 206         {
 207             unset($this->tablewidths);
 208             unset($this->colTitles);
 209             unset($this->titleWidth);
 210             unset($this->colFits);
 211             unset($this->display_column);
 212             unset($this->colAlign);
 213
 214             /**
 215              * Pass 1 for column widths
 216              */
 217             $this->results = PMA_DBI_query($query, null, PMA_DBI_QUERY_UNBUFFERED);
 218             $this->numFields  = PMA_DBI_num_fields($this->results);
 219             $this->fields = PMA_DBI_get_fields_meta($this->results);
 220
 221             // sColWidth = starting col width (an average size width)
 222             $availableWidth = $this->w - $this->lMargin - $this->rMargin;
 223             $this->sColWidth = $availableWidth / $this->numFields;
 224             $totalTitleWidth = 0;
 225
 226             // loop through results header and set initial col widths/ titles/ alignment
 227             // if a col title is less than the starting col width, reduce that column size
 228             for ($i = 0; $i < $this->numFields; $i++) {
 229                 $stringWidth = $this->getstringwidth($this->fields[$i]->name) + 6 ;
 230                 // save the real title's width
 231                 $titleWidth[$i] = $stringWidth;
 232                 $totalTitleWidth += $stringWidth;
 233
 234                 // set any column titles less than the start width to the column title width
 235                 if ($stringWidth < $this->sColWidth) {
 236                     $colFits[$i] = $stringWidth ;
 237                 }
 238                 $this->colTitles[$i] = $this->fields[$i]->name;
 239                 $this->display_column[$i] = true;
 240
 241                 switch ($this->fields[$i]->type) {
 242                 case 'int':
 243                     $this->colAlign[$i] = 'R';
 244                     break;
 245                 case 'blob':
 246                 case 'tinyblob':
 247                 case 'mediumblob':
 248                 case 'longblob':
 249                     /**
 250                      * @todo do not deactivate completely the display
 251                      * but show the field's name and [BLOB]
 252                      */
 253                     if (stristr($this->fields[$i]->flags, 'BINARY')) {
 254                         $this->display_column[$i] = false;
 255                         unset($this->colTitles[$i]);
 256                     }
 257                     $this->colAlign[$i] = 'L';
 258                     break;
 259                 default:
 260                     $this->colAlign[$i] = 'L';
 261                 }
 262             }
 263
 264             // title width verification
 265             if ($totalTitleWidth > $availableWidth) {
 266                 $adjustingMode = true;
 267             } else {
 268                 $adjustingMode = false;
 269                 // we have enough space for all the titles at their
 270                 // original width so use the true title's width
 271                 foreach ($titleWidth as $key => $val) {
 272                     $colFits[$key] = $val;
 273                 }
 274             }
 275
 276             // loop through the data; any column whose contents
 277             // is greater than the column size is resized
 278             /**
 279               * @todo force here a LIMIT to avoid reading all rows
 280               */
 281             while ($row = PMA_DBI_fetch_row($this->results)) {
 282                 foreach ($colFits as $key => $val) {
 283                     $stringWidth = $this->getstringwidth($row[$key]) + 6 ;
 284                     if ($adjustingMode && ($stringWidth > $this->sColWidth)) {
 285                     // any column whose data's width is bigger than the start width is now discarded
 286                         unset($colFits[$key]);
 287                     } else {
 288                     // if data's width is bigger than the current column width,
 289                     // enlarge the column (but avoid enlarging it if the
 290                     // data's width is very big)
 291                             if ($stringWidth > $val && $stringWidth < ($this->sColWidth * 3)) {
 292                             $colFits[$key] = $stringWidth ;
 293                         }
 294                     }
 295                 }
 296             }
 297
 298             $totAlreadyFitted = 0;
 299             foreach ($colFits as $key => $val) {
 300                 // set fitted columns to smallest size
 301                 $this->tablewidths[$key] = $val;
 302                 // to work out how much (if any) space has been freed up
 303                 $totAlreadyFitted += $val;
 304             }
 305
 306             if ($adjustingMode) {
 307                 $surplus = (sizeof($colFits) * $this->sColWidth) - $totAlreadyFitted;
 308                 $surplusToAdd = $surplus / ($this->numFields - sizeof($colFits));
 309             } else {
 310                 $surplusToAdd = 0;
 311             }
 312
 313             for ($i=0; $i < $this->numFields; $i++) {
 314                 if (!in_array($i, array_keys($colFits))) {
 315                     $this->tablewidths[$i] = $this->sColWidth + $surplusToAdd;
 316                 }
 317                 if ($this->display_column[$i] == false) {
 318                     $this->tablewidths[$i] = 0;
 319                 }
 320             }
 321
 322             ksort($this->tablewidths);
 323
 324             PMA_DBI_free_result($this->results);
 325
 326             // Pass 2
 327
 328             $this->results = PMA_DBI_query($query, null, PMA_DBI_QUERY_UNBUFFERED);
 329             $this->setY($this->tMargin);
 330             $this->AddPage();
 331             $this->morepagestable($this->FontSizePt);
 332             PMA_DBI_free_result($this->results);
 333
 334         } // end of mysql_report function
 335
 336     } // end of PMA_Export_PDF class
 337
 338     $pdf = new PMA_Export_PDF('L', 'pt', 'A3');
 339
 340     /**
 341      * Finalize the pdf.
 342      *
 343      * @return  bool        Whether it suceeded
 344      *
 345      * @access  public
 346      */
 347     function PMA_exportFooter()
 348     {
 349         global $pdf;
 350
 351         // instead of $pdf->Output():
 352         if (!PMA_exportOutputHandler($pdf->getPDFData())) {
 353             return false;
 354         }
 355
 356         return true;
 357     }
 358
 359     /**
 360      * Initialize the pdf to export data.
 361      *
 362      * @return  bool        Whether it suceeded
 363      *
 364      * @access  public
 365      */
 366     function PMA_exportHeader()
 367     {
 368         global $pdf_report_title;
 369         global $pdf;
 370
 371         $pdf->Open();
 372
 373         $attr=array('titleFontSize' => 18, 'titleText' => $pdf_report_title);
 374         $pdf->setAttributes($attr);
 375         $pdf->setTopMargin(45);
 376
 377         return true;
 378     }
 379
 380     /**
 381      * Outputs database header
 382      *
 383      * @param string  $db Database name
 384      * @return  bool        Whether it suceeded
 385      *
 386      * @access  public
 387      */
 388     function PMA_exportDBHeader($db)
 389     {
 390         return true;
 391     }
 392
 393     /**
 394      * Outputs database footer
 395      *
 396      * @param string  $db Database name
 397      * @return  bool        Whether it suceeded
 398      *
 399      * @access  public
 400      */
 401     function PMA_exportDBFooter($db)
 402     {
 403         return true;
 404     }
 405
 406     /**
 407      * Outputs CREATE DATABASE statement
 408      *
 409      * @param string  $db Database name
 410      * @return  bool        Whether it suceeded
 411      *
 412      * @access  public
 413      */
 414     function PMA_exportDBCreate($db)
 415     {
 416         return true;
 417     }
 418
 419     /**
 420      * Outputs the content of a table in PDF format
 421      *
 422      * @param string  $db         database name
 423      * @param string  $table      table name
 424      * @param string  $crlf       the end of line sequence
 425      * @param string  $error_url  the url to go back in case of error
 426      * @param string  $sql_query  SQL query for obtaining data
 427      * @return  bool        Whether it suceeded
 428      *
 429      * @access  public
 430      */
 431     function PMA_exportData($db, $table, $crlf, $error_url, $sql_query)
 432     {
 433         global $pdf;
 434
 435         $attr=array('currentDb' => $db, 'currentTable' => $table);
 436         $pdf->setAttributes($attr);
 437         $pdf->mysql_report($sql_query);
 438
 439         return true;
 440     } // end of the 'PMA_exportData()' function
 441 }
 442 ?>