targetj 1.0.2

package/src/Bracket.js

@@ -0,0 +1,201 @@
+function Bracket(parent) {
+
+    var tm = new TModel("BI");
+    tm.parent = parent;
+    tm.newFlag = true;
+    
+    tm.targets = {
+        canHaveDom: false,
+        innerXEast: {
+            loop: true,
+            value: function() {
+                return TUtil.isDefined(tm.getRealParent().getValue('innerXEast')) ? tm.getRealParent().getValue('innerXEast') : tm.getRealParent().absX + tm.getRealParent().getWidth();
+            }
+        },
+        xOverflow: {
+            loop: true,
+            value: function() { 
+                return this.getRealParent().getX();
+            }
+        },
+        outerXEast: 0
+    };
+
+    tm.getTargetWidth = function()  {
+        return this.getContentWidth();
+    };
+    
+    tm.getTargetHeight = function()   {
+        return this.getContentHeight();
+    };
+    
+    tm.getWidth = function()    {
+        return this.getContentWidth() || 1;
+    };
+    
+    tm.getHeight = function()   {
+        return this.getContentHeight() || 1;
+    };
+    
+    tm.getInnerWidth = function() {
+        return this.innerContentWidth;
+    };
+    
+    tm.getInnerContentHeight = function() {
+        return this.innerContentHeight;
+    };
+    
+    tm.getScrollTop = function() {
+        this.initParents();
+        return this.getRealParent().getScrollTop();
+    };
+    
+    tm.getScrollLeft = function() {
+        this.initParents();
+        return this.getRealParent().getScrollLeft();
+    };
+    
+    tm.addUpdatingChild = function(child) {
+        this.getRealParent().addUpdatingChild(child);
+    };
+    
+    tm.createViewport = function() { 
+        return this.getRealParent().createViewport.call(this);
+    };
+   
+    tm.getRealParent = function()   {
+        this.initParents();
+        return this.realParent;
+    };
+    
+    tm.shouldCalculateChildrenLocations = function()    {
+        var result = this.isVisible() || this.newFlag;
+        this.newFlag = false;
+                
+        return result;
+    };
+    
+    tm.getChildren = function() {
+        return this.actualValues.tchildren;
+    };
+    
+    tm.addToParentVisibleList = function() {};
+    
+    tm.initParents = function() {
+        if (this.realParent || this.topBracket)    {
+            return;
+        }
+        
+        var topBracket = this;
+        var parent = this.bracketParent;
+                        
+        while (parent) {
+            
+            if (parent.type !== 'BI')  {
+                break;
+            } else {
+                topBracket = parent;
+                parent = parent.bracketParent;
+            }
+        }   
+        
+        this.realParent = parent;
+        this.topBracket = topBracket;
+    };
+    
+    tm.getChildrenOids = function()    {
+        
+        var oids = [], list = this.getChildren();
+        
+        for (var i = 0; i < list.length; i++)  {
+            var item = list[i];
+            if (item.type === 'BI')   {
+                var goids = item.getChildrenOids();
+
+                oids = [].concat(oids, [item.oid], goids);
+            } else {
+                oids.push(item.oid + ":" + (item.location ? item.y + "px" : "0px"));
+            }
+            
+        }
+        
+        return oids;
+    };
+
+    return tm;
+}
+
+Bracket.bracketMap = {};
+Bracket.bracketAllMap = {};
+
+Bracket.generate = function(page, listOfTModel)  {
+    var i;
+    var brackets = Bracket.bracketMap[page.oid];
+    
+    var maxLastUpdate = Math.max(page.getActualValueLastUpdate('allChildren'), page.getActualValueLastUpdate('width'), page.getActualValueLastUpdate('height'));
+    
+    if (brackets && brackets.lastUpdate >= maxLastUpdate) {
+        brackets = Bracket.bracketMap[page.oid];
+    } else {       
+        brackets = {
+            lastUpdate: maxLastUpdate,
+            list: []
+        };  
+        
+        listOfTModel = page.type !== 'BI' && !listOfTModel ? page.getChildren() : listOfTModel;
+
+        var length = listOfTModel.length;
+        var cannotBeBracketedIndex = 0;
+        
+        for (i = 0; i < length; i++) {
+            if (!listOfTModel[i].canBeBracketed()) {
+                cannotBeBracketedIndex++;
+                brackets.list.push(listOfTModel[i]);
+            } else {
+                break;
+            }
+        }
+
+        var bracketSize = Math.max(2, tapp.locationManager.bracketThreshold - 1);
+        var bracketCount = Math.ceil((length - cannotBeBracketedIndex) / bracketSize);
+        
+        var index = cannotBeBracketedIndex;
+        for (i = 0; i < bracketCount; i++) {
+
+            var size = Math.min(length - index, bracketSize);
+
+            var bracketId = page.oid + "_" + page.getWidth() + "_" + page.getHeight() + "_" + listOfTModel.slice(index, index + size).oids('_');
+            var bracket;
+
+            if (Bracket.bracketAllMap[bracketId]) {
+                bracket = Bracket.bracketAllMap[bracketId];
+            } else {
+                bracket = new Bracket(page);
+
+                Bracket.bracketAllMap[bracketId] = bracket;
+
+                bracket.actualValues.tchildren = listOfTModel.slice(index, index + size);
+
+                if (bracket.actualValues.tchildren[0].type === 'BI')   { 
+
+                    bracket.actualValues.children.forEach(function(b) {
+                        b.bracketParent = bracket; 
+                    });
+                }
+
+                bracket.bracketParent = page;
+            }
+
+            brackets.list.push(bracket);
+            index += size;
+        }
+
+        if (brackets.list.length - cannotBeBracketedIndex > tapp.locationManager.bracketThreshold)   {
+            brackets = Bracket.generate(page, brackets.list);
+        } else {
+            Bracket.bracketMap[page.oid] = brackets;
+        }
+    }
+          
+    return brackets;  
+};

