class.ilTestQuestionNavigationGUI.php

Go to the documentation of this file.

<?php
 
class ilTestQuestionNavigationGUI
{
    public const SHOW_DISABLED_COMMANDS = false;
 
    public const CSS_CLASS_SUBMIT_BUTTONS = 'ilc_qsubmit_Submit';
 
    protected $lng;
 
    private $editSolutionCommand = '';
 
    private $questionWorkedThrough = false;
 
    private $submitSolutionCommand = '';
 
    // fau: testNav - new variable for 'revert changes' link target
    private $revertChangesLinkTarget = '';
    // fau.
 
    private $discardSolutionButtonEnabled = false;
 
    private $skipQuestionLinkTarget = '';
 
    private $instantFeedbackCommand = '';
 
    private $answerFreezingEnabled = false;
 
    private $forceInstantResponseEnabled = false;
 
    private $requestHintCommand = '';
 
    private $showHintsCommand = '';
 
    private $hintRequestsExist = false;
 
    // fau: testNav - change question mark command to link target
    private $questionMarkLinkTarget = '';
    // fau.
 
    private $questionMarked = false;
 
    private $charSelectorEnabled = false;
 
    private $anythingRendered = false;
 
    public function __construct(ilLanguage $lng)
    {
        $this->lng = $lng;
    }
 
    public function getEditSolutionCommand(): string
    {
        return $this->editSolutionCommand;
    }
 
    public function setEditSolutionCommand($editSolutionCommand)
    {
        $this->editSolutionCommand = $editSolutionCommand;
    }
 
    public function isQuestionWorkedThrough(): bool
    {
        return $this->questionWorkedThrough;
    }
 
    public function setQuestionWorkedThrough($questionWorkedThrough)
    {
        $this->questionWorkedThrough = $questionWorkedThrough;
    }
 
    public function getSubmitSolutionCommand(): string
    {
        return $this->submitSolutionCommand;
    }
 
    public function setSubmitSolutionCommand($submitSolutionCommand)
    {
        $this->submitSolutionCommand = $submitSolutionCommand;
    }
 
    // fau: testNav - get/set revertChangesCommand
    public function getRevertChangesLinkTarget(): string
    {
        return $this->revertChangesLinkTarget;
    }
 
    public function setRevertChangesLinkTarget($revertChangesLinkTarget)
    {
        $this->revertChangesLinkTarget = $revertChangesLinkTarget;
    }
    // fau.
 
    public function isDiscardSolutionButtonEnabled(): bool
    {
        return $this->discardSolutionButtonEnabled;
    }
 
    public function setDiscardSolutionButtonEnabled($discardSolutionButtonEnabled)
    {
        $this->discardSolutionButtonEnabled = $discardSolutionButtonEnabled;
    }
 
    public function getSkipQuestionLinkTarget(): string
    {
        return $this->skipQuestionLinkTarget;
    }
 
    public function setSkipQuestionLinkTarget($skipQuestionLinkTarget)
    {
        $this->skipQuestionLinkTarget = $skipQuestionLinkTarget;
    }
 
    public function getInstantFeedbackCommand(): string
    {
        return $this->instantFeedbackCommand;
    }
 
    public function setInstantFeedbackCommand($instantFeedbackCommand)
    {
        $this->instantFeedbackCommand = $instantFeedbackCommand;
    }
 
    public function isAnswerFreezingEnabled(): bool
    {
        return $this->answerFreezingEnabled;
    }
 
    public function isForceInstantResponseEnabled(): bool
    {
        return $this->forceInstantResponseEnabled;
    }
 
    public function setForceInstantResponseEnabled($forceInstantResponseEnabled)
    {
        $this->forceInstantResponseEnabled = $forceInstantResponseEnabled;
    }
 
    public function setAnswerFreezingEnabled($answerFreezingEnabled)
    {
        $this->answerFreezingEnabled = $answerFreezingEnabled;
    }
 
