mstepbystepform.class

Ir para a documentação deste ficheiro.

<?php
 
class MStepByStepForm extends MForm
{
    public $steps;
    public $step;
    public $nextStep;
    public $stepName;
    public $prevStep;
    public $data;
    private static $defaultButtons = true;
    private static $showImageOnButtons = false;
 
    const BUTTONS_DIV_ID = 'stepButtonsDiv';
    const BUTTONS_DIV_STYLE = 'm-stepbystep-buttons';
    const BUTTONS_DIV_IMG_STYLE = 'm-stepbystep-buttons-img';
 
    public function __construct($title, $steps = NULL, $step = NULL, $nextStep = NULL)
    {
        $MIOLO = MIOLO::getInstance();
 
        $this->steps = $steps;
        $this->stepName = MIOLO::getCurrentAction();
 
        parent::__construct($title);
        $this->eventHandler();
 
        $this->buttons = array();
        $this->step = $step;
        $this->nextStep = $nextStep;
    }
 
    public function createFields()
    {
        $MIOLO = MIOLO::getInstance();
        $module = MIOLO::getCurrentModule();
 
        parent::createFields();
 
        if ( !self::getCurrentStep() )
        {
            $this->cleanStepData();
        }
 
        $this->step = $this->step ? $this->step : self::getCurrentStep() ? self::getCurrentStep() : 1;
        $this->nextStep = $this->nextStep ? $this->nextStep : $this->step+1;
 
        foreach ( $this->steps as $k => $stp )
        {
            if ( $this->step == $k )
            {
                $type = MStep::TYPE_CURRENT;
            }
            elseif ( $this->step < $k )
            {
                $type = MStep::TYPE_NEXT;
            }
            elseif ( $this->step > $k )
            {
                $type = MStep::TYPE_PREVIOUS;
            }
 
            $stepsDiv[$k] = new MStep($k, $stp, $type);
        }
 
        /*
         * If it has more than five steps shows the first, the previous,
         * the current, the next and the last one.
         */
        if ( count($this->steps) > 5 )
        {
            $asteps[] = $stepsDiv[1];
            if ( $this->step <= 3 )
            {
                $asteps[] = $stepsDiv[2];
                $asteps[] = $stepsDiv[3];
                $asteps[] = $stepsDiv[4];
                $asteps[] = new MDiv(NULL, '...', MStep::HIDE_STYLE);
                $asteps[] = $stepsDiv[count($this->steps)];
            }
            elseif ( $this->step >= (count($this->steps) - 2) )
            {
                $step = count($this->steps) - 2;
                $asteps[] = new MDiv(NULL, '...', MStep::HIDE_STYLE);
                $asteps[] = $stepsDiv[$step - 1];
                $asteps[] = $stepsDiv[$step];
                $asteps[] = $stepsDiv[$step + 1];
                $asteps[] = $stepsDiv[count($this->steps)];
            }
            else
            {
                $asteps[] = new MDiv(NULL, '...', MStep::HIDE_STYLE);
                $asteps[] = $stepsDiv[$this->step - 1];
                $asteps[] = $stepsDiv[$this->step];
                $asteps[] = $stepsDiv[$this->step + 1];
                $asteps[] = new MDiv('', '...', MStep::HIDE_STYLE);
                $asteps[] = $stepsDiv[count($this->steps)];
            }
        }
        else
        {
            $asteps = $stepsDiv;
        }
 
        $fields[] = new MBaseGroup(NULL, NULL, $asteps);
 
        $this->addFields($fields);
    }
 
    public function nextStepButton_click()
    {
        if ( !$this->nextStep )
        {
            $this->nextStep = $this->step ? $this->step + 1 : 2;
        }
 
        $this->prepareData($this->getData());
        self::setCurrentStep($this->nextStep);
 
        $this->redirect(MIOLO::getCurrentModule(), MIOLO::getCurrentAction(), $_GET);
    }
 
    public function previousStepButton_click()
    {
        if ( !$this->prevStep )
        {
            $this->prevStep = $this->step - 1;
        }
 
        if ( $this->prevStep < 1 )
        {
            $this->prevStep = 1;
        }
 
        $this->prepareData($this->getData());
        self::setCurrentStep($this->prevStep);
 
        $this->redirect(MIOLO::getCurrentModule(), MIOLO::getCurrentAction(), $_GET);
    }
 
