uki 1.0.0

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

@@ -0,0 +1,90 @@
+include('uki.js');
+include('dom.js');
+
+/**
+ * Creates image element from url
+ *
+ * @param {string} url Image url
+ * @param {string=} dataUrl Data url representation of image, used if supported
+ * @param {string=} alphaUrl Gif image url for IE6
+ *
+ * @namespace
+ * @function
+ *
+ * @returns {Element}
+ */
+uki.image = function(url, dataUrl, alphaUrl) {
+    var result = new Image();
+    result.src = uki.imageSrc(url, dataUrl, alphaUrl);
+    return result;
+};
+
+/**
+ * Selects image src depending on browser
+ *
+ * @param {string} url Image url
+ * @param {string=} dataUrl Data url representation of image, used if supported
+ * @param {string=} alphaUrl Gif image url for IE6
+ *
+ * @returns {string}
+ */
+uki.imageSrc = function(url, dataUrl, alphaUrl) {
+    if (uki.image.dataUrlSupported && dataUrl) return dataUrl;
+    if (alphaUrl && uki.image.needAlphaFix) return alphaUrl;
+    return url;
+};
+
+/**
+ * Image html representation: '<img src="">'
+ *
+ * @param {string} url Image url
+ * @param {string=} dataUrl Data url representation of image, used if supported
+ * @param {boolean=} alphaUrl Gif image url for IE6
+ * @param {string=} html Additional html
+ *
+ * @returns {string} html
+ */
+uki.imageHTML = function(url, dataUrl, alphaUrl, html) {
+    if (uki.image.needAlphaFix && alphaUrl) {
+        url = alphaUrl;
+    } else if (uki.image.dataUrlSupported) {
+        url = dataUrl;
+    }
+    return '<img' + (html || '') + ' src="' + url + '" />';
+};
+
+/**
+ * Loads given images, callbacks after all of them loads
+ *
+ * @param {Array.<Element>} images Images to load
+ * @param {function()} callback
+ */
+uki.image.load = function(images, callback) {
+    var imagesToLoad = images.length;
+    
+    uki.each(images, function(i, img) {
+        if (!img || img.width) {
+            if (!--imagesToLoad) callback();
+            return;
+        }
+
+        var handler = function() {
+                img.onload = img.onerror = img.onabort = null; // prevent memory leaks
+                if (!--imagesToLoad) callback();
+            };
+		img.onload  = handler;
+		img.onerror = handler;
+		img.onabort = handler;
+    });
+};
+
+/**
+ * @type boolean
+ */
+uki.image.dataUrlSupported = doc.createElement('canvas').toDataURL || (/MSIE (8)/).test(ua);
+
+/**
+ * @type boolean
+ */
+uki.image.needAlphaFix = /MSIE 6/.test(ua);
+if(uki.image.needAlphaFix) doc.execCommand("BackgroundImageCache", false, true);

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

