gridcontrols.class

Ir para a documentação deste ficheiro.

<?php
 
class MBaseGrid extends MControl
{
    public function column()
    {
        return new MGridColumn();
    }
}
 
class MGridColumn extends MBaseGrid
{
    var $grid; // grid which this columns belongs to
    var $title; // column title
    var $footer; // column footer
    var $options; // array for mapping of data value to display value
    var $align; // column align - rigth, center, left
    var $nowrap; // column wrap/nowrap
    var $width; // column width in pixels or percent
    var $order; // column position on the grid
    var $value; // value at current row
    var $basecontrol; // base Control to render value
    var $control; // array of Control clonning of basecontrol
    var $index; // column index in the data array
 
    public $replace;
    
    public $numberFormat = false;
 
    public $colorOptions = array();
 
    public $hidden;
 
    function __construct($title = '',    $align = 'left', $nowrap = false,
                         $width = 0,     $visible = true, $options = null,
                         $order = false, $replace = NULL, $numberFormat = false,
                         $colorOptions = array())
    {
        parent::__construct();
 
        $this->setClass('m-grid-column');
        $this->visible = $visible;
        $this->title   = $title;
        $this->options = $options;
        $this->align   = $align;
        $this->nowrap  = $nowrap;
        $this->width   = $width;
        $this->order   = $order;
        $this->value   = '';
        $this->index   = 0;
        $this->footer  = null;
        $this->basecontrol = new MLabel('');
        $this->control = array();
        $this->replace = $replace;
        $this->numberFormat = $numberFormat;
        $this->colorOptions = $colorOptions;
    }
    
    public function getGrid()
    {
        return $this->grid;
    }
 
    public function setGrid(MGrid $grid)
    {
        $this->grid = $grid;
        
        return $this;
    }
 
    public function getTitle()
    {
        return $this->title;
    }
 
    public function setTitle($title)
    {
        $this->title = $title;
        
        return $this;
    }
 
    public function getFooter()
    {
        return $this->footer;
    }
 
    public function setFooter($footer)
    {
        $this->footer = $footer;
        
        return $this;
    }
 
    public function getOptions()
    {
        return $this->options;
    }
 
    public function setOptions($options)
    {
        $this->options = $options;
        
        return $this;
    }
 
    public function getAlign()
    {
        return $this->align;
    }
 
    public function setAlign($align)
    {
        $this->align = $align;
        
        return $this;
    }
 
    public function getNowrap()
    {
        return $this->nowrap;
    }
 
    public function setNowrap($nowrap)
    {
        $this->nowrap = $nowrap;
        
        return $this;
    }
 
    public function getWidth()
    {
        return $this->width;
    }
 
    public function setWidth($width)
    {
        $this->width = $width;
        
        return $this;
    }
 
    public function getOrder()
    {
        return $this->order;
    }
 
    public function setOrder($order)
    {
        $this->order = $order;
        
        return $this;
    }
 
    public function getValue()
    {
        return $this->value;
    }
 
    public function setValue($value)
    {
        $this->value = $value;
        
        return $this;
    }
 
    public function getBasecontrol()
    {
        return $this->basecontrol;
    }
 
    public function setBasecontrol($basecontrol)
    {
        $this->basecontrol = $basecontrol;
        
        return $this;
    }
 
    public function getControl($pos)
    {
        return $this->control;
    }
 
    public function setControl($control, $pos = 0)
    {
        $this->control = $control;
        
        return $this;
    }
 
    public function getIndex()
    {
        return $this->index;
    }
 
    public function setIndex($index)
    {
        $this->index = $index;
        
        return $this;
    }
 
    public function getReplace()
    {
        return $this->replace;
    }
 
    public function setReplace($replace)
    {
        $this->replace = $replace;
        
        return $this;
    }
 
    public function setHidden($hidden)
    {
        $this->hidden = $hidden;
    }
    
    public function getConstructorArgsData()
    {
        $args = new stdClass();
        $args->title = $this->title;
        $args->align = $this->align;
        $args->nowrap = $this->nowrap;
        $args->width = $this->width;
        $args->visible = $this->visible;
        $args->options = $this->options;
        $args->order = $this->order;
        $args->replace = $this->replace;
        $args->numberFormat = $this->numberFormat;
        
        return $args;
    }
 
    function generate()
    {
        $i   = $this->grid->currentRow;
        $row = $this->grid->data[$i];
        $this->control[$i] = clone $this->basecontrol; // clonning
        $value = $row[$this->index];
        $this->control[$i]->value = $value;
                
        if ( $this->numberFormat )
        {
            $this->control[$i]->value = number_format($value, 2, ',', '.');
        }
 
        $this->formatSpecificColumnValues();
 
        $this->generateColumnOptions();
 
        if ( $this->hidden )
        {
            $this->control[$i]->addBoxStyle('display', 'none');
        }
 
        return $this->control[$i];
    }
 
    public function generateColumnOptions()
    {
        $originalValue = $this->control[$this->grid->currentRow]->value;
 
        if ( $this->options )
        {
            $this->control[$this->grid->currentRow]->value = $this->options[$originalValue];
 
            if ( $this->grid->showid )
            {
                $this->control[$this->grid->currentRow]->value .= " (" . $originalValue . ")";
            }
        }
 
        if (strpos(MIOLO::getInstance()->getTheme()->id, "sbootstrap") !== false)
        {
            $this->generateColoredLabels($originalValue);
        }
    }
 
    public function generateColoredLabels($valueOfColumn)
    {
        if (count($this->colorOptions) > 0 && key_exists($valueOfColumn, $this->colorOptions))
        {
            $badgeLabel = new MBadge($this->control[$this->grid->currentRow]->value, $this->colorOptions[$valueOfColumn]);
            $this->control[$this->grid->currentRow]->value = $badgeLabel->generate();
        }
        // Quando forem apenas um booleano, então ele faz sozinho, senão precisa informar as cores
        else if (count($this->options) == 2 && (key_exists(DB_FALSE, $this->options) && key_exists(DB_TRUE, $this->options)))
        {
            if (MUtil::getBooleanValue($valueOfColumn))
            {
                $badgeLabel = new MBadge($this->control[$this->grid->currentRow]->value, MBadge::COLOR_GREEN);
            }
            else if (strlen($valueOfColumn) > 0)
            {
                $badgeLabel = new MBadge($this->control[$this->grid->currentRow]->value, MBadge::COLOR_RED);
            }
 
            if (!empty($badgeLabel))
            {
                $this->control[$this->grid->currentRow]->value = $badgeLabel->generate();
            }
        }
    }
 
    public function formatSpecificColumnValues()
    {
        $colunasCep = array_filter($this->grid->columns, function($column){
            return ($column->title == 'CEP');
        });
 
        foreach ($colunasCep as $key => $t)
        {
            if ( $key == $this->index && !empty($this->control[$this->grid->currentRow]->value) 
            && is_numeric($this->control[$this->grid->currentRow]->value) 
            && strlen($this->control[$this->grid->currentRow]->value) == 8 )
            {
                $mascarado = substr($this->control[$this->grid->currentRow]->value, 0, 5);
                $mascarado .= "-";
                $mascarado .= substr($this->control[$this->grid->currentRow]->value, 5, 3);
                $this->control[$this->grid->currentRow]->value = $mascarado;
            }
        }
    }
}
 
 
class MGridHyperlink extends MGridColumn
{
    var $href; // link - replaces #?# with column's value
 
    function __construct($title = '', $href, $width = 0, $visible = true, $options = null, $order = false, $filter = false)
    {
        parent::__construct($title, null, false, $width, $visible, $options, $order, $filter);
 
        $this->align = 'left';
        $this->href = $href;
        $this->basecontrol = new Hyperlink('', '', $href);
        $this->basecontrol->setClass('m-grid-column-link');
    }
 
