tk2/TKComponent.php5

<?php

abstract class TKComponent extends SObject {
    private $id;
    private $html = false;
    private $parent = null;

    private $directEvents = array();
    private $indirectEvents = array();
    private $eventExtra = array();
    private $hasActions = false;

    private $properties = array();
    private $propTypes = array();
    private $propListeners = array();

    private $theme = null;
    private $themeClass = 'default';

    private $bTranslateFields = true;

    private $translatedClass = array();
    private $translatedStyle = array();
    private $translatedActions = '';
    private $translatedId = '';

    const PROP_NUMERIC = 1;
    const PROP_STRING = 2;
    const PROP_OBJECT = 3;
    const PROP_BOOLEAN = 4;
    const PROP_ARRAY = 5;
    const PROP_CLASS = 6;
    const PROP_STYLE = 7;

    const EVENT_DIRECT = 1;
    const EVENT_INDIRECT = 2;

    private static $NULL_VALUE = null;

    public function __construct() {
        // autogenerate unique ID
        $this->id = 'id' . Toolkit::getNextId();

        // every component has these properties
        $this->addProperty('class', self::PROP_CLASS);
        $this->addProperty('style', self::PROP_STYLE);
        $this->addProperty('alt', self::PROP_STRING);

        // for performance reasons we manually set these arrays
        $this->directEvents = array(
            'onload' => array(),
            'onclick' => array(),
            'ondblclick' => array(),
            'onmousedown' => array(),
            'onmousemove' => array(),
            'onmouseout' => array(),
            'onmouseover' => array(),
            'onmouseup' => array(),
            'onkeydown' => array(),
            'onkeyup' => array(),
            'onkeypress' => array()
        );

        $this->eventExtra = array(
            'onload' => array(),
            'onclick' => array(),
            'ondblclick' => array(),
            'onmousedown' => array(),
            'onmousemove' => array(),
            'onmouseout' => array(),
            'onmouseover' => array(),
            'onmouseup' => array(),
            'onkeydown' => array(),
            'onkeyup' => array(),
            'onkeypress' => array()
        );

        // always use default theme initially (instead of no theme)
        $this->theme = Toolkit::getDefaultTheme();

        // register this object with the giant component registry
        Toolkit::addObject($this, $this->id);
    }

    /*------------------------------------------------------------------------*/
    /*  Public API functions                                                  */
    /*------------------------------------------------------------------------*/

    public function &__get($fldName) {
        if($fldName == 'html') {
            $html = $this->render();
            return $html;
        }
        // TODO: we don't want to return the raw event structure, so we need to retool this
        // to do something more reasonable; commenting out for now
        /*
        else if($this->eventExists($fldName)) {
            return $this->events[$fldName];
        }
        */
        return $this->get($fldName);
    }

    public function __set($fldName, $value) {
        if($this->eventExists($fldName))
            return $this->setAction($fldName, $value);
        else
            return $this->set($fldName, $value);
    }

    public function __isset($fldName) {
        if($this->eventExists($fldName))
            return true;
        else
            return $this->isset($fldName);
    }

    public function __toString() {
        return 'Component [id: ' . $this->getId() . ', type: '
            . get_class($this) . ']';
    }

    public function __call($name, $args) {
        if(substr($name, 0, 3) == 'set') {
            $op = 'set';
            $name = substr($name, 3);
        }
        else if(substr($name, 0, 3) == 'get') {
            $op = 'get';
            $name = substr($name, 3);
        }
        else if(substr($name, 0, 6) == 'append') {
            $op = 'append';
            $name = substr($name, 6);
        }
        else if(substr($name, 0, 6) == 'exists') {
            $op = 'exists';
            $name = substr($name, 6);
        }
        else {
            $this->setError("Invalid dynamic function '$name'");
            return false;
        }

        $name = preg_replace('/([A-Z])([a-z]*)/e', "'_'.strtolower('$1').'$2'",
                            $name);
        $name = ltrim($name, '_');

        $args = array_merge(array($name), $args);

        return call_user_func_array(array($this, $op), $args);
    }