    public function getRequestHintCommand(): string
    {
        return $this->requestHintCommand;
    }
 
    public function setRequestHintCommand($requestHintCommand)
    {
        $this->requestHintCommand = $requestHintCommand;
    }
 
    public function getShowHintsCommand(): string
    {
        return $this->showHintsCommand;
    }
 
    public function setShowHintsCommand($showHintsCommand)
    {
        $this->showHintsCommand = $showHintsCommand;
    }
 
    public function hintRequestsExist(): bool
    {
        return $this->hintRequestsExist;
    }
 
    public function setHintRequestsExist($hintRequestsExist)
    {
        $this->hintRequestsExist = $hintRequestsExist;
    }
 
    // fau: testNav - change setter/getter of question mark command to link target
    public function getQuestionMarkLinkTarget(): string
    {
        return $this->questionMarkLinkTarget;
    }
 
    public function setQuestionMarkLinkTarget($questionMarkLinkTarget)
    {
        $this->questionMarkLinkTarget = $questionMarkLinkTarget;
    }
    // fau.
 
    public function isQuestionMarked(): bool
    {
        return $this->questionMarked;
    }
 
    public function setQuestionMarked($questionMarked)
    {
        $this->questionMarked = $questionMarked;
    }
 
    public function isAnythingRendered(): bool
    {
        return $this->anythingRendered;
    }
 
    public function setAnythingRendered()
    {
        $this->anythingRendered = true;
    }
 
    public function isCharSelectorEnabled(): bool
    {
        return $this->charSelectorEnabled;
    }
 
    public function setCharSelectorEnabled($charSelectorEnabled)
    {
        $this->charSelectorEnabled = $charSelectorEnabled;
    }
 
