uki 1.0.0

data/frameworks/uki/src/uki-core/view/focusable.js

@@ -0,0 +1,93 @@
+include('../view.js');
+include('observable.js');
+
+/**
+ * @class
+ */
+uki.view.Focusable = /** @lends uki.view.Focusable.prototype */ {
+    // dom: function() {
+    //     return null; // should implement
+    // },
+    _focusable: true, // default value
+    
+    focusable: uki.newProp('_focusable', function(v) {
+        this._focusable = v;
+        this._updateTabIndex();
+    }),
+    
+    disabled: uki.newProp('_disabled', function(d) {
+        this._disabled = d;
+        if (d) this.blur();
+        this._updateTabIndex();
+        if (this._updateBg) this._updateBg();
+    }),
+    
+    _updateTabIndex: function() {
+        if (this._focusTarget) {
+            if (this._focusable && !this._disabled) this._focusTarget.setAttribute('tabIndex', 1)
+            else this._focusTarget.removeAttribute('tabIndex');
+        }
+    }, 
+    
+    _initFocusable: function(preCreatedInput) {
+        this._focusTarget = preCreatedInput;
+
+        if (!preCreatedInput) {
+            this._focusTarget = root.opera ? uki.createElement('div', 'position:absolute;left:-999px;top:0;width:1px;height:1px;') : this.dom();
+            if (root.opera) this.dom().appendChild(this._focusTarget);
+            this._updateTabIndex();
+            this._focusTarget.style.outline = 'none';
+            this._focusTarget.hideFocus = true;
+        }
+        this._hasFocus = false;
+        this._firstFocus = true;
+            
+        uki.dom.bind(this._focusTarget, 'focus', uki.proxy(function(e) {
+            if (!this._hasFocus) this._focus(e);
+        }, this));
+        uki.dom.bind(this._focusTarget, 'blur', uki.proxy(function(e) {
+            if (this._hasFocus) this._blur(e);
+        }, this));
+        
+        if (!preCreatedInput) this.bind('mousedown', function(e) {
+            setTimeout(uki.proxy(function() {
+                try { this.focus(); } catch (e) {};
+            }, this), 1);
+        });
+    },
+    
+    _focus: function(e) {
+        this._hasFocus = true;
+        this._firstFocus = false;
+    },
+    
+    _blur: function(e) {
+        this._hasFocus = false;
+    },
+    
+    focus: function() {
+        try {
+            if (this._focusable && !this._disabled) this._focusTarget.focus();
+        } catch(e) {}
+        return this;
+    },
+    
+    blur: function() {
+        try {
+            this._focusTarget.blur();
+        } catch(e) {}
+        return this;
+    },
+    
+    hasFocus: function() {
+        return this._hasFocus;
+    },
+    
+    _bindToDom: function(name) {
+        if (!this._focusTarget || 'keyup keydown keypress focus blur'.indexOf(name) == -1) return false;
+        
+        return uki.view.Observable._bindToDom.call(this, name, this._focusableInput);
+    }
+    
+
+};

data/frameworks/uki/src/uki-core/view/observable.js