    // added for performance reasons
    public function setStyle($style) {
        if(is_array($style))
            $this->properties['style'] = $style;
        else
            $this->properties['style'] = array($style);
        return $this;
    }

    // added for performance reasons
    public function setClass($class) {
        if(is_array($class))
            $this->properties['class'] = $class;
        else
            $this->properties['class'] = array($class);
        return $this;
    }

    public function __clone() {
        // all properties are cloned for us, but if those properties
        //   contain objects, those must be cloned as well
        foreach($this->properties as $key => $value) {
            if($this->propTypes[$key] == self::PROP_OBJECT)
                $this->properties[$key] = clone $this->properties[$key];
        }
        foreach($this->events as $k => $v) {
            $this->events[$k] = clone $this->events[$k];
        }
        $this->parent = null;
        $this->onClone();
    }

    public function &get($fldName) {
        if(isset($this->properties[$fldName]))
            return $this->properties[$fldName];
        $this->setError("No such property '$fldName'");
        return self::$NULL_VALUE;
    }

    public function set($fldName, $value) {
        // only check to make sure property exists if we have checking enabled (for debugging purposes)
        if(Toolkit::$ENABLE_PROP_EXIST_CHECKING && !isset($this->properties[$fldName])) {
            $this->setError("No such property '$fldName'");
            return $this;
        }

        // if type checking is disabled, we just trust that $value is of the correct type (this is faster)
        if(!Toolkit::$ENABLE_PROP_TYPE_CHECKING) {
            if(!isset($this->propListeners[$fldName])) {
                if($this->propTypes[$fldName] >= self::PROP_ARRAY && $this->propTypes[$fldName] <= self::PROP_STYLE
                    && !is_array($value))
                {
                    $this->properties[$fldName] = array($value);
                }
                else
                    $this->properties[$fldName] = $value;
            }
            else {
                list($yes, $value) = $this->onPropChange($fldName, $value);
                if($yes) {
                    if($this->propTypes[$fldName] >= self::PROP_ARRAY && $this->propTypes[$fldName] <= self::PROP_STYLE
                        && !is_array($value))
                    {
                        $this->properties[$fldName] = array($value);
                    }
                    else
                        $this->properties[$fldName] = $value;
                }
            }
            return $this;
        }
        switch($this->propTypes[$fldName]) {
            case self::PROP_NUMERIC:
                if(!ctype_digit((string) $value)) {
                    $this->setError("Property '$fldName' requires a numeric "
                                    . 'value');
                    return $this;
                }
                break;
            case self::PROP_STRING:
                if($value != '' && !is_string($value) && !ctype_digit((string) $value)) {
                    $this->setError("Property '$fldName' requires a string "
                         . 'value');
                    return $this;
                }
                break;
            case self::PROP_CLASS:
            case self::PROP_STYLE:
            case self::PROP_ARRAY:
                if(!is_array($value)) {
                    if(!isset($this->propListeners[$fldName]))
                        $this->properties[$fldName] = array($value);
                    else {
                        list($yes, $val) = $this->onPropChange($fldName, $value);
                        if($yes)
                            $this->properties[$fldName] = array($val);
                    }
                    return $this;
                }
                break;
            case self::PROP_OBJECT:
                if(!is_object($value)) {
                    $this->setError("Property '$fldName' requires an object");
                    return $this;
                }
                break;
            case self::PROP_BOOLEAN:
                if(!is_bool($value)) {
                    $this->setError("Property '$fldName' requires a boolean "
                        . 'value');
                    return $this;
                }
                break;
        }

        if(!isset($this->propListeners[$fldName])) {
            if($value == '' && $this->propTypes[$fldName] == self::PROP_STRING)
                $value = '';
            $this->properties[$fldName] = $value;
        }
        else {
            if($value == '' && $this->propTypes[$fldName] == self::PROP_STRING)
                $value = '';
            list($yes, $val) = $this->onPropChange($fldName, $value);
            if($yes)
                $this->properties[$fldName] = $val;
        }
        return $this;
    }

    public function setMany($fields) {
        foreach($fields as $name => $value) {
            if(!$this->set($name, $value))
                return $this;
        }
        return $this;
    }

