mform.class

Ir para a documentação deste ficheiro.

<?php
define ('FORM_SUBMIT_BTN_NAME', 'submit_button');
 
class MForm extends MControl
{
    var $title;
 
    var $action;
 
    var $method;
 
    var $buttons;
 
    var $fields=array();
 
    var $return;
 
    var $reset;
 
    var $styles;
 
    var $help;
 
    var $footer;
 
    var $width;
 
    public static $showHints = true;
 
    var $enctype;
 
    var $validations;
 
    var $defaultButton;
 
    var $errors;
 
    var $infos;
 
    var $alerts;
 
    var $box;
 
    static $fieldNum = 0;
    var $layout;
 
    var $cssForm = false;
    var $cssButtons;
    var $zebra = false;
    var $labelWidth = NULL;
 
    var $bgColor = NULL;
    var $align = NULL;
 
    public $mioloCustomFields;
 
    public $mioloCustomizedId;
    
    private $formControlFields = array();
 
    function __construct($title='',$action='',$close='',$icon='', $help='')
    {
        parent::__construct();
        $this->AddStyleFile('m_forms.css');
        $this->name          = $this->page->name;
        $this->box           = new MBox($title,$close,$icon,$help);
        $this->title         = $title;
        $this->action        = $action;
        $this->method        = 'post';
        $this->return        = false;
        $this->width         = '95%';
        $this->defaultButton = true;
        $this->fields        = array();
        $this->validations   = array();
        
        // Adiciona campo oculto para armazenar o randomid gerado da tela, utilizado para não conflitar dados.
        $this->setRandomField();
        
        $this->CreateFields();
        if ($this->IsSubmitted())
        {
            $this->GetFormFields(); // set the fields array with form post/get values
        }
        $this->onLoad();
    }
    
    public function getRandomField()
    {
        $MIOLO = MIOLO::getInstance();
        $randomId = (Integer) $MIOLO->_REQUEST('randomid');
        
        if ( empty($randomId) )
        {
            $randomId = rand();
            $_REQUEST["randomid"] = (Integer) $randomId;
        }
        
        return new MHiddenField('randomid', $randomId);
    }
    
    public function setRandomField()
    {
        $fieldRandom = $this->getRandomField();
        $this->_RegisterField($fieldRandom);
        $this->layout[] = $fieldRandom;
    }
 
    function __set($name, $value)
    {
        $this->AddControl($value);
        $this->fields[$name] = $value;
    }
 
 
    function __get($name)
    {
        return $this->fields[$name] ?? null;
    }
 
    public function getValidations()
    {
        return $this->validations;
    }
 
    public function setValidations($validations)
    {
        $this->validations = $validations;
    }    
 
    function OnLoad()
    {
    }
 
 
    function CreateFields()
    {
    }
 
 
    function AddValidator($validator)
    {
        $field = $this->{$validator->field};
 
        if ( !$field )
        {
            $field = $this->getFieldFromFields($validator->field, $this->fields);
            if( isset($field) )
            {
                $field->validator = $validator;
            }
        }
 
        if ( !$validator->label )
        {
            $validator->label = ( $validator->label == '' ? ( $field->label ?? '' ) : $validator->label );
        }
 
        $name = '_validator_' . $this->name . '_' . $validator->id . '_' . $validator->field;
        $validator->name     = strtr( $name, array('['=>'_', ']'=>'_'));
        $validator->form     = $this->name;
        $validator->max      = $validator->max ?? 0;
        $this->validations[] = $validator;
        return $name;
    }
    
    public function getFormControlFields()
    {
        return $this->formControlFields;
    }
 
    public function getFieldFromFields($fieldName, $fields)
    {
        $field = NULL;
 
        foreach ( (array) $fields as $f )
        {
            if ( $f instanceof MTabbedBaseGroup )
            {
                $field = $this->getFieldFromFields($fieldName, $f->getTabs());
            }
            elseif ( $f instanceof MContainer )
            {
                $field = $this->getFieldFromFields($fieldName, $f->getControls());
            }
            elseif ( $f instanceof MDiv )
            {
                $field = $this->getFieldFromFields($fieldName, $f->getInner());
            }
            elseif ( is_object($f) && ($f->name == $fieldName) )
            {
                $field = $f;
                break;
            }
 
            if ( $field )
            {
                break;
            }
        }
 
        return $field;
    }
 
    function SetValidators($validators)
    {
        if (is_array($validators))
        {
            foreach($validators as $v)
            {
                if ( !is_null($v) )
                {
                    $this->AddValidator($v);
                }
            }
        }
        elseif (is_subclass_of( $validators, 'validator'))
        {
            $this->AddValidator($validators);
        }
    }
 
 
    function IsSubmitted()
    {
        $isSubmitted = $this->defaultButton && MForm::getFormValue(FORM_SUBMIT_BTN_NAME);
        if (isset($this->buttons))
        {
            foreach($this->buttons as $b)
            {
                $isSubmitted = $isSubmitted || MForm::GetFormValue($b->name);
            }
        }
        return $isSubmitted;
    }
 
 
    function GetTitle()
    {
        return $this->title;
    }
 
 
    function SetTitle($title)
    {
        $this->title = $title;
        $this->caption = $title;
        $this->box->SetCaption($title);
    }
 
    function SetClose($action)
    {
        if ($this->box->boxTitle != NULL)
        {
           $this->box->boxTitle->SetClose($action);
        }
    }
 
 
    public function SetIcon($icon)
    {
        if ($this->box->boxTitle != NULL)
        {
            $this->box->boxTitle->SetIcon($icon);
        }
    }
 
    function SetAlternate($color0, $color1)
    {
        $this->zebra = array($color0, $color1);
    }
 
 
    function GetFooter()
    {
        return $this->footer;
    }
 