@@ -0,0 +1,66 @@
+include('../view.js');
+
+/**
+ * @class
+ */
+uki.view.Observable = /** @lends uki.view.Observable.prototype */ {
+    // dom: function() {
+    //     return null; // should implement
+    // },
+    
+    bind: function(name, callback) {
+        uki.each(name.split(' '), function(i, name) {
+            if (!this._bound(name)) this._bindToDom(name);
+            this._observersFor(name).push(callback);
+        }, this);
+        return this;
+    },
+    
+    unbind: function(name, callback) {
+        uki.each(name.split(' '), function(i, name) {
+            this._observers[name] = uki.grep(this._observers[name], function(observer) {
+                return observer != callback;
+            });
+            if (this._observers[name].length == 0) {
+                this._unbindFromDom(name);
+            }
+        }, this);
+        return this;
+    },
+    
+    trigger: function(name/*, data1, data2*/) {
+        var attrs = Array.prototype.slice.call(arguments, 1);
+        uki.each(this._observersFor(name, true), function(i, callback) {
+            callback.apply(this, attrs);
+        }, this);
+        return this;
+    },
+    
+    _unbindFromDom: function(name) {
+        if (!this._domHander || !this._eventTargets[name]) return;
+        uki.dom.unbind(this._eventTargets[name], name, this._domHander);
+    },
+    
+    _bindToDom: function(name, target) {
+        if (!target && !this.dom) return;
+        this._domHander = this._domHander || uki.proxy(function(e) {
+            e.source = this;
+            this.trigger(e.type, e);
+        }, this);
+        this._eventTargets = this._eventTargets || {};
+        this._eventTargets[name] = target || this.dom();
+        uki.dom.bind(this._eventTargets[name], name, this._domHander);
+        return true;
+    },
+    
+    _bound: function(name) {
+        return this._observers && this._observers[name];
+    },
+    
+    _observersFor: function(name, skipCreate) {
+        if (skipCreate && (!this._observers || !this._observers[name])) return [];
+        if (!this._observers) this._observers = {};
+        if (!this._observers[name]) this._observers[name] = [];
+        return this._observers[name];
+    }
+};

data/frameworks/uki/src/uki-core/view/styleable.js

@@ -0,0 +1,70 @@
+include('../view.js');
+
+/**
+ * @class
+ */
+uki.view.Styleable = new function() {
+    /** @scope uki.view.Styleable.prototype */
+    
+    /**
+     * @name style
+     * @memberOf uki.view.Styleable#
+     * @function
+     */
+    this.style = function(name, value) {
+        if (typeof name == 'string') return this._style(name, value);
+        
+        uki.each(name, function(name, value) {
+            this._style(name, value);
+        }, this);
+        return this;
+    };
+    
+    this._style = function(name, value) {
+        if (value === undefined) return this._dom.style[name];
+        this._dom.style[name] = value;
+        return this;
+    };
+    
+    // TODO: is this really needed?
+    // uki.each('fontSize,textAlign,color,fontFamily,fontWeight,lineHeight,zIndex'.split(','), function(i, name) {
+    //     proto[name] = function(value) {
+    //         return this._style(name, value);
+    //     };
+    // });
+    
+    var probe = uki.createElement('div').style,
+        proto = this;
+    uki.each(['userSelect', 'MozUserSelect', 'WebkitUserSelect'], function() {
+        if (typeof probe[this] == 'string') proto._textSelectProp = this;
+    });
+    
+    /**
+     * Sets whether text of the view can be selected.
+     *
+     * @memberOf uki.view.Styleable#
+     * @name textSelectable
+     * @function
+     * @param {boolean=} state 
+     * @returns {boolean|uki.view.Base} current textSelectable state of self
+     */
+    this.textSelectable = function(state) {
+        if (state === undefined) return this._textSelectable;
+        this._textSelectable = state;
+        if (this._textSelectProp) {
+            this._dom.style[this._textSelectProp] = state ? '' : this._textSelectProp == 'MozUserSelect' ? '-moz-none' : 'none';
+        } else {
+            // uki.dom[state ? 'unbind' : 'bind'](this.dom(), 'selectstart mousedown', uki.dom.preventDefaultHandler);
+        }
+        this._dom.style.cursor = state ? 'text' : 'default';
+        return this;
+    };
+    
+    this.draggable = function(state) {
+        if (state === undefined) return this._dom.getAttribute('draggable');
+        this._dom.setAttribute('draggable', true);
+        this._dom.style.WebkitUserDrag = 'element';
+    };
+    
+    /**#@-*/ 
+};

data/frameworks/uki/src/uki-core/view/utils.js

