system/libraries/Table.php

   1 <?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
   2 /**
   3  * CodeIgniter
   4  *
   5  * An open source application development framework for PHP 5.1.6 or newer
   6  *
   7  * @package             CodeIgniter
   8  * @author              ExpressionEngine Dev Team
   9  * @copyright   Copyright (c) 2008 - 2011, EllisLab, Inc.
  10  * @license             http://codeigniter.com/user_guide/license.html
  11  * @link                http://codeigniter.com
  12  * @since               Version 1.3.1
  13  * @filesource
  14  */
  15
  16 // ------------------------------------------------------------------------
  17
  18 /**
  19  * HTML Table Generating Class
  20  *
  21  * Lets you create tables manually or from database result objects, or arrays.
  22  *
  23  * @package             CodeIgniter
  24  * @subpackage  Libraries
  25  * @category    HTML Tables
  26  * @author              ExpressionEngine Dev Team
  27  * @link                http://codeigniter.com/user_guide/libraries/uri.html
  28  */
  29 class CI_Table {
  30
  31         var $rows                               = array();
  32         var $heading                    = array();
  33         var $auto_heading               = TRUE;
  34         var $caption                    = NULL;
  35         var $template                   = NULL;
  36         var $newline                    = "\n";
  37         var $empty_cells                = "";
  38         var     $function                       = FALSE;
  39
  40         public function __construct()
  41         {
  42                 log_message('debug', "Table Class Initialized");
  43         }
  44
  45         // --------------------------------------------------------------------
  46
  47         /**
  48          * Set the template
  49          *
  50          * @access      public
  51          * @param       array
  52          * @return      void
  53          */
  54         function set_template($template)
  55         {
  56                 if ( ! is_array($template))
  57                 {
  58                         return FALSE;
  59                 }
  60
  61                 $this->template = $template;
  62         }
  63
  64         // --------------------------------------------------------------------
  65
  66         /**
  67          * Set the table heading
  68          *
  69          * Can be passed as an array or discreet params
  70          *
  71          * @access      public
  72          * @param       mixed
  73          * @return      void
  74          */
  75         function set_heading()
  76         {
  77                 $args = func_get_args();
  78                 $this->heading = $this->_prep_args($args);
  79         }
  80
  81         // --------------------------------------------------------------------
  82
  83         /**
  84          * Set columns.  Takes a one-dimensional array as input and creates
  85          * a multi-dimensional array with a depth equal to the number of
  86          * columns.  This allows a single array with many elements to  be
  87          * displayed in a table that has a fixed column count.
  88          *
  89          * @access      public
  90          * @param       array
  91          * @param       int
  92          * @return      void
  93          */
  94         function make_columns($array = array(), $col_limit = 0)
  95         {
  96                 if ( ! is_array($array) OR count($array) == 0)
  97                 {
  98                         return FALSE;
  99                 }
 100
 101                 // Turn off the auto-heading feature since it's doubtful we
 102                 // will want headings from a one-dimensional array
 103                 $this->auto_heading = FALSE;
 104
 105                 if ($col_limit == 0)
 106                 {
 107                         return $array;
 108                 }
 109
 110                 $new = array();
 111                 while (count($array) > 0)
 112                 {
 113                         $temp = array_splice($array, 0, $col_limit);
 114
 115                         if (count($temp) < $col_limit)
 116                         {
 117                                 for ($i = count($temp); $i < $col_limit; $i++)
 118                                 {
 119                                         $temp[] = '&nbsp;';
 120                                 }
 121                         }
 122
 123                         $new[] = $temp;
 124                 }
 125
 126                 return $new;
 127         }
 128
 129         // --------------------------------------------------------------------
 130
 131         /**
 132          * Set "empty" cells
 133          *
 134          * Can be passed as an array or discreet params
 135          *
 136          * @access      public
 137          * @param       mixed
 138          * @return      void
 139          */
 140         function set_empty($value)
 141         {
 142                 $this->empty_cells = $value;
 143         }
 144
 145         // --------------------------------------------------------------------
 146
 147         /**
 148          * Add a table row
 149          *
 150          * Can be passed as an array or discreet params
 151          *
 152          * @access      public
 153          * @param       mixed
 154          * @return      void
 155          */
 156         function add_row()
 157         {
 158                 $args = func_get_args();
 159                 $this->rows[] = $this->_prep_args($args);
 160         }
 161
 162         // --------------------------------------------------------------------
 163
 164         /**
 165          * Prep Args
 166          *
 167          * Ensures a standard associative array format for all cell data
 168          *
 169          * @access      public
 170          * @param       type
 171          * @return      type
 172          */
 173         function _prep_args($args)
 174         {
 175                 // If there is no $args[0], skip this and treat as an associative array
 176                 // This can happen if there is only a single key, for example this is passed to table->generate
 177                 // array(array('foo'=>'bar'))
 178                 if (isset($args[0]) AND (count($args) == 1 && is_array($args[0])))
 179                 {
 180                         // args sent as indexed array
 181                         if ( ! isset($args[0]['data']))
 182                         {
 183                                 foreach ($args[0] as $key => $val)
 184                                 {
 185                                         if (is_array($val) && isset($val['data']))
 186                                         {
 187                                                 $args[$key] = $val;
 188                                         }
 189                                         else
 190                                         {
 191                                                 $args[$key] = array('data' => $val);
 192                                         }
 193                                 }
 194                         }
 195                 }
 196                 else
 197                 {
 198                         foreach ($args as $key => $val)
 199                         {
 200                                 if ( ! is_array($val))
 201                                 {
 202                                         $args[$key] = array('data' => $val);
 203                                 }
 204                         }
 205                 }
 206
 207                 return $args;
 208         }
 209
 210         // --------------------------------------------------------------------
 211
 212         /**
 213          * Add a table caption
 214          *
 215          * @access      public
 216          * @param       string
 217          * @return      void
 218          */
 219         function set_caption($caption)
 220         {
 221                 $this->caption = $caption;
 222         }
 223
 224         // --------------------------------------------------------------------
 225
 226         /**
 227          * Generate the table
 228          *
 229          * @access      public
 230          * @param       mixed
 231          * @return      string
 232          */
 233         function generate($table_data = NULL)
 234         {
 235                 // The table data can optionally be passed to this function
 236                 // either as a database result object or an array
 237                 if ( ! is_null($table_data))
 238                 {
 239                         if (is_object($table_data))
 240                         {
 241                                 $this->_set_from_object($table_data);
 242                         }
 243                         elseif (is_array($table_data))
 244                         {
 245                                 $set_heading = (count($this->heading) == 0 AND $this->auto_heading == FALSE) ? FALSE : TRUE;
 246                                 $this->_set_from_array($table_data, $set_heading);
 247                         }
 248                 }
 249
 250                 // Is there anything to display?  No?  Smite them!
 251                 if (count($this->heading) == 0 AND count($this->rows) == 0)
 252                 {
 253                         return 'Undefined table data';
 254                 }
 255
 256                 // Compile and validate the template date
 257                 $this->_compile_template();
 258
 259                 // set a custom cell manipulation function to a locally scoped variable so its callable
 260                 $function = $this->function;
 261
 262                 // Build the table!
 263
 264                 $out = $this->template['table_open'];
 265                 $out .= $this->newline;
 266
 267                 // Add any caption here
 268                 if ($this->caption)
 269                 {
 270                         $out .= $this->newline;
 271                         $out .= '<caption>' . $this->caption . '</caption>';
 272                         $out .= $this->newline;
 273                 }
 274
 275                 // Is there a table heading to display?
 276                 if (count($this->heading) > 0)
 277                 {
 278                         $out .= $this->template['thead_open'];
 279                         $out .= $this->newline;
 280                         $out .= $this->template['heading_row_start'];
 281                         $out .= $this->newline;
 282
 283                         foreach ($this->heading as $heading)
 284                         {
 285                                 $temp = $this->template['heading_cell_start'];
 286
 287                                 foreach ($heading as $key => $val)
 288                                 {
 289                                         if ($key != 'data')
 290                                         {
 291                                                 $temp = str_replace('<th', "<th $key='$val'", $temp);
 292                                         }
 293                                 }
 294
 295                                 $out .= $temp;
 296                                 $out .= isset($heading['data']) ? $heading['data'] : '';
 297                                 $out .= $this->template['heading_cell_end'];
 298                         }
 299
 300                         $out .= $this->template['heading_row_end'];
 301                         $out .= $this->newline;
 302                         $out .= $this->template['thead_close'];
 303                         $out .= $this->newline;
 304                 }
 305
 306                 // Build the table rows
 307                 if (count($this->rows) > 0)
 308                 {
 309                         $out .= $this->template['tbody_open'];
 310                         $out .= $this->newline;
 311
 312                         $i = 1;
 313                         foreach ($this->rows as $row)
 314                         {
 315                                 if ( ! is_array($row))
 316                                 {
 317                                         break;
 318                                 }
 319
 320                                 // We use modulus to alternate the row colors
 321                                 $name = (fmod($i++, 2)) ? '' : 'alt_';
 322
 323                                 $out .= $this->template['row_'.$name.'start'];
 324                                 $out .= $this->newline;
 325
 326                                 foreach ($row as $cell)
 327                                 {
 328                                         $temp = $this->template['cell_'.$name.'start'];
 329
 330                                         foreach ($cell as $key => $val)
 331                                         {
 332                                                 if ($key != 'data')
 333                                                 {
 334                                                         $temp = str_replace('<td', "<td $key='$val'", $temp);
 335                                                 }
 336                                         }
 337
 338                                         $cell = isset($cell['data']) ? $cell['data'] : '';
 339                                         $out .= $temp;
 340
 341                                         if ($cell === "" OR $cell === NULL)
 342                                         {
 343                                                 $out .= $this->empty_cells;
 344                                         }
 345                                         else
 346                                         {
 347                                                 if ($function !== FALSE && is_callable($function))
 348                                                 {
 349                                                         $out .= call_user_func($function, $cell);
 350                                                 }
 351                                                 else
 352                                                 {
 353                                                         $out .= $cell;
 354                                                 }
 355                                         }
 356
 357                                         $out .= $this->template['cell_'.$name.'end'];
 358                                 }
 359
 360                                 $out .= $this->template['row_'.$name.'end'];
 361                                 $out .= $this->newline;
 362                         }
 363
 364                         $out .= $this->template['tbody_close'];
 365                         $out .= $this->newline;
 366                 }
 367
 368                 $out .= $this->template['table_close'];
 369
 370                 // Clear table class properties before generating the table
 371                 $this->clear();
 372
 373                 return $out;
 374         }
 375
 376         // --------------------------------------------------------------------
 377
 378         /**
 379          * Clears the table arrays.  Useful if multiple tables are being generated
 380          *
 381          * @access      public
 382          * @return      void
 383          */
 384         function clear()
 385         {
 386                 $this->rows                             = array();
 387                 $this->heading                  = array();
 388                 $this->auto_heading             = TRUE;
 389         }
 390
 391         // --------------------------------------------------------------------
 392
 393         /**
 394          * Set table data from a database result object
 395          *
 396          * @access      public
 397          * @param       object
 398          * @return      void
 399          */
 400         function _set_from_object($query)
 401         {
 402                 if ( ! is_object($query))
 403                 {
 404                         return FALSE;
 405                 }
 406
 407                 // First generate the headings from the table column names
 408                 if (count($this->heading) == 0)
 409                 {
 410                         if ( ! method_exists($query, 'list_fields'))
 411                         {
 412                                 return FALSE;
 413                         }
 414
 415                         $this->heading = $this->_prep_args($query->list_fields());
 416                 }
 417
 418                 // Next blast through the result array and build out the rows
 419
 420                 if ($query->num_rows() > 0)
 421                 {
 422                         foreach ($query->result_array() as $row)
 423                         {
 424                                 $this->rows[] = $this->_prep_args($row);
 425                         }
 426                 }
 427         }
 428
 429         // --------------------------------------------------------------------
 430
 431         /**
 432          * Set table data from an array
 433          *
 434          * @access      public
 435          * @param       array
 436          * @return      void
 437          */
 438         function _set_from_array($data, $set_heading = TRUE)
 439         {
 440                 if ( ! is_array($data) OR count($data) == 0)
 441                 {
 442                         return FALSE;
 443                 }
 444
 445                 $i = 0;
 446                 foreach ($data as $row)
 447                 {
 448                         // If a heading hasn't already been set we'll use the first row of the array as the heading
 449                         if ($i == 0 AND count($data) > 1 AND count($this->heading) == 0 AND $set_heading == TRUE)
 450                         {
 451                                 $this->heading = $this->_prep_args($row);
 452                         }
 453                         else
 454                         {
 455                                 $this->rows[] = $this->_prep_args($row);
 456                         }
 457
 458                         $i++;
 459                 }
 460         }
 461
 462         // --------------------------------------------------------------------
 463
 464         /**
 465          * Compile Template
 466          *
 467          * @access      private
 468          * @return      void
 469          */
 470         function _compile_template()
 471         {
 472                 if ($this->template == NULL)
 473                 {
 474                         $this->template = $this->_default_template();
 475                         return;
 476                 }
 477
 478                 $this->temp = $this->_default_template();
 479                 foreach (array('table_open', 'thead_open', 'thead_close', 'heading_row_start', 'heading_row_end', 'heading_cell_start', 'heading_cell_end', 'tbody_open', 'tbody_close', 'row_start', 'row_end', 'cell_start', 'cell_end', 'row_alt_start', 'row_alt_end', 'cell_alt_start', 'cell_alt_end', 'table_close') as $val)
 480                 {
 481                         if ( ! isset($this->template[$val]))
 482                         {
 483                                 $this->template[$val] = $this->temp[$val];
 484                         }
 485                 }
 486         }
 487
 488         // --------------------------------------------------------------------
 489
 490         /**
 491          * Default Template
 492          *
 493          * @access      private
 494          * @return      void
 495          */
 496         function _default_template()
 497         {
 498                 return  array (
 499                                                 'table_open'                    => '<table border="0" cellpadding="4" cellspacing="0">',
 500
 501                                                 'thead_open'                    => '<thead>',
 502                                                 'thead_close'                   => '</thead>',
 503
 504                                                 'heading_row_start'             => '<tr>',
 505                                                 'heading_row_end'               => '</tr>',
 506                                                 'heading_cell_start'    => '<th>',
 507                                                 'heading_cell_end'              => '</th>',
 508
 509                                                 'tbody_open'                    => '<tbody>',
 510                                                 'tbody_close'                   => '</tbody>',
 511
 512                                                 'row_start'                             => '<tr>',
 513                                                 'row_end'                               => '</tr>',
 514                                                 'cell_start'                    => '<td>',
 515                                                 'cell_end'                              => '</td>',
 516
 517                                                 'row_alt_start'         => '<tr>',
 518                                                 'row_alt_end'                   => '</tr>',
 519                                                 'cell_alt_start'                => '<td>',
 520                                                 'cell_alt_end'                  => '</td>',
 521
 522                                                 'table_close'                   => '</table>'
 523                                         );
 524         }
 525
 526
 527 }
 528
 529
 530 /* End of file Table.php */
 531 /* Location: ./system/libraries/Table.php */