    function generate()
    {
        $i   = $this->grid->currentRow;
        $row = $this->grid->data[$i];
        $this->control[$i] = clone $this->basecontrol; // clonning
        $value = $row[$this->index];
        $n = count($row);
        $href  = $this->href;
 
        for ($r = 0; $r < $n; $r++)
        {
            $href = str_replace("#$r#", trim($row[$r]), $href);
        }
 
        $href = str_replace('#?#', $value, $href);
        $this->control[$i]->href   = $href;
        $this->control[$i]->action = $href;
        $this->control[$i]->label  = $value;
 
        if ( $this->hidden )
        {
            $this->control[$i]->addBoxStyle('display', 'none');
        }
 
        return $this->control[$i];
    }
}
 
class MGridControl extends MGridColumn
{
    public $control;
 
    public function __construct($control, $title='', $align='left', $nowrap=false, $width=0, $visible=true)
    {
        parent::__construct($title, $align, $nowrap, $width, $visible);
        $this->basecontrol = $control;
    }
 
    public function generate()
    {
        $i = $this->grid->currentRow;
        $row = $this->grid->data[$i];
        $this->control[$i] = clone $this->basecontrol;
        $name = $this->control[$i]->getName();
 
        // If the name is not an array, add brackets to transform it.
        if ( strpos($name, "[") === false && strpos($name, "]") === false )
        {
            $name .= "[$i]";
        }
        else
        {
            // Position of the identifier character which will be substituted.
            $pos = strpos($name, '%');
 
            // If the name is ok with grid naming rules, line number is between %. E.g. %N%.
            if ( !$pos === false )
            {
                $rowNumber = substr($name, $pos + 1, -2);
                $name = str_replace("%$rowNumber%", trim($row[$rowNumber]), $name);
            }
        }
 
        $this->control[$i]->setName($name);
        $this->control[$i]->setId($name);
        $n = count($row);
 
        for ( $r = 0; $r < $n; $r++ )
        {
            $this->control[$i]->setValue(str_replace("%$r%", trim($row[$r]), $this->control[$i]->getValue()));
        }
 
        if ( $this->hidden )
        {
            $this->control[$i]->addBoxStyle('display', 'none');
        }
 
        return $this->control[$i];
    }
}
 
class MGridAction extends MBaseGrid
{
    public $grid; // grid which this action belongs to
    public $type; // "text", "image", "select" or "none"
    public $alt; // image alt
    public $value; // image/text label for on
    public $valueoff; // image/text label for off
    public $href; // link pattern - replaces
    // #n# with value of column "n"
    // %n% with urlencode(value) of column "n"
    // $id with value of column "index"
    public $index; // deprecated
    public $enabled;
    public $target;
 
    public function __construct($grid, $type, $alt, $value, $href, $enabled = true, $index = null)
    {
        parent::__construct();
        $this->grid = $grid;
        $this->type = $type;
        $this->alt  = $alt;
 
        if ( is_array($value) )
        {
            $this->value    = $value[0];
            $this->valueoff = $value[1];
        }
        else
        {
            $this->value = $this->valueoff = $value;
        }
 
        $this->href  = $href;
        $this->index = $index;
        $this->enabled = $enabled;
    }
 
    public function enable()
    {
        $this->enabled = true;
    }
 
    public function disable()
    {
        $this->enabled = false;
    }
 
    public function GenerateLink($row)
    {
        $index = $row[$this->grid->index];
        $href  = preg_replace('#\$id#', $index, $this->href);
        $n = count($row);
 
        // substitute named parameters
        foreach ( (array) $row as $tempKey => $tempValue )
        {
            $href = str_replace("%$tempKey%", urlencode($tempValue), $href);
        }
        
        // substitute positional parameters
        for ($r = 0; $r < $n; $r++)
        {
            if( is_object($row[$r]) )
            {
                $row[$r] = $row[$r]->generate( );
            }
            
            $href = str_replace("%$r%", urlencode($row[$r]), $href);
            $href = str_replace("#$r#", $row[$r], $href);
            $href = str_replace('"', '', $href);
        }
 
        return $href;
    }
 
    public function generate()
    {
    }
 
    public function setTarget($target)
    {
        $this->target = $target;
    }
 
}
 
class MGridActionIcon extends MGridAction
{
    public $path;
 
    public function __construct($grid, $value, $href, $alt=NULL)
    {
        parent::__construct($grid, 'image', $alt, $value, $href);
 
        $class = "m-grid-action-icon-{$this->value}-on";
 
        preg_match_all("#{$class}[\s]*\{[\s]*background-image:[\s]*url\‍((.*?)\‍);[\s]*\}#i", $this->grid->css, $match);
 
        $this->path = ( isset($match[1][0]) ? $match[1][0] : null);
    }
 
    public function generate()
    {
        $path  = $this->path;
        $class = "m-grid-action-icon";
 
        if ( !$path )
        {
            $path = $this->grid->getImage($this->value);
        }
 
        if ($this->enabled)
        {
            $row  = $this->grid->data[$this->grid->currentRow];
            $href = $this->generateLink($row);
 
            $control = ( $this->grid->linktype == 'hyperlink') ?
                         new MImageLink('', $this->alt, $href, $path) :
                         new MImageButton('', $this->alt, $href, $path
                       );
            $control->setTarget( $this->target );
        }
        else
        {
            $control = new MImage('', $this->alt, $path);
            $control->setClass('m-grid-action-icon-off');
        }
 
        $control->setClass($class);
 
        return $control;
    }
}
 
class MGridActionText extends MGridAction
{
 
    function __construct($grid, $value, $href)
    {
        parent::__construct($grid, 'text', null, $value, $href);
        $this->attributes = "width=\"20\" align=\"center\"";
    }
 
    function generate()
    {
        $value = $this->value;
 
        if ( $this->enabled )
        {
            $row = $this->grid->data[$this->grid->currentRow];
            $n   = count($row);
 
            for ($r = 0; $r < $n; $r++)
            {
                $value = str_replace("%$r%", $row[$r], $value);
            }
 
            $href    = $this->generateLink($row);
            $control = ( $this->grid->linktype == 'hyperlink') ?
                         new HyperLink('', $value, $href) :
                         new LinkButton('', $value, $href
                       );
            $control->setTarget( $this->target );
            $control->setClass('m-grid-link');
        }
        else
        {
            $control = new MSpan('', $value, 'm-grid-link-disable');
        }
 
        return $control;
    }
}
 
class MGridActionSelect extends MGridAction
{
    public function __construct($grid, $index=0)
    {
        parent::__construct($grid, 'select', null, null, null, true, $index);
    }
 
    public function generate()
    {
        $i = $this->grid->currentRow;
        $row = $this->grid->data[$i];
        $index = $row[$this->grid->index];
        
        if ( $this->grid instanceof SGrid )
        {
            $primaryKeys = array_values($this->grid->getPrimaryKey());
            $indexPrimaryKey = $row[str_replace("%", "", $primaryKeys[0])];
            
            $index = $this->grid->indexPrimaryKey ? $indexPrimaryKey : $index;
        }
 
        $onclick = "javascript:gridChk(this,'" . $this->grid->name . "[$i]" . "');";
 
        $control = new MCheckBox("select" . $this->grid->name . "[$i]", $index, '');
        $control->addAttribute('onclick', $onclick);
 
        // Put the MGridActionSelect attributes on the check box
        foreach ( $this->attrs->getItems() as $attr => $value )
        {
            $value = trim($value, '"');
 
            if ( strtolower($attr) == 'onclick' )
            {
                $value = "$onclick $value";
            }
 
            $control->addAttribute($attr, $value);
        }
 
        return $control;
    }
}
 
class MGridHeaderLink extends MLink
{
    function __construct($id, $label, $href)
    {
        parent::__construct($id, "[$label]", $href);
        $this->setClass('m-grid-link');
    }
}
 
class MGridFilter extends MBaseGrid
{
    var $grid; // grid which this filter belongs to
    var $type; // "text", "selection"
    var $label; // image alt
    var $value; // image/text label for on/off
    var $index; // column index in the data array
    var $enabled;
    var $control;
 