@@ -0,0 +1,66 @@
+include('../view.js');
+
+/**
+ * @namespace
+ */
+uki.view.utils = new function() {
+    this.visibleRect = function (from, upTo) {
+        var queue = [],
+            rect, i, tmpRect, c = from;
+            
+        do {
+            queue[queue.length] = c;
+            c = c.parent();
+        } while (c && c != upTo);
+        
+        if (upTo && upTo != from) queue[queue.length] = upTo;
+
+        for (i = queue.length - 1; i >= 0; i--){
+            c = queue[i];
+            tmpRect = visibleRect(c);
+            rect = rect ? rect.intersection(tmpRect) : tmpRect;
+            rect.x -= c.rect().x;
+            rect.y -= c.rect().y;
+            
+        };
+        return rect;
+    };
+    
+    this.top = function(c) {
+        while (c.parent()) c = c.parent();
+        return c;
+    };
+    
+    this.offset = function(c, upTo) {
+        var offset = new Point(),
+            rect;
+        
+        while (c && c != upTo) {
+            rect = c.rect();
+            offset.x += rect.x;
+            offset.y += rect.y;
+            if (c.scrollTop) {
+                offset.x -= c.scrollLeft();
+                offset.y -= c.scrollTop();
+            }
+            c = c.parent();
+        }
+        return offset;
+    };
+    
+    this.scrollableParent = function(c) {
+        do {
+            if (uki.isFunction(c.scrollTop)) return c;
+            c = c.parent();
+        } while (c);
+        return null;
+    };
+    
+    /** @inner */
+    function visibleRect (c) {
+        return c.visibleRect ? c.visibleRect() : c.rect().clone();
+    }
+    /**#@-*/ 
+};
+
+uki.extend(uki.view, uki.view.utils);

data/frameworks/uki/src/uki-core/view.js

@@ -0,0 +1,21 @@
+include('uki.js');
+/** @namespace */
+uki.view = {
+    declare: function(/*name, baseClasses, implementation*/) {
+        var args  = uki.toArray(arguments),
+            name  = args.shift(),
+            klass = uki.newClass.apply(uki, args),
+            parts = name.split('.'),
+            obj   = root,
+            i, part;
+        
+        klass.prototype.typeName = function() { return name; };
+        for ( i=0; i < parts.length - 1; i++ ) {
+            part = parts[i];
+            if (!obj[part]) obj[part] = {};
+            obj = obj[part];
+        };
+        obj[parts[parts.length - 1]] = klass;
+        return klass;
+    }
+};

data/frameworks/uki/src/uki-core.js

@@ -0,0 +1,36 @@
+include('uki-core/const.js');
+include('uki-core/uki.js');
+include('uki-core/utils.js');
+include('uki-core/geometry.js');
+
+include('uki-core/dom.js');
+include('uki-core/dom/event.js');
+include('uki-core/dom/dnd.js');
+include('uki-core/dom/w3cdnd.js');
+include('uki-core/dom/offset.js');
+include('uki-core/dom/nativeLayout.js');
+
+include('uki-core/attachment.js');
+include('uki-core/builder.js');
+include('uki-core/selector.js');
+
+include('uki-core/image.js');
+
+include('uki-core/background.js');
+include('uki-core/background/null.js');
+include('uki-core/background/sliced9.js');
+include('uki-core/background/css.js');
+include('uki-core/background/cssBox.js');
+include('uki-core/background/rows.js');
+include('uki-core/background/multi.js');
+
+include('uki-core/theme.js');
+include('uki-core/theme/base.js');
+include('uki-core/theme/template.js');
+
+include('uki-core/view/utils.js');
+include('uki-core/view/styleable.js');
+include('uki-core/view/observable.js');
+include('uki-core/view/focusable.js');
+include('uki-core/view/base.js');
+include('uki-core/view/container.js');

data/frameworks/uki/src/uki-data/data.js