    function SetFooter($footer)
    {
        $this->footer = $footer;
    }
 
 
    function GetFormFields()
    {
       $this->_GetFormFieldValue($this->fields);
    }
 
 
    function _GetFormFieldValue($field)
    {
        if ( is_array($field) )
        {
            foreach($field as $f)
            {
                $this->_GetFormFieldValue($f);
            }
        }
        else
        {
            if ($field instanceof MFormControl)
            {
                if ( $field->name )
                {
                    $defvalue = $field->GetValue();
                    $value = $this->page->Request($field->name);
                    if ( ($field instanceof MCheckBox) || ($field instanceof MRadioButton) )
                    {
                       $field->checked = (isset($value) ? ($value == $field->value) : $field->checked);
                    }
                    else
                    {
                       $field->SetValue(isset($value) ? $value : $defvalue);
                    }
                }
            }
        }
    }
 
 
    function GetFormValue($name = null ,$value=NULL)
    {
        $result = '';
        if ( ($name != '') && ((strpos($name,'[')) === false))
        {
           $result = MIOLO::_REQUEST($name, 'ALL');
        }
        if (! isset($result))
        {
            $result = $value;
        }
 
        return $result;
    }
 
 
    function SetFormValue($name,$value)
    {
        $value = $this->EscapeValue($value);
 
        if ( $this->$name )
        {
            $this->$name->SetValue($value);
        }
 
        $_REQUEST[$name] = $value;
    }
 
 
    private function /* PRIVATE */ EscapeValue($value)
    {
        if ( is_array($value) )
        {
            for ( $i=0, $n = count($value); $i < $n; $i++ )
            {   
                $val = htmlentities($value[$i], ENT_QUOTES);
                $value[$i] = $this->EscapeValue($val);
            }
        }
        else
        {
            $value = str_replace('\"','&quot;',$value);
            $value = str_replace('"','&quot;',$value);
            $value = htmlentities($value, ENT_QUOTES);
        }
 
        return $value;
    }
 
 
    function OnSubmit($jscode)
    {
        $this->page->OnSubmit($jscode);
    }
 
 
    function AddJsCode($jscode)
    {
        $this->page->AddJsCode($jscode);
    }
 
 
    function SetAction($action)
    {
        $this->action = $action;
    }
 
 
    function setHelp($help, $module=null, $action=null)
    {
        $MIOLO = MIOLO::getInstance();
        if ($this->box->boxTitle != NULL)
        {
            if ( $action != null )
            {
                //Verifica actions de relatorios generic e generate
                $action = $this->normalizaActionParaConsulta($action);
                $content = MTransaction::getNameTransaction($action, $module);
                
                if ( strlen($content) > 0 )
                {
                    $content = $MIOLO->getConf('options.urlHelp').$content;
                }
            }
            else
            {
                $content = $help;
            }
 
            $this->box->boxTitle->setHelp($content);
        }
        else
        {
            $this->help = $help;
        }
    }
 
    private function /*PRIVATE*/ GetFields()
    {
        return $this->fields;
    }
 
 
    function SetFields(&$fields)
    {
        $this->fields = array();
        if (!is_array($fields)) $fields = array($fields);
        $this->layout = $fields;
        $this->_RegisterField($fields);
        
        $this->setRandomField();
    }
 
 
    private function _RegisterField($field, $isNotFormControl = false)
    {
        if ( is_array($field) )
        {
            for ( $i=0, $n = count($field); $i < $n; $i++ )
            {
                $this->_RegisterField($field[$i], $isNotFormControl);
            }
        }
        elseif ($field instanceof MDiv)
        {
            $namefield = $field->id;
            $this->$namefield = $field;
 
            $field = $field->getInner();
 
            if(is_array($field) || is_object($field) )
            {
                return $this->_registerField($field, $isNotFormControl);
            }
        }
        else
        {
            $field instanceof MFormControl;
            $field->form = $this;
            
            if ( method_exists($field, 'setFieldForm') )
            {
                $field->setFieldForm($this);
                $this->formControlFields[ $field->getName() ] = $field;
            }
            
            $className = $field->className;
            if ($field instanceof MFileField)
            {
                $this->enctype='multipart/form-data';
                $this->page->setEnctype($this->enctype);
            }
            if ($field->name == $field->id)
            {
                $namefield = $field->name;
            }
            else
            {
                $namefield = $field->id;
            }
            $this->manager->Assert(!isset($this->$namefield), "Err: property [$namefield] already in use in the form [$this->title]! Choose another name to [$namefield].");
            $this->$namefield = $field;
 
 
            if ($field instanceof MFormControl)
            {
                $value = $this->page->Request($field->name);
                if ( ($field instanceof MCheckBox) || ($field instanceof MRadioButton) )
                {
                    // set checked flag of checkbox or radiobutton if the value matches
                    $field->checked = $this->page->isPostBack() ? ($value == $field->value) : $field->checked;
                }
                elseif ( ($field instanceof MIndexedControl) )
                {
                    $this->AddFields($field->controls);
                    $field->SetValue($value);
                }
                elseif (($field instanceof MInputGrid))
                {
                    $field->SetValue($value);
                }
                elseif ( $field->value == '' )
                {
                    $field->SetValue($value);
                    if ($field instanceof MContainer)
                    {
                        $this->_RegisterField($field->GetControls(), true);
                    }
                    else
                    {
                        $field->SetValue($this->EscapeValue($field->value));
                    }
                }
            }
         }
    }
 
 
    function AddField($field,$hint=false)
    {
        if ( $hint )
        {
            $field->SetHint($hint);
        }
        $this->_RegisterField($field);
        $this->layout[] = $field;
//        $this->fields[] = $field;
    }
 
 
    function AddFields($fields)
    {
        if (is_array($fields))
        {
           foreach($fields as $f)
              $this->AddField($f);
        }
    }
 
 
    function AddButton($btn)
    {
        if (strtoupper($btn->action == 'REPORT'))
        {
           $this->page->hasReport = true;
        }
        $this->buttons[] = $this->{$btn->GetId()} = $btn;
    }
 
 
    function SetButtons($btn)
    {
        if ( is_array($btn) )
        {
            for ( $i=0, $n = count($btn); $i < $n; $i++ )
            {
                $this->SetButtons($btn[$i]);
            }
        }
        else
        {
           $this->AddButton($btn);
        }
    }
 
    public function setButtonLabel( $index, $label )
    {
        $this->buttons[$index]->label = $label;
    }
 
    public function showReturn( $state )
    {
        $this->setShowReturnButton( $state );
    }
 
    public function setShowReturnButton( $state )
    {
        $this->return = $state;
    }
 
    public function setShowPostButton( $state )
    {
        $this->defaultButton = $state;
    }
 
    public function showReset( $state )
    {
        $this->setShowResetButton( $state );
    }
 