    public function gotoStep($step)
    {
        self::setCurrentStep($step);
        $this->redirect(MIOLO::getCurrentModule(), MIOLO::getCurrentAction(), $_GET);
    }
 
    public function objectToArray($object)
    {
        if ( count($object) > 1 )
        {
            $arr = array( );
            for ( $i = 0; $i < count($object); $i++ )
            {
                $arr[] = get_object_vars($object[$i]);
            }
            return $arr;
        }
        else
        {
            return get_object_vars($object);
        }
    }
 
    public function getStepName()
    {
        return $this->stepName;
    }
 
    public function setStepName($stepName)
    {
        $this->stepName = $stepName;
    }
 
    public function setStepData($data, $step = null)
    {
        $data = (object) array_merge($this->getStepData($step, false), (array) $data);
        $this->prepareData($data, $step);
    }
 
    public function getStepData($step = null, $returnAsObject = true)
    {
        $stepsData = $this->getAllStepData();
 
        // gets the last step data because it's not on session yet
        if ( $this->isLastStep() )
        {
            $data = self::objectToArray($this->getData());
            $lastStep = array_pop(array_keys($this->steps));
            $stepsData[$lastStep] = $data;
        }
 
        // if a step is given, returns only the specific step data
        if ( $step )
        {
            $data = $returnAsObject ? (object) $stepsData[$step] : $stepsData[$step];
        }
        else
        {
            if ( $returnAsObject )
            {
                $returnData = array();
                foreach ( $stepsData as $key => $data )
                {
                    $returnData = array_merge($returnData, $data);
                }
 
                $data = (object) $returnData;
            }
            else
            {
                $data = $stepsData;
            }
        }
 
        return $data;
    }
 
    public function cleanStepData($step=null)
    {
        if ( $step )
        {
            $stepsData = $this->getAllStepData();
            $stepsData[$step] = NULL;
 
            $this->setAllStepData($stepsData);
        }
        else
        {
            $this->setAllStepData(NULL);
        }
    }
 
    public function prepareData($data = null, $step = null)
    {
        if ( !$step )
        {
            // the first time on the first step, the step is still undefined
            $step = $this->step ? $this->step : 1;
        }
 
        if ( is_object($data) )
        {
            $data = self::objectToArray($data);
        }
 
        // verifies if there is already data on session of this step by step
        $stepData = $this->getStepData(null, false);
 
        // adds the step data array to be saved on session
        $stepData[$step] = $data;
 
        $this->setAllStepData($stepData);
    }
 
    public function setAllStepData($stepData)
    {
        // serializes the data and saves it
        $MIOLO = MIOLO::getInstance();
        $MIOLO->getSession()->setValue($this->getStepName(), serialize($stepData));
    }
 
    public function getAllStepData()
    {
        $MIOLO = MIOLO::getInstance();
        $data = unserialize($MIOLO->getSession()->getValue($this->getStepName()));
        return $data;
    }
 
    public static function getCurrentStep()
    {
        return MIOLO::_REQUEST('step');
    }
 
    public static function setCurrentStep($step)
    {
        $_GET['step'] = $step;
    }
 
    public static function getShowImageOnButtons()
    {
        return self::$showImageOnButtons;
    }
 
    public static function setShowImageOnButtons($showImageOnButtons)
    {
        self::$showImageOnButtons = $showImageOnButtons;
    }
 
    public function getButtons()
    {
        if ( $this->isFirstStep() )
        {
            $buttons = $this->firstStepButtons();
        }
        elseif ( $this->isLastStep() )
        {
            $buttons = $this->lastStepButtons();
        }
        else
        {
            $buttons = $this->innerStepButtons();
        }
 
        return $this->buttonsDiv($buttons);
    }
 
    public function finalizeStepByStep($buttons = NULL)
    {
        $label = _M('Finished step');
 
        $jsCode = "
            document.getElementById('".self::BUTTONS_DIV_ID."').innerHTML = '';
            document.getElementById('stepImage_{$this->step}').className = '".MStep::PREVIOUS_ICON_STYLE."';
            document.getElementById('stepDescription_{$this->step}').innerHTML = '$label'; ";
 
        foreach ( $this->steps as $step => $stepName )
        {
            $jsCode .= "
                var element = document.getElementById('divStep_$step');
                if ( element )
                {
                   element.className = '".MStep::DISABLED_STYLE."';
                   element.onclick = '';
                }";
        }
 
        $this->page->onLoad($jsCode);
 
        if ( $buttons )
        {
            $this->addField($this->buttonsDiv($buttons));
        }
        else
        {
            $div = $this->buttonsDiv(array( new MButton('closeButton', _M('Close')) ));
            $this->addField($div);
        }
    }
 