@@ -0,0 +1 @@
+uki.data = {};

data/frameworks/uki/src/uki-data/model.js

@@ -0,0 +1,28 @@
+include('observable.js');
+
+uki.data.Model = uki.newClass(uki.data.Observable, function(Observable) {
+    
+    this.change = this.update = function(values, arg2) {
+        var changes = {}, fields = [];
+        if (arg2 !== undefined) {
+            var tmp = {};
+            tmp[values] = arg2;
+            values = tmp;
+        }
+        uki.each(values, function(i) {
+            if (this[i] != values[i]) {
+                changes[i] = true
+                fields.push(i);
+                this[i] = values[i];
+            }
+        }, this);
+        
+        this._triggerChange({changes: changes, fields: fields, model: this});
+        return this;
+    };
+    
+    this._triggerChange = function(e) {
+        this.trigger('change', e);
+    };
+    
+});

data/frameworks/uki/src/uki-data/observable.js

@@ -0,0 +1,34 @@
+include('data.js');
+/**
+ * Легковесная поддержка событий без баблинга
+ */
+uki.data.Observable = {
+    bind: function(name, callback) {
+        var _this = this;
+        uki.each(name.split(' '), function(i, name) {
+            _this._observersFor(name).push(callback);
+        });
+    },
+    
+    unbind: function(name, callback) {
+        var _this = this;
+        uki.each(name.split(' '), function(i, name) {
+            _this._observers[name] = uki.grep(_this._observersFor(name), function(c) {
+                return c != callback;
+            });
+        });
+    },
+    
+    trigger: function(name/*, data1, data2*/) {
+        var attrs = Array.prototype.slice.call(arguments, 1);
+        uki.each(this._observersFor(name), function(i, callback) {
+            callback.apply(this, attrs);
+        });
+    },
+    
+    _observersFor: function(name) {
+        if (!this._observers) this._observers = {};
+        if (!this._observers[name]) this._observers[name] = [];
+        return this._observers[name];
+    }
+};

data/frameworks/uki/src/uki-data.js

@@ -0,0 +1 @@
+include('uki-data/model.js');

data/frameworks/uki/src/uki-more/more/utils.js

@@ -0,0 +1,20 @@
+include('../more.js');
+
+uki.more.utils = {
+    range: function (from, to) {
+        var result = new Array(to - from);
+        for (var idx = 0; from <= to; from++, idx++) {
+            result[idx] = from;
+        };
+        return result;
+    },
+    
+    binarySearch: function (array, value) {
+        var low = 0, high = array.length, mid;
+        while (low < high) {
+            mid = (low + high) >> 1;
+            array[mid] < value ? low = mid + 1 : high = mid;
+        }
+        return low;
+    }
+};

data/frameworks/uki/src/uki-more/more/view/listContainer.js

@@ -0,0 +1,4 @@
+uki.more.view.ListContainer = uki.newClass(uki.view.Container, new function() {
+    var Base = uki.view.Container.prototype;
+    
+});

data/frameworks/uki/src/uki-more/more/view/multiselectList.js