    public function setShowResetButton( $state )
    {
        $this->reset = $state;
    }
 
    public static function getShowHints()
    {
        return self::$showHints;
    }
 
    public static function setShowHints($state)
    {
        self::$showHints = $state;
    }
 
    public function showHints($state)
    {
        self::setShowHints($state);
    }
 
 
    function GetFieldList()
    {
        return $this->_GetFieldList($this->fields);
    }
 
    private function _GetFieldList($allfields)
    {
        $fields = array();
        foreach ($allfields as $f )
        {
            if ( is_array($f) )
            {
                foreach ( $f as $a )
                {
                    if (is_a($a,'BaseLabel')) continue;
                    $fields[] = $a;
                }
            }
            else
            {
                if ( is_a($f,'BaseLabel') || is_null($f->value) ) continue;
                $fields[] = $f;
            }
        }
        return $fields;
    }
 
    function ClearFields()
    {
        $this->fields = NULL;
        $this->layout = NULL;
    }
 
    function ClearButtons()
    {
        $this->buttons = NULL;
    }
 
    function validateAll( $assert=true )
    {
        foreach ( $this->getFieldList() as $f )
        {
            if ( $f->name )
            {
                $required[] = $f->name;
            }
        }
        return $this->validate($required, $assert);
    }
 
    function validateRequiredFields( $assert=true )
    {
        foreach ( $this->getFieldList() as $f )
        {
            if ( $f->required )
            {
                $required[] = $f->name;
            }
        }
        return $this->Validate( $required, $assert );
    }
 
    function validate( $required, $assert=true, $args = NULL)
    {   global $MIOLO,$HTTP_POST_VARS;
 
        $this->errors = array();
        // collect fields by label
        foreach ( $this->getFieldList() as $f )
        {
            $fields[$f->name] = $f->name;
        }
        foreach ( $required as $r )
        {
            $name  = $r;
            $label = $fields[$name];
            $MIOLO->Assert( $label,
                            "ERROR: Required field [<b><font color=red>$name</font></b>] is not defined in form!" );
 
            $value = $this->getFormValue( $name );
            if ( $value === '' || (is_null($value)) )
            {
                $this->errors[] = "<b>$label</b> " . _M("was not informed!");
            }
        }
        if ( $assert && count($this->errors) )
        {
            $theme =& $MIOLO->getTheme();
            $theme->setContent( $this );
            $theme->generate();
        }
        return count( $this->errors ) == 0;
    }
 
    function Error( $err )
    {   global $MIOLO;
 
        $MIOLO->logMessage('[DEPRECATED] Call method Form::Error() is deprecated -- use Form::AddError() instead!');
        $this->addError( $err );
    }
 
    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 HasErrors()
    {
        return $this->errors ? count($this->errors) : 0;
    }
 
 
    function AddInfo($info)
    {
        if ( $info )
        {
            if ( is_array($info) )
            {
                if ( $this->infos )
                {
                    $this->infos = array_merge($this->infos,$info);
                }
 
                else
                {
                    $this->infos = $info;
                }
            }
            else
            {
                $this->infos[] = $info;
            }
        }
    }
 
 
    function HasInfos()
    {
        return $this->infos ? count($this->infos) : 0;
    }
 
    function AddAlert($alert)
    {
        if ( $alert )
        {
            if ( is_array($alert) )
            {
                if ( $this->alerts )
                {
                    $this->alerts = array_merge($this->alerts,$alert);
                }
 
                else
                {
                    $this->alerts = $alert;
                }
            }
            else
            {
                $this->alerts[] = $alert;
            }
        }
    }
 
 
    function HasAlerts()
    {
        return $this->alerts ? count($this->alerts) : 0;
    }
 
 
 
    function CollectInput($data)
    {
        foreach ( $this->GetFieldList() as $f )
        {
            $field = $f->name;
            if ( $f instanceof MSubDetail )
            {
                $data->$field = MSubDetail::getData($field);
            }
            else
            {
                if ( $field != '' )
                {
                    $value = $this->GetFormValue($field);
                    $data->$field = $value;
                }
            }
        }
        return $data;
    }
 
    function getData()
    {
        return $this->collectInput( new FormData() );
    }
 
    public function getRequestData()
    {
        return (object) $_REQUEST;
    }
 
    function SetData($data)
    {
        $this->_SetData($data);
    }
 
 
    private function _SetData($data)
    {
        foreach( $this->fields as $i=>$field) // ( $i=0, $n = count($this->fields); $i < $n; $i++ )
        {
            $name = $this->fields[$i]->name;
            if ( $name )
            {
                if ( ($this->fields[$i] instanceof MRadioButton) ||
                     ($this->fields[$i] instanceof MCheckBox) )
                {
                    $this->fields[$i]->checked = ( $data->$name == $this->fields[$i]->value );
                }
                elseif ( $field instanceof MSubDetail )
                {
                    MSubDetail::setData($data->$name, $name);
                }
                else
                {
                    $value = $data->$name;
 
                    if ( method_exists($this->fields[$i], 'setValue') )
                    {
                        $this->fields[$i]->setValue($value);
                    }
 
                    $_POST[$name] = $value;
                }
            }
        }
    }
 
 
    function GetFieldValue($name,$value=false)
    {
        $field = $this->fields[$name];
        return ($field ? $field->GetValue() : NULL);
    }
 
 
    function SetFieldValue($name, $value)
    {
        $field = $this->fields[$name];
 
        if( method_exists($field, 'setValue') )
        {
            $field->setValue( $value );
        }
    }
 
 
    function SetFieldValidator($name,$value)
    {
        for ( $i=0, $n = count($field); $i < $n; $i++ )
        {
            if ( $name == $this->fields[$i]->name )
            {
                $this->fields[$i]->validator = $value;
                break;
            }
        }
    }
 
 
    function & GetField($name)
    {
        return $this->fields[$name];
    }
 
 
    function & GetButton($name)
    {
        for ( $i=0, $n = count($this->buttons); $i < $n; $i++ )
        {
            if ( $name == $this->buttons[$i]->name )
            {
                return $this->buttons[$i];
            }
        }
    }
 
 
    function & GetPage()
    {
        return $this->page;
    }
 
 
    function SetPage(&$page)
    {
        $this->page = &$page;
    }
 
 
    function SetFieldAttr($name,$attr,$value)
    {
//      $field = $this->$name;
//      $field->$attr = $value;
        $this->fields[$name]->$attr = $value;
    }
 
 
    function GetFieldAttr($name,$attr, $index=NULL)
    {
        $field = $this->fields[$name];
        if ( is_array($field->$attr) )
        {
            $a = $field->$attr;
            $value = $a[$index];
        }
        else
        {
          $value = $field->$attr;
        }
        return $value;
    }
 
 
    function SetButtonAttr($name,$attr,$value)
    {
        $button = &$this->GetButton($name);
        $button->$attr = $value;
    }
 
 
    function SetFieldCSS($name,$top,$left,$width=NULL, $position='absolute')
    {
        $field = $this->$name;
//        $top = $this->box->top + $top;
//        $left = $this->box->left + $left;
        if ($width)
        {
            $field->width = "{$width}px";
        }
        $field->top      = "{$top}px";
        $field->left     = "{$left}px";
        if ($position) $field->position = $position;
        $field->formMode = 2;
    }
 
 
 