    // fau: testNav - generate question actions menu
    public function getActionsHTML(): string
    {
        $tpl = $this->getTemplate('actions');
 
        include_once("Services/UIComponent/GroupedList/classes/class.ilGroupedListGUI.php");
        $actions = new ilGroupedListGUI();
        $actions->setAsDropDown(true, true);
 
        if ($this->getQuestionMarkLinkTarget()) {
            $actions->addEntry(
                $this->getQuestionMarkActionLabel(),
                $this->getQuestionMarkLinkTarget(),
                '',
                '',
                'ilTestQuestionAction',
                'tst_mark_question_action'
            );
            $actions->addSeparator();
        }
 
        if ($this->getRevertChangesLinkTarget()) {
            $actions->addEntry(
                $this->lng->txt('tst_revert_changes'),
                $this->getRevertChangesLinkTarget(),
                '',
                '',
                'ilTestQuestionAction ilTestRevertChangesAction',
                'tst_revert_changes_action'
            );
        } else {
            $actions->addEntry(
                $this->lng->txt('tst_revert_changes'),
                '#',
                '',
                '',
                'ilTestQuestionAction ilTestRevertChangesAction disabled',
                'tst_revert_changes_action'
            );
        }
 
        if ($this->isDiscardSolutionButtonEnabled()) {
            $actions->addEntry(
                $this->lng->txt('discard_answer'),
                '#',
                '',
                '',
                'ilTestQuestionAction ilTestDiscardSolutionAction',
                'tst_discard_solution_action'
            );
        } else {
            $actions->addEntry(
                $this->lng->txt('discard_answer'),
                '#',
                '',
                '',
                'ilTestQuestionAction ilTestDiscardSolutionAction disabled',
                'tst_discard_solution_action'
            );
        }
 
        if ($this->getSkipQuestionLinkTarget()) {
            $actions->addEntry(
                $this->lng->txt('postpone_question'),
                $this->getSkipQuestionLinkTarget(),
                '',
                '',
                'ilTestQuestionAction',
                'tst_skip_question_action'
            );
        } elseif (self::SHOW_DISABLED_COMMANDS) {
            $actions->addEntry(
                $this->lng->txt('postpone_question'),
                '#',
                '',
                '',
                'ilTestQuestionAction disabled',
                'tst_skip_question_action'
            );
        }
 
        if ($this->isCharSelectorEnabled()) {
            $actions->addSeparator();
            $actions->addEntry(
                $this->lng->txt('char_selector_btn_label'),
                '#',
                '',
                '',
                'ilTestQuestionAction ilCharSelectorMenuToggle',
                'ilCharSelectorMenuToggleLink'
            );
        }
 
        // render the mark icon
        if ($this->getQuestionMarkLinkTarget()) {
            $this->renderActionsIcon(
                $tpl,
                $this->getQuestionMarkIconSource(),
                $this->getQuestionMarkIconLabel(),
                'ilTestMarkQuestionIcon'
            );
        }
 
        // render the action menu
        include_once './Services/UIComponent/AdvancedSelectionList/classes/class.ilAdvancedSelectionListGUI.php';
        $list = new ilAdvancedSelectionListGUI();
        $list->setSelectionHeaderClass('btn-primary');
        $list->setId('QuestionActions');
        $list->setListTitle($this->lng->txt("actions"));
        $list->setStyle(1);
        $list->setGroupedList($actions);
        $tpl->setVariable('ACTION_MENU', $list->getHTML());
 
        return $tpl->get();
    }
    // fau.
 
 
    public function getHTML(): string
    {
        // fau: testNav - add parameter for toolbar template purpose
        $tpl = $this->getTemplate('toolbar');
        // fau.
        if ($this->getEditSolutionCommand()) {
            $this->renderSubmitButton(
                $tpl,
                $this->getEditSolutionCommand(),
                $this->getEditSolutionButtonLabel()
            );
        }
 
        // fau: testNav - don't show the standard submit button.
        // fau: testNav - discard answer is moved to the actions menu.
        // fau: testNav - skip question (postpone) is moved to the actions menu.
 
        if ($this->getInstantFeedbackCommand()) {
            $this->renderSubmitButton(
                $tpl,
                $this->getInstantFeedbackCommand(),
                $this->getCheckButtonLabel(),
                $this->isForceInstantResponseEnabled()
            );
        }
 
        if ($this->getRequestHintCommand()) {
            $this->renderSubmitButton(
                $tpl,
                $this->getRequestHintCommand(),
                $this->getRequestHintButtonLabel()
            );
        }
 
        if ($this->getShowHintsCommand()) {
            $this->renderSubmitButton(
                $tpl,
                $this->getShowHintsCommand(),
                'show_requested_question_hints'
            );
        }
 
        // fau: testNav - question mark is moved to the actions menu.
        // fau: testNav - char selector is moved to the actions menu.
 
        if ($this->isAnythingRendered()) {
            $this->parseNavigation($tpl);
        }
 
        return $tpl->get();
    }
 
    private function getEditSolutionButtonLabel(): string
    {
        if ($this->isQuestionWorkedThrough()) {
            return 'edit_answer';
        }
 
        return 'answer_question';
    }
 
    private function getSubmitSolutionButtonLabel(): string
    {
        if ($this->isForceInstantResponseEnabled()) {
            return 'submit_and_check';
        }
 
        // fau: testNav - rename the submit button to simply "Save"
        return 'save';
        // fau.
    }
 
    private function getCheckButtonLabel(): string
    {
        if ($this->isAnswerFreezingEnabled()) {
            return 'submit_and_check';
        }
 
        return 'check';
    }
 
    private function getRequestHintButtonLabel(): string
    {
        if ($this->hintRequestsExist()) {
            return 'button_request_next_question_hint';
        }
 
        return 'button_request_question_hint';
    }
 