    public function append($fldName, $value, $pre = false) {
        if(Toolkit::$ENABLE_PROP_EXIST_CHECKING && !isset($this->properties[$fldName])) {
            $this->setError("No such property '$fldName'");
            return $this;
        }
        // we have to do type checking in order to know what to do with $value
        switch($this->propTypes[$fldName]) {
            case self::PROP_NUMERIC:
                $this->setError('Cannot append numeric values');
                break;
            case self::PROP_STRING:
                if(!is_string($value) && !ctype_digit((string) $value))
                    $this->setError("Property '$fldName' requires a string "
                         . 'value');
                else if($pre == true)
                    $newValue = $value . $this->properties[$fldName];
                else
                    $newValue .= $value;
                break;
            case self::PROP_CLASS:
            case self::PROP_STYLE:
            case self::PROP_ARRAY:
                if(is_array($value)) {
                    if($pre == true)
                        $newValue = array_merge($value, $this->properties[$fldName]);
                    else
                        $newValue = array_merge($this->properties[$fldName], $value);
                }
                else {
                    if($pre == true)
                        $newValue = array_merge(array($value), $this->properties[$fldName]);
                    else
                        $newValue = array_merge($this->properties[$fldName], array($value));
                }
                break;
            case self::PROP_OBJECT:
                $this->setError('Cannot append objects');
                break;
            case self::PROP_BOOLEAN:
                $this->setError('Cannot append booleans');
                break;
        }
        if(!isset($this->propListeners[$fldName]))
            $this->properties[$fldName] = $newValue;
        else {
            list($yes, $val) = $this->onPropChange($fldName, $newValue);
            if($yes)
                $this->properties[$fldName] = $val;
        }
        return $this;
    }

    public function appendMany($fields) {
        foreach($this->fields as $name => $value)
            if(!$this->append($name, $value))
                break;
        return $this;
    }

    public function exists($fld) {
        return isset($this->properties[$fld]);
    }

    public function getProperties($values = false) {
        if($values)
            return array_merge($this->properties);
        else
            return array_keys($this->properties);
    }


    public function setTheme($theme) {
        $this->theme = $theme;
    }

    public function getTheme() {
        return $this->theme;
    }

    public function setThemeClass($class) {
        $this->themeClass = $class;
    }

    public function getThemeClass() {
        return $this->themeClass;
    }

    public function setAction($eventName, $action) {
        if(!$this->eventExists($eventName)) {
            $this->setError("No such event '$eventName'");
            return false;
        }
        if(is_string($action)) {
            $action = new TKCustomAction('', $action);
        }
        else if(is_array($action)) {
            $action = new TKCustomAction($action[0], $action[1]);
        }
        else if(!($action instanceof TKAction)) {
            $this->setError('Action must be subclass of TKAction');
            return false;
        }
        $this->hasActions = true;
        if(isset($this->directEvents[$eventName]))
            array_push($this->directEvents[$eventName], $action);
        else
            array_push($this->indirectEvents[$eventName], $action);
        return true;
    }

    public function eventExists($eventName) {
        return isset($this->directEvents[$eventName]) || isset($this->indirectEvents[$eventName]);
    }

    public function render() {
        if($this->html === false) {
            if($this->theme != null)
                $this->theme->initComponent($this);
            if($this->bTranslateFields) {
                list($class, $style, $events, $id) = $this->translateFields();
                $this->html = $this->renderComponent($class, $style, $events, $id);
            }
            else {
                $this->renderComponent(null, null, null, null);
            }
        }
        return $this->html;
    }

    public function getId() {
        return $this->id;
    }

    public function setId($id) {
        if($id == $this->id)
            return $this;
        Toolkit::setObjectId($this, $id);
        $this->id = $id;
        if($this->parent !== null)
            $this->parent->updateIds();
        return $this;
    }

    /*------------------------------------------------------------------------*/
    /*  Functions that must be overridden by derived classes                  */
    /*------------------------------------------------------------------------*/

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

    protected function onClone() {
        // this is to be overridden by child classes
    }

