tk2/TKContainer.php5

<?php

abstract class TKContainer extends TKComponent {
    protected $children = array('main' => array());
    protected $slotInfo = array('main' => array());
    protected $childParams = array('main' => array());
    protected $defaultSlot = 'main';
    protected $defaultSlotOptions;

    const SLOT_ACCESS_PUBLIC = 0;
    const SLOT_ACCESS_PRIVATE = 1;

    const SLOT_SIZE_SINGLE = 0;
    const SLOT_SIZE_MULTI = 1;

    public static $ENABLE_ADD_CHECKS = false;

    public function __construct() {
        parent::__construct();

        $this->defaultSlotOptions = array(
            'access' => self::SLOT_ACCESS_PUBLIC,
            'type' => 'TKComponent',
            'size' => self::SLOT_SIZE_MULTI
        );

        $this->slotInfo = array('main' => $this->defaultSlotOptions);
    }

    public function __call($name, $args) {
        if(substr($name, 0, 3) != "add")
            return parent::__call($name, $args);

        if(substr($name, -2) == "To") {
            // we check TKFoo and TKFooTo, in case there is a toolkit
            //   class that ends in "To"
            $className1 = "TK" . substr($name, 3, -2);
            $className2 = "TK" . substr($name, 3);
            if(!class_exists($className1)) {
                if(!class_exists($className2)) {
                    $this->setError("Invalid component type specified: "
                        . "'$className1' or '$className2'");
                    return null;
                }
                $className = $className2;
                $withSlot = false;
            }
            else {
                $className = $className1;
                $withSlot = true;
            }

        }
        else {
            $withSlot = false;
            $className = substr($name, 3);
            $className = "TK$className";
            if(!class_exists($className)) {
                $this->setError("Invalid component type specified: '$className'");
                return null;
            }
        }

        if($withSlot) {
            $slot = $args[0];
            $start = 1;
        }
        else {
            $slot = "";
            $start = 0;
        }

        if(count($args) > 0 && is_array($args[count($args) - 1])) {
            $params = $args[count($args) - 1];
            $oneLess = true;
        }
        else
            $params = array();

        $paramStr = '';
        for($i = $start; $i < count($args) - isset($oneLess) ? 1 : 0; $i++) {
            $paramStr .= '$args['.$i.'],';
        }
        $paramStr = rtrim($paramStr, ',');

        $obj = eval("return new $className($paramStr);");

        return $this->add($obj, $slot, $params);
    }

    // for performance reasons
    public function addLabel($txt, $params = array()) {
        return $this->add(new TKLabel($txt), "", $params);
    }

    public function addLabelTo($slot, $txt, $params = array()) {
        return $this->add(new TKLabel($txt), $slot, $params);
    }

    public function addButton($caption, $params = array()) {
        return $this->add(new TKButton($caption), "", $params);
    }

    public function addSelect($name, $multiple = false, $params = array()) {
        return $this->add(new TKSelect($name, $multiple), "", $params);
    }

    public function addFormInput($type, $name, $value = "", $params = array()) {
        return $this->add(new TKFormInput($type, $name, $value), "", $params);
    }

    // TODO: add one of the above for every class in the default TK distribution

    public function __clone() {
        foreach($this->children as $s) {
            foreach($this->children[$s] as $c)
                $this->children[$s][$c] = clone $this->children[$s][$c];
        }
    }

    public function add($component, $slot = "", $params = array()) {
        if(is_array($slot)) {
            $params = $slot;
            $slot = "";
        }
        if(!is_string($slot))
            $this->setError("Slot must be a string!");
        if($slot == "" || !is_string($slot))
            $slot = $this->defaultSlot;
        if(!is_object($component)) {
            $this->setError("Component must not be null or a non-object!");
            return null;
        }

        if(self::$ENABLE_ADD_CHECKS) {
            if($this->getSlotOption($slot, 'access') != self::SLOT_ACCESS_PUBLIC) {
                $this->setError("Cannot add item to slot '$slot' because it is "
                    . "private");
                return null;
            }
            $type = $this->getSlotOption($slot, 'type');
            if($type != "" && !is_a($component, $type)) {
                $this->setError("Cannot add item to slot '$slot' because item is of"
                    . " incorrect type");
                return null;
            }
            if($this->getSlotOption($slot, 'size') == self::SLOT_SIZE_SINGLE
                && count($this->children[$slot]) != 0) {
                $this->setError("Cannot add item to slot '$slot' because it is "
                    . "full");
                return null;
            }
        }
        if(!$this->onAdd($component, $slot, $params, $component->getId())) {
            return null;
        }
        $this->children[$slot][$component->getId()] = $component;
        $this->childParams[$slot][$component->getId()] = $params;
        return $component;
    }

