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
{
    protected $lng;
 
    protected $tree = null;
    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();
    
    public function __construct($a_expl_id, $a_parent_obj, $a_parent_cmd, $a_tree)
    {
        global $DIC;
 
        $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)) {
                    $bl_childs[$k] = $c;
                }
            }
            return $bl_childs;
        }
 
        $final_childs = [];
        foreach ($childs as $k => $c) {
            if ($this->matches($c)) {
                $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()
    {
        if ($this->getPreloadChilds()) {
            $this->preloadChilds();
        }
        return parent::getHTML();
    }
}