    public static function setDefaultButtons($defaultButtons)
    {
        self::$defaultButtons = $defaultButtons;
    }
 
    public static function getDefaultButtons()
    {
        return self::$defaultButtons;
    }
 
    public function onLoad()
    {
        if ( self::$defaultButtons )
        {
            $this->addFields(array( $this->getButtons() ));
        }
 
        if ( !$this->isFirstAccess($this->step) )
        {
            parent::setData($this->getStepData($this->step));
        }
    }
 
    public function isFirstStep()
    {
        if ( self::getCurrentStep() == 1 || !self::getCurrentStep() )
        {
            return true;
        }
        else
        {
            return false;
        }
    }
 
    public function isLastStep()
    {
        $lastStep = array_pop(array_keys($this->steps));
        return $lastStep == $this->step;
    }
 
    public function isFirstAccess($step = NULL)
    {
        $MIOLO = MIOLO::getInstance();
 
        if ( !$step )
        {
            $step = $this->step;
        }
 
        $stepsData = $this->getAllStepData();
 
        $data = $stepsData[$step];
 
        // if is set, returns true
        return !$data;
    }
 
    public function cancelButton_click($args)
    {
        $this->redirect(MIOLO::getCurrentModule(), MIOLO::getCurrentAction());
    }
 
    public function finalizeButton_click($args)
    {
        $MIOLO = MIOLO::getInstance();
        $module = MIOLO::getCurrentModule();
        $url = $MIOLO->getActionUrl($module, 'main');
        $buttons[] = new MButton(NULL, _M('Close'), $url);
        $this->finalizeStepByStep($buttons);
    }
 
    public function redirect($module, $action, $args = NULL)
    {
        $MIOLO = MIOLO::getInstance();
        $url = $MIOLO->getActionURL($module, $action, '', $args);
        $MIOLO->page->redirect($url);
    }
 
    public function cancelButton()
    {
        if ( self::$showImageOnButtons )
        {
            $image = MIOLO::getInstance()->getUI()->getImageTheme(MIOLO::getInstance()->getTheme()->id, 'button_cancel.png');
        }
        return new MButton('cancelButton', '<span>'._M('Cancel').'</span>', NULL, $image);
    }
 
    public function nextStepButton()
    {
        if ( self::$showImageOnButtons )
        {
            $image = MIOLO::getInstance()->getUI()->getImageTheme(MIOLO::getInstance()->getTheme()->id, 'button_next.png');
        }
        return new MButton('nextStepButton', '<span>'._M('Next step').'</span>', NULL, $image);
    }
 
    public function previousStepButton()
    {
        if ( self::$showImageOnButtons )
        {
            $image = MIOLO::getInstance()->getUI()->getImageTheme(MIOLO::getInstance()->getTheme()->id, 'button_previous.png');
        }
        return new MButton('previousStepButton', '<span>'._M('Previous step').'</span>', NULL, $image);
    }
 
    public function finalizeButton()
    {
        if ( self::$showImageOnButtons )
        {
            $image = MIOLO::getInstance()->getUI()->getImageTheme(MIOLO::getInstance()->getTheme()->id, 'button_finalize.png');
        }
        return new MButton('finalizeButton', '<span>'._M('Finalize').'</span>', NULL, $image);
    }
 
    public function firstStepButtons()
    {
        return $this->buttonsDiv(array( $this->nextStepButton(), $this->cancelButton() ));
    }
 
    public function innerStepButtons()
    {
        return $this->buttonsDiv(array( $this->nextStepButton(), $this->previousStepButton(), $this->cancelButton() ));
    }
 
    public function lastStepButtons()
    {
        return $this->buttonsDiv(array( $this->finalizeButton(), $this->previousStepButton(), $this->cancelButton() ));
    }
 
    public function buttonsDiv($buttons)
    {
        $class = self::$showImageOnButtons ? self::BUTTONS_DIV_IMG_STYLE : self::BUTTONS_DIV_STYLE;
        $div = new MDiv(self::BUTTONS_DIV_ID, $buttons, $class);
        $div->addBoxStyle('direction', 'rtl');
        $div->addBoxStyle('width', '100%');
        return $div;
    }
}
?>