MainBar.php

Go to the documentation of this file.

<?php
 
declare(strict_types=1);
 
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;
use InvalidArgumentException;
use LogicException;
 
class MainBar implements MainControls\MainBar
{
    use ComponentHelper;
    use JavaScriptBindable;
 
    public const ENTRY_ACTION_TRIGGER = 'trigger';
    public const ENTRY_ACTION_REMOVE = 'remove';
    public const ENTRY_ACTION_TRIGGER_MAPPED = 'trigger_mapped';
    public const ENTRY_ACTION_TOGGLE_TOOLS = 'toggle_tools';
    public const ENTRY_ACTION_DISENGAGE_ALL = 'disengage_all';
    public const NONE_ACTIVE = '_none';
 
    protected array $entries = [];
 
    private array $initially_hidden_ids = [];
 
    private array $tool_signals = [];
 
    private array $close_buttons = [];
 
    private array $tool_entries = [];
 
    private ?Button\Bulky $tools_button = null;
    private Button\Bulky $more_button;
    private ?string $active = null;
    private string $mainbar_tree_position;
    private SignalGeneratorInterface $signal_generator;
    private Signal $entry_click_signal;
    private Signal $tools_click_signal;
    private Signal $tools_removal_signal;
    private Signal $disengage_all_signal;
    protected Signal $toggle_tools_signal;
 
    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 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(): void
    {
        $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(): ?string
    {
        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;
    }
}