    public static function createFromXML($attrs, $data, $childNodes) {
        self::setError('Cannot create a TKComponent from XML!');
        return null;
    }

    /*------------------------------------------------------------------------*/
    /*  Utility functions for derived classes                                 */
    /*------------------------------------------------------------------------*/

    protected function addExtraJS($slot, $js) {
        Toolkit::globalAddExtraJS($slot, $js);
    }

    protected function addExtraCSS($slot, $css) {
        Toolkit::globalAddExtraCSS($slot, $css);
    }

    protected static function convertStdAttributes($obj, $attrs) {
        if(isset($attrs['id'])) {
            $obj->setId($attrs['id']);
            unset($attrs['id']);
        }
        if(isset($attrs['theme'])) {
            $theme = $attrs['theme'];
            if(class_exists($theme)) {
                $t = new $theme();
                $obj->setTheme($t);
            }
        }
        if(isset($attrs['theme_class'])) {
            $obj->setThemeClass($attrs['theme_class']);
        }
        foreach($attrs as $a => $v) {
            if($obj->exists($a)) {
                if(substr($a, -5) == 'class') {
                    $cl = explode(' ', $v);
                    $obj->set($a, $cl);
                }
                else if(substr($a, -5) == 'style') {
                    $cl = explode(';', $v);
                    $stl = array();
                    foreach($cl as $s) {
                        $tmp = explode(':', $s);
                        $stl[$tmp[0]] = $tmp[1];
                    }
                    $obj->set($a, $stl);
                }
                else {
                    $obj->set($a, $v);
                }
            }
        }
    }

    protected static function convertStdEvents($obj, $node) {
        foreach($node['children'] as $evt) {
            if($evt['tag'] != 'event')
                continue;
            $attrs = $evt['attrs'];
            $type = (string)$attrs['type'];
            $actionName = (string)$attrs['action'];
            $action = call_user_func(array($actionName, 'createFromXML'), $evt['attrs'], $evt['children']);
            if($action !== null)
                $obj->setAction($type, $action);
        }
    }

    protected static function convertChild($child) {
        $classname = $child['tag'];
        $value = $child['value'];
        $attribs = $child['attrs'];
        $nobj = call_user_func(array($classname, 'createFromXML'), $attribs, $value, $child);
        return $nobj;
    }

    protected function enableTranslateFields($bEnable) {
        $this->bTranslateFields = $bEnable;
    }

    protected function addProperty($propName, $type) {
        if(Toolkit::$ENABLE_PROP_EXIST_CHECKING && isset($this->propTypes[$propName])) {
            $this->setDebug('WARNING: Redefinition of existing property '
                 . "'$propName'");
            return false;
        }
        switch($type) {
            case self::PROP_NUMERIC:
                $this->properties[$propName] = (int)0;
                break;
            case self::PROP_STRING:
                $this->properties[$propName] = (string)'';
                break;
            case self::PROP_CLASS:
            case self::PROP_STYLE:
            case self::PROP_ARRAY:
                $this->properties[$propName] = array();
                break;
            case self::PROP_OBJECT:
                $this->properties[$propName] = (object)'';
                break;
            case self::PROP_BOOLEAN:
                $this->properties[$propName] = (boolean)false;
                break;
            default:
                $this->setDebug("ERROR: Invalid property type: $type");
                return false;
        }
        $this->propTypes[$propName] = $type;
        return true;
    }

    protected function removeProperty($propName) {
        if(!isset($this->propTypes[$propName])) {
            $this->setDebug("WARNING: No such property '$propName'");
            return false;
        }
        unset($this->propTypes[$propName]);
        unset($this->properties[$propName]);
        return true;
    }

    protected function setPropChangeListener($prop, $fn) {
        if(isset($this->propListeners[$prop])) {
            $this->setWarning("Property change listener already registered for property '$prop'");
            return false;
        }

        $oldListener = isset($this->propListeners[$prop]) ? $this->propListeners[$prop] : null;
        $this->propListeners[$prop] = $fn;
        return $oldListener;
    }

    protected function removePropChangeListener($prop) {
        if(!isset($this->propListeners[$prop])) {
            $this->setWarning("No such property '$prop'");
            return false;
        }
        unset($this->propListeners[$prop]);
        return true;
    }