    function __construct($grid, $type, $label, $value, $index, $enabled = false)
    {
        parent::__construct();
        $this->grid  = $grid;
        $this->type  = $type;
        $this->label = $label;
        $this->index = $index;
        $this->enabled = $enabled;
        $this->control = null;
    }
 
    function generate()
    {
        if ( $this->enabled )
        {
            $array[] = new MSpan('', $this->label . '&nbsp;', 'm-grid-font');
            $this->control->setValue( ( $this->grid->getFiltered() ) ? $this->value : NULL);
            $array[] = $this->control->generate();
            $array[] = '&nbsp;&nbsp;&nbsp;';
        }
 
        return $array;
    }
}
 
class MGridFilterText extends MGridFilter
{
    function __construct($grid, $label, $value = '', $index = 0, $enabled = false)
    {
        parent::__construct($grid, 'text', $label, $value, $index, $enabled);
 
        $this->control = new MTextField("m-grid-filter-text-$index", $value, $label, 20);
        $this->value = $this->page->request($this->control->name) ? $this->page->request($this->control->name) : $value;
    }
}
 
class MGridFilterSelection extends MGridFilter
{
 
    function __construct($grid, $label, $options = array(), $index = 0, $enabled = false)
    {
        parent::__construct($grid, 'selection', $label, '', $index, $enabled);
 
        $this->control = new MSelection("m-grid-filter-sel-$index", '', $label, $options);
        $this->value   = $this->page->request($this->control->name) ? $this->page->request($this->control->name) : $value;
    }
}
 
class MGridFilterControl extends MGridFilter
{
 
    function __construct($grid, &$control, $type = 'text', $index = 0, $enabled = false)
    {
        parent::__construct($grid, $type, $control->label, $control->value, $index, $enabled);
 
        $this->control = $control;
        $this->value   = $this->page->request($this->control->name) ? $this->page->request($this->control->name) : $control->value;
    }
}
 
class MGrid extends MBaseGrid
{
    var $title; // table display title
    var $filters; // array of grid filter controls
    var $filtered; // is filtered?
    var $filter; // show/hide filters
    var $orderby; // base column to sort
    var $ordered; // is ordered?
    var $data; // table data cells
    var $actions; // array with actions controls
    var $select; // a column for select action
    var $showid; // show ids or not?
    var $columns; // array with columns
    var $icons; // action icons
    var $errors; // array of errors
    var $pageLength; // max number of rows to show - 0 to all rows
    var $rowCount; // total number of rows
    var $href; // grid url
    var $pn; // gridnavigator
    var $headerLinks; // array of headerlinks
    var $linktype; // hyperlink or linkbutton (forced post)
    var $width; // table width for the grid
    var $rowmethod; // method to execute (callback) at each row
    var $index; // the column to act as index of grid
    var $controls;
    var $emptyMsg;
    var $currentRow=0; // index of row to renderize
    var $box;
    var $selecteds;
    var $selectsreadonly;
    var $allSelecteds;
    var $pageNumber;
    var $prevPage;
    var $name;
    var $css;
    var $footer;
    public $header;
    protected $isShowHeaders= true;
    protected $scrollable   = false;
    protected $scrollWidth  = '99%';
    protected $scrollHeight = '99%';
    protected $orderByDatabase = false; // Quando o orderBy da grid é feito por banco
    private $gridMostraTotalNumeric = false;
 
    private $offset = NULL;
 
    private $hiddenControls = array();
 
    /*
     * @var boolean Show all export buttons.
     */
    public $showExport;
 
    /*
     * @var boolean Show export as CSV button, it needs an exportGridAsCSV_click method on form.
     */
    public $showExportAsCSV;
 
    /*
     * @var boolean Show export as HTML button, it needs an exportGridAsHTML_click method on form.
     */
    public $showExportAsHTML;
 
    /*
     * @var boolean Show export as PDF button, it needs an exportGridAsPDF_click method on form.
     */
    public $showExportAsPDF;
    
    private $generateDataCalled = false;
 
/*
      Grid constructor
         $data - the data array
         $columns - array of columns objects
         $href - base url of this grid
         $pageLength - max number of rows to show (0 to show all)
*/
    
    public $colSortingCleanURL = false;
    
    public $actionColumnName;
    
    public $query;
 
    private $idResult;
    
    protected $gerarQuebraDeLinhaActions = false;
 
    public function __construct($data, $columns, $href, $pageLength=15, $index=0, $name='', $useSelecteds=TRUE, $useNavigator=TRUE, $showExport=FALSE, $gridMostraTotalNumeric=false, $fixedTableHeader=true)
    {
        global $state;
        
        parent::__construct(NULL);
        $this->addStyleFile('m_grids.css');
        $this->setColumns($columns);
        $this->href = $href;
        $this->pageLength  = $pageLength;
        $this->headerLinks = array();
        $this->width = '';
        $this->setLinkType('linkbutton');
        $this->box = new MBox('', 'backContext', '');
        $this->rowmethod = null;
        $this->index = $index;
        $this->emptyMsg = _M('No records found!');
        $this->data = $data;
        $this->rowCount = count($this->data);
        $this->controls = array();
        $this->select   = NULL;
        $this->name = $name;
        $this->showExport = $showExport;
        $this->gridMostraTotalNumeric = $gridMostraTotalNumeric;
 
        $this->pageNumber = MUtil::NVL($state->get('pn_page', $this->name),'1');
        $this->prevPage   = MUtil::NVL($state->get('grid_page', $this->name),'1');
        $state->set('grid_page', $this->pageNumber, $this->name);
 
//        $this->setCurrentPage( $this->pageNumber );
 
        $this->selecteds = array();
        $this->selectsreadonly = array();
        $this->allSelecteds = array();
 
        $this->setUseSelecteds($useSelecteds);
 
//        if (!$useNavigator) {
          $this->handlerSelecteds();
//        }
        $this->page->addScript('m_grid.js');
 
        $this->css = file_get_contents($this->manager->getTheme()->getPath() . '/m_grids.css');
        
        $this->actionColumnName = _M('Action');
 
        $MIOLO = MIOLO::getInstance();
        if ( $fixedTableHeader )
        {
            $this->page->addScript("../themes/{$MIOLO->getTheme()->getName()}/scripts/fixed_table_header.js");
        }
        $this->page->addScript("../themes/{$MIOLO->getTheme()->getName()}/scripts/sagu.js");
    }
 
    function setShowHeaders( $show=true )
    {
        $this->isShowHeaders = $show;
    }
 
    function showHeaders( )
    {
        return $this->isShowHeaders;
    }
 
    public function setCurrentPage($pageNumber)
    {
        global $state;
 
        $this->pageNumber = $pageNumber;
        $state->set('grid_page', $pageNumber, $this->name);
        $this->prevPage = MUtil::NVL($state->get('grid_page', $this->name),'1');
    }
 
    function getURL($filter = false, $order = false, $item = '')
    {
        $url = $this->href;
        $url .= ($filter) ? "&__filter=1" : "&__filter=0";
 
        if ($order)
        {
            $url .= "&orderby={$this->orderby}";
            
            // Adiciona order by inverso (DESC / ASC)
            $currentOrder = MIOLO::_REQUEST('orderby');
 
            if ( strlen($currentOrder) > 0 && ( $this->orderby == $currentOrder ) )
            {
                if ( strlen($this->getOrderMode()) <= 0 || $this->getOrderMode() == 'asc' )
                {
                    $orderMode = 'desc';
                }
                else
                {
                    $orderMode = 'asc';
                }
                
                $url .= '&ordermode=' . $orderMode;
            }
        }
        
        // concatena function na url
        // code fix para componente grid do slinkedform, para funcionar a ordenacao e os formularios corretamente
        if ( ( strlen( ( isset($_REQUEST['function']) ? $_REQUEST['function'] : null) ) > 0 ) && !preg_match('/function=/', $url) )
        {
            $url .= '&function=' . $_REQUEST['function'];
        }
 
        if ($item)
        {
            $url .= $item;
        }
 
        return $url;
    }
    
