class.ilTreeExplorerGUI.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
include_once("./Services/UIComponent/Explorer2/classes/class.ilExplorerBaseGUI.php");
 
abstract class ilTreeExplorerGUI extends ilExplorerBaseGUI implements \ILIAS\UI\Component\Tree\TreeRecursion
{
    protected $lng;
 
    protected $httpRequest;
 
    protected $tree = null;
    protected $tree_label = "";
    protected $order_field = "";
    protected $order_field_numeric = false;
    protected $type_white_list = array();
    protected $type_black_list = array();
    protected $childs = array();                        // preloaded childs
    protected $preloaded = false;
    protected $preload_childs = false;
    protected $root_node_data = null;
    protected $all_childs = array();
 
    protected $ui;
    
    public function __construct($a_expl_id, $a_parent_obj, $a_parent_cmd, $a_tree)
    {
        global $DIC;
 
        $this->httpRequest = $DIC->http()->request();
        $this->ui = $DIC->ui();
        $this->lng = $DIC->language();
        parent::__construct($a_expl_id, $a_parent_obj, $a_parent_cmd);
        $this->tree = $a_tree;
    }
    
    public function getTree()
    {
        return $this->tree;
    }
    
    public function setOrderField($a_val, $a_numeric = false)
    {
        $this->order_field = $a_val;
        $this->order_field_numeric = $a_numeric;
    }
    
    public function getOrderField()
    {
        return $this->order_field;
    }
    
    public function setTypeWhiteList($a_val)
    {
        $this->type_white_list = $a_val;
    }
    
    public function getTypeWhiteList()
    {
        return $this->type_white_list;
    }
    
    public function setTypeBlackList($a_val)
    {
        $this->type_black_list = $a_val;
    }
    
    public function getTypeBlackList()
    {
        return $this->type_black_list;
    }
 
    public function setPreloadChilds($a_val)
    {
        $this->preload_childs = $a_val;
    }
 
    public function getPreloadChilds()
    {
        return $this->preload_childs;
    }
 
    protected function preloadChilds()
    {
        $subtree = $this->tree->getSubTree($this->getRootNode());
        foreach ($subtree as $s) {
            $wl = $this->getTypeWhiteList();
            if (is_array($wl) && count($wl) > 0 && !in_array($s["type"], $wl)) {
                continue;
            }
            $bl = $this->getTypeBlackList();
            if (is_array($bl) && count($bl) > 0 && in_array($s["type"], $bl)) {
                continue;
            }
            $this->childs[$s["parent"]][] = $s;
            $this->all_childs[$s["child"]] = $s;
        }
 
        if ($this->order_field != "") {
            foreach ($this->childs as $k => $childs) {
                $this->childs[$k] = ilUtil::sortArray($childs, $this->order_field, "asc", $this->order_field_numeric);
            }
        }
 
        // sort childs and store prev/next reference
        if ($this->order_field == "") {
            $this->all_childs =
                ilUtil::sortArray($this->all_childs, "lft", "asc", true, true);
            $prev = false;
            foreach ($this->all_childs as $k => $c) {
                if ($prev) {
                    $this->all_childs[$prev]["next_node_id"] = $k;
                }
                $this->all_childs[$k]["prev_node_id"] = $prev;
                $this->all_childs[$k]["next_node_id"] = false;
                $prev = $k;
            }
        }
 
        $this->preloaded = true;
    }
 
 
 
    public function getSuccessorNode($a_node_id, $a_type = "")
    {
        if ($this->order_field != "") {
            die("ilTreeExplorerGUI::getSuccessorNode not implemented for order field " . $this->order_field);
        }
 
        if ($this->preloaded) {
            $next_id = $a_node_id;
            while (($next_id = $this->all_childs[$next_id]["next_node_id"]) && $a_type != "" &&
                $this->all_childs[$next_id]["type"] != $a_type);
            if ($next_id) {
                return $this->all_childs[$next_id];
            }
            return false;
        }
        return $this->getTree()->fetchSuccessorNode($a_node_id, $a_type);
    }
 
 
 
    public function getChildsOfNode($a_parent_node_id)
    {
        if ($this->preloaded && $this->getSearchTerm() == "") {
            if (is_array($this->childs[$a_parent_node_id])) {
                return $this->childs[$a_parent_node_id];
            }
            return array();
        }
 
        $wl = $this->getTypeWhiteList();
        if (is_array($wl) && count($wl) > 0) {
            $childs = $this->tree->getChildsByTypeFilter($a_parent_node_id, $wl, $this->getOrderField());
        } else {
            $childs = $this->tree->getChilds($a_parent_node_id, $this->getOrderField());
        }
        
        // apply black list filter
        $bl = $this->getTypeBlackList();
        if (is_array($bl) && count($bl) > 0) {
            $bl_childs = array();
            foreach ($childs as $k => $c) {
                if (!in_array($c["type"], $bl) && ($this->matches($c) || $this->requested_node_id != $this->getDomNodeIdForNodeId($a_parent_node_id))) {
                    $bl_childs[$k] = $c;
                }
            }
            return $bl_childs;
        }
 
        $final_childs = [];
        foreach ($childs as $k => $c) {
            if ($this->matches($c) || $this->requested_node_id != $this->getDomNodeIdForNodeId($a_parent_node_id)) {
                $final_childs[$k] = $c;
            }
        }
        return $final_childs;
    }
 
