Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.dtl.tag.logic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.dtl.tag.logic"] = true;
dojo.provide("dojox.dtl.tag.logic");

dojo.require("dojox.dtl._base");

dojox.dtl.tag.logic.IfNode = function(bools, trues, falses, type){
        this.bools = bools;
        this.trues = trues;
        this.falses = falses;
        this.type = type;
}
dojo.extend(dojox.dtl.tag.logic.IfNode, {
        render: function(context, buffer){
                if(this.type == "or"){
                        for(var i = 0, bool; bool = this.bools[i]; i++){
                                var ifnot = bool[0];
                                var filter = bool[1];
                                var value = filter.resolve(context);
                                if((value && !ifnot) || (ifnot && !value)){
                                        if(this.falses){
                                                buffer = this.falses.unrender(context, buffer);
                                        }
                                        return this.trues.render(context, buffer, this);
                                }
                                buffer = this.trues.unrender(context, buffer);
                                if(this.falses) return this.falses.render(context, buffer, this);
                        }
                }else{
                        for(var i = 0, bool; bool = this.bools[i]; i++){
                                var ifnot = bool[0];
                                var filter = bool[1];
                                var value = filter.resolve(context);
                                if(!((value && !ifnot) || (ifnot && !value))){
                                        if(this.trues){
                                                buffer = this.trues.unrender(context, buffer);
                                        }
                                        return this.falses.render(context, buffer, this);
                                }
                                buffer = this.falses.unrender(context, buffer);
                                if(this.falses) return this.trues.render(context, buffer, this);
                        }
                }
                return buffer;
        },
        unrender: function(context, buffer){
                if(this.trues) buffer = this.trues.unrender(context, buffer);
                if(this.falses) buffer = this.falses.unrender(context, buffer);
                return buffer;
        },
        clone: function(buffer){
                var trues = this.trues;
                var falses = this.falses;
                if(trues){
                        trues = trues.clone(buffer);
                }
                if(falses){
                        falses = falses.clone(buffer);
                }
                return new this.constructor(this.bools, trues, falses, this.type);
        },
        toString: function(){ return "dojox.dtl.tag.logic.IfNode"; }
});

dojox.dtl.tag.logic.ForNode = function(assign, loop, reversed, nodelist){
        this.assign = assign;
        this.loop = loop;
        this.reversed = reversed;
        this.nodelist = nodelist;
        this.pool = [];
}
dojo.extend(dojox.dtl.tag.logic.ForNode, {
        render: function(context, buffer){
                var parentloop = {};
                if(context.forloop){
                        parentloop = context.forloop;
                }
                var items = dojox.dtl.resolveVariable(this.loop, context);
                context.push();
                for(var i = items.length; i < this.pool.length; i++){
                        this.pool[i].unrender(context, buffer);
                }
                if(this.reversed){
                        items = items.reversed();
                }
                var j = 0;
                for(var i in items){
                        var item = items[i];
                        context.forloop = {
                                key: i,
                                counter0: j,
                                counter: j + 1,
                                revcounter0: items.length - j - 1,
                                revcounter: items.length - j,
                                first: j == 0,
                                parentloop: parentloop
                        };
                        context[this.assign] = item;
                        if(j + 1 > this.pool.length){
                                this.pool.push(this.nodelist.clone(buffer));
                        }
                        buffer = this.pool[j].render(context, buffer, this);
                        ++j;
                }
                context.pop();
                return buffer;
        },
        unrender: function(context, buffer){
                for(var i = 0, pool; pool = this.pool[i]; i++){
                        buffer = pool.unrender(context, buffer);
                }
                return buffer;
        },
        clone: function(buffer){
                return new this.constructor(this.assign, this.loop, this.reversed, this.nodelist.clone(buffer));
        },
        toString: function(){ return "dojox.dtl.tag.logic.ForNode"; }
});

dojox.dtl.tag.logic.if_ = function(parser, text){
        var parts = text.split(/\s+/g);
        var type;
        var bools = [];
        parts.shift();
        text = parts.join(" ");
        parts = text.split(" and ");
        if(parts.length == 1){
                type = "or";
                parts = text.split(" or ");
        }else{
                type = "and";
                for(var i = 0; i < parts.length; i++){
                        if(parts[i] == "or"){
                                throw new Error("'if' tags can't mix 'and' and 'or'");
                        }
                }
        }
        for(var i = 0, part; part = parts[i]; i++){
                var not = false;
                if(part.indexOf("not ") == 0){
                        part = part.substring(4);
                        not = true;
                }
                bools.push([not, new dojox.dtl.Filter(part)]);
        }
        var trues = parser.parse(["else", "endif"]);
        var falses = false;
        var token = parser.next();
        if(token.text == "else"){
                var falses = parser.parse(["endif"]);
                parser.next();
        }
        return new dojox.dtl.tag.logic.IfNode(bools, trues, falses, type);
}

dojox.dtl.tag.logic.for_ = function(parser, text){
        var parts = text.split(/\s+/g);
        var reversed = parts.length == 5;
        var nodelist = parser.parse(["endfor"]);
        parser.next();
        return new dojox.dtl.tag.logic.ForNode(parts[1], parts[3], reversed, nodelist);
}

}