    public function getOrderMode()
    {
        return MIOLO::_REQUEST('ordermode');
    }
 
    function setTitle($title)
    {
        $this->caption = $this->title = $title;
    }
 
    function setPageLength($pageLength)
    {
        $this->pageLength = $pageLength;
    }
 
    function getPageLength()
    {
        return $this->pageLength;
    }
 
    function setFooter($footer)
    {
        $this->footer = $footer;
    }
 
    function setColumns($columns)
    {
        $this->columns = array();
 
        if ( ! is_array($columns) )
        {
            $columns = array($columns);
        }
 
        foreach ($columns as $k => $c)
        {
            $this->columns[$k] = $c;
            $this->columns[$k]->index = $k;
            $this->columns[$k]->grid = $this;
        }
    }
 
    function setLinkType($linktype)
    {
        $this->linktype = strtolower($linktype);
    }
 
    function setControls($controls)
    {
        if ( ! is_array($controls) )
        {
            $controls = array($controls);
        }
 
        $this->controls = array_merge($this->controls, $controls);
    }
 
    function setButtons($aButtons) //backward compatibility
    {
        $this->setControls($aButtons);
    }
 
    function setWidth($width)
    {
        $this->width = $width;
    }
 
    function setIndex($index)
    {
        $this->index = $index;
    }
 
    function setRowMethod($class, $method)
    {
        $this->rowmethod = array($class, $method);
    }
 
    function setIsScrollable($scrollable=true, $width='99%', $height='99%')
    {
        $this->scrollable   = $scrollable;
        $this->scrollWidth  = $width;
        $this->scrollHeight = $height;
    }
 
    function setScrollWidth($width='99%')
    {
        $this->scrollWidth = $width;
    }
 
    function setScrollHeight($height='99%')
    {
        $this->scrollHeight = $height;
    }
 
    function headerLink($id, $label, $href)
    {
        $this->headerLinks[$id] = new MGridHeaderLink($id, $label, $href);
    }
 
    function setColumnAttr($col, $attr, $value)
    {
        $this->columns[$col]->$attr = $value;
    }
 
    function setData($data, $rowCount = null)
    {
        $this->data = $data;
        $this->rowCount = (strlen($rowCount) > 0) ? $rowCount : count($this->data);
 
        // Verificações para não contabilizar a linha de totais, caso esteja configurado para exibí-la.
        if ( $this->gridMostraTotalNumeric && empty($this->rowCount) && ($this->rowCount >= $this->pageLength || $this->pageLength == 999999999) )
        {
            $this->rowCount --;
        }
    }
 
    function getData()
    {
        return $this->data;
    }
 
    function getDataValue($row, $col)
    {
        return $this->data[$row][$col];
    }
 
    function getPage()
    {
        if ( count($this->data) )
        {
            $gridCount = $this->pn->gridCount;
            if ( $this->gridMostraTotalNumeric )
            {
                $gridCount ++;
            }
 
            $offset = $this->pn->idxFirst >= count($this->data) ? 0 : $this->pn->idxFirst;
            return array_slice($this->data, $offset, $gridCount);
        }
    }
 
    function getPageNumber()
    {
        return $this->pageNumber;
    }
 
    function getPrevPage()
    {
        return $this->prevPage;
    }
 
    function addActionSelect()
    {
        $this->select = new MGridActionSelect($this);
    }
 
    function addActionIcon($alt, $icon, $href, $index = null)
    {
        // If temporário, retirar assim que o sbootstrap for padrão no sistema
        if (strpos(MIOLO::getInstance()->getTheme()->id, "sbootstrap") !== false)
        {
            $icon = str_replace(array('cal.gif'), array('calendario.png'), $icon);
        }
 
        //if ($p = strpos($icon,'.')) $icon = substr($icon,0,$p);
        if (!is_null($index))
        {
            $this->actions[$index] = new MGridActionIcon($this, $icon, $href, $alt);
        }
        else
        {
            $this->actions[] = new MGridActionIcon($this, $icon, $href, $alt);
        }
    }
 
    function addActionText($alt, $text, $href, $index = 0)
    {
        $this->actions[] = new MGridActionText($this, $text, $href);
    }
 
    function addActionUpdate($href)
    {
//        $this->AddActionIcon('Editar', array('button_edit.png', 'button_noedit.png'), $href);
        $this->addActionIcon( _M('Edit'), 'edit', $href);
    }
 
    function addActionDelete($href, $alt = 'Delete')
    {
//        $this->AddActionIcon('Excluir', array('button_drop.png', 'button_noempty.png'), $href);
        $this->addActionIcon( _M($alt), 'delete', $href);
    }
 
    function addFilterSelection($index, $label, $options, $value = '')
    {
        $f = new MGridFilterSelection($this, $label, $options, $index, $this->getFilter());
        $this->filters[$index] = $f;
    }
 
    function addFilterText($index, $label, $value = '')
    {
        $f = new MGridFilterText($this, $label, $value, $index, $this->getFilter());
        $this->filters[$index] = $f;
    }
 
    function addFilterControl($index, $control, $type = 'text')
    {
        $this->filters[$index] = new MGridFilterControl($this, $control, $type, $index, $this->getFilter());
    }
 
    function getFilterValue($index)
    {
        return $this->filters[$index]->value;
    }
 
    function getFilterControl($index)
    {
        return $this->filters[$index]->control;
    }
 
    function setFiltered($value = false)
    {
        $this->filtered = $value;
    }
 
    function getFiltered()
    {
        if ( ( $f = $this->page->Request('__filter') ) != '' )
        {
            $this->filtered = ($f == '1');
        }
 
        return $this->filtered;
    }
 
    function getFilter()
    {
        return $this->filter;
    }
 
    function setFilter($status)
    {
        $this->filter = $status;
 
        if ($this->filters)
        {
            foreach ($this->filters as $k => $f)
            {
                $this->filters[$k]->enabled = $status;
            }
        }
    }
 
    function applyFilter()
    {
        if ($this->filters)
        {
            foreach ($this->filters as $f)
            {
                $value[$f->index] = $f->value;
            }
 
            foreach ($this->data as $row)
            {
                $ok = true;
 
                foreach ($value as $k => $v)
                {
                    $n = strlen( trim($v) );
                    $ok = $ok && ( ! strncasecmp($row[$k], $v, $n) );
                }
 
                if ($ok)
                    $data[] = $row;
            }
            $this->data = $data;
            $this->rowCount = count($this->data);
        }
    }
 
    function applyOrder($column)
    {
        $p = $this->columns[$column]->index;
        $n = count($this->data[0]);
 
        foreach ($this->data as $key => $row)
        {
            for ($i = 0; $i < $n; $i++)
            {
                $arr[$i][$key] = $row[$i];
            }
        }
 
        $sortcols = "\$arr[$p]";
 
        for ($i = 0; $i < $n; $i++)
        {
            if ($i != $p)
            {
                $sortcols .= ",\$arr[$i]";
            }
        }
        
        // Se já foi ordenado na base de dados, não ordena no PHP
        if ( $this->orderByDatabase != true )
        {
            eval("array_multisort({$sortcols}, SORT_ASC);");
        }
        
        $this->data = array();
 
        for ($i = 0; $i < $n; $i++)
        {
            foreach ($arr[$i] as $key => $row)
            {
                $this->data[$key][$i] = $row;
            }
        }
    }
 
    function addError($err)
    {
        if ($err)
        {
            if ( is_array($err) )
            {
                if ($this->errors)
                {
                    $this->errors = array_merge($this->errors, $err);
                }
                else
                {
                    $this->errors = $err;
                }
            }
            else
            {
                $this->errors[] = $err;
            }
        }
    }
 
    function showID($state)
    {
        $this->showid = $state;
    }
 
    function setClose($action)
    {
        $this->box->setClose($action);
    }
 
    function setSelecteds($s)
    {
        global $state;
        $selecteds = $state->get('selecteds', $this->name);
        $selecteds[$this->pageNumber] = $s;
        $state->set('selecteds',$selecteds, $this->name);
        $state->set('useselecteds', true, $this->name);
    }
 