    protected function matches($node) : bool
    {
        if ($this->getSearchTerm() == "" ||
            is_int(stripos($this->getNodeContent($node), $this->getSearchTerm()))) {
            return true;
        }
        return false;
    }
 
    
    public function getNodeId($a_node)
    {
        return $a_node["child"];
    }
 
    public function getNodeIconAlt($a_node)
    {
        $lng = $this->lng;
        
        return $lng->txt("icon") . " " . $lng->txt("obj_" . $a_node["type"]);
    }
 
    public function getRootNode()
    {
        if (!isset($this->root_node_data)) {
            $this->root_node_data = $this->getTree()->getNodeData($this->getRootId());
        }
        return $this->root_node_data;
    }
    
    public function setRootId($a_root)
    {
        $this->root_id = $a_root;
    }
    
    protected function getRootId()
    {
        return $this->root_id
            ? $this->root_id
            : $this->getTree()->readRootId();
    }
    
    public function setPathOpen($a_id)
    {
        $path = $this->getTree()->getPathId($a_id);
        foreach ($path as $id) {
            $this->setNodeOpen($id);
        }
    }
 
    public function getHTML($new = false)
    {
        if ($this->getPreloadChilds()) {
            $this->preloadChilds();
        }
        if (!$new) {
            return parent::getHTML();
        }
        return $this->render();
    }
 
    // New implementation
 
    public function getChildren($node, $environment = null) : array
    {
        return $this->getChildsOfNode($node["child"]);
    }
 
    protected function createNode(
        \ILIAS\UI\Component\Tree\Node\Factory $factory,
        $record
    ) : \ILIAS\UI\Component\Tree\Node\Node {
        $nodeIconPath = $this->getNodeIcon($record);
 
        $icon = null;
        if (is_string($nodeIconPath) && strlen($nodeIconPath) > 0) {
            $icon = $this->ui
                ->factory()
                ->symbol()
                ->icon()
                ->custom($nodeIconPath, $this->getNodeIconAlt($record));
        }
 
        return $factory->simple($this->getNodeContent($record), $icon);
    }
 
    protected function getNodeStateToggleCmdClasses($record) : array
    {
        return [];
    }
 
    public function build(
        \ILIAS\UI\Component\Tree\Node\Factory $factory,
        $record,
        $environment = null
    ) : \ILIAS\UI\Component\Tree\Node\Node {
        $node = $this->createNode($factory, $record);
 
        $href = $this->getNodeHref($record);
        if (is_string($href) && strlen($href) > 0 && '#' !== $href) {
            $node = $node->withLink(new \ILIAS\Data\URI(ILIAS_HTTP_PATH . '/' . $href));
        }
 
        if ($this->isNodeOpen((int) $this->getNodeId($record))) {
            $node = $node->withExpanded(true);
        }
 
        $nodeStateToggleCmdClasses = $this->getNodeStateToggleCmdClasses($record);
        $cmdClass = end($nodeStateToggleCmdClasses);
 
        if (is_string($cmdClass) && strlen($cmdClass) > 0) {
            $node = $node->withAdditionalOnLoadCode(function ($id) use ($record, $nodeStateToggleCmdClasses, $cmdClass) {
                $serverNodeId = $this->getNodeId($record);
 
                $this->ctrl->setParameterByClass($cmdClass, 'node_id', $serverNodeId);
                $url = $this->ctrl->getLinkTargetByClass($nodeStateToggleCmdClasses, 'toggleExplorerNodeState', '', true, false);
                $this->ctrl->setParameterByClass($cmdClass, 'node_id', null);
 
                $javascript = "il.UI.tree.registerToggleNodeAsyncAction('$id', '$url', 'prior_state');";
 
                return $javascript;
            });
        }
 
        return $node;
    }
 
    public function getTreeLabel()
    {
        return $this->tree_label;
    }
 
    public function getTreeComponent()
    {
        $f = $this->ui->factory();
        $tree = $this->getTree();
 
        $data = array(
            $tree->getNodeData($tree->readRootId())
        );
 
        $label = $this->getTreeLabel();
        if ($this->getTreeLabel() == "" && $this->getNodeContent($this->getRootNode())) {
            $label = $this->getNodeContent($this->getRootNode());
        }
 
        $tree = $f->tree()->expandable($label, $this)
            ->withData($data)
            ->withHighlightOnNodeClick(true);
 
        return $tree;
    }
 
    public function toggleExplorerNodeState() : void
    {
        $nodeId = (int) ($this->httpRequest->getQueryParams()['node_id'] ?? 0);
        $priorState = (int) ($this->httpRequest->getQueryParams()['prior_state'] ?? 0);
 
        if ($nodeId > 0) {
            if (0 === $priorState && !in_array($nodeId, $this->open_nodes)) {
                $this->open_nodes[] = $nodeId;
            } elseif (1 === $priorState && in_array($nodeId, $this->open_nodes)) {
                $key = array_search($nodeId, $this->open_nodes);
                unset($this->open_nodes[$key]);
            }
 
            $this->store->set('on_' . $this->id, serialize($this->open_nodes));
        }
        exit();
    }
 
    protected function render()
    {
        $r = $this->ui->renderer();
 
        return $r->render([
            $this->getTreeComponent()
        ]);
    }
}