    protected function addEvent($eventName, $eventType = self::EVENT_DIRECT,
                                $eventExtra = array())
    {
        if($eventType == self::EVENT_DIRECT) {
            if(isset($this->directEvents[$eventName])) {
                $this->setDebug("WARNING: Event '$eventName' already exists");
                return false;
            }
            $this->directEvents[$eventName] = array();
        }
        else if($eventType == self::EVENT_INDIRECT) {
            if(isset($this->indirectEvents[$eventName])) {
                $this->setDebug("WARNING: Event '$eventName' already exists");
                return false;
            }
            $this->indirectEvents[$eventName] = array();
        }
        else {
            $this->setDebug("ERROR: Invalid event type $eventType");
            return false;
        }
        /*$this->events[$eventName] = array();
        $this->eventTypes[$eventName] = $eventType;*/
        $this->eventExtra[$eventName] = $eventExtra;
        return true;
    }

    protected function removeEvent($eventName) {
        if(isset($this->directEvents[$eventName])) {
            unset($this->directEvents[$eventName]);
        }
        else if(isset($this->indirectEvents[$eventName])) {
            unset($this->indirectEvents[$eventName]);
        }
        else {
            $this->setDebug("WARNING: No such event '$eventName'");
            return false;
        }
        unset($this->eventExtra[$eventName]);
        return true;
    }

    protected function getAllEventJS() {
        if($this->hasActions == false)
            return '';
        $collect = '';
        foreach($this->indirectEvents as $evt => $dummy) {
            $collect .= $this->getIndirectEventJS($evt);
        }
        foreach($this->directEvents as $evt => $dummy) {
            $collect .= $this->getDirectEventJS($evt);
        }
        return $collect;
    }

    protected function translateClass($name, $extra = array()) {
        $propName = $name === 0 ? 'class' : $name . '_class';
        return Toolkit::classToString(array_merge($this->properties[$propName], $extra));
    }

    protected function translateStyle($name, $extra = array()) {
        $propName = $name === 0 ? 'style' : $name . '_style';
        return Toolkit::styleToString(array_merge($this->properties[$propName], $extra));
    }

    protected function mergeClasses($names, $extra = array()) {
        $classes = array();
        foreach($names as $name)
            $classes[] = $this->properties[$name == 0 ? 'class' : $name . '_class'];
        foreach($extra as $e)
            $classes[] = $e;
        return Toolkit::classToString($classes);
    }

    protected function mergeStyles($names, $extra = array()) {
        $styles = array();
        foreach($names as $name)
            $styles = array_merge($styles, $this->properties[$name == 0 ? 'style' : $name . '_style']);
        foreach($extra as $a => $v)
            $styles[$a] = $v;
        return Toolkit::styleToString($styles);
    }

    protected function translateFields($extraClasses = array(), $extraStyles = array()) {
        $class = array();
        $style = array();
        foreach($this->properties as $name => $prop) {
            if($name == 'class') {
                if(isset($extraClasses[0]))
                    $class[0] = ' class="' . $extraClasses[0] . ' ' .  implode(' ', $prot) . '"';
                else
                    $class[0] = (count($prop) > 0 ? ' class="'. implode(' ', $prop) . '"' : '');
            }
            else if($this->propTypes[$name] == self::PROP_CLASS) {
                if(isset($extraClasses[$name]))
                    $class[substr($name, 0, -6)] = ' class="' . $extraClasses[$name] . ' ' . implode(' ', $prop) . '"';
                else
                    $class[substr($name, 0, -6)] = (count($prop) > 0 ? ' class="' . implode(' ', $prop) . '"' : '');
            }
            else if($name == 'style') {
                if(count($prop) > 0 || isset($extraStyles[0])) {
                    $collect = ' style="';
                    foreach($prop as $attr => $value)
                        $collect .= "$attr:$value;";
                    if(isset($extraStyles[0]))
                        foreach($extraStyles[0] as $attr => $value)
                            $collect .= "$attr:$value;";
                    $collect .= '"';
                }
                else
                    $collect = '';
                $style[0] = $collect;

            }
            else if($this->propTypes[$name] == self::PROP_STYLE) {
                if(count($prop) > 0 || isset($extraStyles[$name])) {
                    $collect = ' style="';
                    foreach($prop as $attr => $value)
                        $collect .= "$attr:$value;";
                    if(isset($extraStyles[$name]))
                        foreach($extraStyles[$name] as $attr => $value)
                            $collect .= "$attr:$value;";
                    $collect .= '"';
                }
                else
                    $collect = '';
                $style[substr($name, 0, -6)] = $collect;
            }
        }

        $this->translatedClass = $class;
        $this->translatedStyle = $style;
        $this->translatedActions = $this->hasActions ? $this->getAllEventJS() : '';
        $this->translatedId = " id=\"$this->id\"";
        return array($class, $style, $this->translatedActions, $this->translatedId);
    }