    function SetFormCSS($height=0, $width=0, $top=0, $left=0, $buttons=0, $position='absolute')
    {
        if ($height)   $this->box->AddStyle('height',"{$height}px");
        if ($width)    $this->box->AddStyle('width',"{$width}px");
        if ($top)      $this->box->AddStyle('top',"{$top}px");
        if ($left)     $this->box->AddStyle('left',"{$left}px");
        if ($position) $this->box->AddStyle('position',$position);
        $this->cssButtons = "{$buttons}px";
        $this->cssForm    = true;
    }
 
    function SetBackgroundColor($bgcolor)
    {
        $this->bgColor = $bgcolor;
    }
 
    function SetAlign($value)
    {
        $this->align = $value;
    }
 
    function SetWidth($width=NULL)
    {
        if ($width) $this->box->AddStyle('width',"{$width}");
    }
 
    function SetHeight($height=NULL)
    {
        if ($height) $this->box->AddStyle('height',"{$height}");
    }
   function SetLabelWidth($width)
   {
       $this->labelWidth = $width;
   }
 
   function GenerateErrors()
   {
        $prompt = Prompt::Error($this->errors,'NONE','Erros');
        return $prompt;
   }
 
 
   function GenerateInfos()
   {
        $prompt = Prompt::Information($this->infos,'NONE','Informações');
        return $prompt;
   }
   
   function GenerateAlerts()
   {
        $prompt = Prompt::Alert($this->alerts,'NONE','Alertas');
        return $prompt;
   }
 
 
 
   function GenerateBody()
   {
        global $MIOLO;
 
        $row = 0;
        $t = array();
        // optionally generate errors
        if ( $this->HasErrors() )
        {
            $t[] = $this->GenerateErrors();
        }
        if ( $this->HasInfos() )
        {
            $t[] = $this->GenerateInfos();
        }
        if ( $this->HasAlerts() )
        {
            $t[] = $this->GenerateAlerts();
        }
        $hidden = null;
        $t = array_merge($t, $this->GenerateLayoutFields($hidden));
 
        if( method_exists($this->page,'getLayout') )
        {
            $layout = $this->page->theme->GetLayout();
        }
        else
        {
            $layout = $this->manager->theme->GetLayout();
        }
 
        if ( $layout != 'print')
        {
           $buttons = $this->GenerateButtons();
           if ($buttons)
           {
              $t = array_merge($t,array($buttons));
           }
        }
        if ( $hidden )
        {
           $t = array_merge($t,$this->GenerateHiddenFields($hidden));
        }
        $t = array_merge($t,$this->GenerateScript());
//        $t[] = new MDiv('','&nbsp;','m-spacer');
        $body = new MDiv('',$t);
        return $body;
   }
 
 
   function GenerateFooter()
   {
   }
 
 
   function GenerateLayoutFields(&$hidden)
   {
       $line = 0;
       $zebra = is_array($this->zebra);
       $t = array();
       if (is_array($this->layout))
       {
           $this->generateValidators($this->layout);
           foreach ( $this->layout as $f )
           {
               $row = $t[] = $this->GenerateLayoutField($f, $hidden);
               if ($zebra)
               {
                   $row->AddStyle('backgroundColor', $this->zebra[($line++) % 2]);
               }
           }
       }
       return $t;
   }
 
    public function generateValidators($fields)
    {
        foreach ( $fields as $field )
        {
            if ( $field instanceof MContainer )
            {
                $this->generateValidators($field->getControls());
            }
            elseif ( $field instanceof MDiv )
            {
                $this->generateValidators((array)$field->getInner());
            }
            elseif ( $field->validator != NULL && $field->validator instanceof MValidator )
            {
                $this->addValidator($field->validator);
                $validator = $this->getFieldValidator($field->name);
 
                if ( $validator )
                {
                    $field->validator = $validator;
                }
            }
            elseif ( $field instanceof MFormControl )
            {
                $field->validator = $this->getFieldValidator($field->name);
            }
        }
    }
 
    public function getFieldValidator($name)
    {
        foreach ( $this->validations as $validator )
        {
            if ( $validator && $validator->field == $name )
            {
                return $validator;
            }
        }
 
        return false;
    }
    
    public function getFieldValidators($name)
    {
        $list = array();
 
        foreach( $this->validations as $validator )
        {
            if ( $validator && $validator->field == $name )
            {
                $list[] = $validator;
            }
        }
 
        return $list;
    }
 
    public function removeAJAXValidator($fieldId)
    {
        // Unique identifier. Remove [] to avoid javascript errors.
        $identifier = str_replace(']', '_', str_replace('[', '_', $fieldId));
        
        $identifier = str_replace('.', '_', $identifier);
 
        $this->page->addAJAXJsCode("delete window.MIOLO_validators.$identifier;");
    }
 