package/src/Browser.js

@@ -0,0 +1,297 @@
+var browser = {
+    style: undefined,
+    localStorage: null,
+    startTimes: [],
+    callCount: {},
+    delayProcess: {},
+    setup: function () {
+
+        if (typeof String.prototype.trim !== 'function') {
+            String.prototype.trim = function () {
+                return this.replace(/^\s+|\s+$/g, '');
+            };
+        }     
+        if (typeof String.prototype.startsWith !== 'function') {
+            String.prototype.startsWith = function (str) {
+                return this.indexOf(str) === 0;
+            };
+        }
+
+        if (typeof String.prototype.endsWith !== 'function') {
+            String.prototype.endsWith = function (suffix) {
+                return this.indexOf(suffix, this.length - suffix.length) !== -1;
+            };
+        }
+
+        if (typeof String.prototype.hashCode !== 'function') {
+            String.prototype.hashCode = function () {
+                var hash = 0, i, chr, len;
+                if (this.length === 0)
+                    return hash;
+                for (i = 0, len = this.length; i < len; i++) {
+                    chr = this.charCodeAt(i);
+                    hash = ((hash << 5) - hash) + chr;
+                    hash |= 0; // Convert to 32bit integer
+                }
+                return Math.abs(hash);
+            };
+        }
+
+        if (!Array.prototype.oids) {
+            Array.prototype.oids = function(separator)   {
+                return this.map(function(o) { return o.oid; }).join(separator || " ");
+            };
+        }
+        
+        if (!Array.spaces)  {
+            Array.spaces = function(count)   {
+                return Array(count).join(' ');
+            };
+        }
+        
+        
+
+        if (!Array.prototype.find) {
+          Object.defineProperty(Array.prototype, 'find', {
+            value: function(predicate) {
+              if (this === null) {
+                throw new TypeError('"this" is null or not defined');
+              }
+
+              var o = Object(this);
+
+              var len = o.length >>> 0;
+
+              if (typeof predicate !== 'function') {
+                throw new TypeError('predicate must be a function');
+              }
+
+              var thisArg = arguments[1];
+
+              var k = 0;
+
+              while (k < len) {
+                var kValue = o[k];
+                if (predicate.call(thisArg, kValue, k, o)) {
+                  return kValue;
+                }
+                k++;
+              }
+
+              return undefined;
+            },
+            configurable: true,
+            writable: true
+          });
+        }
+
+
+        if (!document.getElementsByClassName) {
+            var indexOf = [].indexOf || function (prop) {
+                for (var i = 0; i < this.length; i++) {
+                    if (this[i] === prop)
+                        return i;
+                }
+                return -1;
+            };
+            var getElementsByClassName = function (className, context) {
+                var elems = document.querySelectorAll ? context.querySelectorAll("." + className) : (function () {
+                    var all = context.getElementsByTagName("*"),
+                            elements = [],
+                            i = 0;
+                    for (; i < all.length; i++) {
+                        if (all[i].className && (" " + all[i].className + " ").indexOf(" " + className + " ") > -1 && indexOf.call(elements, all[i]) === -1)
+                            elements.push(all[i]);
+                    }
+                    return elements;
+                })();
+                return elems;
+            };
+            document.getElementsByClassName = function (className) {
+                return getElementsByClassName(className, document);
+            };
+            Element.prototype.getElementsByClassName = function (className) {
+                return getElementsByClassName(className, this);
+            };
+        }
+
+        var lastTime = 0;
+        var vendors = ['ms', 'moz', 'webkit', 'o'];
+        for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
+            window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
+            window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] ||
+                    window[vendors[x] + 'CancelRequestAnimationFrame'];
+        }
+
+        if (!window.requestAnimationFrame) {
+            window.requestAnimationFrame = function (callback, element) {
+                var currTime = new Date().getTime();
+                var timeToCall = Math.max(0, 16 - (currTime - lastTime));
+                var id = window.setTimeout(function () {
+                    callback(currTime + timeToCall);
+                },
+                        timeToCall);
+                lastTime = currTime + timeToCall;
+                return id;
+            };
+        }
+
+        if (!window.cancelAnimationFrame) {
+            window.cancelAnimationFrame = function (id) {
+                clearTimeout(id);
+            };
+        }
+
+        this.style = {
+            transform: this.prefixStyle('transform'),
+            transitionTimingFunction: this.prefixStyle('transitionTimingFunction'),
+            transitionDuration: this.prefixStyle('transitionDuration')
+        };
+        
+    },
+    log: function(condition) {
+        if (condition === true) {
+            return console.log;
+        } else {
+            return function() {};
+        }
+    },   
+    getLocalStorage: function () {
+        if (this.localStorage === null) {
+            try {
+                this.localStorage = window.localStorage; // This will throw an exception in some browsers when cookies/localStorage are explicitly disabled (i.e. Chrome)
+                this.localStorage.setItem('TEST', '1');
+                this.localStorage.removeItem('TEST');
+            } catch (e) {
+                this.localStorage = false;
+            }
+        }
+
+        return this.localStorage;
+    },
+    prefixStyle: function (style) {
+        var elementStyle = document.createElement('div').style;
+        
+        var vendor = '';
+        
+        var vendors = ['webkitT', 'MozT', 'msT', 'OT', 't'];
+
+        for (var i = 0; i < vendors.length; i++) {
+            var transform = vendors[i] + 'ransform';
+            if (transform in elementStyle) {
+                vendor = vendors[i].substr(0, vendors[i].length - 1);
+            }
+        }
+
+        style = vendor === '' ? style : vendor + style.charAt(0).toUpperCase() + style.substr(1);
+        
+        return style;
+    },
+    getParameterByName: function (name) {
+        name = name.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
+        var regex = new RegExp("[\\?&]" + name + "=([^&#]*)"),
+                results = regex.exec(location.search);
+        return results === null ? 0 : decodeURIComponent(results[1].replace(/\+/g, " "));
+    },
+    now: Date.now || function () {
+        return new Date().getTime();
+    },
+    nowInSeconds: function () {
+        return Math.floor(this.now() / 1000);
+    },
+    time: function (s) {     
+        this.startTimes.push({label: s, time: this.now()});
+    },
+    timeEnd: function (minTime) {
+        minTime = minTime || 0;
+        var total = 0, diff;
+        var key, out = [];
+        browser.time("#end#");
+        for (var i = 1; i < this.startTimes.length; i++) {
+  
+            diff = (this.startTimes[i].time - this.startTimes[i - 1].time);
+            total += diff;
+
+            if (diff >= minTime) {
+               out.push(this.startTimes[i - 1].label + " =  " + diff); 
+            }
+            
+        }
+        for (key in this.callCount) {
+            out.push("count: " + key + " =  " + this.callCount[key]);
+        }
+              
+        console.log(out);
+
+        this.startTimes.length = 0;
+        this.callCount = {};
+        
+        return out;
+    },
+    createCookie: function (name, value, days) {
+        if (!name) return;
+
+        var expires;
+
+        if (days) {
+            var date = new Date();
+            date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+            expires = "; expires=" + date.toGMTString();
+        } else {
+            expires = "";
+        }
+        document.cookie = escape(name) + "=" + escape(value) + expires + "; path=/";
+    },
+    readCookie: function (name) {
+        var nameEQ = escape(name) + "=";
+        var ca = document.cookie.split(';');
+        for (var i = 0; i < ca.length; i++) {
+            var c = ca[i];
+            while (c.charAt(0) === ' ')
+                c = c.substring(1, c.length);
+            if (c.indexOf(nameEQ) === 0)
+                return unescape(c.substring(nameEQ.length, c.length));
+        }
+        return null;
+    },
+    eraseCookie: function (name) {
+        browser.createCookie(name, "", -1);
+    },
+    delay: function (fn, oid, delay) {
+        var timeStamp = browser.now() + delay;
+        
+        var nextRun;
+        
+        if (this.delayProcess.id) {
+            if (timeStamp >= this.delayProcess.timeStamp)    {
+                nextRun = { timeStamp: timeStamp, oid: oid, delay: delay };
+            } else if (timeStamp < this.delayProcess.timeStamp) {
+                nextRun = { timeStamp: this.delayProcess.timeStamp, oid: this.delayProcess.oid, delay: this.delayProcess.delay };
+                
+                clearTimeout(this.delayProcess.id);
+                
+                //console.log("clearing: " + oid + ", " + (this.delayProcess.timeStamp) + " vs " + timeStamp);
+                
+                this.delayProcess.oid = oid;
+                this.delayProcess.timeStamp = timeStamp;
+                this.delayProcess.delay = delay;
+                
+                this.delayProcess.id = setTimeout(function() {
+                   fn();
+                   browser.delayProcess = {};
+                }, delay);                
+            }
+        } else {
+            this.delayProcess.oid = oid;
+            this.delayProcess.timeStamp = timeStamp;
+            this.delayProcess.delay = delay;
+            
+            this.delayProcess.id = setTimeout(function() {
+               fn();
+               browser.delayProcess = {};
+            }, delay);             
+        }
+        
+        return nextRun;
+    }
+};

package/src/Dim.js

@@ -0,0 +1,19 @@
+function Dim()  {
+    function my() {}
+            
+    my.screen ={
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0    
+    };
+  
+    my.measureScreen = function() {
+        my.screen.width = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
+        my.screen.height = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight; 
+        
+        return my;
+    };
+    
+    return my;
+}