MainBar.php

Go to the documentation of this file.

<?php

/* Copyright (c) 2018 Nils Haagen <nils.haagen@concepts-and-training.de> Extended GPL, see docs/LICENSE */

namespace ILIAS\UI\Implementation\Component\MainControls;

use ILIAS\UI\Component\Signal;
use ILIAS\UI\Component\Button;
use ILIAS\UI\Component\Link;
use ILIAS\UI\Component\MainControls;
use ILIAS\UI\Component\MainControls\Slate\Slate;
use ILIAS\UI\Implementation\Component\ComponentHelper;
use ILIAS\UI\Implementation\Component\JavaScriptBindable;
use ILIAS\UI\Implementation\Component\SignalGeneratorInterface;

class MainBar implements MainControls\MainBar
{
    use ComponentHelper;
    use JavaScriptBindable;

    const ENTRY_ACTION_TRIGGER = 'trigger';
    const ENTRY_ACTION_REMOVE = 'remove';
    const ENTRY_ACTION_TRIGGER_MAPPED = 'trigger_mapped';
    const ENTRY_ACTION_TOGGLE_TOOLS = 'toggle_tools';
    const ENTRY_ACTION_DISENGAGE_ALL = 'disengage_all';
    const NONE_ACTIVE = '_none';

    private $signal_generator;

    private $entry_click_signal;

    private $tools_click_signal;

    private $tools_removal_signal;

    private $disengage_all_signal;

    protected $entries = [];

    private $tool_entries = [];

    private $tools_button;

    private $more_button;

    private $active;

    private $initially_hidden_ids = [];

    private $tool_signals = [];

    private $close_buttons = [];

    private $mainbar_tree_position;

    public function __construct(SignalGeneratorInterface $signal_generator)
    {
        $this->signal_generator = $signal_generator;
        $this->initSignals();
    }

    public function getEntries() : array
    {
        return $this->entries;
    }

    public function withAdditionalEntry(string $id, $entry) : MainControls\MainBar
    {
        $classes = [
            Button\Bulky::class,
            Link\Bulky::class,
            MainControls\Slate\Slate::class
        ];
        $check = [$entry];
        $this->checkArgListElements("Bulky or Slate", $check, $classes);

        if (array_key_exists($id, $this->entries)) {
            throw new \InvalidArgumentException("The id of this entry is already taken.", 1);
        }

        $clone = clone $this;
        $clone->entries[$id] = $entry;
        return $clone;
    }

    public function getToolEntries() : array
    {
        return $this->tool_entries;
    }

    public function withAdditionalToolEntry(
        string $id,
        Slate $entry,
        bool $initially_hidden = false,
        Button\Close $close_button = null
    ) : MainControls\MainBar {
        if (!$this->tools_button) {
            throw new \LogicException("There must be a tool-button configured to add tool-entries", 1);
        }

        if (array_key_exists($id, $this->tool_entries)) {
            throw new \InvalidArgumentException("The id of this entry is already taken.", 1);
        }

        $clone = clone $this;
        $clone->tool_entries[$id] = $entry;
        $signal = $this->signal_generator->create();
        $signal->addOption('entry_id', $id);
        $signal->addOption('action', self::ENTRY_ACTION_TRIGGER_MAPPED);
        $clone->tool_signals[$id] = $signal;

        if ($initially_hidden) {
            $clone->initially_hidden_ids[] = $id;
        }

        if ($close_button) {
            $clone->close_buttons[$id] = $close_button;
        }
        return $clone;
    }

    public function withToolsButton(Button\Bulky $button) : MainControls\MainBar
    {
        $clone = clone $this;
        $clone->tools_button = $button;
        return $clone;
    }

    public function getToolsButton() : Button\Bulky
    {
        return $this->tools_button;
    }

    public function withMoreButton(Button\Bulky $button) : MainControls\MainBar
    {
        $clone = clone $this;
        $clone->more_button = $button;
        return $clone;
    }

    public function getMoreButton() : Button\Bulky
    {
        return $this->more_button;
    }

    public function getEntryClickSignal() : Signal
    {
        return $this->entry_click_signal;
    }

    public function getToolsClickSignal() : Signal
    {
        return $this->tools_click_signal;
    }

    public function getToolsRemovalSignal() : Signal
    {
        return $this->tools_removal_signal;
    }

    public function getDisengageAllSignal() : Signal
    {
        return $this->disengage_all_signal;
    }

    public function getToggleToolsSignal() : Signal
    {
        return $this->toggle_tools_signal;
    }

    protected function initSignals()
    {
        $this->entry_click_signal = $this->signal_generator->create();
        $this->tools_click_signal = $this->signal_generator->create();
        $this->tools_removal_signal = $this->signal_generator->create();
        $this->disengage_all_signal = $this->signal_generator->create();
        $this->disengage_all_signal->addOption('action', self::ENTRY_ACTION_DISENGAGE_ALL);
        $this->toggle_tools_signal = $this->signal_generator->create();
        $this->toggle_tools_signal->addOption('action', self::ENTRY_ACTION_TOGGLE_TOOLS);
    }

    public function withResetSignals() : MainControls\MainBar
    {
        $clone = clone $this;
        $clone->initSignals();
        foreach (array_keys($this->tool_entries) as $tool_id) {
            $this->tool_signals[$tool_id] = $this->signal_generator->create();
        }
        return $clone;
    }

    public function getActive()
    {
        return $this->active;
    }

    public function withActive(string $active) : MainControls\MainBar
    {
        $valid_entries = array_merge(
            array_keys($this->entries),
            array_keys($this->tool_entries),
            [self::NONE_ACTIVE]
        );
        if (!in_array($active, $valid_entries)) {
            throw new \InvalidArgumentException("Invalid entry to activate: $active", 1);
        }

        $clone = clone $this;
        $clone->active = $active;
        return $clone;
    }

    public function getInitiallyHiddenToolIds() : array
    {
        return array_unique($this->initially_hidden_ids);
    }

    public function getEngageToolSignal(string $tool_id) : Signal
    {
        return $this->tool_signals[$tool_id];
    }

    public function getCloseButtons() : array
    {
        return $this->close_buttons;
    }


    public function withClearedEntries() : MainControls\MainBar
    {
        $clone = clone $this;
        $clone->entries = [];
        $clone->tool_entries = [];
        return $clone;
    }

    public function getTriggerSignal(
        string $entry_id,
        string $action
    ) : Signal {
        if (!in_array($action, [self::ENTRY_ACTION_TRIGGER, self::ENTRY_ACTION_REMOVE])) {
            throw new InvalidArgumentException("invalid action for mainbar entry: $action", 1);
        }
        $signal = $this->signal_generator->create();
        $signal->addOption('entry_id', $entry_id);
        $signal->addOption('action', $action);
        return $signal;
    }

    public function withMainBarTreePosition(string $tree_pos) : MainBar
    {
        $clone = clone $this;
        $clone->mainbar_tree_position = $tree_pos;
        return $clone;
    }

    public function withMappedSubNodes(callable $f) : MainBar
    {
        $clone = clone $this;

        $counter = 0;
        foreach ($clone->getEntries() as $k => $v) {
            $clone->entries[$k] = $f($counter, $v, false);
            $counter++;
        }

        $counter = 0;
        foreach ($clone->getToolEntries() as $k => $v) {
            $clone->tool_entries[$k] = $f($counter, $v, true);
            $counter++;
        }

        return $clone;
    }
}