    public function GenerateLayoutField($field, &$hidden)
    {
        if ( is_array($field) )
        {
            $c = array();
            foreach ( $field as $fld )
            {
                if ( $fld->visible )
                {
                    $c[] = $fld;
                }
            }
            $field = new MHContainer('', $c);
            $field->showLabel = true;
        }
 
        if ( !$field->visible )
        {
            return;
        }
 
        $rowContent = NULL;
        $label = $field->label;
        if ( ( ( ($field->className == 'textfield') || ($field->className == 'mtextfield')) && ($field->size == 0) ) || ($field instanceof MHiddenField) )
        {
            $hidden[] = $field;
            return;
        }
        if ( $field->maintainstate )
        {
            $hidden[] = $field;
        }
        if ( $field->cssp )
        {
            return $field;
        }
 
        if ( ($field->formMode != MFormControl::FORM_MODE_SHOW_SIDE) ||
           ( ($field->formMode == MFormControl::FORM_MODE_SHOW_SIDE) && (! $label)) )
        {
            $rowContent = $field;
        }
        else
        {
            //FIXME: Nao processar label aqui, ao invez disso chamar $field->generateLabel()
 
            if ( $label != '' && $label != '&nbsp;' && $label[strlen($label)-1] != ':' )
            {
                $label .= ':';
            }
 
            if ( $label != '' )
            {
                if ( $field->id != '' )
                {
                    $lbl = new MFieldLabel($field->id, $label);
                    $lbl->setClass(MControl::CLASS_CAPTION);
                }
                else
                {
                    $lbl = new MSpan('', $label, MControl::CLASS_CAPTION);
                }
 
                if ( $field->validator )
                {
                    if ( $field->validator->type == 'required' )
                    {
                        $lbl->setClass( MControl::CLASS_CAPTION_REQUIRED );
                    }
                    elseif ( is_array($this->validations) )
                    {
                        // checks if there is at least one required validator to put
                        // or not a required label (*)
                        foreach ( $this->validations as $validator )
                        {
                            if ( $validator && $validator->field == $field->name && $validator->type == 'required' )
                            {
                                $lbl->setClass( MControl::CLASS_CAPTION_REQUIRED );
                                break;
                            }
                        }
                    }
                }
                elseif ( $field instanceof MContainer && $field->showRequiredLabel )
                {
                    $lbl->setClass( MControl::CLASS_CAPTION_REQUIRED );
                }
 
                $slbl = $rowContent[] = new MSpan('', $lbl, 'label');
                if ( $this->labelWidth != NULL )
                {
                    $slbl->_AddStyle('width', $this->labelWidth . 'px');
                }
            }
 
            $sfld = new MSpan('', $field, 'field');
            $rowContent[] = $sfld;
        }
        return new MDiv('', $rowContent, "m-form-row row");
    }
 
    function GenerateButtons()
    {
           $ul = new MUnorderedList();
           if (isset($this->buttons) )
           {
              $ul->AddOption(new MHr);
              foreach ( $this->buttons as $b )
              {
                 if ($b->visible) $ul->AddOption($b);
              }
           }
           if ( $this->reset )
           {
              $ul->AddOption(new MButton('_reset','Limpar','RESET'));
           }
           if ( $this->return )
           {
              $ul->AddOption(new MButton('_return','Voltar','RETURN'));
           }
           $d = (count($ul->options) ? new MDiv('',$ul,'m-form-button-box') : NULL);
           return ($d ? new MDiv('', $d, 'm-form-row row') : NULL);
    }
 
 
    function GenerateHiddenFields($hidden)
    {
        $f[] = "\n<!-- START OF HIDDEN FIELDS -->\n";
        foreach ( $hidden as $h )
        {
            $f[] = new HiddenField($h->name,$h->value);
        }
        $f[] = "\n<!-- END OF HIDDEN FIELDS -->";
        return $f;
    }
 
 
    function GenerateScript()
    {
        $f = array();
        if ( $this->validations )
        {
            // we generate the form onSubmit handler right in the body of the form
            $f[] = "\n<!-- START OF FORM SCRIPT CODE -->\n";
            $f[] =  "<script language=\"JavaScript\">\n";
//            echo "document.{$this->name}.elements[0].focus();\n";
            $this->OnSubmit("MIOLO_Validate_Input()");
            $f[] =  "\n";
            $f[] =  "/*\n";
            $f[] =  " * MIOLO Form Validation Objects\n";
            $f[] =  "*/\n";
            foreach ( $this->validations as $v )
            {
                $f[] = $v;
                $f[] = "\n";
            }
            $f[] = "var {$this->name}_validations = Array( ";
            $i   = 0;
            foreach ( $this->validations as $v )
            {
                if ( $i++ )
                {
                    $f[] = ",\n                                ";
                }
                $f[] = str_replace('.', '_', $v->name);
            }
            $f[] = " );\n";
            $f[] = "\n";
            $f[] = "</script>\n";
            $f[] = "<!-- END OF FORM SCRIPT CODE -->\n";
        }
        return $f;
    }
 
    function generateAJAXValidators()
    {
        $f = '';
        $f .= "\n<!-- START OF FORM SCRIPT CODE -->\n";
        $f .=  "<script language=\"JavaScript\">\n";
        if ( $this->validations )
        {
            $f .= "document.forms[0].onsubmit = function () { return MIOLO_Validate_Input(); }";
            $f .=  "\n";
            $f .=  "/*\n";
            $f .=  " * MIOLO Form Validation Objects\n";
            $f .=  "*/\n";
            foreach ( $this->validations as $v )
            {
                $f .= $v->generate();
                $f .= "\n";
            }
            $f .= "var {$this->name}_validations = Array( ";
            $i   = 0;
            foreach ( $this->validations as $v )
            {
                if ( $i++ )
                {
                    $f .= ",\n                                ";
                }
                $f .= str_replace('.', '_', $v->name);
            }
            $f .= " );\n";
            $f .= "\n";
        }
        else
        {
            $f .= "var {$this->name}_validations = Array();";
            $f .= "document.forms[0].onsubmit = function () { return MIOLO_Validate_Input(); }";
        }
        $f .= "</script>\n";
        $f .= "<!-- END OF FORM SCRIPT CODE -->\n";
        echo $f;
    }
 