    function setUseSelecteds($opt)
    {
        global $state;
        $state->set('useselecteds', $opt, $this->name);
    }
 
    function handlerSelecteds()
    {
        global $state;
 
        $selecteds    = $state->get('selecteds', $this->name);
        $useSelecteds = $state->get('useselecteds', $this->name);
 
        if ( urldecode( $this->page->request('gridName') ) == $this->name )
        {
          $state->set('pn_page', $this->page->request('pn_page'), $this->name);
        }
        $state->set('gridName', $this->name); //para gravar o nome do grid na sessão
        $this->pageNumber = MUtil::NVL($state->get('pn_page', $this->name),1);
        $this->prevPage   = MUtil::NVL($state->get('grid_page', $this->name),1);
        
        $this->selecteds = array();
 
        if ($useSelecteds)
        {
            $selecteds[$this->prevPage] = array();
 
            if ($select = $this->page->request('select'.$this->name))
            {
                foreach( $select as $k=>$v )
                {
                    $selecteds[$this->prevPage][] = $k;
                }
            }
            if ( is_array($selecteds[$this->pageNumber]) )
            {
                $this->selecteds = $selecteds[$this->pageNumber];
            }
            $this->allSelecteds = $selecteds;
        }
 
        $state->set('grid_page', $this->pageNumber, $this->name);
 
        $state->set('useselecteds', $useSelecteds, $this->name);
        $state->set('selecteds',$selecteds, $this->name);
    }
 
    function generateTitle()
    {
        if ( $this->caption != '' )
        {
            $this->box->SetCaption($this->caption);
 
            return $this->box->boxTitle->generate();
        }
    }
 