    // fau: testNav - adjust mark icon and action labels
    private function getQuestionMarkActionLabel(): string
    {
        if ($this->isQuestionMarked()) {
            return $this->lng->txt('tst_remove_mark');
        }
 
        return $this->lng->txt('tst_question_mark');
    }
 
 
    private function getQuestionMarkIconLabel(): string
    {
        if ($this->isQuestionMarked()) {
            return $this->lng->txt('tst_question_marked');
        }
 
        return$this->lng->txt('tst_question_not_marked');
    }
    // fau.
 
    private function getQuestionMarkIconSource(): string
    {
        if ($this->isQuestionMarked()) {
            return ilUtil::getImagePath('marked.svg');
        }
 
        return ilUtil::getImagePath('marked_.svg');
    }
 
    // fau: testNav - add parameter for template purpose
    private function getTemplate($a_purpose = 'toolbar'): ilTemplate
    {
        switch ($a_purpose) {
            case 'toolbar':
                return new ilTemplate(
                    'tpl.tst_question_navigation.html',
                    true,
                    true,
                    'Modules/Test'
                );
            default:
            case 'actions':
                return new ilTemplate(
                    'tpl.tst_question_actions.html',
                    true,
                    true,
                    'Modules/Test'
                );
        }
    }
    // fau.
 
    private function parseNavigation(ilTemplate $tpl)
    {
        $tpl->setCurrentBlock('question_related_navigation');
        $tpl->parseCurrentBlock();
    }
 
    private function parseButtonsBlock(ilTemplate $tpl)
    {
        $tpl->setCurrentBlock('buttons');
        $tpl->parseCurrentBlock();
    }
 
    private function renderButtonInstance(ilTemplate $tpl, $button)
    {
        $tpl->setCurrentBlock("button_instance");
        $tpl->setVariable("BUTTON_INSTANCE", $button->render());
        $tpl->parseCurrentBlock();
 
        $this->parseButtonsBlock($tpl);
        $this->setAnythingRendered();
    }
 
    private function renderSubmitButton(ilTemplate $tpl, $command, $label, $primary = false)
    {
        $button = ilSubmitButton::getInstance();
        $button->setCommand($command);
        $button->setCaption($label);
        $button->setPrimary($primary);
        $button->addCSSClass(self::CSS_CLASS_SUBMIT_BUTTONS);
 
        $this->renderButtonInstance($tpl, $button);
    }
 
    private function renderLinkButton(ilTemplate $tpl, $href, $label)
    {
        $button = ilLinkButton::getInstance();
        $button->setUrl($href);
        $button->setCaption($label);
 
        $this->renderButtonInstance($tpl, $button);
    }
 
    private function renderJsLinkedButton(ilTemplate $tpl, $htmlId, $label, $cssClass)
    {
        $button = ilLinkButton::getInstance();
        $button->setId($htmlId);
        $button->addCSSClass($cssClass);
        $button->setCaption($label);
 
        $this->renderButtonInstance($tpl, $button);
    }
 
    private function renderIcon(ilTemplate $tpl, $command, $iconSrc, $label, $cssClass)
    {
        $tpl->setCurrentBlock("submit_icon");
        $tpl->setVariable("SUBMIT_ICON_CMD", $command);
        $tpl->setVariable("SUBMIT_ICON_SRC", $iconSrc);
        $tpl->setVariable("SUBMIT_ICON_TEXT", $label);
        $tpl->setVariable("SUBMIT_ICON_CLASS", $cssClass);
        $tpl->parseCurrentBlock();
 
        $this->parseButtonsBlock($tpl);
        $this->setAnythingRendered();
    }
 
    // fau: testNav - render an icon beneath the actions menu
    private function renderActionsIcon(ilTemplate $tpl, $iconSrc, $label, $cssClass)
    {
        $tpl->setCurrentBlock("actions_icon");
        $tpl->setVariable("ICON_SRC", $iconSrc);
        $tpl->setVariable("ICON_TEXT", $label);
        $tpl->setVariable("ICON_CLASS", $cssClass);
        $tpl->parseCurrentBlock();
    }
    // fau.
}