    function Generate()
    {
        if (!isset($this->buttons))
        {
            if ($this->defaultButton)
            {
                $this->buttons[] = new FormButton(FORM_SUBMIT_BTN_NAME, 'Enviar', 'SUBMIT');
            }
        }
        $footer = $this->GenerateFooter();
        if ($this->cssForm)
        {
            $body = $this->GenerateBody();
            $this->box->SetControls(array($body));
            $this->box->SetBoxClass('m-form-css');
            return $this->box->Generate();
        }
        else
        {
            $body = new MDiv('',$this->GenerateBody(),'m-form-body panel-body card-body');
            if (!is_null($this->bgColor)) $body->AddStyle('backgroundColor',$this->bgColor);
            $this->box->SetControls(array($body, $footer));
            $id   = strlen($this->id) > 0 ? $this->id : $this->GetUniqueId();
            $this->box->SetBoxClass("m-form-outer");
            $form = new MDiv("frm$id", $this->box,"m-form-box");
            if (!is_null($this->align)) $form->AddBoxStyle('text-align',$this->align);
            return $form->Generate();
//            return $this->box->Generate();
        }
    }
    
    protected function getGrid($campos = array(), $gridName = NULL)
    {
        $grid = null;
        
        // Navega entre os campos
        foreach ( $campos as $field )
        {
            // Verifica se o campo é uma grid, caso seja um container
            // verifica os elementos que compõe este recursivamente
            $grid = $this->procuraGrid($field, $gridName);
 
            if( $grid )
            {
                break;
 
            }
 
        }
 
        return $grid;
        
    }
    
    protected function procuraGrid($field, $gridName)
    {
        // Se é a grid
        if ( is_subclass_of($field, "MGrid") && $field->name == $gridName )
        {
            return $field;
 
        }
        
        $camposAtuais = $this->getCamposConformeContainer($field);
        
        // Se há campos no container
        if( $camposAtuais )
        {
            return $this->getGrid($camposAtuais, $gridName);
 
        }
        
        return null;
        
    }
    
    protected function getCamposConformeContainer($field)
    {
        $camposAtuais = null;
        
        if( $field instanceof MDiv)
        {
            $camposAtuais = $field->getInner();
 
        }
        else if( $field instanceof MTab)
        {
            $camposAtuais = $field->getControls();
 
        }
        else if( $field instanceof MTabbedBaseGroup)
        {
            $camposAtuais = $field->getTabs();
 
        }
        
        return $camposAtuais;
        
    }
    
    public function getGridQuery($gridName)
    {
        $grid = $this->getGrid($this->fields, $gridName);
        
        if ( !$grid )
        {
            return;
        }
        
        return is_subclass_of($grid, "MGrid") ? $grid->getQuery() : null;
    }
    
    public function getGridData($gridName)
    {       
        $grid = $this->getGrid($this->fields, $gridName);
        
        if ( !$grid )
        {
            return;
        }
        
        $isArrayGridMode = !isset($grid->columns[0]); // Modo array associativo de grids
        $titles = array();
        
        foreach ($grid->columns as $index => $c)
        {
            if ( $c->visible )
            {
                $titles[] = $c->title;
            }
            else
            {
                $invisibleColumns[] = $index;
            }
        }
        
        $data = $grid->getData();
        if ( !$data )
        {
            return;
        }
        
        $titleCount = count($titles);
        $visibleData = array();
        foreach ( $data as $line )
        {
            if ( $invisibleColumns )
            {
                // Remove invisible columns
                foreach ( $invisibleColumns as $index )
                {
                    unset( $line[$index] );
                }
            }
            
            $newLine = array();
            if ( $isArrayGridMode )
            {
                $keys = array_keys($grid->columns);
                
                foreach ( $keys as $columnName )
                {
                    if( !in_array($columnName, $invisibleColumns) )
                    {
                        // Caso exista um options na grid, substitui o valor
                        if ( $grid->columns[$columnName]->options )
                        {
                            $line[$columnName] = $grid->columns[$columnName]->options[$line[$columnName]];
                        }
 
                        $newLine[] = $line[$columnName];
                    }
                }
            }
            else
            {
                $newLine = array_values(array_slice($line, 0, $titleCount));                 
            }
 
            $visibleData[] = $newLine;
        }
 
        $titles = array_values( $titles );
        return array_merge( array($titles), $visibleData );
    }
 
    public function addCustomFields($identifier, $customizedId=NULL, $suffix='', $somenteComActionUrl = false)
    {
        $fields = $this->getCustomFields($identifier, $customizedId, $suffix, $somenteComActionUrl);
 
        if ( count($fields) > 0 )
        {
            $this->addFields( $fields );
        }
    }
    
    public function getCustomFields($identifier, $customizedId=NULL, $suffix='', $somenteComActionUrl = false, $step = null)
    {
        $MIOLO = MIOLO::getInstance();
 
        if ( !$identifier )
        {
            return;
        }
 
        $this->mioloCustomizedId = $customizedId;
        
        // If customized id is set, then it's an edit action
        if ( isset($customizedId) )
        {
            // Load the custom fields values
            $data = MCustomValue::getFieldValues($identifier, $customizedId);
        }
 
        $actionURL = null;
        if( $somenteComActionUrl )
        {
            $actionURL = MIOLO::getCurrentAction();
        }
        $this->mioloCustomFields = MCustomField::listByIdentifier($identifier, $actionURL, $step);
 
        $fieldsNormalizados = $this->normalizaCamposCustomizados($this->mioloCustomFields);
 
        $fields = $this->generateCustomFields($fieldsNormalizados, $data, $suffix);
 
        return $fields;
    }
 
    protected function normalizaCamposCustomizados($customFields)
    {
        return $customFields;
    }
    