    public function getTranslatedClass($className) {
        return isset($this->translatedClass[$className]) ? $this->translatedClass[$className] : '';
    }

    public function getTranslatedStyle($styleName) {
        return isset($this->translatedSyyle[$styleName]) ? $this->translatedStyle[$styleName] : '';
    }

    public function getTranslatedActions() {
        return $this->translatedActions;
    }

    public function getTranslatedId() {
        return $this->translatedId;
    }

    /*------------------------------------------------------------------------*/
    /*  For internal use only                                                 */
    /*------------------------------------------------------------------------*/

    /*
     * Sets the parent object of this component.  This should only be used by TKContainer
     * when constructing hierarchies.  The old parent is lost, and the TKContainer implementation
     * should make sure that that parent knows it lost a child.
     *
     * @param $parent [TKContainer]: parent container
     */
    protected function setParent($parent) {
        if(!($parent instanceof TKComponent)) {
            $this->setDebug('ERROR: Parent must be a TKComponent');
            return false;
        }
        $this->parent = $parent;
        return true;
    }

    /*
     * Called when a property is changed.  It will call a property listener callback
     * if such a callback exists, otherwise, it just returns true and passes through the
     * property change.
     *
     * @param $prop [string]: name of property that is changing
     * @param $newValue [mixed]: proposed new value of property
     * @return [array]: array(true, $newValue) if there is no property listener, otherwise, returns
     *   what the property listener returns
     */
    private function onPropChange($prop, $newValue) {
        if(isset($this->propListeners[$prop])) {
            $fn = $this->propListeners[$prop];
            return call_user_func($fn, $prop, $newValue);
        }
        else
            return array(true, $newValue);
    }

    /*
     * This generates JavaScript event handler attributes.  This method
     * is called as part of the render process.  Direct events are generated
     * by just concatenating the JavaScript generated by calling getInvocation() on
     * all the actions associated with the given event.
     *
     * @param $event [string]: name of event to generate
     * @return [string]: JavaScript event attribute: <tt> onfoo='some javascript'</tt>
     */
    protected function getDirectEventJS($event) {
        if(count($this->directEvents[$event]) > 0) {
            $collect = " $event=\"";
            foreach($this->directEvents[$event] as $i => $action) {
                $collect .= $action->getInvocation() . ';';
            }
            $collect .= '"';

            return $collect;
        }
        else
            return '';
    }

    /*
     * This generates JavaScript event handler code for indirect events.  The generated JavaScript
     * is placed in in-page JavaScript sections and not inline.
     *
     * @param $event [string]: name of event to generate JS for
     */
    protected function getIndirectEventJS($event) {
        $extraInfo = $this->eventExtra[$event];
        if(count($this->indirectEvents[$event]) > 0) {
            $accum = array();
            foreach($this->indirectEvents[$event] as $i => $action) {
                $accum[] = $action->getInvocation() . ';';
            }
            if(isset($extraInfo['emitTo'])) {
                Toolkit::$INDIRECT[$extraInfo['emitTo']->getId()][$event] = $accum;
            }
            else {
                Toolkit::$INDIRECT[$this->getId()][$event] = $accum;
            }
        }
        return '';
    }
}

?>

---