@@ -0,0 +1,196 @@
+include('../view.js');
+include('../utils.js');
+
+uki.view.declare('uki.more.view.MultiselectList', uki.view.List, function(Base) {
+        
+    this._setup = function() {
+        Base._setup.call(this);
+        uki.extend(this, {
+            _selectedIndexes: [],
+            _lastClickIndex: -1
+        });
+    };
+    
+    this.lastClickIndex = uki.newProp('_lastClickIndex');
+    
+    this.clearSelection = function(skipClickIndex) {
+        for (var i=0; i < this._selectedIndexes.length; i++) {
+            this._setSelected(this._selectedIndexes[i], false);
+        };
+        this._selectedIndexes = [];
+        if (!skipClickIndex) this._lastClickIndex = -1;
+    };
+    
+    this.selectedIndexes = function(indexes) {
+        if (indexes === undefined) return this._selectedIndexes;
+        this.clearSelection(true);
+        this._selectedIndexes = indexes;
+        for (var i=0; i < this._selectedIndexes.length; i++) {
+            this._setSelected(this._selectedIndexes[i], true);
+        };
+        this.trigger('selection', {source: this});
+        return this;
+    };
+    
+    this.selectedRows = function() {
+        return uki.map(this.selectedIndexes(), function(index) {
+            return this._data[index];
+        }, this)
+    };
+    
+    this.selectedIndex = function(position) {
+        if (position === undefined) return this._selectedIndexes.length ? this._selectedIndexes[0] : -1;
+        this.selectedIndexes([position]);
+        this._scrollToPosition(position);
+        return this;
+    };
+    
+    function removeRange (array, from, to) {
+        var p = uki.more.utils.binarySearch(array, from),
+            initialP = p;
+        while (array[p] <= to) p++;
+        if (p > initialP) array.splice(initialP, p - initialP);
+    }
+    
+    this._toggleSelection = function(p) {
+        var indexes = [].concat(this._selectedIndexes);
+        var addTo = uki.more.utils.binarySearch(indexes, p);
+        if (indexes[addTo] == p) {
+            indexes.splice(addTo, 1);
+        } else {
+            indexes.splice(addTo, 0, p);
+        }
+        this.selectedIndexes(indexes);
+    };
+    
+    this._bindSelectionEvents = function() {
+        this.bind('mousedown', this._mousedown);
+        this.bind('mouseup', this._mouseup);
+        this.bind(this.keyPressEvent(), this._keypress);
+    };
+    
+    this._mouseup = function(e) {
+        var o = uki.dom.offset(this._dom),
+            y = e.pageY - o.y,
+            p = y / this._rowHeight << 0;
+            
+        if (this._selectionInProcess && this._lastClickIndex == p && this.isSelected(p)) this.selectedIndexes([p]);
+        this._selectionInProcess = false;
+    };
+    
+    this._mousedown = function(e) {
+        var o = uki.dom.offset(this._dom),
+            y = e.pageY - o.y,
+            p = y / this._rowHeight << 0,
+            indexes = this._selectedIndexes;
+
+        this._selectionInProcess = false;
+        if (e.shiftKey && indexes.length > 0) {
+            if (this.isSelected(p)) {
+                indexes = [].concat(indexes);
+                removeRange(indexes, Math.min(p+1, this._lastClickIndex), Math.max(p-1, this._lastClickIndex));
+                this.selectedIndexes(indexes);
+            } else {
+                this.selectedIndexes(uki.more.utils.range(
+                    Math.min(p, indexes[0]),
+                    Math.max(p, indexes[indexes.length - 1])
+                ));
+            }
+        } else if (e.metaKey) {
+            this._toggleSelection(p);
+        } else {
+            if (!this.isSelected(p)) {
+                this.selectedIndexes([p]);
+            } else {
+                this._selectionInProcess = true;
+            }
+        }
+        this._lastClickIndex = p;
+    };
+    
+    this._keypress = function(e) {
+        var indexes = this._selectedIndexes,
+            nextIndex = -1;
+        if (e.which == 38 || e.keyCode == 38) { // UP
+            nextIndex = Math.max(0, this._lastClickIndex - 1);
+        } else if (e.which == 40 || e.keyCode == 40) { // DOWN
+            nextIndex = Math.min(this._data.length-1, this._lastClickIndex + 1);
+        }
+        if (nextIndex > -1 && nextIndex != this._lastClickIndex) {
+            if (e.shiftKey) {
+                if (this.isSelected(nextIndex)) {
+                    this._toggleSelection(this._lastClickIndex);
+                } else {
+                    this._toggleSelection(nextIndex);
+                }
+            } else {
+                this.selectedIndex(nextIndex);
+            }
+            this._lastClickIndex = nextIndex;
+            e.preventDefault();
+        }
+    };
+    
+    this.isSelected = function(index) {
+        var found = uki.more.utils.binarySearch(this._selectedIndexes, index);
+        return this._selectedIndexes[found] == index;
+    };
+    
+    //   xxxxx    |    xxxxx  |  xxxxxxxx  |     xxx
+    //     yyyyy  |  yyyyy    |    yyyy    |   yyyyyyy
+    this._restorePackSelection = function(pack) {
+        var indexes = this._selectedIndexes;
+        
+        if (
+            (indexes[0] <= pack.itemFrom && indexes[indexes.length - 1] >= pack.itemFrom) || // left index
+            (indexes[0] <= pack.itemTo   && indexes[indexes.length - 1] >= pack.itemTo) || // right index
+            (indexes[0] >= pack.itemFrom && indexes[indexes.length - 1] <= pack.itemTo) // within
+        ) {
+            var currentSelection = uki.more.utils.binarySearch(indexes, pack.itemFrom);
+            currentSelection = Math.max(currentSelection, 0);
+            while(indexes[currentSelection] !== null && indexes[currentSelection] < pack.itemTo) {
+                var position = indexes[currentSelection] - pack.itemFrom;
+                this._render.setSelected(pack.dom.childNodes[position], this._data[position], true, this.hasFocus());
+                currentSelection++;
+            }
+        }
+    };
+    
+    this._setSelected = function(position, state) {
+        var item = this._itemAt(position);
+        if (item) this._render.setSelected(item, this._data[position], state, this.hasFocus());
+    };
+    
+    this._focus = function() {
+        if (this._selectedIndexes.length == 0 && this._data.length > 0) {
+            this.selectedIndexes([0]);
+        } else {
+            this.selectedIndexes(this.selectedIndexes());
+        }
+    };
+    
+    this._blur = function() {
+        this.selectedIndexes(this.selectedIndexes());
+    };
+});
+
+uki.view.declare('uki.more.view.ScrollableMultiselectList', uki.view.ScrollPane, function(Base) {
+
+    this._createDom = function() {
+        Base._createDom.call(this);
+        this._list = uki({ view: 'uki.more.view.MultiselectList', rect: this.rect().clone().normalize(), anchors: 'left top right bottom' })[0];
+        this.appendChild(this._list);
+    };
+    
+    uki.each('data rowHeight render packSize visibleRectExt throttle focusable selectedIndexes selectedIndex selectedRows contentDraggable draggable hasFocus'.split(' '), 
+        function(i, name) {
+            uki.delegateProp(this, name, '_list');
+        }, this);
+    
+});
+
+
+// export properties
+uki.Collection.addAttrs(['lastClickIndex','selectedIndexes']);
+uki.delegateProp(uki.view.Table.prototype, 'selectedIndexes', '_list');
+uki.delegateProp(uki.view.Table.prototype, 'lastClickIndex', '_list');

data/frameworks/uki/src/uki-more/more/view/radioButton.js

@@ -0,0 +1,27 @@
+include('toggleButton.js');
+
+uki.view.declare('uki.more.view.RadioButton', uki.more.view.ToggleButton, function(base) {
+    var manager = uki.view.Radio;
+    
+    this.group = uki.newProp('_group', function(g) {
+        manager.unregisterGroup(this);
+        this._group = g;
+        manager.registerGroup(this);
+        manager.clearGroup(this);
+    });
+    
+    this.value = this.checked = uki.newProp('_checked', function(state) {
+        this._checked = !!state;
+        if (state) manager.clearGroup(this);
+        this._updateBg();
+    });
+    
+    this._mouseup = function() {
+        if (!this._down) return;
+        this._down = false;
+        if (!this._checked && !this._disabled) {
+            this.checked(!this._checked);
+            this.trigger('change', {checked: this._checked, source: this});
+        }
+    }
+});