    public function generateCustomFields($mioloCustomFields = array(), $data = null, $suffix = null)
    {
        $fields = array();
        
        $listNoYes = array(
            'f' => _M('No'),
            't' => _M('Yes'),
        );
        
        foreach ( $mioloCustomFields as $cfield )
        {
            $cfield instanceof MCustomField;
            
            $field = NULL;
            $validator = NULL;
 
            $cfield->suffix = $suffix;
            $id = $cfield->getInputId();
 
            $value = $this->GetFormValue($id, isset($data) && isset($data->$id) ? $data->$id : $cfield->defaultValue);
            $label = _M($cfield->label, MIOLO::getCurrentModule());
 
            if ( $cfield->isRequired() )
            {
                $validator = new MRequiredValidator($id, $label);
            }
 
            switch ( $cfield->fieldFormat )
            {
                case MCustomField::FORMAT_BOOLEAN:
                    $field = new MSelection($id, MUtil::getBooleanValue($value) ? 't' : 'f', $label, $listNoYes, false, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    break;
 
                case MCustomField::FORMAT_DATE:
                    $field = new MCalendarField($id, $value, $label, 20, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
 
                    if ( $cfield->isRequired() && $cfield->isEditable() && $cfield->isVisible() )
                    {
                        $field->isRequired = 'true';
                        $validator = NULL;
                    }
                    break;
 
                case MCustomField::FORMAT_DECIMAL:
                    $field = new MFloatField($id, $value, $label, 10, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    break;
 
                case MCustomField::FORMAT_INTEGER:
                    $field = new MTextField($id, $value, $label, strlen($cfield->largura) > 0 ? $cfield->largura : 10, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    $validator = new MIntegerValidator($id, $label, $cfield->isRequired() ? 'required' : 'optional');
                    break;
 
                case MCustomField::FORMAT_SESCOLHA:
                    $field = new sEscolha($id, $value, $label, new $cfield->objetoreferencia(), $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    break;
 
                case MCustomField::FORMAT_LIST:
                    $field = new MSelection($id, $value, $label, $cfield->getListValues(), false, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    break;
                
                case MCustomField::FORMAT_LISTSQL:
                    $field = new MSelection($id, $value, $label, $cfield->getListSQL());
                    $field->hint = $cfield->getFieldHint() ?? $cfield->hint;
                    $field->setJsHint($cfield->jshint);
                    break;
 
                case MCustomField::FORMAT_MTAG:
                    if (isset($value) && SAGU::is_json($value))
                    {
                        $value = json_decode($value);
                    }
 
                    $field = new MTagSelection($id, $value, $label, $cfield->getListSQL(), false, '', '3', 1);
                    $field->hint = $cfield->getFieldHint() ?? $cfield->hint;
                    if (!empty($cfield->jshint))
                    {
                        $field->addAttribute('title', $cfield->jshint);
                    }
                    
                    break;
 
                case MCustomField::FORMAT_MULTI_LIST:
                    $selectValues = $cfield->getListValues();
                    $countValues = count($selectValues);
 
                    //Verifica se $value foi definida e se é um json
                    if (isset($value) && SAGU::is_json($value))
                    {
                        $value = json_decode($value);
                    }
 
                    $field = new MTagSelection($id, $value, $label, $selectValues, false, $cfield->hint);
                    $field->size = '10';
                    if (!empty($cfield->jshint))
                    {
                        $field->addAttribute('title', $cfield->jshint);
                    }
                    if ($countValues < 10)
                    {
                        $field->size = $countValues;
                    }
                    break;
 
                case MCustomField::FORMAT_MULTI_LISTSQL:
                    $selectValues = $cfield->getListSQL();
                    $countValues = count($selectValues);
 
                    //Verifica se $value foi definida e se é um json
                    if (isset($value) && sagu::is_json($value))
                    {
                        $value = json_decode($value);
                    }
 
                    $field = new MTagSelection($id, $value, $label, $selectValues);
                    $field->hint = $cfield->getFieldHint() ?? $cfield->hint;
                    if (!empty($cfield->jshint))
                    {
                        $field->addAttribute('title', $cfield->jshint);
                    }
                    $field->size = '10';
                    if ($countValues < 10)
                    {
                        $field->size = $countValues;
                    }
                    break;
 
                case MCustomField::FORMAT_LONG_TEXT:
                    $field = new MMultilineField($id, $value, $label, strlen($cfield->largura) > 0 ? $cfield->largura : 25, strlen($cfield->altura) ? $cfield->altura : 5, strlen($cfield->largura) ? $cfield->largura : 20, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    break;
 
                case MCustomField::FORMAT_TEXT:
                    $field = new MTextField($id, $value, $label, strlen($cfield->largura) > 0 ? $cfield->largura : 10, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    break;
                case MCustomField::FORMAT_SESCOLHA_LIST:
                    $field = new sEscolha($id, $value, $label, null, $cfield->hint, $cfield->getListValues());
                    $field->setJsHint($cfield->jshint);
                    $this->page->addJsCode("$('#" . $id . "').hide();");
                    break;
                case MCustomField::FORMAT_SESCOLHA_LISTSQL:
                    $field = new sEscolha($id, $value, $label, null, $cfield->hint, $cfield->getListSQL());
                    $field->setJsHint($cfield->jshint);
                    break;
                case MCustomField::FORMAT_JAVASCRIPT:
                    $field = new MDiv($id, "<script>" . $value . "</script>");
                    break;
                case MCustomField::FORMAT_FILE:
                    $field = new MFileField($id, $value, $label, strlen($cfield->largura) > 0 ? $cfield->largura : 10, $cfield->hint);
                    $field->setJsHint($cfield->jshint);
                    $field->addAttribute("accept", $cfield->possibleValues);
                    break;
                case MCustomField::FORMAT_EDITOR:
                    $field = new MEditor($id, $value);
                    // $field->setHint($cfield->hint);
                    // $field->setJsHint($cfield->jshint);
                    $field->forceShowLabel = true;
                    $field->setWidth($cfield->largura ?? SAGU::getParameter('BASIC', 'FIELD_EDITOR_SIZE'));
                    break;
                    
            }
 
            if ( $cfield->maxLength != 0 )
            {
                if ( !$validator )
                {
                    $validator = new MRegExpValidator($id, $label);
                }
 
                $validator->min = $cfield->minLength;
                $validator->max = $cfield->maxLength;
            }
 
            if ( $field )
            {
                if ( !$cfield->isEditable() )
                {
                    $field->setReadOnly(true);
                    $validator = NULL;
                }
 
                if ( !$cfield->isVisible() )
                {
                    $field->addBoxStyle('display', 'none');
                    $validator = NULL;
                }
 
                if( in_array($cfield->fieldFormat, [MCustomField::FORMAT_SESCOLHA, MCustomField::FORMAT_SESCOLHA_LIST, MCustomField::FORMAT_SESCOLHA_LISTSQL, MCustomField::FORMAT_EDITOR])  )
                {
                    $fieldLabel = new MLabel($label . ":");
                    $fieldLabel->setClass("m-caption");
                    if($cfield->isRequired())
                    {
                        $fieldLabel->setClass('m-caption m-caption-required');
                    }
                    $fieldLabel->setWidth(SAGU::getParameter('BASIC', 'FIELD_CONTAINER_SIZE'));
                    $field = new MHContainer('htc'.$id, array($fieldLabel, $field));
                }
                $fields[] = $field;
            }
 
            if ( $validator != NULL )
            {
                $this->addValidator($validator);
            }
        }
 
 
 
        return $fields;
    }
 
    public function saveCustomFields($customizedId, $data = null, $identifier = null, $somenteComActionUrl = false, $cfId = null)
    {   
        if ( strlen($identifier) > 0 )
        {
            $this->getCustomFields($identifier, $customizedId, '', $somenteComActionUrl);
        }
 
        if ( count($this->mioloCustomFields) == 0 )
        {
            return NULL;
        }
 
        if (!isset($this->mioloCustomizedId) && isset($customizedId))
        {
            $this->mioloCustomizedId = $customizedId;
        }
        
        // Se nao passar dados, pega o padrao getData()
        if ( !$data )
        {
            $data = $this->getData();
        }
        
        $ok = false;
 
        foreach ( $this->mioloCustomFields as $cf )
        {   
            //se recebeu id só salva este
            if ($cfId != null && $cfId != $cf->id)
            {
                continue;
            }
            
            $cf instanceof MCustomField;
            
            $inputId = $cf->getInputId();
 
            $customValue = new MCustomValue();
            $customValue->customizedId = $customizedId;
            $customValue->customFieldId = $cf->id;
            $customValue->value = $data->$inputId;
            if ($cf->fieldFormat == MCustomField::FORMAT_FILE && is_array($_FILES[$inputId]))
            {   
                if ($_FILES[$inputId]['error'] == UPLOAD_ERR_NO_FILE)
                {
                    continue;
                }
                $busFile = new BusinessBasicBusFile();
                $fdata = new stdClass();
                $fdata->uploadFileName = $_FILES[$inputId]['name'];
                $fdata->contentType = mime_content_type($_FILES[$inputId]['tmp_name']);
                $fileId = $busFile->insertFile($fdata, $_FILES[$inputId]['tmp_name']);
                $customValue->value = $fileId;
            }
 
            //Verifica se é um array
            if (is_array($data->$inputId))
            {
                //Transforma o array em JSON e atribui na variavel
                $customValue->value = json_encode($data->$inputId, JSON_UNESCAPED_UNICODE);
            }
            // If customized id is set, then it's an edit action
            if ( isset($this->mioloCustomizedId) )
            {
                if ( $customValue->updateByData() )
                {
                    $ok = true;
                }
                else
                {
                    $ok = false;
                    break;
                }
            }
            else
            {
                if ( $customValue->insert() )
                {
                    $ok = true;
                }
                else
                {
                    $ok = false;
                    break;
                }
            }
        }
        return $ok;
    }
 
    public function searchCustomFieldValues($identifier, $returnSql = false, $onlyCustomizedid = false, $filters = null)
    {
        if ( !count($this->mioloCustomFields) )
        {
            return NULL;
        }
 
        $searchData = array();
        $values = NULL;
 
        foreach ( $this->mioloCustomFields as $cf )
        {
            $value = MIOLO::_REQUEST($cf->getInputId());
 
            if ( strlen($value) )
            {
                $searchData[$cf->id] = $value;
            }
        }
        $values = MCustomValue::searchFieldValues($identifier, $searchData, $returnSql, $onlyCustomizedid, $filters);
 
        return $values;
    }
    
    public function getCustomFieldValues()
    {
        $values = array();
 
        foreach ( $this->mioloCustomFields as $cf )
        {
            $cf instanceof MCustomField;
            $value = MIOLO::_REQUEST($cf->getInputId());
 
            if ( strlen($value) )
            {
                $values[$cf->getInputId()] = $value;
            }
            elseif ( is_array($value) )
            {
                $i = 0;
                foreach ($value as $customValue)
                {
                    $values[$cf->getInputId()][$i] = $customValue;
                    $i ++;
                }
            }
        }
 
        return $values;
    }
 
    public function deleteCustomFieldValues($customizedId)
    {
        if ( count($this->mioloCustomFields) == 0 )
        {
            return NULL;
        }
 
        $ok = false;
 
        foreach ( $this->mioloCustomFields as $cf )
        {
            $customValue = new MCustomValue();
            $customValue->customizedId = $customizedId;
            $customValue->customFieldId = $cf->id;
 
            $ok = $customValue->deleteByCustomizedId();
        }
 
        return $ok;
    }
    
    public static function expansibleText($labelExpand, $labelCollapse, $text)
    {
        $divLabelExpand = md5($text);
        $divContent = md5($text) . 'b';
        
        $text = str_replace("\n", '<br />', $text);
        
        $html .= '<div id="'.$divLabelExpand.'">
                        <a href="javascript: return;"
                           onclick="document.getElementById(\''.$divContent.'\').style.display=\'block\'; document.getElementById(\''.$divLabelExpand.'\').style.display=\'none\'"
                        >'.$labelExpand.'</a>
 
                     </div>';
        
        $html .= '<div id="'.$divContent.'" style="display: none">
                        <a href="javascript: return;"
                           onclick="document.getElementById(\''.$divContent.'\').style.display=\'none\'; document.getElementById(\''.$divLabelExpand.'\').style.display=\'block\'">'.$labelCollapse.'</a>
                        <pre>' . $text . '</pre>
                     </div>';
        
        return $html;
    }
    
    public static function normalizaActionParaConsulta($action)
    {
        $type = MIOLO::_REQUEST('type');
        
        // verifica action genericReports apenas para documentos e relatórios, configuração não deve adicionar o parâmetro reportid
        if ( strpos($action, 'report:genericReports') !== false || strpos($action, 'document:genericReports') !== false )
        {
            // obtém o parâmetro reportid e concatena ao $action
            $action = $action.'&reportid='.MIOLO::_REQUEST('reportid');
        }
        // verifica action generateReport
        else if ( strpos($action, 'generateReport') !== false )
        {
            // obtém o parâmetro report e concatena ao $action
            $action = $action.'&report='.MIOLO::_REQUEST('report');
        }
        // Verifica se é um formulário dinâmico
        else if ( $type )
        {
            $action .= '&type='.$type;
        }
 
        return $action;
    }
}
 
class FormData
{
}
 
?>