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