    public function addText($txt, $params = array()) {
        // for Valerie, with love ::)
        if(!is_string($txt) && !ctype_digit((string) $txt))
            $txt = "";
        $slot = $this->defaultSlot;
        if(!$this->onAdd($txt, $slot, $params, count($this->children)))
            return false;
        array_push($this->children[$this->defaultSlot], $txt);
        array_push($this->childParams[$this->defaultSlot], $params);
        return true;
    }

    public function addTextTo($slot, $txt, $params = array()) {
        if(!is_string($txt))
            $txt = "";
        if(!$this->onAdd($txt, $slot, $params, count($this->children)))
            return false;
        array_push($this->children[$slot], $txt);
        array_push($this->childParams[$slot], $params);
        return true;
    }

    /*
     * This is called by TKComponent::setId() to make sure that references to the
     * object based on ID are updated for the new ID
     */
    protected function updateIds() {
        foreach($this->children as $s => $children) {
            foreach($children as $id => $obj) {
                $newId = $obj->getId();
                if($newId != $id) {
                    unset($this->children[$s][$id]);
                    $this->children[$s][$newId] = $obj;
                }
            }
        }
    }

    protected function addSlot($slotName, $options = array()) {
        if(isset($this->children[$slotName]))
            $this->setWarning("Slot '$slotName' already exists; existing"
                . " members will be destroyed.");
        $this->children[$slotName] = array();
        $this->childParams[$slotName] = array();
        $this->slotInfo[$slotName] = array_merge($this->defaultSlotOptions, $options);
        return true;
    }

    protected function removeSlot($slotName) {
        if(count($this->children[$slotName]) != 0)
            $this->setWarning("Remove non-empty slot '$slotName'");
        unset($this->children[$slotName]);
        unset($this->childParams[$slotName]);
        unset($this->slotInfo[$slotName]);
        return true;
    }

    protected function getSlotOption($slot, $option) {
        if(!isset($this->children[$slot])) {
            $this->setError("Invalid slot '$slot' (DEVELOPER ERROR!)");
            // just return default
            return $this->defaultSlotOptions[$option];
        }

        if(!isset($this->slotInfo[$slot][$option])) {
            return $this->defaultSlotOptions[$option];
        }
        else {
            return $this->slotInfo[$slot][$option];
        }
        return $this->slotInfo[$slot][$option];
    }

    protected function setSlotOption($slot, $option, $value) {
        if(!isset($this->slotInfo[$slot])) {
            $this->setError("Invalid slot '$slot' (DEVELOPER ERROR!)");
            return false;
        }
        $this->slotInfo[$slot][$option] = $value;
        return true;
    }

    protected function setDefaultSlot($slot) {
        $this->defaultSlot = $slot;
    }

    protected function addPriv($component, $slot, $params = array()) {
        if(!is_a($component, $this->getSlotOption($slot, 'type'))) {
            $this->setError("Cannot add item to slot '$slot' because item is of"
                 . " incorrect type");
            return null;
        }
        if(count($this->children[$slot]) != 0
            && $this->getSlotOption($slot, 'size') == self::SLOT_SIZE_SINGLE) {
            $this->setError("Cannot add item to slot '$slot' because it is "
                 . "full");
            return null;
        }
        $this->children[$slot][$component->getId()] = $component;
        $this->childParams[$slot][$component->getId()] = $params;
        return $component;
    }

    protected function getChildrenBySlot($slotName) {
        return $this->children[$slotName];
    }

    protected function getChild($slot, $id) {
        return $this->children[$slot][$id];
    }

    protected function getChildParams($slot, $child) {
        if(!is_object($child))
            return $this->childParams[$slot][$child];
        else
            return $this->childParams[$slot][$child->getId()];
    }

    protected function setChildParams($slot, $child, $params) {
        if(!is_object($child))
            $this->childParams[$slot][$child] = $params;
        else
            $this->childParams[$slot][$child->getId()] = $params;
    }

    protected function addToChildParams($slot, $child, $params) {
        if(!is_object($child))
            $this->childParams[$slot][$child] += $params;
        else
            $this->childParams[$slot][$child->getId()] += $params;
    }

    /*
     * This method just calls renderContainer().  We could just as well use
     * renderComponent() for containers, but by having a different method name,
     * it implies that we are working in a different framework.
     */
    protected function renderComponent($class, $style, $events, $id) {
        return $this->renderContainer($class, $style, $events, $id);
    }

    abstract protected function renderContainer($class, $style, $events, $id);

    protected function onAdd(&$component, &$slot, &$params, $id) {
        return true;
    }

    protected static function convertStdChildren($obj, $children) {
        foreach($children as $child) {
            if(substr($child['tag'], 0, 2) == 'TK') {
                $nobj = self::convertChild($child);
                if($nobj !== null)
                    $obj->add($nobj);
            }
        }
    }
}

?>

---