@@ -0,0 +1,201 @@
+include('uki.js');
+include('collection.js');
+
+/* Ideas and code parts borrowed from Sizzle (http://sizzlejs.com/) */
+(function() {
+    /**#@+ @ignore */
+    var self,
+        attr = uki.attr,
+        chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
+        regexps = [ // enforce order
+    		{ name: 'ID', regexp: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/ },
+    		{ name: 'ATTR', regexp: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/ },
+    		{ name: 'TYPE', regexp: /^((?:[\w\u00c0-\uFFFF\*_\.-]|\\.)+)/ },
+    		{ name: 'POS',  regexp: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/ }
+	    ],
+	    posRegexp = regexps.POS,
+	    posFilters = {
+    		first: function(i){
+    			return i === 0;
+    		},
+    		last: function(i, match, array){
+    			return i === array.length - 1;
+    		},
+    		even: function(i){
+    			return i % 2 === 0;
+    		},
+    		odd: function(i){
+    			return i % 2 === 1;
+    		},
+    		lt: function(i, match){
+    			return i < match[2] - 0;
+    		},
+    		gt: function(i, match){
+    			return i > match[2] - 0;
+    		},
+    		nth: function(i, match){
+    			return match[2] - 0 == i;
+    		},
+    		eq: function(i, match){
+    			return match[2] - 0 == i;
+    		}
+    	},
+	    reducers = {
+    		TYPE: function(comp, match) {
+    		    var expected = match[1];
+    		    if (expected == '*') return true;
+    		    var typeName = attr(comp, 'typeName');
+    		    return typeName && typeName.length >= expected.length && 
+    		           ('.' + typeName).indexOf('.' + expected) == (typeName.length - expected.length);
+    		},
+    		
+    		ATTR: function(comp, match) {
+    			var result = attr(comp, match[1]),
+    			    value = result + '',
+    				type = match[2],
+    				check = match[4];
+    				
+                return result == null ? type === "!=" :
+                       type === "="   ? value === check :
+                       type === "*="  ? value.indexOf(check) >= 0 :
+                       type === "~="  ? (" " + value + " ").indexOf(check) >= 0 :
+                       !check         ? value && result !== false :
+                       type === "!="  ? value != check :
+                       type === "^="  ? value.indexOf(check) === 0 :
+                       type === "$="  ? value.substr(value.length - check.length) === check :
+                       false;
+    		},
+    		
+    		ID: function(comp, match) {
+    		    return reducers.ATTR(comp, ['', 'id', '=', '', match[1]]);
+    		},
+    		
+    		POS: function(comp, match, i, array) {
+    			var filter = posFilters[match[1]];
+				return filter ? filter( i, match, array ) : false;
+    		}
+	    },
+	    mappers = {
+    		"+": function(context){
+    		    return uki.unique( uki.map(context, 'nextView') );
+    		},
+    		
+    		">": function(context){
+    		    return uki.unique( flatten(uki.map(context, 'childViews')) );
+    		},
+    		
+    		"": function(context) {
+    		    return uki.unique( recChildren(flatten(uki.map(context, 'childViews'))) );
+    		},
+    		
+    		"~": function(context){
+    		}	        
+	    };
+	
+	function recChildren (comps) {
+	    return flatten(uki.map(comps, function(comp) {
+	        return [comp].concat( recChildren(attr(comp, 'childViews')) );
+	    }));
+	}
+	    
+	function flatten (array) {
+	   return uki.reduce( [], array, reduceFlatten );
+	}
+	    
+	function reduceFlatten (x, e) {
+	   return x.concat(e);
+	}
+	/**#@-*/
+	
+    self = 
+    /**
+     * @namespace
+     */
+    uki.Selector = {
+    	/**
+    	 * Finds views by CSS3 selectors in view tree.
+    	 * <p>Can be called as uki(selector) instead of uki.Selector.find(selector)</p>
+    	 *
+    	 * @example
+    	 *   uki('Label') find all labels on page
+    	 *   uki('Box[name=main] > Label') find all immediate descendant Labels in a box with name = "main"
+    	 *   uki('> Slider', context) find all direct descendant Sliders within given context
+    	 *   uki('Slider,Checkbox') find all Sliders and Checkboxes
+    	 *   uki('Slider:eq(3)') find 3-d slider
+    	 *
+    	 * @param {string} selector
+    	 * @param {Array.<uki.view.Base>} context to search in
+    	 *
+    	 * @return {uki.Collection} found views
+    	 */    
+        find: function(selector, context, skipFiltering) {
+            context = context || uki.top();
+            if (context.length === undefined) context = [context];
+
+            var tokens = self.tokenize(selector),
+                expr   = tokens[0],
+                extra  = tokens[1],
+                result = context,
+                mapper;
+                
+            while (expr.length > 0) {
+                mapper = mappers[expr[0]] ? mappers[expr.shift()] : mappers[''];
+                result = mapper(result);
+                if (expr.length == 0) break;
+                result = self.reduce(expr.shift(), result);
+            }
+
+            if (extra) {
+                result = result.concat(self.find(extra, context, true));
+            }
+            
+            return skipFiltering ? result : new uki.Collection(uki.unique(result));
+        },
+        
+        /** @ignore */
+        reduce: function(exprItem, context) {
+            if (!context || !context.length) return [];
+            
+            var match, found;
+                
+            while (exprItem != '') {
+                found = false;
+                uki.each(regexps, function(index, row) {
+                    
+                    /*jsl:ignore*/
+                    if (match = exprItem.match(row.regexp)) {
+                    /*jsl:end*/
+                        found = true;
+                        context = uki.grep(context, function(comp, index) { 
+                            return reducers[row.name](comp, match, index, context); 
+                        });
+                        exprItem = exprItem.replace(row.regexp, '');
+                        return false;
+                    }
+                });
+                if (!found) break;
+            }
+            return context;
+        },
+        
+        /** @ignore */
+        tokenize: function(expr) {
+        	var parts = [], match, extra;
+
+        	chunker.lastIndex = 0;
+
+        	while ( (match = chunker.exec(expr)) !== null ) {
+        		parts.push( match[1] );
+
+        		if ( match[2] ) {
+        			extra = RegExp.rightContext;
+        			break;
+        		}
+        	}
+            
+            return [parts, extra];
+        }
+    };
+    
+    uki.find = self.find;
+})();

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