    function generateNavigationHeader()
    {
        if ( ! $this->pn )
        {
            return null;
        }
 
        $links = $this->pn->getPageLinks();
 
        foreach ( $links as $link )
        {
            $link->float = 'left';
        }
 
        $d['pages'] = new MDiv('', $links);
        $d['pages']->addStyle('float', 'left');
        $array[0] = $this->pn->getPageFirst();
        $array[1] = $this->pn->getPagePrev();
        $array[2] = $this->pn->getPageRange();
        $array[3] = $this->pn->getPageNext();
        $array[4] = $this->pn->getPageLast();
 
        if ( !is_null($this->showExportAsCSV) )
        {
            $this->showExport = $this->showExportAsCSV;
        }
 
        if ( $this->showExport )
        {
            $pn_page = !is_null($_GET['pn_page']) ? "&pn_page=" . $_GET['pn_page'] : "";
            if ($this->manager->theme->id == 'smodern')
            {
                // CSV export
                $MIOLO = MIOLO::getInstance();
                $url = "{$this->pn->action}&gridName=". urlencode($this->name) . $pn_page;
                $img = $MIOLO->getUI()->getImage(NULL, 'csv.png');
 
                $export = new MLinkButton('exportGridAsCSV', _M('Export as CSV (Excel)'), $url);
                $export->generateLink();
                $export = new MImageLink('exportGridAsCSV', _M('Export as CSV (Excel)'), $export->href . 'stopShowLoading();', $img);
                $d['export'] = new MDiv('exportButtonDiv', array($export), 'm-grid-export-div');
 
 
                // HTML export
                $MIOLO = MIOLO::getInstance();
                $url = "{$this->pn->action}&gridName=". urlencode($this->name) . $pn_page;
                $img = $MIOLO->getUI()->getImage(NULL, 'html.png');
 
                $export = new MLinkButton('exportGridAsHTML', _M('Export as HTML'), $url);
                $export->target = '_blank';
                $export->generateLink();
                $export = new MImageLink('exportGridAsHTML', _M('Export as HTML'), $export->href . 'stopShowLoading();', $img);
                $d['exportHTML'] = new MDiv('exportButtonDiv', array($export), 'm-grid-export-div');
 
 
                // PDF export
                $MIOLO = MIOLO::getInstance();
                $url = "{$this->pn->action}&gridName=". urlencode($this->name) . $pn_page;
                $img = $MIOLO->getUI()->getImage(NULL, 'pdf.png');
 
                $export = new MLinkButton('exportGridAsPDF', _M('Export as PDF'), $url);
                $export->generateLink();
                $export = new MImageLink('exportGridAsPDF', _M('Export as PDF'), $export->href . 'stopShowLoading();', $img);
                $d['exportPDF'] = new MDiv('exportButtonDiv', array($export), 'm-grid-export-div');
 
                // XLS export
                $MIOLO = MIOLO::getInstance();
                $url = "{$this->pn->action}&gridName=". urlencode($this->name) . $pn_page;
                $img = $MIOLO->getUI()->getImage(NULL, "xls.png");
 
                $export = new MLinkButton("exportGridAsXLS", _M("Exportar como XLS"), $url . "&tipoDeExportacao=0");
                $export->generateLink();
                $export = new MImageLink("exportGridAsXLS", _M("Exportar como XLS"), $export->href . 'stopShowLoading();', $img);
                $d['exportXLS'] = new MDiv('exportButtonDiv', array($export), 'm-grid-export-div');
 
                // JRXML export
                $MIOLO = MIOLO::getInstance();
                $url = "{$this->pn->action}&gridName=". urlencode($this->name) . $pn_page;
                $img = $MIOLO->getUI()->getImage(NULL, "jrxml.png");
 
                $export = new MLinkButton("exportGridAsJRXML", _M("Gerar JRXML"), $url);
                $export->generateLink();
                $export = new MImageLink("exportGridAsJRXML", _M("Gerar JRXML"), $export->href . 'stopShowLoading();', $img);
                $d['exportJRXML'] = new MDiv('exportButtonDiv', array($export), 'm-grid-export-div');
            }
            else
            {
                $newExport = (version_compare(SAGU_VERSION, "3.74.05") >= 0);
                $exportsList = array('PDF', 'XLS', 'HTML', 'JRXML', 'CSV');
                foreach ($exportsList as $ex)
                {
                    $url = "{$this->pn->action}&gridName=". urlencode($this->name) . $pn_page . "&typeExport=$ex";
                    $export = new MLinkButton("exportGridAs$ex", _M(""), $url);
                    $export->generateLink();
 
                    if ( $newExport )
                    {
                        $labelEx = _M("Exportar para $ex");
                        $actionExportUrl = base64_encode($export->href . 'stopShowLoading();');
                        $actionExport = "javascript:saguDoAjax('gerarModalExportacao','divExportsM',false,'&labelExport={$labelEx}&rowCount={$this->rowCount}&actionExport={$actionExportUrl}')";
                        
                        $export = new MText("exportGridAs$ex", _M("Exportar para $ex"));
                        $export->addAttribute('onclick', $actionExport);
                        $export->addAttribute('style', 'cursor: pointer; text-decoration: none; font-size: 11px; font-weight: 500; font-style: normal; white-space: normal; text-align:left !important; min-height: 22px !important; padding-left: 18px;');
                        $linksExport[] = $export;
                    }
                    else
                    {
                        $linksExport[] = new MLink('lnkExport$ex', _M("Exportar para $ex"), $export->href . 'stopShowLoading();', null);
                    }
                }
 
                $d['exportDrop'] = new MDropdownMenu('', ' ', $linksExport, $this->manager->getUI()->getImageTheme($this->manager->theme->id, 'export-20x20.png'));
                $d['exportDrop']->setClass('exportIcon');
                $d['exportDrop']->addAttribute('title', 'Exportar');
                $this->page->onLoad('
                    $(".exportIcon ul").css("left", $(".exportIcon").prev().width()+"px");
                    $(".exportIcon").prop("title", "Visualizar exportações disponíveis");
                ');
            }
        }
 
        $d['nav'] = new MDiv('', $array);
        $d['nav']->addStyle('float', 'right');
 
        $d = new MDiv('', $d, 'm-grid-navigation');
 
        return $d;
    }
 
    function generateNavigationFooter()
    {
        if ( ! $this->pn )
        {
            return null;
        }
 
        $links = $this->pn->getPageLinks();
 
        foreach ($links as $link)
        {
            $link->float = 'left';
        }
 
        $d1 = new MDiv('', $links);
        $d1->addStyle('float', 'left');
        $array[0] = $this->pn->getPageFirst();
        $array[1] = $this->pn->getPagePrev();
        $array[2] = $this->pn->getPageRange();
        $array[3] = $this->pn->getPageNext();
        $array[4] = $this->pn->getPageLast();
 
        $d2 = new MDiv('', $array);
        $d2->addStyle('float', 'right');
 
        $d = new MDiv('', array($d1, $d2), 'm-grid-navigation m-grid-navigation-bottom');
 
        return $d;
    }
 
    function generateLinks()
    {
        if ( ! count($this->headerLinks) )
        {
            return NULL;
        }
 
        foreach ($this->headerLinks as $link)
        {
            $link->float = 'left';
        }
 
        $div = new MDiv('', $this->headerLinks, 'm-grid-header-link');
 
        return $div;
    }
 
    function generateControls()
    {
        if ( ! count($this->controls) )
        {
            return NULL;
        }
 
        $i = 0;
 
        foreach ($this->controls as $c)
        {
            $array[$i++] = $c->generate();
            $array[$i++] = '&nbsp;&nbsp;';
        }
 
        return new MDiv('', $array, 'm-grid-controls');
    }
 
    function generateFilter()
    {
        if ( ! $this->filter )
        {
            return null;
        }
 
        foreach ($this->filters as $k => $f)
        {
            $array[] = $f->generate();
        }
 
        $button = new MButton('', _M('Filter'), 'submit', 'images/button_select.png');
        $array[] = $button->generate();
 
        return new MDiv('', $array, 'm-grid-filter');
    }
 
    function hasErrors()
    {
        return count($this->errors);
    }
 
    function generateErrors()
    {
        global $MIOLO;
 
        $caption = ( _M('Errors') );
 
        $t = new MSimpleTable('');
        $t->setAttributes("class=\"m-prompt-box-error\" border=\"0\" cellspacing=\"0\" cellpadding=\"0\" width=\"100%\"  border=\"0\"");
        $t->attributes['cell'][0][0] = "colspan=\"2\" class=\"m-prompt-box-error-title\"";
        $t->cell[0][0] = $caption;
        $t->attributes['cell'][1][0] = "valign=\"top\" width=\"60\"";
        $t->cell[1][0] = new ImageForm('', '', 'images/error.gif');
        $t->attributes['cell'][1][1] = "class=\"m-prompt-box-error-text\"";
        $leftmargin = '&nbsp;&nbsp;&nbsp;&nbsp;';
 
        foreach ($this->errors as $e)
        {
            $msg .= $leftmargin . "-&nbsp;$e<br/>";
        }
 
        $t->cell[1][1] = $msg;
        return $t;
    }
 
    function generateHeader()
    {
        $header[] = $this->generateFilter();
 
        if ($this->data)
        {
            $header[] = $this->generateNavigationHeader();
        }
 
        $header[] = $this->generateLinks();
 
        return $header;
    }
 
    function generateColumnsHeading($tbl)
    {
        $tbl->attributes['row'][0] = "class=\"m-grid-row-heading\"";
        $p = 0;
 
        if ( count($this->actions) )
        {
            $tbl->attributes['cell'][0][$p] = "width=\"16\" align=\"left\" class=\"m-grid-column-heading\"";
            $tbl->cell[0][$p++] = $this->actionColumnName;
        }
 
        if ( $this->select != NULL )
        {
            $rowCount = count($this->data);
            $this->page->onLoad( "gridChkEachRow($rowCount,'".$this->name."');" );
            $tbl->attributes['cell'][0][$p] = "width=\"16\" align=\"center\" class=\"m-grid-column-heading\"";
            $tbl->cell[0][$p] = new CheckBox("chkAll", 'chkAction', '');
            $tbl->cell[0][$p++]->AddAttribute('onclick', "javascript:gridChkAll(this,$rowCount,'".$this->name."');");
        }
 
        // generate column headings
        foreach ($this->columns as $k => $col)
        {
            if ( (!$col->visible) || (!$col->title) || ($col->hidden) )
            {
                continue;
            }
 
            if ($col->order)
            {
                $this->orderby = $k;
                $colTitle = new MLinkButton('', $col->title, $this->getURL($this->filtered, true) );
                $colTitle->setClass('m-grid-column-order');
                $colTitle->setGenerateLinkButton( !$this->colSortingCleanURL );
            }
            else
            {
                $colTitle = $col->title;
            }
 
            if ($col->width)
            {
                $attr = " width=\"$col->width\"";
            }
            else
            {
                // scrollable tables need col width
                if( $this->scrollable )
                {
                    $this->manager->logMessage( _M("[WARNING] Using scrollable table, it's necessary to inform column width. ") );
                }
            }
 
            $tbl->attributes['cell'][0][$p] = "class=\"m-grid-column-heading\" " . ( isset($attr) ? $attr : '');
            $tbl->cell[0][$p++] = $colTitle;
        }
    }
 
    // This method corrects a problem when using scrollable table having
    // only one or few records. Adds a colspaned row.
    function correctActionColSpan($tbl)
    {
        if ( count($this->actions) )
        {
            $tbl->attributes['cell'][0][0] = "width=\"15\" align=\"left\" ";
            $tbl->cell[0][0] = '';
        }
    }
 
    function generateActions(&$tbl)
    {
        $i = $this->currentRow + 1;
 
        // Max of one column for actions
        $n = count($this->actions) ? 1 : 0;
 
        if ( $this->gridMostraTotalNumeric && !empty($this->pn->gridCount) && $this->pn->gridCount < $i && ($n || $this->select != null) )
        {
            $tbl->attributes['cell'][$i][] = "align=\"center\" width=\"0\"";
            $tbl->cell[$i][] = new MDiv("{$this->id}_gridActions", "<span class='m-label'><b>TOTAL DA PÁGINA</b></span>", 'm-grid-actions');
            return;
        }
 
        if ( $n )
        {
            $actions = '';
 
            // generate action links
            foreach ( $this->actions as $k => $action )
            {
                $action->attributes();
                $a = $action->generate();
 
                if ( is_object($a) )
                {
                    $a = $a->generate();
                }
 
                $actions .= "<td>$a</td>";
            }
 
            /*
             * Inner table to align actions horizontally. IE7 does not support 
             * "display: table-cell" and "float: left" does not force column to
             * align stuff horizontally.
             */
            $innerTable = "<table><tr>$actions</tr></table>";
            
            if ( $this->gerarQuebraDeLinhaActions )
            {
                $innerTable = $this->gerarActions();
            }
            
            $tbl->attributes['cell'][$i][] = "align=\"center\" width=\"0\"";
            $tbl->cell[$i][] = new MDiv("{$this->id}_gridActions", $innerTable, 'm-grid-actions');
        }
 
        if ( $this->select != NULL )
        {
            $tbl->attributes['row'][$i] .= " id=\"row".$this->name."[{$this->currentRow}]\" ";
            $tbl->attributes['cell'][$i][$n] = "align=\"center\"";
            $select = $this->select->generate();
            $select->checked = ( array_search($i-1, $this->selecteds) !== false );
            $select->readonly = $this->selectsreadonly[$i-1];
            $tbl->cell[$i][$n] = $select;
        }
    }
    
    function gerarActions()
    {        
    }
 
    function generateColumnsControls()
    {
        foreach ( $this->columns as $k => $col )
        {
            if ( $col instanceof MGridColumn )
            {
                $col->generate();
            }
        }
    }
    
    function generateAlignColumn(&$column, $value)
    {        
    }
    
    function generateColumns($tbl, $row = null, $i = null)
    {
        $i = $this->currentRow + 1;
        
        // Max of one column for actions
        $p = count($this->actions) ? 1 : 0;
 
        if ( $this->select != NULL )
        {
            $p++;
        }
 
        $firstVisible = 0;
 
        foreach ( $this->columns as $k => $col )
        {
            if ( $this->gridMostraTotalNumeric && $k == $firstVisible && !empty($this->pn->gridCount) && $this->pn->gridCount == $this->currentRow && count($this->actions) == 0 && !$this->select )
            {
                if ( $col->visible ) {
                    $col->control[$this->currentRow]->value = "<b>TOTAL DA PÁGINA</b>";
                }
                else
                {
                    $firstVisible ++;
                }
            }
 
            if (( ! $col->title ) || ( ! $col->visible ))
            {
                continue;
            }
            
            // Store the controls on hidden columns to generate them later.
            if ( $col->hidden )
            {
                $this->hiddenControls[] = $col->control[$this->currentRow];
                continue;
            }
 
            $control = $col->control[$this->currentRow];
            $attr = "";
            
            $this->generateAlignColumn($col, $control->value);
            
            if ( $col->nowrap )
            {
                $attr .= " nowrap ";
            }
 
            if ( $col->width )
            {
                $attr .= " width=\"$col->width\"";
            }
 
            if ( $col->align )
            {
                $attr .= " align=\"$col->align\"";
            }
 
            $class = $col->getClass();
            $tbl->attributes['cell'][$i][$p] = "$attr class=\"$class\"";
            $tbl->cell[$i][$p++] = $control;
        }
    }
 
    function generateEmptyMsg()
    {
        $div = new MDiv('', $this->emptyMsg, 'gridAttention');
        return $div;
    }
 
    function generateData()
    {
        global $state;
 
        if ( ! $this->data || $this->generateDataCalled )
        {
            return;
        }
        
        $this->generateDataCalled = true;
 
        $this->orderby = $this->page->request('orderby');
        $isAssociativeGrid = !isset($this->columns[0]);
 
        if ( $this->ordered = isset($this->orderby) && !$isAssociativeGrid )
        {
            $this->applyOrder( $this->orderby );
            $this->page->state->set('orderby', $this->orderby, $this->name);
        }
 
        if ( $this->getFiltered() )
        {
            $this->applyFilter();
        }
 
        if ( $this->pageLength )
        {
            $this->pn = new MGridNavigator( $this->pageLength, $this->rowCount,
                                            $this->getURL( $this->filtered, $this->ordered ),
                                            $this
                                          );
                                          
            if ( $this->offset == NULL )
            {
                $this->data = $this->getPage();
            }
        }
        else
        {
            $this->pn = null;
        }
    }
 
    function callRowMethod()
    {
        if ( isset($this->rowmethod) )
        {
            $i = $this->currentRow;
            $row = $this->data[$i];
 
            $myRowClass = is_object($this->rowmethod[0]) ? get_class($this->rowmethod[0]) : $this->rowmethod[0];
            $myRowFunction = $this->rowmethod[1];
 
            if (get_class($this) == $myRowClass)
            {
                $this->$myRowFunction($i, $row, $this->actions, $this->columns, $this);
            }
            else
            {
                // A grid é refletida para poder fazer o uses dela (necessário PHP7.0+)
                $reflectedGrid = new ReflectionClass($this);
                include_once ($reflectedGrid->getFileName());
 
                $gridClass = new $myRowClass();
                $gridClass->$myRowFunction($i, $row, $this->actions, $this->columns, $this);
            }
 
        }
    }
 
    function generateBody($data = null)
    {
        global $MIOLO, $SCRIPT_NAME;
 
        if ( $this->hasErrors() )
        {
            $this->generateErrors();
        }
 
        $tblData = new MSimpleTable( 'tbody' . $this->id, "cellspacing=\"0\" cellpadding=\"0\" border=\"0\" width=\"100%\" class=\"m-grid-body\"");
 
        $tbodyId = 'tbody' . $this->id;
        $bodyId = 'body' . $this->id;
 
        $this->page->onLoad(
            "if (typeof $('#{$tbodyId}').stickyTableHeaders == 'function' ) $('#{$tbodyId}').stickyTableHeaders();".
            "$('#{$bodyId}').on('scroll', function(){\$('#{$tbodyId}').stickyTableHeaders();});"
        );
 
        $this->generateColumnsHeading($tblData);
 
        if ($this->data)
        {
            // generate data rows
            $i = 0;
 
            foreach ($this->data as $row)
            {
                $this->currentRow = $i;
                $rowId = ($i % 2) + 1;
                $rowClass = "m-grid-row-$rowId";
                $i++;
                $tblData->attributes['row'][$i] = "class=\"$rowClass\"";
                $this->generateColumnsControls();
                $this->callRowMethod();
                $this->generateActions($tblData);
                $this->generateColumns($tblData);
            } // foreach row
        }     // if
        $tblData->setRowAttribute(0, "id", 'tbody'.$this->id.'first');
 
        if( $this->scrollable )
        {
            $bodyHeader = new MDiv('head'.$this->id, null, 'm-grid-head', 'style="'.
                                                       'width:'.$this->scrollWidth.';'.
                                                       'overflow-x:hidden;"');
            $body = new MDiv('body'.$this->id, $tblData,'m-grid-body','style="'.
                                                       'width:'.$this->scrollWidth.';'.
                                                       'height:'.$this->scrollHeight.';'.
                                                       'overflow:auto;" '
                                                    );
            $body = new MDiv('', array($bodyHeader, $body) );
        }
        else
        {
            $body = $tblData;
        }
 
        return $body;
    }
 
    function generateFooter()
    {
        $footer = is_array($this->footer) ? $this->footer : array($this->footer);
 
        if ( ! $this->data )
        {
            $footer[] = $this->generateEmptyMsg();
        }
 
        if ( $this->data )
        {
            $footer[] = $this->generateNavigationFooter();
        }
 
        $footer[] = $this->generateControls();
 
        return $footer;
    }
 
    function getImage($src)
    {
        $url = $this->icons[$src];
        if ( ! $url )
        {
            if ( substr($src, 0, 1) == '/' ||
                 substr($src, 0, 5) == 'http:' ||
                 substr($src, 0, 6) == 'https:')
            {
                $url = $src;
            }
            else
            {
                $file = $this->manager->getConf('home.themes')  . '/' . $this->manager->getConf('theme.main')  . '/images/' . $src;
 
                if ( file_exists($file) )
                {
                    $url = $this->manager->getUI()->getImageTheme( $this->manager->getConf('theme.main'), $src );
                }
                else
                {
                    $url = $this->manager->getUI()->getImage('', $src);
                }
            }
 
            $this->icons[$src] = $url;
        }
 
        return $url;
    }
 
    public function generate()
    {
        $this->generateData();
        $header = $this->painter->generateToString($this->generateHeader());
        $title = $this->painter->generateToString($this->generateTitle());
        $body = $this->painter->generateToString($this->generateBody());
        $footer = $this->painter->generateToString($this->generateFooter());
 
        $f = new MDiv('', array( $title, $header, $body, $footer, $this->hiddenControls ), 'm-grid-box');
 
        if ( $this->width != '' )
        {
            $f->addStyle('width', $this->width);
        }
        
        return $f->generate();
    }
 
    public function hasOffset()
    {
        return $this->offset != NULL;
    }
    
    public function getOffset()
    {
        return $this->offset;
    }
 
    public function setOffset($offset)
    {
        $this->offset = $offset;
    }
 
    public function ajustarFormatacaoGrid()
    {
    }
    
    public function getQuery()
    {
        return $this->query;
    }
    
    public function setQuery($sql = NULL, $dbconf = NULL, $rowCount = NULL, $returnAllData = false, $asAssociative = false, $consultaExportacao = false)
    {
        global $state;
 
        if ( $sql == '' )
        {
            return;
        }
 
        $MIOLO = MIOLO::getInstance();
        $db = $MIOLO->getDatabase($dbconf);
        $queryBackup = $sql;
        $sql = $this->normalizaConsulta($sql, $dbconf, $this->gridMostraTotalNumeric, ($consultaExportacao ? $this->columns : null));
 
        // Seta o order by
        $orderBy = MIOLO::_REQUEST('orderby');
        if ( strlen($orderBy) > 0 )
        {
            $msql = new MSQL();
            $msql->setDb($MIOLO->GetDatabase());
            $msql->createFrom($sql);
            $msql->clearOrderBy();
 
            // Adiciona o novo orderby
            ! is_numeric($orderBy) ? : $orderBy += 1;
            if (is_numeric($orderBy)) {
                $msql->setOrderBy($orderBy . ' ' . MIOLO::_REQUEST('ordermode'));
            }
            else
            {
                $msql->setOrderBy('"' . $orderBy . '" ' . MIOLO::_REQUEST('ordermode'));            
            }
 
            // Adicionado para alternar order mode entre asc e desc.
            $_REQUEST['ordermode'] == 'asc' ? $_REQUEST['ordermode'] = 'desc' : $_REQUEST['ordermode'] = 'asc';
            $sql = $msql->select();
 
            // Avisa o php que o order by j? foi feito na base de dados
            $this->orderByDatabase = true;
        }
 
        // Calculate the current offset
        $this->offset = ($this->pageNumber - 1) * $this->pageLength;
        $query = $this->query;
        if ( empty($query) )
        {
            $this->query = $query = "SELECT *, COUNT(*) OVER () AS rowCount FROM ({$sql}) AS MGRIDTABLE";
            $queryBackup = "SELECT *, COUNT(*) OVER () AS rowCount FROM ({$queryBackup}) AS MGRIDTABLE";
        }
 
        $sql = $query;
        if ( !$returnAllData )
        {
            if( !strlen(strstr($query, ' LIMIT ')) > 0 && !strlen(strstr($query, ' OFFSET ')) > 0 )
            {
                $sqlWithLimit = "{$query} LIMIT $this->pageLength OFFSET $this->offset";
            }
            else
            {
                $sqlWithLimit = $query;
            }
 
            $sql = $sqlWithLimit;
            if ( $this->gridMostraTotalNumeric )
            {
                $sql = $this->obterConsultaComSomatorios($sqlWithLimit);
            }            
        }
        
        try
        {
            
            $data = $db->query($sql);
            $rowCount = $data[0][count($data[0]) - 1];
 
            // Caso deva retornar os dados como array associativa, executa novamente a consulta
            // com LIMIT 1, para obter os nomes das colunas.
            if ( $asAssociative )
            {
                $sqlColumns = $this->obterConsultaComNomesDasColunas($query);
                $columns = $db->query($sqlColumns);
                $associativeData = array();
                foreach ( $data as $record )
                {
                    $associativeValue = array();
                    foreach ( $columns as $key => $column )
                    {
                        $associativeValue[$column[0]] = $record[$key];
                    }
                    $associativeData[] = $associativeValue;
                }
                $data = $associativeData;
            }
        }
        catch ( Exception $err )
        {
            // Caso por algum motivo tenham ocorrido erros ao tentar obter os totalizadores,
            // Executa a consulta original.
            $data = $db->query($queryBackup);
            $rowCount = $data[0][count($data[0]) - 1];
        }
 
        // Converte datas do formato Y-m-d para o formato d/m/Y para exibição na grid
        // é feito aqui pois assim o sistema já terá ordenado os dados da grid. Ao tentar ordenar as datas vindas da
        // base já formatadas como string estava ficando fora de ordem.
        foreach ($data as $rowKey => $rowInfo)
        {
            foreach ($rowInfo as $columnKey => $columnInfo)
            {
                if ( SAGU::isDate($columnInfo) )
                {
                    $data[$rowKey][$columnKey] = SAGU::convertDateToUser($columnInfo);
                }
            }
        }
 
        $this->data = $data;
        $this->idResult = $db->getIdResult();
        $this->rowCount = $rowCount ?? $this->data[0][count($this->data[0]) - 1];
        $this->ajustarFormatacaoGrid();
 
        return $this->data;
    }
 
    public static function obterConsultaComSomatorios($query)
    {
        $randConsulta = rand();
        $sql = "
            CREATE TEMP TABLE consulta_{$randConsulta} ON COMMIT DROP AS (
                {$query}
            );
            SELECT *
              FROM consulta_{$randConsulta}
         UNION ALL   
            SELECT * 
              FROM somatorioDeValoresDaTabela(NULL::consulta_{$randConsulta})
        ";
 
        return $sql;
    }
 
    public static function obterConsultaComNomesDasColunas($query)
    {
        $randConsulta = rand();
        $sql = "
            CREATE TEMP TABLE consulta_{$randConsulta} ON COMMIT DROP AS (
                {$query} LIMIT 1
            );
            SELECT column_name
              FROM information_schema.columns
             WHERE table_name = 'consulta_{$randConsulta}' ORDER BY ordinal_position
        ";
 
        return $sql;
    }
 
    public static function normalizaConsulta($sql, $dbconf, $gridMostraTotalNumeric = false, $columnsGrid = array())
    {
        if ( $gridMostraTotalNumeric )
        {
            $MIOLO = MIOLO::getInstance();
            $db = $MIOLO->getDatabase($dbconf);
 
            $msql = new MSQL();
            $msql->considerarTabelasSubSelects = true;
            $msql->setDb($MIOLO->GetDatabase());
            $msql->createFrom($sql);
            $columns = array();
            $count = 1;
 
            // Seta alias para colunas sem alias
            foreach ($msql->getColumns() as $key => $column)
            {
                // Remove do sql as colunas que não são exibidas
                if ( count($columnsGrid) > 0 )
                {
                    $columnVisible = false;
                    foreach ( $columnsGrid as $keyAux => $columnAux )
                    {
                        // trata as chaves compostas
                        if ( !is_int($keyAux) )
                        {
                            if ( stripos($key, $keyAux) !== false )
                            {
                                $columnVisible = true;
                                if ($columnAux->hidden || !$columnAux->visible || !($columnAux->title))
                                {
                                    $columnVisible = false;
                                }
                                break;
                            }
                        }
                        else
                        {
                            $valueKeyColumn = array_search($key, array_values($msql->getColumns()));
                            if ( $keyAux == $valueKeyColumn )
                            {
                                $columnVisible = true;
                                if ( $columnAux->hidden || !$columnAux->visible || !($columnAux->title) )
                                {
                                    $columnVisible = false;
                                    break;
                                }
                            }
                        }
                    }
 
                    if ( !$columnVisible )
                    {
                        continue;
                    }
                }
 
                // Controles para não ocorrerm erros de tipagem.
                $auxColumn = ($column == 'null' || $column == 'NULL') ? 'NULL::TEXT' : $column;
                $column = str_replace('null as', 'NULL::TEXT AS', $auxColumn);
                $column = str_replace('NULL AS', 'NULL::TEXT AS', $column);
                $column = str_replace('null AS', 'NULL::TEXT AS', $column);
                $column = str_replace('NULL as', 'NULL::TEXT AS', $column);
 
                $columns[$key . '_' . $count] = $column;
                $explodeColumn = explode(" as ", strtolower($column));
                if (count($explodeColumn) < 2 && $column != '*')
                {
                    $columns[$key . '_' . $count] = $column . " AS coluna_" . $count;
                }
 
                $count++;
            }
 
            $msql->clearColumns();
            $msql->setColumns($columns);
            $sql = $msql->select();
        }
 
        return $sql;
    }
 
    public function hideColumn($column)
    {
        $this->page->addStyleCode("table#tbody$this->id td:nth-child($column) {display:none;}");
    }
 
    public function getIdResult()
    {
        return $this->idResult;
    }
 
    public function setIdResult($idResult)
    {
        $this->idResult = $idResult;
    }
 
    public function isGridMostraTotalNumeric()
    {
        return $this->gridMostraTotalNumeric;
    }
 
    public function setGridMostraTotalNumeric($gridMostraTotalNumeric)
    {
        $this->gridMostraTotalNumeric = $gridMostraTotalNumeric;
    }
}
 
?>