lib/MECON/HTML/TablaDB.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 mar 21 ART 2003
  22 Autor:  Martin Marrese <mmarre@mecon.gov.ar>
  23 -------------------------------------------------------------------------------
  24 $Id$
  25 -----------------------------------------------------------------------------*/
  26
  27 require_once 'DB.php';
  28 require_once 'MECON/DB/Pager.php';
  29 require_once 'MECON/HTML/Error.php';
  30 require_once 'MECON/HTML/Link.php';
  31 require_once 'MECON/HTML/Tabla.php';
  32
  33 /**
  34  * Libreria para le manejo de las tablas de los sistemas de intranet.
  35  *
  36  */
  37 class MECON_HTML_TablaDB extends MECON_HTML_Tabla {
  38
  39     /**
  40      * Descripción de los elementos listados.
  41      * Se utiliza en mensajes del paginador y otros mensajes.
  42      */
  43     var $_desc = 'resultados';
  44
  45     /**
  46      * Datos a agregar delante de cada fila que se agregue desde una base de datos.
  47      * Cada elemento del array es a su vez un array cuyo primer elemento es el
  48      * formato del texto a agregar (tipo printf()) y el segundo es un array con los
  49      * campos de la DB a utilizar para ese formato en una fila dada.
  50      * Cuando se utiliza una callback para "dibujar" el campo, el campo puede
  51      * ser un array de campos de la base que se quiere pasar a la callback.
  52      */
  53     var $_prependRowsData = array();
  54
  55     /**
  56      * Datos a agregar al final de cada fila que se agregue desde una base de datos.
  57      * El formato es el mismo que el de _prependRowsData.
  58      */
  59     var $_appendRowsData = array();
  60
  61     /**
  62      * Prefijo a usar para las variables GET que genera la tabla.
  63      */
  64     var $_getVarPrefix = '_';
  65
  66     /**
  67      * Constructor.
  68      * Puede recibir como parametro un string con los atributos que se
  69      * quieren dar a la tabla en cuestion. Estos atributos estan
  70      * seteados por default segun el archivo de configuracion.
  71      * Ademas puede recibir la indicacion de algun estilo en particular.
  72      *
  73      * @param string $desc Descripción de los elementos listados.
  74      * @param mixed $attrs Atributos diferentes a los estandares para la tabla
  75      * @param string $estilo Tipo de tabla
  76      *
  77      * @access public
  78      */
  79     function MECON_HTML_TablaDB($desc = null, $attrs = null, $estilo = 'comun') {
  80         if ($desc) {
  81             $this->_desc = $desc;
  82         }
  83         parent::MECON_HTML_Tabla($attrs, $estilo);
  84     }
  85
  86     /**
  87      * Establece el prefijo usado para las variables de GET que genera la tabla.
  88      */
  89     function setGetVarPrefix($prefix) {
  90         $this->_getVarPrefix = $prefix;
  91     }
  92
  93     /**
  94      * Obtiene el prefijo usado para las variables de GET que genera la tabla.
  95      */
  96     function getGetVarPrefix() {
  97         return $this->_getVarPrefix;
  98     }
  99
 100     /**
 101      * Agrega un páginador a la tabla, basado en un resultado de una base de datos.
 102      * Ejemplo:
 103      * @code
 104      * $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
 105      * $result = $db->query('SELECT nombre, apellido FROM tabla');
 106      * if (DB::isError($result)) {
 107      *      trigger_error('Error', E_USER_ERROR);
 108      * }
 109      * // Agrega el paginador por defecto y lo guarda para mostrar solo los
 110      * // resultados paginados después.
 111      * $pager = $tabla->addPager($result);
 112      * // Agrega cabecera con los nombres de las columnas.
 113      * $tabla->addRow(array('Nombre', 'Apellido'), 'cabecera');
 114      * // Agrega los resultados paginados de la DB.
 115      * $tabla->addRows($pager, array('nombre', 'apellido'));
 116      * $tabla->display();
 117      * @endcode
 118      *
 119      * @param DB_Result $result Resultado de una consulta de base de datos.
 120      * @param mixed $tipo Tipo de link(s) a agregar. Puede ser:
 121      *                    <ul>
 122      *                      <li><tt>'anterior'</tt></li>
 123      *                      <li><tt>'siguiente'</tt></li>
 124      *                      <li><tt>'paginas'</tt></li>
 125      *                      <li><tt>'total'</tt></li>
 126      *                      <li><tt>'info'</tt></li>
 127      *                    </ul>
 128      *                    Puede pasarse uno solo como un string o varios como un
 129      *                    array. Si se pasa <tt>'todo'</tt>, se incluyen todos.
 130      *                    Si se pasa null, se incluyen <tt>'anterior'</tt>,
 131      *                    <tt>'siguiente'</tt> y <tt>'paginas'</tt>.
 132      * @param mixed $link Dirección a la que apuntan los links generados. Puede
 133      *                    ser un MECON_HTML_Link (para poder pasar variables por
 134      *                    GET) o un string.
 135      * @param int $limit Parámetro usado para crear el MECON_DB_Pager.
 136      * @param int $maxpages Parámetro usado para crear el MECON_DB_Pager.
 137      * @param string $getvar Nombre de la variable GET a usar para indicar el número
 138      *               de página actual (se le pone el \ref setGetPrefix prefijo)
 139      *
 140      * @return MECON_DB_Pager Pager que se puede usar para realizar los fetch de
 141      *         los resultados de la página actual.
 142      *
 143      * @see MECON_DB_Pager, addRows().
 144      */
 145     function addPager($result, $tipo = null, $link = null, $limit = 10, $maxpages = 21, $getvar = 'from') {
 146         // Creo el pager con el resultado.
 147         $pager = new MECON_DB_Pager($result, @$_GET[$this->_getVarPrefix.$getvar], $limit, $maxpages);
 148         // Obtengo un link válido.
 149         if (!$link) {
 150             $link = @$_SERVER['PHP_SELF'];
 151         }
 152         if (is_string($link)) {
 153             $link = new MECON_HTML_Link($link, '');
 154         }
 155         // Si es el tipo por defecto pone paginador nada más.
 156         if (!$tipo) {
 157             $tipo = array('anterior', 'paginas', 'siguiente');
 158         }
 159         // Convierte tipo a array.
 160         if (!is_array($tipo)) {
 161             $tipo = array($tipo);
 162         }
 163         // Si se quiere mostrar todas las decoraciones del paginador.
 164         if (in_array('todo', $tipo)) {
 165             $tipo = array('anterior', 'paginas', 'siguiente', 'total', 'info');
 166         }
 167         // Me fijo si tiene cada uno de los elementos y los agrego.
 168         if (in_array('anterior', $tipo) and $pager->numRows() and $pager->currentpage != 1) {
 169             $link->setGetVar($this->_getVarPrefix.$getvar, $pager->prev);
 170             $this->addLink('anterior', $link);
 171         }
 172         if (in_array('siguiente', $tipo) and $pager->numRows() and $pager->currentpage != $pager->numpages) {
 173             $link->setGetVar($this->_getVarPrefix.$getvar, $pager->next);
 174             $this->addLink('siguiente', $link);
 175         }
 176         if (in_array('paginas', $tipo) and $pager->numRows() and $pager->numpages > 1) {
 177             $from = @$_GET[$this->_getVarPrefix.$getvar];
 178             $pags = '';
 179             $lnk = $link->getContents();
 180             foreach ($pager->pages as $page => $start_row) {
 181                 if ($start_row == $from) {
 182                     $pags .= $page;
 183                 } else {
 184                     $link->setGetVar($this->_getVarPrefix.$getvar, $start_row);
 185                     $link->setContents($page);
 186                     $pags .= $link->toHtml();
 187                 }
 188                 if ($page != $pager->lastpage) {
 189                     $pags .= ' | ';
 190                 }
 191             }
 192             $link->setContents($lnk);
 193             $this->updatePie($pags, 'centro');
 194         }
 195         if (in_array('total', $tipo) and $pager->numRows()) {
 196             $this->updateCabecera("Se encontraron {$pager->numrows} {$this->_desc}.", 'izquierda');
 197         }
 198         if (in_array('info', $tipo) and $pager->numRows()) {
 199             $this->updateCabecera("'Página {$pager->currentpage} de {$pager->numpages} - "
 200                 . "{$pager->limit} {$this->_desc} por página.", 'derecha');
 201         }
 202         return $pager;
 203     }
 204
 205     /**
 206      * Agrega filas desde el resultado de una consulta a una base de datos.
 207      * Si no hay resultados, muestra un mensaje. Dependiendo de si es se pasa
 208      * un objeto a usar o no, llama a addRowsObject() o addRowsResult()
 209      * respectivamente.
 210      *
 211      * @param DB_Result $result Resultados de una consulta.
 212      * @param array $campos Propiedades del objeto a mostrar.
 213      * @param mixed $obj Objeto a usar. Puede ser un objeto instanciado o un
 214      *                   string con el nombre de la clase.
 215      *
 216      * @see addRowsData(), addRowsIcon(), ejemplo en addPager().
 217      */
 218     function addRows($result, $campos, $obj = null) {
 219         if ($result->numRows()) {
 220             if ($obj) {
 221                 $this->addRowsObject($result, $campos, $obj);
 222             } else {
 223                 $this->addRowsResult($result, $campos, $obj);
 224             }
 225         } else {
 226             $id = $this->addRow(array(
 227                 new MECON_HTML_Error("No se encontraron {$this->_desc}.")));
 228             $this->updateCellAttributes($id, 0,
 229                 array('colspan' => count($campos)
 230                     + count($this->_prependRowsData)
 231                     + count($this->_appendRowsData)));
 232         }
 233     }
 234
 235     /**
 236      * Agrega filas usando un resultado.
 237      *
 238      * @param DB_Result $result Resultados de una consulta.
 239      * @param array $campos Campos de la base de datos a mostrar.
 240      */
 241     function addRowsResult($result, $campos) {
 242         while ($row = $result->fetchRow(DB_FETCHMODE_ASSOC)) {
 243             $columnas = array();
 244             foreach ($this->_prependRowsData as $data) {
 245                 $columnas[] = $this->_buildCustomColumn($data, $row);
 246             }
 247             foreach ($campos as $campo) {
 248                 $columnas[] = $row[$campo];
 249             }
 250             foreach ($this->_appendRowsData as $data) {
 251                 $columnas[] = $this->_buildCustomColumn($data, $row);
 252             }
 253             $this->addRow($columnas);
 254         }
 255     }
 256
 257     /**
 258      * Agrega filas usando un objeto.
 259      * El objeto debe tener un método llamado cargar que acepte como primer (y
 260      * único obligatorio) parámetro un DB_Result para cargar sus datos desde una
 261      * base de datos.
 262      *
 263      * @param DB_Result $result Resultados de una consulta.
 264      * @param array $campos Propiedades del objeto a mostrar.
 265      * @param mixed $obj Objeto a usar. Puede ser un objeto instanciado o un
 266      *                   string con el nombre de la clase.
 267      *
 268      * @see La interfaz MECON_DBO que tiene el método MECON_DBO::cargar().
 269      */
 270     function addRowsObject($result, $campos, $obj) {
 271         if (is_string($obj)) {
 272             $obj = new $obj;
 273         }
 274         if (!method_exists($obj, 'cargar')) {
 275             $this->raiseError('La clase ' . get_class($obj) . ' no tiene un metodo cargar().');
 276         }
 277         while ($obj->cargar($result)) {
 278             foreach ($this->_prependRowsData as $data) {
 279                 $columnas[] = $this->_buildCustomColumn($data, $row);
 280             }
 281             foreach ($campos as $campo) {
 282                 $columnas[] = $obj->$campo;
 283             }
 284             foreach ($this->_appendRowsData as $data) {
 285                 $columnas[] = $this->_buildCustomColumn($data, $row);
 286             }
 287             $this->addRow($columnas);
 288         }
 289     }
 290
 291     /**
 292      * Agrega una columna arbitraria a la tabla basado en valores de una fila.
 293      * Ejemplo:
 294      * @code
 295      * $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
 296      * $result = $db->query('SELECT nombre, apellido, activo FROM tabla');
 297      * if (DB::isError($result)) {
 298      *      trigger_error('Error', E_USER_ERROR);
 299      * }
 300      * $tabla->addRow(
 301      *      array('Col1', 'Nombre', 'Apellido', 'Activo', 'PopUp1', 'PopUp2'),
 302      *      'cabecera');
 303      * // Agrega una columna con una leyenda 'El nombre es: {nombre}' al principio.
 304      * $tabla->addRowsData('Me llamo %s.', 'nombre', 'prepend');
 305      * // Agrega una columna al final con checkbox para seleccionar filas. El
 306      * // segundo elemento será procesado por la callback checked_callback().
 307      * $tabla->addRowsData('<input type="checkbox" name="datos[%s]" value="1" %s />',
 308      *          array('nombre', array('activo', 'checked_callback')));
 309      * // Agrega el nombre con un link a un popup (sin javascript).
 310      * $tabla->addRowsData(
 311      *      new MECON_HTML_Link('popup.php', '%s', array('nombre' => null),
 312      *          array('target' => '_blank')),
 313      *      'nombre',
 314      *      'prepend');
 315      * // Agrega el nombre con un link a un popup (con javascript).
 316      * $tabla->addRowsData('<a href="popup.php?nombre=%s" '
 317      *          . 'onclick="'."javascript:window.open('popup.php?nombre=%s',"
 318      *          . "'win_id','width=400,height=400,scrollbars=no');"
 319      *          . 'return false;">%s</a>',
 320      *      array('nombre', 'nombre', 'apellido'));
 321      * // Agrega resultados de la tabla.
 322      * $tabla->addRows($result, array('nombre', 'apellido'));
 323      *
 324      *
 325      * //Ejemplo utilizando una funcion callback con varios parametros obtenidos
 326      * //de la DB.
 327      * $tabla->addRowsData (
 328      *      'Mi nombre es: %s, por lo tanto %s', //Formato de la columna a agregar.
 329      *      array(                               //Array de campos a incluir en el formato
 330      *          'nombre',                        //El dato de este campo reemplazara el primer %s
 331      *          //El resultado de la llamada a la funcion nombre_callback que tomo
 332      *          //como paramteros los campos de la db que estan dentro del array
 333      *          //reemplazara al segundo %s
 334      *          array(array('nombre', 'apellido'), 'nombre_callback')
 335      *      )
 336      *  );
 337      *
 338      * $tabla->display();
 339      *
 340      * // Funcion callback para darle formato al campo 'activo'.
 341      * // En este caso devuelve 'checked' para indicar que el checkbox está
 342      * // activado si activo es true.
 343      * function checked_callback($activo) {
 344      *      return $activo ? 'checked' : '';
 345      * }
 346      *
 347      * //Funcion callback que acepta mas de un parametro en un array
 348      * function nombre_callback($parametros) {
 349      *      if ($parametros['nombre'] == 'Juan Carlos' &&
 350      *      $parametros['apellido'] == 'Gomez') {
 351      *          return 'soy Charly';
 352      *      }
 353      *      else {
 354      *          return 'no soy Charly';
 355      *      }
 356      * }
 357      *
 358      * @endcode
 359      *
 360      * @param mixed $format Si es un string, especifica el formato a usar al
 361      *                      estilo de sprintf. Si es un MECON_HTML_Link, se
 362      *                      traduce cada variable por GET que empiece con el
 363      *                      \ref getGetVarPrefix "prefijo" y cuyo valor sea null
 364      *                      al campo correspondiente de la DB:
 365      * @code $tabla->addRowsData(new MECON_HTML_Link('abm.php', 'Ver %s',
 366      *      array($tabla->getGetVarPrefix().'id' => null), 'nombre'); @endcode
 367      *                      Si el valor en vez de ser null es un string, se
 368      *                      fija si existe una función con ese nombre para llamar
 369      *                      con el campo de la DB como argumento para
 370      *                      formatearlo:
 371      * @code $tabla->addRowsData(new MECON_HTML_Link('print.php', 'Mostrar',
 372      *      array($tabla->getGetVarPrefix().'campo1' => 'callback_campo1'));
 373      * function callback_campo1($campo1) {
 374      *      return 'El campo1 es '.strtoupper($campo3);
 375      * } @endcode
 376      *                      Si no existe la función, se toma el string como
 377      *                      formato para sprintf para darle formato:
 378      * @code $tabla->addRowsData(new MECON_HTML_Link('print.php', 'Ver',
 379      *      array($tabla->getGetVarPrefix().'campo1' => 'campo1: %s')); @endcode
 380      * @param mixed $campos Campos de la DB a usar como argumentos del sprintf.
 381      *                      Puede ser un string para pasar un solo campo sin
 382      *                      formato:
 383      *                      @code $tabla->addRowsData('%s', 'campo1'); @endcode
 384      *                      Si es un array, cada elemento es un campo
 385      *                      que puede ser un string representando el nombre de
 386      *                      un campo a usar:
 387      *                      @code $tabla->addRowsData('%s',
 388      *      array('campo1', 'campo2'); @endcode
 389      *                      o un array cuyo primer elemento es un string o un
 390      *                      array con los nombres de los campos de la db a utilizar
 391      *                      y el segundo argumento es una funcion
 392      *                      callback a llamar con el valor del campo (o los
 393      *                      campos si se paso un array de campos) como
 394      *                      argumento para darle formato:
 395      *                      @code $tabla->addRowsData('%s',
 396      *      array('campo1', array(array('campo2', 'campo3'), 'callback_campo_2_3'))));
 397      * function callback_campo_2_3($campos) {
 398      *      return strtoupper($campos['campo2']) . ', ' . strtolower($campos['campo3']);
 399      * } @endcode
 400      *                      Para ver un ejemplo de una callback con muchos
 401      *                      parametros ver la descripcion detallada de esta funcion.
 402      *                      Si no se encuentra la funcion callback, se toma como
 403      *                      un string para formatear el campo con sprintf():
 404      *                      @code $tabla->addRowsData('%s', array('campo1',
 405      *      array('campo2', 'campo2 = %s')); @endcode
 406      * @param string $lugar Indica donde hay que agregar la columna. Puede ser:
 407      *                      <tt>'prepend'</tt> o <tt>'append'</tt>:
 408      *                      @code $tabla->addRowsData('Hola %s!', 'nombre',
 409      *      'prepend'); @endcode
 410      *
 411      * @warning Este método debe ser llamado antes de llamar a addRows().
 412      * @note Las funciones callback toman todas un solo argumento (el valor del
 413      *       campo a formatear) y deben devolver un string con el campo
 414      *       formateado.
 415      */
 416     function addRowsData($format, $campos = array(), $lugar = 'append') {
 417         if (!is_array($campos)) {
 418             $campos = array($campos);
 419         }
 420         switch (strtolower($lugar)) {
 421             case 'prepend':
 422                 $this->_prependRowsData[] = array($format, $campos);
 423                 break;
 424             case 'append':
 425                 $this->_appendRowsData[] = array($format, $campos);
 426                 break;
 427             default:
 428                 $this->raiseError('Lugar incorrecto. Lugares soportados: append, prepend.');
 429         }
 430     }
 431
 432     /**
 433      * Contruye una columna personalizada.
 434      *
 435      * @param array $data Datos sobre la columna, en el formato especificado
 436      *                    para un elemento del array usado en _prependRowsData.
 437      * @param mixed $row Fila de un resultado de una base de datos. Puede ser un
 438      *                   array asociativo o un objeto (en cuyo caso cada campo
 439      *                   debe ser un atributo del mismo).
 440      *
 441      * @return mixed Columna formateada para agregar a la tabla.
 442      *
 443      * @protected
 444      */
 445     function _buildCustomColumn($data, $row) {
 446         list($format, $campos) = $data;
 447         // Si tiene formatos y argumentos.
 448         if ($campos) {
 449             // Si el formato es un MECON_HTML_Link, uso como formato a
 450             // su contenido.
 451             if (is_a($format, 'mecon_html_link')) {
 452                 $args = array($format->getContents());
 453             } else {
 454                 $args = array($format);
 455             }
 456             // Proceso cada agumento.
 457             foreach ($campos as $campo) {
 458                 // Si el agumento es un array, usa una callback para
 459                 // darle formato.
 460                 if (is_array($campo)) {
 461                     list($campo, $callback) = $campo;
 462                 }
 463                 if (is_array($row)) {
 464                     if (is_array($campo)) {
 465                         foreach ($campo as $c) {
 466                             $tmp[$c] = $row[$c];
 467                         }
 468                         $campo = $tmp;
 469                     }
 470                     else {
 471                         $campo = $row[$campo]; // Es un campo de un array.
 472                     }
 473                 } else { //$row es un objeto
 474                     if (is_array($campo)) {
 475                         foreach ($campo as $c) {
 476                             $tmp[$c] = $row->$c;
 477                         }
 478                         $campo = $tmp;
 479                     }
 480                     else {
 481                         $campo = $row->$campo; // Es un atributo de un objeto.
 482                     }
 483                 }
 484                 // Si usa callback, cambio el campo por el resultado del
 485                 // llamado a su callback.
 486                 if (isset($callback)) {
 487                     if(function_exists($callback)) {
 488                         $campo = $callback($campo);
 489                     } else {
 490                         //Si no existe la funcion de callback usa el callback como
 491                         //formato y los campos como argumentos para el sprintf
 492                         array_unshift($campo, $callback);
 493                         $campo = call_user_func_array('sprintf', $campo);
 494                     }
 495                 }
 496                 // Agrego argumento procesado a la lista de argumentos.
 497                 $args[] = $campo;
 498             }
 499             // Si es un link, le seteo los contenidos procesados.
 500             if (is_a($format, 'mecon_html_link')) {
 501                 $format->setContents(call_user_func_array('sprintf', $args));
 502             // Si no formateo la cadena con los argumentos procesados.
 503             } else {
 504                 $format = call_user_func_array('sprintf', $args);
 505             }
 506         }
 507         // Si es un link, traduce las variables GET.
 508         if (is_a($format, 'mecon_html_link')) {
 509             $format = $this->_translateGetVars($format, $row);
 510         }
 511         // devuelve la columna.
 512         return $format;
 513     }
 514
 515     /**
 516      * Traduce las variables GET de un link.
 517      * Puede formatearlas con printf() o llamando una callback.
 518      *
 519      * @param MECON_HTML_Link $link Link con las variables GET a formatear.
 520      * @param mixed $row Fila de un resultado de una base de dotos. Puede ser un
 521      *                   array asociativo o un objeto (en cuyo caso cada campo
 522      *                   debe ser un atributo del mismo).
 523      *
 524      * @return MECON_HTML_Link Link con las variables GET traducidas.
 525      *
 526      * @protected
 527      */
 528     function _translateGetVars($link, $row) {
 529         $vars = $link->getGetVars();
 530         foreach ($vars as $var => $val) {
 531             if (preg_match("/^{$this->_getVarPrefix}(.+)$/", $var, $m)) {
 532                 $campo = $m[1];
 533                 $campo = is_array($row) ? $row[$campo] : $row->$campo;
 534                 // Si no tiene valor, se lo reemplaza por el
 535                 // valor del campo.
 536                 if ($val === null) {
 537                     $link->setGetVar($var, $campo);
 538                 // Si existe una funcion, se la usa para obtener
 539                 // el formato.
 540                 } elseif (function_exists($val)) {
 541                     $link->setGetVar($var, $val($campo));
 542                 // Si no es ni null ni link, lo toma como
 543                 // formato para el sprintf
 544                 } else {
 545                     $link->setGetVar($var, sprintf($val, $campo));
 546                 }
 547             }
 548         }
 549         return $link;
 550     }
 551
 552     /**
 553      * Agrega un ícono predefinido a la tabla.
 554      * Ejemplo:
 555      * @code
 556      * $tabla = new MECON_HTML_TablaDB('personas', array('width' => '100%'));
 557      * $result = $db->query('SELECT nombre, apellido FROM tabla');
 558      * if (DB::isError($result)) {
 559      *      trigger_error('Error', E_USER_ERROR);
 560      * }
 561      * $tabla->addRow(array('Col1', 'Nombre', 'Apellido', 'Modificar', 'Borrar',
 562      *      'Agregar'), 'cabecera');
 563      * // Agrega ícono de modificar que apunta a modificar.php y pasa el 'id'.
 564      * $tabla->addRowsIcon('modificar', 'id', 'modificar.php');
 565      * // Agrega ícono de borrar desactivado.
 566      * $tabla->addRowsIcon('no_borrar');
 567      * // Agrega ícono con una flecha que apunta a agregar.php y no pasa nada.
 568      * $tabla->addRowsIcon('ir', null, 'modificar.php');
 569      * // Agrega resultados de la tabla.
 570      * $tabla->addRows($result, array('nombre', 'apellido'));
 571      * $tabla->display();
 572      * @endcode
 573      *
 574      * @param string $id Identificador del tipo de ícono a agregar. Puede ser:
 575      *                   <ul>
 576      *                     <li><tt>'modificar'</tt>: Ícono de modificar.</li>
 577      *                     <li><tt>'no_modificar'</tt>: Ícono de modificar desactivado.</li>
 578      *                     <li><tt>'borrar'</tt>: Ícono de borrar.</li>
 579      *                     <li><tt>'no_borrar'</tt>: Ícono de borrar desactivado.</li>
 580      *                     <li><tt>'ir'</tt>: Flecha hacia la derecha.</li>
 581      *                   </ul>
 582      * @param mixed $campos Campos de la DB a usar para generar el link. Estos
 583      *                      campos serán pasados por GET a la página destino.
 584      *                      Cada campo es pasado como la variable GET compuesta
 585      *                      por el @ref getGetVarPrefix "prefijo" más el nombre
 586      *                      del campo (ver parámetro $campos de addRowsData()
 587      *                      para conocer de que formas se puede formatear un
 588      *                      campo).
 589      * @param mixed $link Si es un string, se usa como URL del link a generar.
 590      *                    Si es un MECON_HTML_Link, se usa como base para el
 591      *                    link a generar y se le va agregando las variables de
 592      *                    GET generadas por el parámetro $campos (el link es
 593      *                    procesado de la misma forma en que es procesado el
 594      *                    parámetro $formato en addRowsData() con la excepción
 595      *                    de que el contenido del Link no es tomado en cuenta).
 596      * @param string $lugar Indica donde hay que agregar la columna. Puede ser:
 597      *                      <tt>'prepend'</tt> o <tt>'append'</tt>.
 598      *
 599      * @warning Este método debe ser llamado antes de llamar a addRows().
 600      * @note Las funciones callback toman todas un solo argumento (el valor del
 601      *       campo a formatear) y deben devolver un string con el campo
 602      *       formateado.
 603      */
 604     function addRowsIcon($id, $campos = array(), $link = null, $lugar = 'append') {
 605         if (!$campos) {
 606             $campos = array();
 607         }
 608         if (is_string($campos)) {
 609             $campos = array($campos);
 610         }
 611         if (!$link) {
 612             $link = @$_SERVER['PHP_SELF'];
 613         }
 614         if (is_string($link)) {
 615             $link = new MECON_HTML_Link($link, '');
 616         }
 617         switch ($id) {
 618             case 'modificar':
 619                 $img = new MECON_HTML_Image('/MECON/images/general_modificar', '(M)');
 620                 $img->updateAttributes(array('title' => 'Modificar'));
 621                 $link->addContents($img);
 622                 foreach ($campos as $campo) {
 623                     $format = null;
 624                     if (is_array($campo)) {
 625                         list($campo, $format) = $campo;
 626                     }
 627                     $link->setGetVar($this->_getVarPrefix.$campo, $format);
 628                 }
 629                 $this->addRowsData($link, array(), $lugar);
 630                 break;
 631             case 'no_modificar':
 632                 $img = new MECON_HTML_Image('/MECON/images/general_modificar_des', '(-)');
 633                 $img->updateAttributes(array('title' => 'Modificar'));
 634                 $this->addRowsData($img, array(), $lugar);
 635                 break;
 636             case 'borrar':
 637                 $img = new MECON_HTML_Image('/MECON/images/general_eliminar', '(B)');
 638                 $img->updateAttributes(array('title' => 'Borrar'));
 639                 $link->addContents($img);
 640                 foreach ($campos as $campo) {
 641                     $link->setGetVar($this->_getVarPrefix.$campo, null);
 642                 }
 643                 $this->addRowsData($link, array(), $lugar);
 644                 break;
 645             case 'no_borrar':
 646                 $img = new MECON_HTML_Image('/MECON/images/general_eliminar_des', '(-)');
 647                 $img->updateAttributes(array('title' => 'Borrar'));
 648                 $this->addRowsData($img, array(), $lugar);
 649                 break;
 650             case 'ir':
 651                 $img = new MECON_HTML_Image('/MECON/images/general_ir4', '->');
 652                 $img->updateAttributes(array('title' => 'Ir'));
 653                 $link->addContents($img);
 654                 foreach ($campos as $campo) {
 655                     $link->setGetVar($this->_getVarPrefix.$campo, null);
 656                 }
 657                 $this->addRowsData($link, array(), $lugar);
 658                 break;
 659             default:
 660                 $this->raiseError("No hay un ícono predefinido llamado '$id'.");
 661         }
 662     }
 663
 664 }
 665
 666 ?>