@@ -0,0 +1,39 @@
+include('../theme.js');
+
+/**
+ * @class
+ */
+uki.theme.Base = {
+    images: [],
+    imageSrcs: [],
+    backgrounds: [],
+    doms: [],
+    styles: [],
+    templates: [],
+    
+    background: function(name, params) {
+        return this.backgrounds[name] && this.backgrounds[name](params);
+    },
+
+    image: function(name, params) {
+        if (this.images[name]) return this.images[name](params);
+        return this.imageSrcs[name] && uki.image.apply(uki, this.imageSrcs[name](params));
+    },
+    
+    imageSrc: function(name, params) {
+        if (this.imageSrcs[name]) return uki.imageSrc.apply(uki, this.imageSrcs[name](params));
+        return this.images[name] && this.images[name](params).src;
+    },
+    
+    dom: function(name, params) {
+        return this.doms[name] && this.doms[name](params);
+    },
+    
+    style: function(name, params) {
+        return this.styles[name] && this.styles[name](params);
+    },
+    
+    template: function(name, params) {
+        return this.templates[name] && this.templates[name](params);
+    }
+};

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

@@ -0,0 +1,26 @@
+include('../theme.js');
+
+/**
+ * Simple and fast (2x–15x faster than regexp) html template
+ * @example
+ *   var t = new uki.theme.Template('<p class="${className}">${value}</p>')
+ *   t.render({className: 'myClass', value: 'some html'})
+ */
+uki.theme.Template = function(code) {
+    var parts = code.split('${'), i, l, tmp;
+    this.parts = [parts[0]];
+    this.names = [];
+    for (i=1, l = parts.length; i < l; i++) {
+        tmp = parts[i].split('}');
+        this.names.push(tmp.shift());
+        this.parts.push('');
+        this.parts.push(tmp.join('}'));
+    };
+};
+
+uki.theme.Template.prototype.render = function(values) {
+    for (var i=0, names = this.names, l = names.length; i < l; i++) {
+        this.parts[i*2+1] = values[names[i]] || '';
+    };
+    return this.parts.join('');
+};

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

@@ -0,0 +1,45 @@
+include('uki.js');
+
+/**
+ * @namespace
+ */
+uki.theme = {
+    themes: [],
+    
+    register: function(theme) {
+        uki.theme.themes.push(theme);
+    },
+    
+    background: function(name, params) {
+        return uki.theme._namedResource(name, 'background', params) || new uki.background.Null();
+    },
+    
+    image: function(name, params) {
+        return uki.theme._namedResource(name, 'image', params) || new Image();
+    },
+    
+    imageSrc: function(name, params) {
+        return uki.theme._namedResource(name, 'imageSrc', params) || '';
+    },
+    
+    style: function(name, params) {
+        return uki.theme._namedResource(name, 'style', params) || '';
+    },
+    
+    dom: function(name, params) {
+        return uki.theme._namedResource(name, 'dom', params) || uki.createElement('div');
+    },
+    
+    template: function(name, params) {
+        return uki.theme._namedResource(name, 'template', params) || '';
+    },
+    
+    _namedResource: function(name, type, params) {
+        for (var i = uki.theme.themes.length - 1; i >= 0; i--){
+            var result = uki.theme.themes[i][type](name, params);
+            if (result) return result;
+        };
+        return null;
+        
+    }
+};

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

@@ -0,0 +1,45 @@
+/**
+ * Shortcut access to uki.build, uki.Selector.find and uki.Collection constructor
+ * uki('#id') is also a shortcut for search by id
+ *
+ * @param {String|uki.view.Base|Object|Array.<uki.view.Base>} val
+ * @param {Array.<uki.view.Base>=} optional context for selector
+ * @class
+ * @namespace
+ * @name uki
+ * @return {uki.Collection}
+ */
+root.uki = function(val, context) {
+    if (typeof val == 'string') {
+        var m = val.match(/^#((?:[\w\u00c0-\uFFFF_-]|\\.)+)$/),
+            e = m && uki._ids[m[1]];
+        if (m && !context) {
+            return new uki.Collection( e ? [e] : [] );
+        }
+        return uki.find(val, context);
+    }
+    if (val.length === undefined) val = [val];
+    if (val.length > 0 && uki.isFunction(val[0].typeName)) return new uki.Collection(val);
+    return uki.build(val);
+};
+
+/**
+ * @type string
+ * @field
+ */
+uki.version = '0.1.0.1';
+
+/**
+ * Empty function
+ * @type function():boolean
+ */
+uki.F = function() { return false; };
+uki._ids = {};
+
+uki.registerId = function(comp) {
+    uki._ids[uki.attr(comp, 'id')] = comp;
+}; 
+uki.unregisterId = function(comp) {
+    uki._ids[uki.attr(comp, 'id')] = undefined;
+};
+