Catalyst-Controller-POD
view release on metacpan or search on metacpan
share/ext/ext-all-debug.js view on Meta::CPAN
var item = this.activeItem;
delete this.activeItem;
this.layout.setActiveItem(item);
}
if(!this.ownerCt){
this.doLayout(false, true);
}
if(this.monitorResize === true){
Ext.EventManager.onWindowResize(this.doLayout, this, [false]);
}
},
getLayoutTarget : function(){
return this.el;
},
getComponentId : function(comp){
return comp.getItemId();
},
add : function(comp){
this.initItems();
var args = arguments.length > 1;
if(args || Ext.isArray(comp)){
var result = [];
Ext.each(args ? arguments : comp, function(c){
result.push(this.add(c));
}, this);
return result;
}
var c = this.lookupComponent(this.applyDefaults(comp));
var index = this.items.length;
if(this.fireEvent('beforeadd', this, c, index) !== false && this.onBeforeAdd(c) !== false){
this.items.add(c);
c.onAdded(this, index);
this.onAdd(c);
this.fireEvent('add', this, c, index);
}
return c;
},
onAdd : function(c){
},
onAdded : function(container, pos) {
this.ownerCt = container;
this.initRef();
this.cascade(function(c){
c.initRef();
});
this.fireEvent('added', this, container, pos);
},
insert : function(index, comp) {
var args = arguments,
length = args.length,
result = [],
i, c;
this.initItems();
if (length > 2) {
for (i = length - 1; i >= 1; --i) {
result.push(this.insert(index, args[i]));
}
return result;
}
c = this.lookupComponent(this.applyDefaults(comp));
index = Math.min(index, this.items.length);
if (this.fireEvent('beforeadd', this, c, index) !== false && this.onBeforeAdd(c) !== false) {
if (c.ownerCt == this) {
this.items.remove(c);
}
this.items.insert(index, c);
c.onAdded(this, index);
this.onAdd(c);
this.fireEvent('add', this, c, index);
}
return c;
},
applyDefaults : function(c){
var d = this.defaults;
if(d){
if(Ext.isFunction(d)){
d = d.call(this, c);
}
if(Ext.isString(c)){
c = Ext.ComponentMgr.get(c);
Ext.apply(c, d);
}else if(!c.events){
Ext.applyIf(c.isAction ? c.initialConfig : c, d);
}else{
Ext.apply(c, d);
}
}
return c;
},
onBeforeAdd : function(item){
if(item.ownerCt){
item.ownerCt.remove(item, false);
share/ext/ext-all-debug.js view on Meta::CPAN
shouldBufferLayout: function(){
var hl = this.hasLayout;
if(this.ownerCt){
return hl ? !this.hasLayoutPending() : false;
}
return hl;
},
hasLayoutPending: function(){
var pending = false;
this.ownerCt.bubble(function(c){
if(c.layoutPending){
pending = true;
return false;
}
});
return pending;
},
onShow : function(){
Ext.Container.superclass.onShow.call(this);
if(Ext.isDefined(this.deferLayout)){
delete this.deferLayout;
this.doLayout(true);
}
},
getLayout : function(){
if(!this.layout){
var layout = new Ext.layout.AutoLayout(this.layoutConfig);
this.setLayout(layout);
}
return this.layout;
},
beforeDestroy : function(){
var c;
if(this.items){
while(c = this.items.first()){
this.doRemove(c, true);
}
}
if(this.monitorResize){
Ext.EventManager.removeResizeListener(this.doLayout, this);
}
Ext.destroy(this.layout);
Ext.Container.superclass.beforeDestroy.call(this);
},
cascade : function(fn, scope, args){
if(fn.apply(scope || this, args || [this]) !== false){
if(this.items){
var cs = this.items.items;
for(var i = 0, len = cs.length; i < len; i++){
if(cs[i].cascade){
cs[i].cascade(fn, scope, args);
}else{
fn.apply(scope || cs[i], args || [cs[i]]);
}
}
}
}
return this;
},
findById : function(id){
var m = null,
ct = this;
this.cascade(function(c){
if(ct != c && c.id === id){
m = c;
return false;
}
});
return m;
},
findByType : function(xtype, shallow){
return this.findBy(function(c){
return c.isXType(xtype, shallow);
});
},
find : function(prop, value){
return this.findBy(function(c){
return c[prop] === value;
});
},
findBy : function(fn, scope){
var m = [], ct = this;
this.cascade(function(c){
if(ct != c && fn.call(scope || c, c, ct) === true){
m.push(c);
}
});
return m;
},
get : function(key){
return this.getComponent(key);
}
});
Ext.Container.LAYOUTS = {};
Ext.reg('container', Ext.Container);
Ext.layout.ContainerLayout = Ext.extend(Object, {
monitorResize:false,
activeItem : null,
constructor : function(config){
this.id = Ext.id(null, 'ext-layout-');
Ext.apply(this, config);
},
type: 'container',
IEMeasureHack : function(target, viewFlag) {
var tChildren = target.dom.childNodes, tLen = tChildren.length, c, d = [], e, i, ret;
for (i = 0 ; i < tLen ; i++) {
c = tChildren[i];
e = Ext.get(c);
if (e) {
d[i] = e.getStyle('display');
e.setStyle({display: 'none'});
}
}
ret = target ? target.getViewSize(viewFlag) : {};
for (i = 0 ; i < tLen ; i++) {
c = tChildren[i];
e = Ext.get(c);
if (e) {
e.setStyle({display: d[i]});
}
}
return ret;
},
getLayoutTargetSize : Ext.EmptyFn,
share/ext/ext-all-debug.js view on Meta::CPAN
afterEffect : function(anim){
this.syncShadow();
this.el.removeClass('x-panel-animated');
},
createEffect : function(a, cb, scope){
var o = {
scope:scope,
block:true
};
if(a === true){
o.callback = cb;
return o;
}else if(!a.callback){
o.callback = cb;
}else {
o.callback = function(){
cb.call(scope);
Ext.callback(a.callback, a.scope);
};
}
return Ext.applyIf(o, a);
},
collapse : function(animate){
if(this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforecollapse', this, animate) === false){
return;
}
var doAnim = animate === true || (animate !== false && this.animCollapse);
this.beforeEffect(doAnim);
this.onCollapse(doAnim, animate);
return this;
},
onCollapse : function(doAnim, animArg){
if(doAnim){
this[this.collapseEl].slideOut(this.slideAnchor,
Ext.apply(this.createEffect(animArg||true, this.afterCollapse, this),
this.collapseDefaults));
}else{
this[this.collapseEl].hide(this.hideMode);
this.afterCollapse(false);
}
},
afterCollapse : function(anim){
this.collapsed = true;
this.el.addClass(this.collapsedCls);
if(anim !== false){
this[this.collapseEl].hide(this.hideMode);
}
this.afterEffect(anim);
this.cascade(function(c) {
if (c.lastSize) {
c.lastSize = { width: undefined, height: undefined };
}
});
this.fireEvent('collapse', this);
},
expand : function(animate){
if(!this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforeexpand', this, animate) === false){
return;
}
var doAnim = animate === true || (animate !== false && this.animCollapse);
this.el.removeClass(this.collapsedCls);
this.beforeEffect(doAnim);
this.onExpand(doAnim, animate);
return this;
},
onExpand : function(doAnim, animArg){
if(doAnim){
this[this.collapseEl].slideIn(this.slideAnchor,
Ext.apply(this.createEffect(animArg||true, this.afterExpand, this),
this.expandDefaults));
}else{
this[this.collapseEl].show(this.hideMode);
this.afterExpand(false);
}
},
afterExpand : function(anim){
this.collapsed = false;
if(anim !== false){
this[this.collapseEl].show(this.hideMode);
}
this.afterEffect(anim);
if (this.deferLayout) {
delete this.deferLayout;
this.doLayout(true);
}
this.fireEvent('expand', this);
},
toggleCollapse : function(animate){
this[this.collapsed ? 'expand' : 'collapse'](animate);
return this;
},
onDisable : function(){
if(this.rendered && this.maskDisabled){
this.el.mask();
}
Ext.Panel.superclass.onDisable.call(this);
},
share/ext/ext-all-debug.js view on Meta::CPAN
delete this.el.lastLT;
if(this.x === undefined || this.y === undefined){
var xy = this.el.getAlignToXY(this.container, 'c-c');
var pos = this.el.translatePoints(xy[0], xy[1]);
this.x = this.x === undefined? pos.left : this.x;
this.y = this.y === undefined? pos.top : this.y;
}
this.el.setLeftTop(this.x, this.y);
if(this.expandOnShow){
this.expand(false);
}
if(this.modal){
Ext.getBody().addClass('x-body-masked');
this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
this.mask.show();
}
},
show : function(animateTarget, cb, scope){
if(!this.rendered){
this.render(Ext.getBody());
}
if(this.hidden === false){
this.toFront();
return this;
}
if(this.fireEvent('beforeshow', this) === false){
return this;
}
if(cb){
this.on('show', cb, scope, {single:true});
}
this.hidden = false;
if(Ext.isDefined(animateTarget)){
this.setAnimateTarget(animateTarget);
}
this.beforeShow();
if(this.animateTarget){
this.animShow();
}else{
this.afterShow();
}
return this;
},
afterShow : function(isAnim){
if (this.isDestroyed){
return false;
}
this.proxy.hide();
this.el.setStyle('display', 'block');
this.el.show();
if(this.maximized){
this.fitContainer();
}
if(Ext.isMac && Ext.isGecko2){
this.cascade(this.setAutoScroll);
}
if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){
Ext.EventManager.onWindowResize(this.onWindowResize, this);
}
this.doConstrain();
this.doLayout();
if(this.keyMap){
this.keyMap.enable();
}
this.toFront();
this.updateHandles();
if(isAnim && (Ext.isIE || Ext.isWebKit)){
var sz = this.getSize();
this.onResize(sz.width, sz.height);
}
this.onShow();
this.fireEvent('show', this);
},
animShow : function(){
this.proxy.show();
this.proxy.setBox(this.animateTarget.getBox());
this.proxy.setOpacity(0);
var b = this.getBox();
this.el.setStyle('display', 'none');
this.proxy.shift(Ext.apply(b, {
callback: this.afterShow.createDelegate(this, [true], false),
scope: this,
easing: 'easeNone',
duration: this.showAnimDuration,
opacity: 0.5
}));
},
hide : function(animateTarget, cb, scope){
if(this.hidden || this.fireEvent('beforehide', this) === false){
return this;
}
if(cb){
this.on('hide', cb, scope, {single:true});
}
this.hidden = true;
if(animateTarget !== undefined){
this.setAnimateTarget(animateTarget);
}
if(this.modal){
this.mask.hide();
Ext.getBody().removeClass('x-body-masked');
}
if(this.animateTarget){
this.animHide();
}else{
this.el.hide();
this.afterHide();
}
return this;
},
share/ext/ext-all-debug.js view on Meta::CPAN
onHide : Ext.emptyFn,
onWindowResize : function(){
if(this.maximized){
this.fitContainer();
}
if(this.modal){
this.mask.setSize('100%', '100%');
var force = this.mask.dom.offsetHeight;
this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
}
this.doConstrain();
},
doConstrain : function(){
if(this.constrain || this.constrainHeader){
var offsets;
if(this.constrain){
offsets = {
right:this.el.shadowOffset,
left:this.el.shadowOffset,
bottom:this.el.shadowOffset
};
}else {
var s = this.getSize();
offsets = {
right:-(s.width - 100),
bottom:-(s.height - 25)
};
}
var xy = this.el.getConstrainToXY(this.container, true, offsets);
if(xy){
this.setPosition(xy[0], xy[1]);
}
}
},
ghost : function(cls){
var ghost = this.createGhost(cls);
var box = this.getBox(true);
ghost.setLeftTop(box.x, box.y);
ghost.setWidth(box.width);
this.el.hide();
this.activeGhost = ghost;
return ghost;
},
unghost : function(show, matchPosition){
if(!this.activeGhost) {
return;
}
if(show !== false){
this.el.show();
this.focus.defer(10, this);
if(Ext.isMac && Ext.isGecko2){
this.cascade(this.setAutoScroll);
}
}
if(matchPosition !== false){
this.setPosition(this.activeGhost.getLeft(true), this.activeGhost.getTop(true));
}
this.activeGhost.hide();
this.activeGhost.remove();
delete this.activeGhost;
},
minimize : function(){
this.fireEvent('minimize', this);
return this;
},
close : function(){
if(this.fireEvent('beforeclose', this) !== false){
if(this.hidden){
this.doClose();
}else{
this.hide(null, this.doClose, this);
}
}
},
doClose : function(){
this.fireEvent('close', this);
this.destroy();
},
maximize : function(){
if(!this.maximized){
this.expand(false);
this.restoreSize = this.getSize();
this.restorePos = this.getPosition(true);
if (this.maximizable){
this.tools.maximize.hide();
this.tools.restore.show();
}
this.maximized = true;
this.el.disableShadow();
if(this.dd){
this.dd.lock();
}
if(this.collapsible){
this.tools.toggle.hide();
}
this.el.addClass('x-window-maximized');
this.container.addClass('x-window-maximized-ct');
this.setPosition(0, 0);
this.fitContainer();
this.fireEvent('maximize', this);
}
return this;
share/ext/ext-all-debug.js view on Meta::CPAN
}
if(this.innerCt){
this.clearInnerCt();
this.renderRoot();
}
return node;
},
clearInnerCt : function(){
this.innerCt.update('');
},
renderRoot : function(){
this.root.render();
if(!this.rootVisible){
this.root.renderChildren();
}
},
getNodeById : function(id){
return this.nodeHash[id];
},
registerNode : function(node){
this.nodeHash[node.id] = node;
},
unregisterNode : function(node){
delete this.nodeHash[node.id];
},
toString : function(){
return '[Tree'+(this.id?' '+this.id:'')+']';
},
restrictExpand : function(node){
var p = node.parentNode;
if(p){
if(p.expandedChild && p.expandedChild.parentNode == p){
p.expandedChild.collapse();
}
p.expandedChild = node;
}
},
getChecked : function(a, startNode){
startNode = startNode || this.root;
var r = [];
var f = function(){
if(this.attributes.checked){
r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a]));
}
};
startNode.cascade(f);
return r;
},
getLoader : function(){
return this.loader;
},
expandAll : function(){
this.root.expand(true);
},
collapseAll : function(){
this.root.collapse(true);
},
getSelectionModel : function(){
if(!this.selModel){
this.selModel = new Ext.tree.DefaultSelectionModel();
}
return this.selModel;
},
expandPath : function(path, attr, callback){
if(Ext.isEmpty(path)){
if(callback){
callback(false, undefined);
}
return;
}
attr = attr || 'id';
var keys = path.split(this.pathSeparator);
var curNode = this.root;
if(curNode.attributes[attr] != keys[1]){
if(callback){
callback(false, null);
}
return;
}
var index = 1;
var f = function(){
if(++index == keys.length){
if(callback){
callback(true, curNode);
}
return;
}
var c = curNode.findChild(attr, keys[index]);
if(!c){
if(callback){
callback(false, curNode);
}
return;
}
curNode = c;
c.expand(false, false, f);
share/ext/ext-all-debug.js view on Meta::CPAN
if(tree != this.ownerTree){
if(this.ownerTree){
this.ownerTree.unregisterNode(this);
}
this.ownerTree = tree;
if(destroy !== true){
Ext.each(this.childNodes, function(n){
n.setOwnerTree(tree);
});
}
if(tree){
tree.registerNode(this);
}
}
},
setId: function(id){
if(id !== this.id){
var t = this.ownerTree;
if(t){
t.unregisterNode(this);
}
this.id = this.attributes.id = id;
if(t){
t.registerNode(this);
}
this.onIdChange(id);
}
},
onIdChange: Ext.emptyFn,
getPath : function(attr){
attr = attr || "id";
var p = this.parentNode;
var b = [this.attributes[attr]];
while(p){
b.unshift(p.attributes[attr]);
p = p.parentNode;
}
var sep = this.getOwnerTree().pathSeparator;
return sep + b.join(sep);
},
bubble : function(fn, scope, args){
var p = this;
while(p){
if(fn.apply(scope || p, args || [p]) === false){
break;
}
p = p.parentNode;
}
},
cascade : function(fn, scope, args){
if(fn.apply(scope || this, args || [this]) !== false){
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++) {
cs[i].cascade(fn, scope, args);
}
}
},
eachChild : function(fn, scope, args){
var cs = this.childNodes;
for(var i = 0, len = cs.length; i < len; i++) {
if(fn.apply(scope || cs[i], args || [cs[i]]) === false){
break;
}
}
},
findChild : function(attribute, value, deep){
return this.findChildBy(function(){
return this.attributes[attribute] == value;
}, null, deep);
},
findChildBy : function(fn, scope, deep){
var cs = this.childNodes,
len = cs.length,
i = 0,
n,
res;
for(; i < len; i++){
n = cs[i];
if(fn.call(scope || n, n) === true){
return n;
}else if (deep){
res = n.findChildBy(fn, scope, deep);
if(res != null){
return res;
}
}
}
return null;
},
sort : function(fn, scope){
var cs = this.childNodes;
var len = cs.length;
if(len > 0){
var sortFn = scope ? function(){fn.apply(scope, arguments);} : fn;
cs.sort(sortFn);
for(var i = 0; i < len; i++){
var n = cs[i];
n.previousSibling = cs[i-1];
n.nextSibling = cs[i+1];
if(i === 0){
this.setFirstChild(n);
}
if(i == len-1){
this.setLastChild(n);
}
share/ext/ext-all-debug.js view on Meta::CPAN
});
Ext.tree.TreeFilter = function(tree, config){
this.tree = tree;
this.filtered = {};
Ext.apply(this, config);
};
Ext.tree.TreeFilter.prototype = {
clearBlank:false,
reverse:false,
autoClear:false,
remove:false,
filter : function(value, attr, startNode){
attr = attr || "text";
var f;
if(typeof value == "string"){
var vlen = value.length;
if(vlen == 0 && this.clearBlank){
this.clear();
return;
}
value = value.toLowerCase();
f = function(n){
return n.attributes[attr].substr(0, vlen).toLowerCase() == value;
};
}else if(value.exec){
f = function(n){
return value.test(n.attributes[attr]);
};
}else{
throw 'Illegal filter type, must be string or regex';
}
this.filterBy(f, null, startNode);
},
filterBy : function(fn, scope, startNode){
startNode = startNode || this.tree.root;
if(this.autoClear){
this.clear();
}
var af = this.filtered, rv = this.reverse;
var f = function(n){
if(n == startNode){
return true;
}
if(af[n.id]){
return false;
}
var m = fn.call(scope || n, n);
if(!m || rv){
af[n.id] = n;
n.ui.hide();
return false;
}
return true;
};
startNode.cascade(f);
if(this.remove){
for(var id in af){
if(typeof id != "function"){
var n = af[id];
if(n && n.parentNode){
n.parentNode.removeChild(n);
}
}
}
}
},
clear : function(){
var t = this.tree;
var af = this.filtered;
for(var id in af){
if(typeof id != "function"){
var n = af[id];
if(n){
n.ui.show();
}
}
}
this.filtered = {};
}
};
Ext.tree.TreeSorter = Ext.extend(Object, {
constructor: function(tree, config){
Ext.apply(this, config);
tree.on({
scope: this,
beforechildrenrendered: this.doSort,
append: this.updateSort,
insert: this.updateSort,
textchange: this.updateSortParent
});
var desc = this.dir && this.dir.toLowerCase() == 'desc',
prop = this.property || 'text';
sortType = this.sortType;
folderSort = this.folderSort;
caseSensitive = this.caseSensitive === true;
leafAttr = this.leafAttr || 'leaf';
if(Ext.isString(sortType)){
sortType = Ext.data.SortTypes[sortType];
}
this.sortFn = function(n1, n2){
var attr1 = n1.attributes,
attr2 = n2.attributes;
( run in 1.440 second using v1.01-cache-2.11-cpan-df04353d9ac )