Catalyst-Controller-POD
view release on metacpan or search on metacpan
share/ext/ext-all-debug.js view on Meta::CPAN
getLayoutTargetSize : function() {
var target = this.container.getLayoutTarget(), ret;
if (target) {
ret = target.getViewSize();
if (Ext.isIE && Ext.isStrict && ret.width == 0){
ret = target.getStyleSize();
}
ret.width -= target.getPadding('lr');
ret.height -= target.getPadding('tb');
}
return ret;
},
renderItem : function(c) {
if(Ext.isString(c.margins)){
c.margins = this.parseMargins(c.margins);
}else if(!c.margins){
c.margins = this.defaultMargins;
}
Ext.layout.BoxLayout.superclass.renderItem.apply(this, arguments);
},
destroy: function() {
Ext.destroy(this.overflowHandler);
Ext.layout.BoxLayout.superclass.destroy.apply(this, arguments);
}
});
Ext.ns('Ext.layout.boxOverflow');
Ext.layout.boxOverflow.None = Ext.extend(Object, {
constructor: function(layout, config) {
this.layout = layout;
Ext.apply(this, config || {});
},
handleOverflow: Ext.emptyFn,
clearOverflow: Ext.emptyFn
});
Ext.layout.boxOverflow.none = Ext.layout.boxOverflow.None;
Ext.layout.boxOverflow.Menu = Ext.extend(Ext.layout.boxOverflow.None, {
afterCls: 'x-strip-right',
noItemsMenuText : '<div class="x-toolbar-no-items">(None)</div>',
constructor: function(layout) {
Ext.layout.boxOverflow.Menu.superclass.constructor.apply(this, arguments);
this.menuItems = [];
},
createInnerElements: function() {
if (!this.afterCt) {
this.afterCt = this.layout.innerCt.insertSibling({cls: this.afterCls}, 'before');
}
},
clearOverflow: function(calculations, targetSize) {
var newWidth = targetSize.width + (this.afterCt ? this.afterCt.getWidth() : 0),
items = this.menuItems;
this.hideTrigger();
for (var index = 0, length = items.length; index < length; index++) {
items.pop().component.show();
}
return {
targetSize: {
height: targetSize.height,
width : newWidth
}
};
},
showTrigger: function() {
this.createMenu();
this.menuTrigger.show();
},
hideTrigger: function() {
if (this.menuTrigger != undefined) {
this.menuTrigger.hide();
}
},
beforeMenuShow: function(menu) {
var items = this.menuItems,
len = items.length,
item,
prev;
var needsSep = function(group, item){
return group.isXType('buttongroup') && !(item instanceof Ext.Toolbar.Separator);
};
this.clearMenu();
menu.removeAll();
for (var i = 0; i < len; i++) {
item = items[i].component;
if (prev && (needsSep(item, prev) || needsSep(prev, item))) {
menu.add('-');
}
this.addComponentToMenu(menu, item);
prev = item;
}
if (menu.items.length < 1) {
menu.add(this.noItemsMenuText);
}
},
createMenuConfig : function(component, hideOnClick){
var config = Ext.apply({}, component.initialConfig),
group = component.toggleGroup;
Ext.copyTo(config, component, [
'iconCls', 'icon', 'itemId', 'disabled', 'handler', 'scope', 'menu'
]);
Ext.apply(config, {
text : component.overflowText || component.text,
hideOnClick: hideOnClick
});
if (group || component.enableToggle) {
Ext.apply(config, {
group : group,
checked: component.pressed,
listeners: {
checkchange: function(item, checked){
component.toggle(checked);
}
}
});
}
delete config.ownerCt;
delete config.xtype;
delete config.id;
return config;
},
addComponentToMenu : function(menu, component) {
if (component instanceof Ext.Toolbar.Separator) {
menu.add('-');
} else if (Ext.isFunction(component.isXType)) {
if (component.isXType('splitbutton')) {
menu.add(this.createMenuConfig(component, true));
} else if (component.isXType('button')) {
menu.add(this.createMenuConfig(component, !component.menu));
} else if (component.isXType('buttongroup')) {
component.items.each(function(item){
this.addComponentToMenu(menu, item);
}, this);
}
}
},
clearMenu : function(){
var menu = this.moreMenu;
if (menu && menu.items) {
menu.items.each(function(item){
delete item.menu;
});
}
},
createMenu: function() {
if (!this.menuTrigger) {
this.createInnerElements();
this.menu = new Ext.menu.Menu({
ownerCt : this.layout.container,
listeners: {
scope: this,
beforeshow: this.beforeMenuShow
}
});
this.menuTrigger = new Ext.Button({
iconCls : 'x-toolbar-more-icon',
cls : 'x-toolbar-more',
menu : this.menu,
renderTo: this.afterCt
});
}
},
destroy: function() {
Ext.destroy(this.menu, this.menuTrigger);
}
});
Ext.layout.boxOverflow.menu = Ext.layout.boxOverflow.Menu;
Ext.layout.boxOverflow.HorizontalMenu = Ext.extend(Ext.layout.boxOverflow.Menu, {
constructor: function() {
Ext.layout.boxOverflow.HorizontalMenu.superclass.constructor.apply(this, arguments);
var me = this,
layout = me.layout,
origFunction = layout.calculateChildBoxes;
layout.calculateChildBoxes = function(visibleItems, targetSize) {
var calcs = origFunction.apply(layout, arguments),
meta = calcs.meta,
items = me.menuItems;
var hiddenWidth = 0;
for (var index = 0, length = items.length; index < length; index++) {
hiddenWidth += items[index].width;
}
meta.minimumWidth += hiddenWidth;
meta.tooNarrow = meta.minimumWidth > targetSize.width;
return calcs;
};
},
handleOverflow: function(calculations, targetSize) {
this.showTrigger();
var newWidth = targetSize.width - this.afterCt.getWidth(),
boxes = calculations.boxes,
usedWidth = 0,
recalculate = false;
for (var index = 0, length = boxes.length; index < length; index++) {
usedWidth += boxes[index].width;
}
var spareWidth = newWidth - usedWidth,
showCount = 0;
for (var index = 0, length = this.menuItems.length; index < length; index++) {
var hidden = this.menuItems[index],
comp = hidden.component,
width = hidden.width;
if (width < spareWidth) {
comp.show();
spareWidth -= width;
showCount ++;
recalculate = true;
} else {
break;
}
}
if (recalculate) {
this.menuItems = this.menuItems.slice(showCount);
} else {
for (var i = boxes.length - 1; i >= 0; i--) {
var item = boxes[i].component,
right = boxes[i].left + boxes[i].width;
if (right >= newWidth) {
this.menuItems.unshift({
component: item,
width : boxes[i].width
});
item.hide();
} else {
break;
}
}
}
if (this.menuItems.length == 0) {
this.hideTrigger();
}
return {
targetSize: {
height: targetSize.height,
width : newWidth
},
recalculate: recalculate
};
}
});
Ext.layout.boxOverflow.menu.hbox = Ext.layout.boxOverflow.HorizontalMenu;
Ext.layout.boxOverflow.Scroller = Ext.extend(Ext.layout.boxOverflow.None, {
animateScroll: true,
scrollIncrement: 100,
wheelIncrement: 3,
scrollRepeatInterval: 400,
scrollDuration: 0.4,
beforeCls: 'x-strip-left',
afterCls: 'x-strip-right',
scrollerCls: 'x-strip-scroller',
beforeScrollerCls: 'x-strip-scroller-left',
afterScrollerCls: 'x-strip-scroller-right',
createWheelListener: function() {
this.layout.innerCt.on({
scope : this,
mousewheel: function(e) {
e.stopEvent();
this.scrollBy(e.getWheelDelta() * this.wheelIncrement * -1, false);
}
});
},
handleOverflow: function(calculations, targetSize) {
this.createInnerElements();
this.showScrollers();
},
clearOverflow: function() {
this.hideScrollers();
},
showScrollers: function() {
this.createScrollers();
this.beforeScroller.show();
this.afterScroller.show();
share/ext/ext-all-debug.js view on Meta::CPAN
for (i = 0; i < visibleCount; i++) {
child = visibleItems[i];
calcs = boxes[i];
childMargins = child.margins;
topOffset += childMargins.top;
horizMargins = childMargins.left + childMargins.right;
calcs.left = leftOffset + childMargins.left;
calcs.top = topOffset;
switch (this.align) {
case 'stretch':
stretchWidth = availWidth - horizMargins;
calcs.width = stretchWidth.constrain(child.minWidth || 0, child.maxWidth || 1000000);
calcs.dirtySize = true;
break;
case 'stretchmax':
stretchWidth = maxWidth - horizMargins;
calcs.width = stretchWidth.constrain(child.minWidth || 0, child.maxWidth || 1000000);
calcs.dirtySize = true;
break;
case 'center':
var diff = availWidth - calcs.width - horizMargins;
if (diff > 0) {
calcs.left = leftOffset + horizMargins + (diff / 2);
}
}
topOffset += calcs.height + childMargins.bottom;
}
return {
boxes: boxes,
meta : {
maxWidth : maxWidth,
nonFlexHeight: nonFlexHeight,
desiredHeight: desiredHeight,
minimumHeight: minimumHeight,
shortfall : desiredHeight - height,
tooNarrow : tooNarrow
}
};
}
});
Ext.Container.LAYOUTS.vbox = Ext.layout.VBoxLayout;
Ext.layout.ToolbarLayout = Ext.extend(Ext.layout.ContainerLayout, {
monitorResize : true,
type: 'toolbar',
triggerWidth: 18,
noItemsMenuText : '<div class="x-toolbar-no-items">(None)</div>',
lastOverflow: false,
tableHTML: [
'<table cellspacing="0" class="x-toolbar-ct">',
'<tbody>',
'<tr>',
'<td class="x-toolbar-left" align="{0}">',
'<table cellspacing="0">',
'<tbody>',
'<tr class="x-toolbar-left-row"></tr>',
'</tbody>',
'</table>',
'</td>',
'<td class="x-toolbar-right" align="right">',
'<table cellspacing="0" class="x-toolbar-right-ct">',
'<tbody>',
'<tr>',
'<td>',
'<table cellspacing="0">',
'<tbody>',
'<tr class="x-toolbar-right-row"></tr>',
'</tbody>',
'</table>',
'</td>',
'<td>',
'<table cellspacing="0">',
'<tbody>',
'<tr class="x-toolbar-extras-row"></tr>',
'</tbody>',
'</table>',
'</td>',
'</tr>',
'</tbody>',
'</table>',
'</td>',
'</tr>',
'</tbody>',
'</table>'
].join(""),
onLayout : function(ct, target) {
if (!this.leftTr) {
var align = ct.buttonAlign == 'center' ? 'center' : 'left';
target.addClass('x-toolbar-layout-ct');
target.insertHtml('beforeEnd', String.format(this.tableHTML, align));
this.leftTr = target.child('tr.x-toolbar-left-row', true);
this.rightTr = target.child('tr.x-toolbar-right-row', true);
this.extrasTr = target.child('tr.x-toolbar-extras-row', true);
if (this.hiddenItem == undefined) {
this.hiddenItems = [];
}
share/ext/ext-all-debug.js view on Meta::CPAN
item.show();
item.xtbHidden = false;
this.hiddenItems.remove(item);
},
getItemWidth : function(c) {
return c.hidden ? (c.xtbWidth || 0) : c.getPositionEl().dom.parentNode.offsetWidth;
},
fitToSize : function(target) {
if (this.container.enableOverflow === false) {
return;
}
var width = target.dom.clientWidth,
tableWidth = target.dom.firstChild.offsetWidth,
clipWidth = width - this.triggerWidth,
lastWidth = this.lastWidth || 0,
hiddenItems = this.hiddenItems,
hasHiddens = hiddenItems.length != 0,
isLarger = width >= lastWidth;
this.lastWidth = width;
if (tableWidth > width || (hasHiddens && isLarger)) {
var items = this.container.items.items,
len = items.length,
loopWidth = 0,
item;
for (var i = 0; i < len; i++) {
item = items[i];
if (!item.isFill) {
loopWidth += this.getItemWidth(item);
if (loopWidth > clipWidth) {
if (!(item.hidden || item.xtbHidden)) {
this.hideItem(item);
}
} else if (item.xtbHidden) {
this.unhideItem(item);
}
}
}
}
hasHiddens = hiddenItems.length != 0;
if (hasHiddens) {
this.initMore();
if (!this.lastOverflow) {
this.container.fireEvent('overflowchange', this.container, true);
this.lastOverflow = true;
}
} else if (this.more) {
this.clearMenu();
this.more.destroy();
delete this.more;
if (this.lastOverflow) {
this.container.fireEvent('overflowchange', this.container, false);
this.lastOverflow = false;
}
}
},
createMenuConfig : function(component, hideOnClick){
var config = Ext.apply({}, component.initialConfig),
group = component.toggleGroup;
Ext.copyTo(config, component, [
'iconCls', 'icon', 'itemId', 'disabled', 'handler', 'scope', 'menu'
]);
Ext.apply(config, {
text : component.overflowText || component.text,
hideOnClick: hideOnClick
});
if (group || component.enableToggle) {
Ext.apply(config, {
group : group,
checked: component.pressed,
listeners: {
checkchange: function(item, checked){
component.toggle(checked);
}
}
});
}
delete config.ownerCt;
delete config.xtype;
delete config.id;
return config;
},
addComponentToMenu : function(menu, component) {
if (component instanceof Ext.Toolbar.Separator) {
menu.add('-');
} else if (Ext.isFunction(component.isXType)) {
if (component.isXType('splitbutton')) {
menu.add(this.createMenuConfig(component, true));
} else if (component.isXType('button')) {
menu.add(this.createMenuConfig(component, !component.menu));
} else if (component.isXType('buttongroup')) {
component.items.each(function(item){
this.addComponentToMenu(menu, item);
}, this);
}
}
},
clearMenu : function(){
var menu = this.moreMenu;
if (menu && menu.items) {
menu.items.each(function(item){
delete item.menu;
});
}
},
beforeMoreShow : function(menu) {
var items = this.container.items.items,
len = items.length,
item,
prev;
var needsSep = function(group, item){
return group.isXType('buttongroup') && !(item instanceof Ext.Toolbar.Separator);
};
this.clearMenu();
menu.removeAll();
for (var i = 0; i < len; i++) {
item = items[i];
if (item.xtbHidden) {
if (prev && (needsSep(item, prev) || needsSep(prev, item))) {
menu.add('-');
}
this.addComponentToMenu(menu, item);
prev = item;
}
}
if (menu.items.length < 1) {
menu.add(this.noItemsMenuText);
}
},
initMore : function(){
if (!this.more) {
this.moreMenu = new Ext.menu.Menu({
ownerCt : this.container,
listeners: {
beforeshow: this.beforeMoreShow,
scope: this
}
});
this.more = new Ext.Button({
iconCls: 'x-toolbar-more-icon',
cls : 'x-toolbar-more',
menu : this.moreMenu,
ownerCt: this.container
});
var td = this.insertCell(this.more, this.extrasTr, 100);
this.more.render(td);
}
},
destroy : function(){
Ext.destroy(this.more, this.moreMenu);
delete this.leftTr;
delete this.rightTr;
delete this.extrasTr;
Ext.layout.ToolbarLayout.superclass.destroy.call(this);
}
});
Ext.Container.LAYOUTS.toolbar = Ext.layout.ToolbarLayout;
Ext.layout.MenuLayout = Ext.extend(Ext.layout.ContainerLayout, {
monitorResize : true,
type: 'menu',
setContainer : function(ct){
this.monitorResize = !ct.floating;
ct.on('autosize', this.doAutoSize, this);
Ext.layout.MenuLayout.superclass.setContainer.call(this, ct);
},
renderItem : function(c, position, target){
if (!this.itemTpl) {
this.itemTpl = Ext.layout.MenuLayout.prototype.itemTpl = new Ext.XTemplate(
'<li id="{itemId}" class="{itemCls}">',
'<tpl if="needsIcon">',
'<img alt="{altText}" src="{icon}" class="{iconCls}"/>',
'</tpl>',
'</li>'
);
}
if(c && !c.rendered){
if(Ext.isNumber(position)){
position = target.dom.childNodes[position];
}
var a = this.getItemArgs(c);
c.render(c.positionEl = position ?
this.itemTpl.insertBefore(position, a, true) :
this.itemTpl.append(target, a, true));
c.positionEl.menuItemId = c.getItemId();
if (!a.isMenuItem && a.needsIcon) {
c.positionEl.addClass('x-menu-list-item-indent');
}
this.configureItem(c);
}else if(c && !this.isValidParent(c, target)){
if(Ext.isNumber(position)){
position = target.dom.childNodes[position];
}
target.dom.insertBefore(c.getActionEl().dom, position || null);
}
},
getItemArgs : function(c) {
var isMenuItem = c instanceof Ext.menu.Item,
canHaveIcon = !(isMenuItem || c instanceof Ext.menu.Separator);
return {
isMenuItem: isMenuItem,
needsIcon: canHaveIcon && (c.icon || c.iconCls),
icon: c.icon || Ext.BLANK_IMAGE_URL,
iconCls: 'x-menu-item-icon ' + (c.iconCls || ''),
itemId: 'x-menu-el-' + c.id,
itemCls: 'x-menu-list-item ',
altText: c.altText || ''
};
},
isValidParent : function(c, target) {
return c.el.up('li.x-menu-list-item', 5).dom.parentNode === (target.dom || target);
},
onLayout : function(ct, target){
Ext.layout.MenuLayout.superclass.onLayout.call(this, ct, target);
this.doAutoSize();
},
doAutoSize : function(){
var ct = this.container, w = ct.width;
if(ct.floating){
if(w){
ct.setWidth(w);
}else if(Ext.isIE){
ct.setWidth(Ext.isStrict && (Ext.isIE7 || Ext.isIE8) ? 'auto' : ct.minWidth);
var el = ct.getEl(), t = el.dom.offsetWidth;
ct.setWidth(ct.getLayoutTarget().getWidth() + el.getFrameWidth('lr'));
}
}
}
});
Ext.Container.LAYOUTS['menu'] = Ext.layout.MenuLayout;
Ext.Viewport = Ext.extend(Ext.Container, {
initComponent : function() {
Ext.Viewport.superclass.initComponent.call(this);
document.getElementsByTagName('html')[0].className += ' x-viewport';
this.el = Ext.getBody();
this.el.setHeight = Ext.emptyFn;
this.el.setWidth = Ext.emptyFn;
this.el.setSize = Ext.emptyFn;
this.el.dom.scroll = 'no';
this.allowDomMove = false;
this.autoWidth = true;
this.autoHeight = true;
Ext.EventManager.onWindowResize(this.fireResize, this);
this.renderTo = this.el;
},
fireResize : function(w, h){
this.fireEvent('resize', this, w, h, w, h);
}
});
Ext.reg('viewport', Ext.Viewport);
Ext.Panel = Ext.extend(Ext.Container, {
share/ext/ext-all-debug.js view on Meta::CPAN
selectedClass : "x-view-selected",
emptyText : "",
deferEmptyText: true,
trackOver: false,
blockRefresh: false,
last: false,
initComponent : function(){
Ext.DataView.superclass.initComponent.call(this);
if(Ext.isString(this.tpl) || Ext.isArray(this.tpl)){
this.tpl = new Ext.XTemplate(this.tpl);
}
this.addEvents(
"beforeclick",
"click",
"mouseenter",
"mouseleave",
"containerclick",
"dblclick",
"contextmenu",
"containercontextmenu",
"selectionchange",
"beforeselect"
);
this.store = Ext.StoreMgr.lookup(this.store);
this.all = new Ext.CompositeElementLite();
this.selected = new Ext.CompositeElementLite();
},
afterRender : function(){
Ext.DataView.superclass.afterRender.call(this);
this.mon(this.getTemplateTarget(), {
"click": this.onClick,
"dblclick": this.onDblClick,
"contextmenu": this.onContextMenu,
scope:this
});
if(this.overClass || this.trackOver){
this.mon(this.getTemplateTarget(), {
"mouseover": this.onMouseOver,
"mouseout": this.onMouseOut,
scope:this
});
}
if(this.store){
this.bindStore(this.store, true);
}
},
refresh : function() {
this.clearSelections(false, true);
var el = this.getTemplateTarget(),
records = this.store.getRange();
el.update('');
if(records.length < 1){
if(!this.deferEmptyText || this.hasSkippedEmptyText){
el.update(this.emptyText);
}
this.all.clear();
}else{
this.tpl.overwrite(el, this.collectData(records, 0));
this.all.fill(Ext.query(this.itemSelector, el.dom));
this.updateIndexes(0);
}
this.hasSkippedEmptyText = true;
},
getTemplateTarget: function(){
return this.el;
},
prepareData : function(data){
return data;
},
collectData : function(records, startIndex){
var r = [],
i = 0,
len = records.length;
for(; i < len; i++){
r[r.length] = this.prepareData(records[i].data, startIndex + i, records[i]);
}
return r;
},
bufferRender : function(records, index){
var div = document.createElement('div');
this.tpl.overwrite(div, this.collectData(records, index));
share/ext/ext-all-debug.js view on Meta::CPAN
this.store.un("add", this.onAdd, this);
this.store.un("remove", this.onRemove, this);
this.store.un("update", this.onUpdate, this);
this.store.un("clear", this.refresh, this);
}
if(!store){
this.store = null;
}
}
if(store){
store = Ext.StoreMgr.lookup(store);
store.on({
scope: this,
beforeload: this.onBeforeLoad,
datachanged: this.onDataChanged,
add: this.onAdd,
remove: this.onRemove,
update: this.onUpdate,
clear: this.refresh
});
}
this.store = store;
if(store){
this.refresh();
}
},
onDataChanged: function() {
if (this.blockRefresh !== true) {
this.refresh.apply(this, arguments);
}
},
findItemFromChild : function(node){
return Ext.fly(node).findParent(this.itemSelector, this.getTemplateTarget());
},
onClick : function(e){
var item = e.getTarget(this.itemSelector, this.getTemplateTarget()),
index;
if(item){
index = this.indexOf(item);
if(this.onItemClick(item, index, e) !== false){
this.fireEvent("click", this, index, item, e);
}
}else{
if(this.fireEvent("containerclick", this, e) !== false){
this.onContainerClick(e);
}
}
},
onContainerClick : function(e){
this.clearSelections();
},
onContextMenu : function(e){
var item = e.getTarget(this.itemSelector, this.getTemplateTarget());
if(item){
this.fireEvent("contextmenu", this, this.indexOf(item), item, e);
}else{
this.fireEvent("containercontextmenu", this, e);
}
},
onDblClick : function(e){
var item = e.getTarget(this.itemSelector, this.getTemplateTarget());
if(item){
this.fireEvent("dblclick", this, this.indexOf(item), item, e);
}
},
onMouseOver : function(e){
var item = e.getTarget(this.itemSelector, this.getTemplateTarget());
if(item && item !== this.lastItem){
this.lastItem = item;
Ext.fly(item).addClass(this.overClass);
this.fireEvent("mouseenter", this, this.indexOf(item), item, e);
}
},
onMouseOut : function(e){
if(this.lastItem){
if(!e.within(this.lastItem, true, true)){
Ext.fly(this.lastItem).removeClass(this.overClass);
this.fireEvent("mouseleave", this, this.indexOf(this.lastItem), this.lastItem, e);
delete this.lastItem;
}
}
},
onItemClick : function(item, index, e){
if(this.fireEvent("beforeclick", this, index, item, e) === false){
return false;
}
if(this.multiSelect){
this.doMultiSelection(item, index, e);
e.preventDefault();
}else if(this.singleSelect){
this.doSingleSelection(item, index, e);
e.preventDefault();
}
return true;
},
doSingleSelection : function(item, index, e){
if(e.ctrlKey && this.isSelected(index)){
this.deselect(index);
}else{
this.select(index, false);
}
},
share/ext/ext-all-debug.js view on Meta::CPAN
onRender : function(ct, position){
Ext.TabPanel.superclass.onRender.call(this, ct, position);
if(this.plain){
var pos = this.tabPosition == 'top' ? 'header' : 'footer';
this[pos].addClass('x-tab-panel-'+pos+'-plain');
}
var st = this[this.stripTarget];
this.stripWrap = st.createChild({cls:'x-tab-strip-wrap', cn:{
tag:'ul', cls:'x-tab-strip x-tab-strip-'+this.tabPosition}});
var beforeEl = (this.tabPosition=='bottom' ? this.stripWrap : null);
st.createChild({cls:'x-tab-strip-spacer'}, beforeEl);
this.strip = new Ext.Element(this.stripWrap.dom.firstChild);
this.edge = this.strip.createChild({tag:'li', cls:'x-tab-edge', cn: [{tag: 'span', cls: 'x-tab-strip-text', cn: ' '}]});
this.strip.createChild({cls:'x-clear'});
this.body.addClass('x-tab-panel-body-'+this.tabPosition);
if(!this.itemTpl){
var tt = new Ext.Template(
'<li class="{cls}" id="{id}"><a class="x-tab-strip-close"></a>',
'<a class="x-tab-right" href="#"><em class="x-tab-left">',
'<span class="x-tab-strip-inner"><span class="x-tab-strip-text {iconCls}">{text}</span></span>',
'</em></a></li>'
);
tt.disableFormats = true;
tt.compile();
Ext.TabPanel.prototype.itemTpl = tt;
}
this.items.each(this.initTab, this);
},
afterRender : function(){
Ext.TabPanel.superclass.afterRender.call(this);
if(this.autoTabs){
this.readTabs(false);
}
if(this.activeTab !== undefined){
var item = Ext.isObject(this.activeTab) ? this.activeTab : this.items.get(this.activeTab);
delete this.activeTab;
this.setActiveTab(item);
}
},
initEvents : function(){
Ext.TabPanel.superclass.initEvents.call(this);
this.mon(this.strip, {
scope: this,
mousedown: this.onStripMouseDown,
contextmenu: this.onStripContextMenu
});
if(this.enableTabScroll){
this.mon(this.strip, 'mousewheel', this.onWheel, this);
}
},
findTargets : function(e){
var item = null,
itemEl = e.getTarget('li:not(.x-tab-edge)', this.strip);
if(itemEl){
item = this.getComponent(itemEl.id.split(this.idDelimiter)[1]);
if(item.disabled){
return {
close : null,
item : null,
el : null
};
}
}
return {
close : e.getTarget('.x-tab-strip-close', this.strip),
item : item,
el : itemEl
};
},
onStripMouseDown : function(e){
if(e.button !== 0){
return;
}
e.preventDefault();
var t = this.findTargets(e);
if(t.close){
if (t.item.fireEvent('beforeclose', t.item) !== false) {
t.item.fireEvent('close', t.item);
this.remove(t.item);
}
return;
}
if(t.item && t.item != this.activeTab){
this.setActiveTab(t.item);
}
},
onStripContextMenu : function(e){
e.preventDefault();
var t = this.findTargets(e);
if(t.item){
this.fireEvent('contextmenu', this, t.item, e);
}
},
readTabs : function(removeExisting){
if(removeExisting === true){
this.items.each(function(item){
this.remove(item);
}, this);
}
var tabs = this.el.query(this.autoTabSelector);
for(var i = 0, len = tabs.length; i < len; i++){
var tab = tabs[i],
title = tab.getAttribute('title');
tab.removeAttribute('title');
this.add({
title: title,
contentEl: tab
});
}
},
initTab : function(item, index){
var before = this.strip.dom.childNodes[index],
p = this.getTemplateArgs(item),
el = before ?
this.itemTpl.insertBefore(before, p) :
this.itemTpl.append(this.strip, p),
cls = 'x-tab-strip-over',
tabEl = Ext.get(el);
tabEl.hover(function(){
if(!item.disabled){
tabEl.addClass(cls);
}
}, function(){
tabEl.removeClass(cls);
});
if(item.tabTip){
tabEl.child('span.x-tab-strip-text', true).qtip = item.tabTip;
}
item.tabEl = el;
tabEl.select('a').on('click', function(e){
if(!e.getPageX()){
this.onStripMouseDown(e);
}
}, this, {preventDefault: true});
item.on({
scope: this,
disable: this.onItemDisabled,
enable: this.onItemEnabled,
share/ext/ext-all-debug.js view on Meta::CPAN
};
};
Ext.Button = Ext.extend(Ext.BoxComponent, {
hidden : false,
disabled : false,
pressed : false,
enableToggle : false,
menuAlign : 'tl-bl?',
type : 'button',
menuClassTarget : 'tr:nth(2)',
clickEvent : 'click',
handleMouseEvents : true,
tooltipType : 'qtip',
buttonSelector : 'button:first-child',
scale : 'small',
iconAlign : 'left',
arrowAlign : 'right',
initComponent : function(){
if(this.menu){
this.menu = Ext.menu.MenuMgr.get(this.menu);
this.menu.ownerCt = this;
}
Ext.Button.superclass.initComponent.call(this);
this.addEvents(
'click',
'toggle',
'mouseover',
'mouseout',
'menushow',
'menuhide',
'menutriggerover',
'menutriggerout'
);
if (this.menu){
this.menu.ownerCt = undefined;
}
if(Ext.isString(this.toggleGroup)){
this.enableToggle = true;
}
},
getTemplateArgs : function(){
return [this.type, 'x-btn-' + this.scale + ' x-btn-icon-' + this.scale + '-' + this.iconAlign, this.getMenuClass(), this.cls, this.id];
},
setButtonClass : function(){
if(this.useSetClass){
if(!Ext.isEmpty(this.oldCls)){
this.el.removeClass([this.oldCls, 'x-btn-pressed']);
}
this.oldCls = (this.iconCls || this.icon) ? (this.text ? 'x-btn-text-icon' : 'x-btn-icon') : 'x-btn-noicon';
this.el.addClass([this.oldCls, this.pressed ? 'x-btn-pressed' : null]);
}
},
getMenuClass : function(){
return this.menu ? (this.arrowAlign != 'bottom' ? 'x-btn-arrow' : 'x-btn-arrow-bottom') : '';
},
onRender : function(ct, position){
if(!this.template){
if(!Ext.Button.buttonTemplate){
Ext.Button.buttonTemplate = new Ext.Template(
'<table id="{4}" cellspacing="0" class="x-btn {3}"><tbody class="{1}">',
'<tr><td class="x-btn-tl"><i> </i></td><td class="x-btn-tc"></td><td class="x-btn-tr"><i> </i></td></tr>',
'<tr><td class="x-btn-ml"><i> </i></td><td class="x-btn-mc"><em class="{2}" unselectable="on"><button type="{0}"></button></em></td><td class="x-btn-mr"><i> </i></td></tr>',
'<tr><td class="x-btn-bl"><i> </i></td><td class="x-btn-bc"></td><td class="x-btn-br"><i> </i></td></tr>',
'</tbody></table>');
Ext.Button.buttonTemplate.compile();
}
this.template = Ext.Button.buttonTemplate;
}
var btn, targs = this.getTemplateArgs();
if(position){
btn = this.template.insertBefore(position, targs, true);
}else{
btn = this.template.append(ct, targs, true);
}
this.btnEl = btn.child(this.buttonSelector);
this.mon(this.btnEl, {
scope: this,
focus: this.onFocus,
blur: this.onBlur
});
this.initButtonEl(btn, this.btnEl);
Ext.ButtonToggleMgr.register(this);
},
initButtonEl : function(btn, btnEl){
this.el = btn;
this.setIcon(this.icon);
this.setText(this.text);
this.setIconClass(this.iconCls);
if(Ext.isDefined(this.tabIndex)){
btnEl.dom.tabIndex = this.tabIndex;
}
if(this.tooltip){
this.setTooltip(this.tooltip, true);
}
if(this.handleMouseEvents){
this.mon(btn, {
scope: this,
mouseover: this.onMouseOver,
mousedown: this.onMouseDown
});
}
if(this.menu){
this.mon(this.menu, {
scope: this,
show: this.onMenuShow,
hide: this.onMenuHide
});
}
if(this.repeat){
var repeater = new Ext.util.ClickRepeater(btn, Ext.isObject(this.repeat) ? this.repeat : {});
this.mon(repeater, 'click', this.onRepeatClick, this);
}else{
this.mon(btn, this.clickEvent, this.onClick, this);
}
},
afterRender : function(){
Ext.Button.superclass.afterRender.call(this);
this.useSetClass = true;
this.setButtonClass();
this.doc = Ext.getDoc();
this.doAutoWidth();
},
setIconClass : function(cls){
this.iconCls = cls;
if(this.el){
this.btnEl.dom.className = '';
this.btnEl.addClass(['x-btn-text', cls || '']);
this.setButtonClass();
}
return this;
},
setTooltip : function(tooltip, initial){
if(this.rendered){
if(!initial){
this.clearTip();
}
if(Ext.isObject(tooltip)){
Ext.QuickTips.register(Ext.apply({
target: this.btnEl.id
}, tooltip));
this.tooltip = tooltip;
}else{
this.btnEl.dom[this.tooltipType] = tooltip;
}
}else{
this.tooltip = tooltip;
}
return this;
},
clearTip : function(){
if(Ext.isObject(this.tooltip)){
Ext.QuickTips.unregister(this.btnEl);
}
},
beforeDestroy : function(){
if(this.rendered){
this.clearTip();
}
if(this.menu && this.destroyMenu !== false) {
Ext.destroy(this.btnEl, this.menu);
}
Ext.destroy(this.repeater);
},
onDestroy : function(){
if(this.rendered){
this.doc.un('mouseover', this.monitorMouseOver, this);
this.doc.un('mouseup', this.onMouseUp, this);
delete this.doc;
delete this.btnEl;
Ext.ButtonToggleMgr.unregister(this);
}
Ext.Button.superclass.onDestroy.call(this);
},
doAutoWidth : function(){
if(this.autoWidth !== false && this.el && this.text && this.width === undefined){
this.el.setWidth('auto');
if(Ext.isIE7 && Ext.isStrict){
var ib = this.btnEl;
if(ib && ib.getWidth() > 20){
ib.clip();
ib.setWidth(Ext.util.TextMetrics.measure(ib, this.text).width+ib.getFrameWidth('lr'));
}
}
if(this.minWidth){
if(this.el.getWidth() < this.minWidth){
this.el.setWidth(this.minWidth);
}
}
}
},
setHandler : function(handler, scope){
this.handler = handler;
this.scope = scope;
return this;
},
setText : function(text){
this.text = text;
if(this.el){
this.btnEl.update(text || ' ');
this.setButtonClass();
}
this.doAutoWidth();
return this;
},
setIcon : function(icon){
this.icon = icon;
if(this.el){
this.btnEl.setStyle('background-image', icon ? 'url(' + icon + ')' : '');
this.setButtonClass();
}
return this;
},
getText : function(){
return this.text;
},
toggle : function(state, suppressEvent){
state = state === undefined ? !this.pressed : !!state;
if(state != this.pressed){
if(this.rendered){
this.el[state ? 'addClass' : 'removeClass']('x-btn-pressed');
}
this.pressed = state;
if(!suppressEvent){
this.fireEvent('toggle', this, state);
if(this.toggleHandler){
this.toggleHandler.call(this.scope || this, this, state);
}
}
}
return this;
},
onDisable : function(){
this.onDisableChange(true);
},
onEnable : function(){
this.onDisableChange(false);
},
onDisableChange : function(disabled){
if(this.el){
if(!Ext.isIE6 || !this.text){
this.el[disabled ? 'addClass' : 'removeClass'](this.disabledClass);
}
this.el.dom.disabled = disabled;
}
this.disabled = disabled;
},
showMenu : function(){
if(this.rendered && this.menu){
if(this.tooltip){
Ext.QuickTips.getQuickTip().cancelShow(this.btnEl);
}
if(this.menu.isVisible()){
this.menu.hide();
}
this.menu.ownerCt = this;
this.menu.show(this.el, this.menuAlign);
}
return this;
},
hideMenu : function(){
if(this.hasVisibleMenu()){
this.menu.hide();
}
return this;
},
hasVisibleMenu : function(){
return this.menu && this.menu.ownerCt == this && this.menu.isVisible();
},
onRepeatClick : function(repeat, e){
this.onClick(e);
},
onClick : function(e){
if(e){
e.preventDefault();
}
if(e.button !== 0){
return;
}
if(!this.disabled){
this.doToggle();
if(this.menu && !this.hasVisibleMenu() && !this.ignoreNextClick){
this.showMenu();
}
this.fireEvent('click', this, e);
if(this.handler){
this.handler.call(this.scope || this, this, e);
}
}
},
doToggle: function(){
if (this.enableToggle && (this.allowDepress !== false || !this.pressed)) {
this.toggle();
}
},
isMenuTriggerOver : function(e, internal){
return this.menu && !internal;
},
isMenuTriggerOut : function(e, internal){
return this.menu && !internal;
},
onMouseOver : function(e){
if(!this.disabled){
var internal = e.within(this.el, true);
if(!internal){
this.el.addClass('x-btn-over');
if(!this.monitoringMouseOver){
this.doc.on('mouseover', this.monitorMouseOver, this);
this.monitoringMouseOver = true;
}
this.fireEvent('mouseover', this, e);
}
if(this.isMenuTriggerOver(e, internal)){
this.fireEvent('menutriggerover', this, this.menu, e);
}
}
},
monitorMouseOver : function(e){
if(e.target != this.el.dom && !e.within(this.el)){
if(this.monitoringMouseOver){
this.doc.un('mouseover', this.monitorMouseOver, this);
this.monitoringMouseOver = false;
}
this.onMouseOut(e);
}
},
onMouseOut : function(e){
var internal = e.within(this.el) && e.target != this.el.dom;
this.el.removeClass('x-btn-over');
this.fireEvent('mouseout', this, e);
if(this.isMenuTriggerOut(e, internal)){
this.fireEvent('menutriggerout', this, this.menu, e);
}
},
focus : function() {
this.btnEl.focus();
},
blur : function() {
this.btnEl.blur();
},
onFocus : function(e){
if(!this.disabled){
this.el.addClass('x-btn-focus');
}
},
onBlur : function(e){
this.el.removeClass('x-btn-focus');
},
getClickEl : function(e, isUp){
return this.el;
},
onMouseDown : function(e){
if(!this.disabled && e.button === 0){
this.getClickEl(e).addClass('x-btn-click');
this.doc.on('mouseup', this.onMouseUp, this);
}
},
onMouseUp : function(e){
if(e.button === 0){
this.getClickEl(e, true).removeClass('x-btn-click');
this.doc.un('mouseup', this.onMouseUp, this);
}
},
onMenuShow : function(e){
if(this.menu.ownerCt == this){
this.menu.ownerCt = this;
this.ignoreNextClick = 0;
this.el.addClass('x-btn-menu-active');
this.fireEvent('menushow', this, this.menu);
}
},
onMenuHide : function(e){
if(this.menu.ownerCt == this){
this.el.removeClass('x-btn-menu-active');
this.ignoreNextClick = this.restoreClick.defer(250, this);
this.fireEvent('menuhide', this, this.menu);
delete this.menu.ownerCt;
}
},
restoreClick : function(){
this.ignoreNextClick = 0;
}
});
Ext.reg('button', Ext.Button);
Ext.ButtonToggleMgr = function(){
var groups = {};
function toggleGroup(btn, state){
if(state){
var g = groups[btn.toggleGroup];
for(var i = 0, l = g.length; i < l; i++){
if(g[i] != btn){
g[i].toggle(false);
}
}
}
}
return {
register : function(btn){
if(!btn.toggleGroup){
return;
}
var g = groups[btn.toggleGroup];
if(!g){
g = groups[btn.toggleGroup] = [];
}
g.push(btn);
btn.on('toggle', toggleGroup);
},
unregister : function(btn){
if(!btn.toggleGroup){
return;
}
var g = groups[btn.toggleGroup];
if(g){
g.remove(btn);
btn.un('toggle', toggleGroup);
}
},
getPressed : function(group){
var g = groups[group];
if(g){
for(var i = 0, len = g.length; i < len; i++){
if(g[i].pressed === true){
return g[i];
}
}
}
return null;
}
};
}();
Ext.SplitButton = Ext.extend(Ext.Button, {
arrowSelector : 'em',
split: true,
initComponent : function(){
Ext.SplitButton.superclass.initComponent.call(this);
this.addEvents("arrowclick");
},
onRender : function(){
Ext.SplitButton.superclass.onRender.apply(this, arguments);
if(this.arrowTooltip){
this.el.child(this.arrowSelector).dom[this.tooltipType] = this.arrowTooltip;
}
},
setArrowHandler : function(handler, scope){
this.arrowHandler = handler;
this.scope = scope;
},
getMenuClass : function(){
return 'x-btn-split' + (this.arrowAlign == 'bottom' ? '-bottom' : '');
},
isClickOnArrow : function(e){
if (this.arrowAlign != 'bottom') {
var visBtn = this.el.child('em.x-btn-split');
var right = visBtn.getRegion().right - visBtn.getPadding('r');
return e.getPageX() > right;
} else {
return e.getPageY() > this.btnEl.getRegion().bottom;
}
},
onClick : function(e, t){
e.preventDefault();
if(!this.disabled){
if(this.isClickOnArrow(e)){
if(this.menu && !this.menu.isVisible() && !this.ignoreNextClick){
this.showMenu();
}
this.fireEvent("arrowclick", this, e);
if(this.arrowHandler){
this.arrowHandler.call(this.scope || this, this, e);
}
}else{
this.doToggle();
this.fireEvent("click", this, e);
if(this.handler){
this.handler.call(this.scope || this, this, e);
}
}
}
},
isMenuTriggerOver : function(e){
return this.menu && e.target.tagName == this.arrowSelector;
},
isMenuTriggerOut : function(e, internal){
return this.menu && e.target.tagName != this.arrowSelector;
}
});
Ext.reg('splitbutton', Ext.SplitButton);
Ext.CycleButton = Ext.extend(Ext.SplitButton, {
getItemText : function(item){
if(item && this.showText === true){
var text = '';
if(this.prependText){
text += this.prependText;
}
text += item.text;
return text;
}
return undefined;
},
setActiveItem : function(item, suppressEvent){
if(!Ext.isObject(item)){
item = this.menu.getComponent(item);
}
if(item){
if(!this.rendered){
this.text = this.getItemText(item);
this.iconCls = item.iconCls;
}else{
var t = this.getItemText(item);
if(t){
this.setText(t);
}
this.setIconClass(item.iconCls);
}
this.activeItem = item;
if(!item.checked){
item.setChecked(true, false);
}
if(this.forceIcon){
this.setIconClass(this.forceIcon);
}
if(!suppressEvent){
this.fireEvent('change', this, item);
}
}
},
getActiveItem : function(){
return this.activeItem;
},
share/ext/ext-all-debug.js view on Meta::CPAN
checkHandler : function(item, pressed){
if(pressed){
this.setActiveItem(item);
}
},
toggleSelected : function(){
var m = this.menu;
m.render();
if(!m.hasLayout){
m.doLayout();
}
var nextIdx, checkItem;
for (var i = 1; i < this.itemCount; i++) {
nextIdx = (this.activeItem.itemIndex + i) % this.itemCount;
checkItem = m.items.itemAt(nextIdx);
if (!checkItem.disabled) {
checkItem.setChecked(true);
break;
}
}
}
});
Ext.reg('cycle', Ext.CycleButton);
Ext.Toolbar = function(config){
if(Ext.isArray(config)){
config = {items: config, layout: 'toolbar'};
} else {
config = Ext.apply({
layout: 'toolbar'
}, config);
if(config.buttons) {
config.items = config.buttons;
}
}
Ext.Toolbar.superclass.constructor.call(this, config);
};
(function(){
var T = Ext.Toolbar;
Ext.extend(T, Ext.Container, {
defaultType: 'button',
enableOverflow : false,
trackMenus : true,
internalDefaults: {removeMode: 'container', hideParent: true},
toolbarCls: 'x-toolbar',
initComponent : function(){
T.superclass.initComponent.call(this);
this.addEvents('overflowchange');
},
onRender : function(ct, position){
if(!this.el){
if(!this.autoCreate){
this.autoCreate = {
cls: this.toolbarCls + ' x-small-editor'
};
}
this.el = ct.createChild(Ext.apply({ id: this.id },this.autoCreate), position);
Ext.Toolbar.superclass.onRender.apply(this, arguments);
}
},
lookupComponent : function(c){
if(Ext.isString(c)){
if(c == '-'){
c = new T.Separator();
}else if(c == ' '){
c = new T.Spacer();
}else if(c == '->'){
c = new T.Fill();
}else{
c = new T.TextItem(c);
}
this.applyDefaults(c);
}else{
if(c.isFormField || c.render){
c = this.createComponent(c);
}else if(c.tag){
c = new T.Item({autoEl: c});
}else if(c.tagName){
c = new T.Item({el:c});
}else if(Ext.isObject(c)){
c = c.xtype ? this.createComponent(c) : this.constructButton(c);
}
}
return c;
},
applyDefaults : function(c){
if(!Ext.isString(c)){
c = Ext.Toolbar.superclass.applyDefaults.call(this, c);
var d = this.internalDefaults;
if(c.events){
Ext.applyIf(c.initialConfig, d);
Ext.apply(c, d);
share/ext/ext-all-debug.js view on Meta::CPAN
addSpacer : function(){
return this.add(new T.Spacer());
},
addFill : function(){
this.add(new T.Fill());
},
addElement : function(el){
return this.addItem(new T.Item({el:el}));
},
addItem : function(item){
return this.add.apply(this, arguments);
},
addButton : function(config){
if(Ext.isArray(config)){
var buttons = [];
for(var i = 0, len = config.length; i < len; i++) {
buttons.push(this.addButton(config[i]));
}
return buttons;
}
return this.add(this.constructButton(config));
},
addText : function(text){
return this.addItem(new T.TextItem(text));
},
addDom : function(config){
return this.add(new T.Item({autoEl: config}));
},
addField : function(field){
return this.add(field);
},
insertButton : function(index, item){
if(Ext.isArray(item)){
var buttons = [];
for(var i = 0, len = item.length; i < len; i++) {
buttons.push(this.insertButton(index + i, item[i]));
}
return buttons;
}
return Ext.Toolbar.superclass.insert.call(this, index, item);
},
trackMenu : function(item, remove){
if(this.trackMenus && item.menu){
var method = remove ? 'mun' : 'mon';
this[method](item, 'menutriggerover', this.onButtonTriggerOver, this);
this[method](item, 'menushow', this.onButtonMenuShow, this);
this[method](item, 'menuhide', this.onButtonMenuHide, this);
}
},
constructButton : function(item){
var b = item.events ? item : this.createComponent(item, item.split ? 'splitbutton' : this.defaultType);
return b;
},
onAdd : function(c){
Ext.Toolbar.superclass.onAdd.call(this);
this.trackMenu(c);
if(this.disabled){
c.disable();
}
},
onRemove : function(c){
Ext.Toolbar.superclass.onRemove.call(this);
if (c == this.activeMenuBtn) {
delete this.activeMenuBtn;
}
this.trackMenu(c, true);
},
onDisable : function(){
this.items.each(function(item){
if(item.disable){
item.disable();
}
});
},
onEnable : function(){
this.items.each(function(item){
if(item.enable){
item.enable();
}
});
},
onButtonTriggerOver : function(btn){
if(this.activeMenuBtn && this.activeMenuBtn != btn){
this.activeMenuBtn.hideMenu();
btn.showMenu();
this.activeMenuBtn = btn;
}
},
onButtonMenuShow : function(btn){
this.activeMenuBtn = btn;
},
onButtonMenuHide : function(btn){
delete this.activeMenuBtn;
}
});
Ext.reg('toolbar', Ext.Toolbar);
T.Item = Ext.extend(Ext.BoxComponent, {
hideParent: true,
enable:Ext.emptyFn,
disable:Ext.emptyFn,
focus:Ext.emptyFn
});
Ext.reg('tbitem', T.Item);
T.Separator = Ext.extend(T.Item, {
onRender : function(ct, position){
this.el = ct.createChild({tag:'span', cls:'xtb-sep'}, position);
}
});
Ext.reg('tbseparator', T.Separator);
T.Spacer = Ext.extend(T.Item, {
onRender : function(ct, position){
this.el = ct.createChild({tag:'div', cls:'xtb-spacer', style: this.width?'width:'+this.width+'px':''}, position);
}
});
Ext.reg('tbspacer', T.Spacer);
T.Fill = Ext.extend(T.Item, {
render : Ext.emptyFn,
isFill : true
});
Ext.reg('tbfill', T.Fill);
T.TextItem = Ext.extend(T.Item, {
constructor: function(config){
T.TextItem.superclass.constructor.call(this, Ext.isString(config) ? {text: config} : config);
},
onRender : function(ct, position) {
this.autoEl = {cls: 'xtb-text', html: this.text || ''};
T.TextItem.superclass.onRender.call(this, ct, position);
},
setText : function(t) {
if(this.rendered){
this.el.update(t);
}else{
this.text = t;
share/ext/ext-all-debug.js view on Meta::CPAN
});
Ext.tree.TreePanel.nodeTypes = {};
Ext.reg('treepanel', Ext.tree.TreePanel);Ext.tree.TreeEventModel = function(tree){
this.tree = tree;
this.tree.on('render', this.initEvents, this);
};
Ext.tree.TreeEventModel.prototype = {
initEvents : function(){
var t = this.tree;
if(t.trackMouseOver !== false){
t.mon(t.innerCt, {
scope: this,
mouseover: this.delegateOver,
mouseout: this.delegateOut
});
}
t.mon(t.getTreeEl(), {
scope: this,
click: this.delegateClick,
dblclick: this.delegateDblClick,
contextmenu: this.delegateContextMenu
});
},
getNode : function(e){
var t;
if(t = e.getTarget('.x-tree-node-el', 10)){
var id = Ext.fly(t, '_treeEvents').getAttribute('tree-node-id', 'ext');
if(id){
return this.tree.getNodeById(id);
}
}
return null;
},
getNodeTarget : function(e){
var t = e.getTarget('.x-tree-node-icon', 1);
if(!t){
t = e.getTarget('.x-tree-node-el', 6);
}
return t;
},
delegateOut : function(e, t){
if(!this.beforeEvent(e)){
return;
}
if(e.getTarget('.x-tree-ec-icon', 1)){
var n = this.getNode(e);
this.onIconOut(e, n);
if(n == this.lastEcOver){
delete this.lastEcOver;
}
}
if((t = this.getNodeTarget(e)) && !e.within(t, true)){
this.onNodeOut(e, this.getNode(e));
}
},
delegateOver : function(e, t){
if(!this.beforeEvent(e)){
return;
}
if(Ext.isGecko && !this.trackingDoc){
Ext.getBody().on('mouseover', this.trackExit, this);
this.trackingDoc = true;
}
if(this.lastEcOver){
this.onIconOut(e, this.lastEcOver);
delete this.lastEcOver;
}
if(e.getTarget('.x-tree-ec-icon', 1)){
this.lastEcOver = this.getNode(e);
this.onIconOver(e, this.lastEcOver);
}
if(t = this.getNodeTarget(e)){
this.onNodeOver(e, this.getNode(e));
}
},
trackExit : function(e){
if(this.lastOverNode){
if(this.lastOverNode.ui && !e.within(this.lastOverNode.ui.getEl())){
this.onNodeOut(e, this.lastOverNode);
}
delete this.lastOverNode;
Ext.getBody().un('mouseover', this.trackExit, this);
this.trackingDoc = false;
}
},
delegateClick : function(e, t){
if(this.beforeEvent(e)){
if(e.getTarget('input[type=checkbox]', 1)){
this.onCheckboxClick(e, this.getNode(e));
}else if(e.getTarget('.x-tree-ec-icon', 1)){
this.onIconClick(e, this.getNode(e));
}else if(this.getNodeTarget(e)){
this.onNodeClick(e, this.getNode(e));
}
}else{
this.checkContainerEvent(e, 'click');
}
},
delegateDblClick : function(e, t){
if(this.beforeEvent(e)){
if(this.getNodeTarget(e)){
this.onNodeDblClick(e, this.getNode(e));
}
}else{
this.checkContainerEvent(e, 'dblclick');
}
},
delegateContextMenu : function(e, t){
if(this.beforeEvent(e)){
if(this.getNodeTarget(e)){
this.onNodeContextMenu(e, this.getNode(e));
}
}else{
this.checkContainerEvent(e, 'contextmenu');
}
},
checkContainerEvent: function(e, type){
if(this.disabled){
e.stopEvent();
return false;
}
this.onContainerEvent(e, type);
},
onContainerEvent: function(e, type){
this.tree.fireEvent('container' + type, this.tree, e);
},
onNodeClick : function(e, node){
node.ui.onClick(e);
},
onNodeOver : function(e, node){
this.lastOverNode = node;
node.ui.onOver(e);
},
onNodeOut : function(e, node){
node.ui.onOut(e);
},
onIconOver : function(e, node){
node.ui.addClass('x-tree-ec-over');
},
onIconOut : function(e, node){
node.ui.removeClass('x-tree-ec-over');
},
onIconClick : function(e, node){
node.ui.ecClick(e);
},
onCheckboxClick : function(e, node){
node.ui.onCheckChange(e);
},
onNodeDblClick : function(e, node){
node.ui.onDblClick(e);
},
onNodeContextMenu : function(e, node){
node.ui.onContextMenu(e);
},
beforeEvent : function(e){
var node = this.getNode(e);
if(this.disabled || !node || !node.ui){
e.stopEvent();
return false;
}
return true;
},
disable: function(){
this.disabled = true;
},
enable: function(){
this.disabled = false;
}
};
Ext.tree.DefaultSelectionModel = Ext.extend(Ext.util.Observable, {
constructor : function(config){
this.selNode = null;
this.addEvents(
'selectionchange',
'beforeselect'
);
Ext.apply(this, config);
Ext.tree.DefaultSelectionModel.superclass.constructor.call(this);
},
init : function(tree){
this.tree = tree;
tree.mon(tree.getTreeEl(), 'keydown', this.onKeyDown, this);
tree.on('click', this.onNodeClick, this);
},
onNodeClick : function(node, e){
this.select(node);
},
select : function(node, selectNextNode){
if (!Ext.fly(node.ui.wrap).isVisible() && selectNextNode) {
return selectNextNode.call(this, node);
}
var last = this.selNode;
if(node == last){
node.ui.onSelectedChange(true);
}else if(this.fireEvent('beforeselect', this, node, last) !== false){
if(last && last.ui){
last.ui.onSelectedChange(false);
}
this.selNode = node;
share/ext/ext-all-debug.js view on Meta::CPAN
Ext.fly(this.elNode).removeClass(cls);
}
},
remove : function(){
if(this.rendered){
this.holder = document.createElement("div");
this.holder.appendChild(this.wrap);
}
},
fireEvent : function(){
return this.node.fireEvent.apply(this.node, arguments);
},
initEvents : function(){
this.node.on("move", this.onMove, this);
if(this.node.disabled){
this.onDisableChange(this.node, true);
}
if(this.node.hidden){
this.hide();
}
var ot = this.node.getOwnerTree();
var dd = ot.enableDD || ot.enableDrag || ot.enableDrop;
if(dd && (!this.node.isRoot || ot.rootVisible)){
Ext.dd.Registry.register(this.elNode, {
node: this.node,
handles: this.getDDHandles(),
isHandle: false
});
}
},
getDDHandles : function(){
return [this.iconNode, this.textNode, this.elNode];
},
hide : function(){
this.node.hidden = true;
if(this.wrap){
this.wrap.style.display = "none";
}
},
show : function(){
this.node.hidden = false;
if(this.wrap){
this.wrap.style.display = "";
}
},
onContextMenu : function(e){
if (this.node.hasListener("contextmenu") || this.node.getOwnerTree().hasListener("contextmenu")) {
e.preventDefault();
this.focus();
this.fireEvent("contextmenu", this.node, e);
}
},
onClick : function(e){
if(this.dropping){
e.stopEvent();
return;
}
if(this.fireEvent("beforeclick", this.node, e) !== false){
var a = e.getTarget('a');
if(!this.disabled && this.node.attributes.href && a){
this.fireEvent("click", this.node, e);
return;
}else if(a && e.ctrlKey){
e.stopEvent();
}
e.preventDefault();
if(this.disabled){
return;
}
if(this.node.attributes.singleClickExpand && !this.animating && this.node.isExpandable()){
this.node.toggle();
}
this.fireEvent("click", this.node, e);
}else{
e.stopEvent();
}
},
onDblClick : function(e){
e.preventDefault();
if(this.disabled){
return;
}
if(this.fireEvent("beforedblclick", this.node, e) !== false){
if(this.checkbox){
this.toggleCheck();
}
if(!this.animating && this.node.isExpandable()){
this.node.toggle();
}
this.fireEvent("dblclick", this.node, e);
}
},
onOver : function(e){
this.addClass('x-tree-node-over');
},
onOut : function(e){
this.removeClass('x-tree-node-over');
},
share/ext/ext-all-debug.js view on Meta::CPAN
Ext.chart.CategoryAxis = Ext.extend(Ext.chart.Axis, {
type: "category",
categoryNames: null,
calculateCategoryCount: false
});
Ext.chart.Series = function(config) { Ext.apply(this, config); };
Ext.chart.Series.prototype =
{
type: null,
displayName: null
};
Ext.chart.CartesianSeries = Ext.extend(Ext.chart.Series, {
xField: null,
yField: null,
showInLegend: true,
axis: 'primary'
});
Ext.chart.ColumnSeries = Ext.extend(Ext.chart.CartesianSeries, {
type: "column"
});
Ext.chart.LineSeries = Ext.extend(Ext.chart.CartesianSeries, {
type: "line"
});
Ext.chart.BarSeries = Ext.extend(Ext.chart.CartesianSeries, {
type: "bar"
});
Ext.chart.PieSeries = Ext.extend(Ext.chart.Series, {
type: "pie",
dataField: null,
categoryField: null
});
Ext.menu.Menu = Ext.extend(Ext.Container, {
minWidth : 120,
shadow : 'sides',
subMenuAlign : 'tl-tr?',
defaultAlign : 'tl-bl?',
allowOtherMenus : false,
ignoreParentClicks : false,
enableScrolling : true,
maxHeight : null,
scrollIncrement : 24,
showSeparator : true,
defaultOffsets : [0, 0],
plain : false,
floating : true,
zIndex: 15000,
hidden : true,
layout : 'menu',
hideMode : 'offsets',
scrollerHeight : 8,
autoLayout : true,
defaultType : 'menuitem',
bufferResize : false,
initComponent : function(){
if(Ext.isArray(this.initialConfig)){
Ext.apply(this, {items:this.initialConfig});
}
this.addEvents(
'click',
'mouseover',
'mouseout',
'itemclick'
);
Ext.menu.MenuMgr.register(this);
if(this.floating){
Ext.EventManager.onWindowResize(this.hide, this);
}else{
if(this.initialConfig.hidden !== false){
this.hidden = false;
}
this.internalDefaults = {hideOnClick: false};
}
Ext.menu.Menu.superclass.initComponent.call(this);
if(this.autoLayout){
var fn = this.doLayout.createDelegate(this, []);
this.on({
add: fn,
remove: fn
});
}
},
getLayoutTarget : function() {
return this.ul;
},
onRender : function(ct, position){
if(!ct){
ct = Ext.getBody();
}
var dh = {
id: this.getId(),
cls: 'x-menu ' + ((this.floating) ? 'x-menu-floating x-layer ' : '') + (this.cls || '') + (this.plain ? ' x-menu-plain' : '') + (this.showSeparator ? '' : ' x-menu-nosep'),
style: this.style,
cn: [
{tag: 'a', cls: 'x-menu-focus', href: '#', onclick: 'return false;', tabIndex: '-1'},
{tag: 'ul', cls: 'x-menu-list'}
]
};
if(this.floating){
this.el = new Ext.Layer({
shadow: this.shadow,
dh: dh,
constrain: false,
parentEl: ct,
zindex: this.zIndex
});
}else{
this.el = ct.createChild(dh);
}
Ext.menu.Menu.superclass.onRender.call(this, ct, position);
if(!this.keyNav){
this.keyNav = new Ext.menu.MenuNav(this);
}
this.focusEl = this.el.child('a.x-menu-focus');
this.ul = this.el.child('ul.x-menu-list');
this.mon(this.ul, {
scope: this,
click: this.onClick,
mouseover: this.onMouseOver,
mouseout: this.onMouseOut
});
if(this.enableScrolling){
this.mon(this.el, {
scope: this,
delegate: '.x-menu-scroller',
click: this.onScroll,
mouseover: this.deactivateActive
});
}
},
findTargetItem : function(e){
var t = e.getTarget('.x-menu-list-item', this.ul, true);
if(t && t.menuItemId){
return this.items.get(t.menuItemId);
}
},
onClick : function(e){
var t = this.findTargetItem(e);
if(t){
if(t.isFormField){
this.setActiveItem(t);
}else if(t instanceof Ext.menu.BaseItem){
if(t.menu && this.ignoreParentClicks){
t.expandMenu();
e.preventDefault();
}else if(t.onClick){
t.onClick(e);
this.fireEvent('click', this, t, e);
}
}
}
},
setActiveItem : function(item, autoExpand){
if(item != this.activeItem){
this.deactivateActive();
if((this.activeItem = item).isFormField){
item.focus();
}else{
item.activate(autoExpand);
}
}else if(autoExpand){
item.expandMenu();
}
},
deactivateActive : function(){
var a = this.activeItem;
if(a){
if(a.isFormField){
if(a.collapse){
a.collapse();
}
}else{
a.deactivate();
}
delete this.activeItem;
}
},
tryActivate : function(start, step){
var items = this.items;
for(var i = start, len = items.length; i >= 0 && i < len; i+= step){
var item = items.get(i);
if(item.isVisible() && !item.disabled && (item.canActivate || item.isFormField)){
this.setActiveItem(item, false);
return item;
}
}
return false;
},
onMouseOver : function(e){
var t = this.findTargetItem(e);
if(t){
if(t.canActivate && !t.disabled){
this.setActiveItem(t, true);
}
}
this.over = true;
this.fireEvent('mouseover', this, e, t);
},
onMouseOut : function(e){
var t = this.findTargetItem(e);
if(t){
if(t == this.activeItem && t.shouldDeactivate && t.shouldDeactivate(e)){
this.activeItem.deactivate();
delete this.activeItem;
}
}
this.over = false;
this.fireEvent('mouseout', this, e, t);
},
onScroll : function(e, t){
if(e){
e.stopEvent();
}
var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top');
ul.scrollTop += this.scrollIncrement * (top ? -1 : 1);
if(top ? ul.scrollTop <= 0 : ul.scrollTop + this.activeMax >= ul.scrollHeight){
this.onScrollerOut(null, t);
}
},
onScrollerIn : function(e, t){
var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top');
if(top ? ul.scrollTop > 0 : ul.scrollTop + this.activeMax < ul.scrollHeight){
Ext.fly(t).addClass(['x-menu-item-active', 'x-menu-scroller-active']);
}
},
onScrollerOut : function(e, t){
Ext.fly(t).removeClass(['x-menu-item-active', 'x-menu-scroller-active']);
},
show : function(el, pos, parentMenu){
if(this.floating){
this.parentMenu = parentMenu;
if(!this.el){
this.render();
this.doLayout(false, true);
}
this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign, this.defaultOffsets), parentMenu);
}else{
Ext.menu.Menu.superclass.show.call(this);
}
},
showAt : function(xy, parentMenu){
if(this.fireEvent('beforeshow', this) !== false){
this.parentMenu = parentMenu;
if(!this.el){
this.render();
}
if(this.enableScrolling){
this.el.setXY(xy);
xy[1] = this.constrainScroll(xy[1]);
xy = [this.el.adjustForConstraints(xy)[0], xy[1]];
}else{
xy = this.el.adjustForConstraints(xy);
}
this.el.setXY(xy);
this.el.show();
Ext.menu.Menu.superclass.onShow.call(this);
if(Ext.isIE){
this.fireEvent('autosize', this);
if(!Ext.isIE8){
this.el.repaint();
}
}
this.hidden = false;
this.focus();
this.fireEvent('show', this);
}
},
constrainScroll : function(y){
var max, full = this.ul.setHeight('auto').getHeight(),
returnY = y, normalY, parentEl, scrollTop, viewHeight;
if(this.floating){
parentEl = Ext.fly(this.el.dom.parentNode);
scrollTop = parentEl.getScroll().top;
viewHeight = parentEl.getViewSize().height;
normalY = y - scrollTop;
max = this.maxHeight ? this.maxHeight : viewHeight - normalY;
if(full > viewHeight) {
max = viewHeight;
returnY = y - normalY;
} else if(max < full) {
returnY = y - (full - max);
max = full;
}
}else{
max = this.getHeight();
}
if (this.maxHeight){
max = Math.min(this.maxHeight, max);
}
if(full > max && max > 0){
this.activeMax = max - this.scrollerHeight * 2 - this.el.getFrameWidth('tb') - Ext.num(this.el.shadowOffset, 0);
this.ul.setHeight(this.activeMax);
this.createScrollers();
this.el.select('.x-menu-scroller').setDisplayed('');
}else{
this.ul.setHeight(full);
this.el.select('.x-menu-scroller').setDisplayed('none');
}
this.ul.dom.scrollTop = 0;
return returnY;
},
createScrollers : function(){
if(!this.scroller){
this.scroller = {
pos: 0,
top: this.el.insertFirst({
tag: 'div',
cls: 'x-menu-scroller x-menu-scroller-top',
html: ' '
}),
bottom: this.el.createChild({
tag: 'div',
cls: 'x-menu-scroller x-menu-scroller-bottom',
html: ' '
})
};
this.scroller.top.hover(this.onScrollerIn, this.onScrollerOut, this);
this.scroller.topRepeater = new Ext.util.ClickRepeater(this.scroller.top, {
listeners: {
click: this.onScroll.createDelegate(this, [null, this.scroller.top], false)
}
});
this.scroller.bottom.hover(this.onScrollerIn, this.onScrollerOut, this);
this.scroller.bottomRepeater = new Ext.util.ClickRepeater(this.scroller.bottom, {
listeners: {
click: this.onScroll.createDelegate(this, [null, this.scroller.bottom], false)
}
});
}
},
onLayout : function(){
if(this.isVisible()){
if(this.enableScrolling){
this.constrainScroll(this.el.getTop());
}
if(this.floating){
this.el.sync();
}
}
},
focus : function(){
if(!this.hidden){
this.doFocus.defer(50, this);
}
},
doFocus : function(){
if(!this.hidden){
this.focusEl.focus();
}
},
hide : function(deep){
if (!this.isDestroyed) {
this.deepHide = deep;
Ext.menu.Menu.superclass.hide.call(this);
delete this.deepHide;
}
},
onHide : function(){
Ext.menu.Menu.superclass.onHide.call(this);
this.deactivateActive();
if(this.el && this.floating){
this.el.hide();
}
var pm = this.parentMenu;
if(this.deepHide === true && pm){
if(pm.floating){
pm.hide(true);
}else{
pm.deactivateActive();
}
}
},
lookupComponent : function(c){
if(Ext.isString(c)){
c = (c == 'separator' || c == '-') ? new Ext.menu.Separator() : new Ext.menu.TextItem(c);
this.applyDefaults(c);
}else{
if(Ext.isObject(c)){
c = this.getMenuItem(c);
}else if(c.tagName || c.el){
c = new Ext.BoxComponent({
el: c
});
}
}
return c;
},
applyDefaults : function(c) {
if (!Ext.isString(c)) {
c = Ext.menu.Menu.superclass.applyDefaults.call(this, c);
var d = this.internalDefaults;
if(d){
if(c.events){
Ext.applyIf(c.initialConfig, d);
Ext.apply(c, d);
}else{
Ext.applyIf(c, d);
}
}
}
return c;
},
getMenuItem : function(config) {
if (!config.isXType) {
if (!config.xtype && Ext.isBoolean(config.checked)) {
return new Ext.menu.CheckItem(config);
}
return Ext.create(config, this.defaultType);
}
return config;
},
addSeparator : function() {
return this.add(new Ext.menu.Separator());
},
addElement : function(el) {
return this.add(new Ext.menu.BaseItem({
el: el
}));
},
addItem : function(item) {
return this.add(item);
},
addMenuItem : function(config) {
return this.add(this.getMenuItem(config));
},
addText : function(text){
return this.add(new Ext.menu.TextItem(text));
},
onDestroy : function(){
Ext.EventManager.removeResizeListener(this.hide, this);
var pm = this.parentMenu;
if(pm && pm.activeChild == this){
delete pm.activeChild;
}
delete this.parentMenu;
Ext.menu.Menu.superclass.onDestroy.call(this);
Ext.menu.MenuMgr.unregister(this);
if(this.keyNav) {
this.keyNav.disable();
}
var s = this.scroller;
if(s){
Ext.destroy(s.topRepeater, s.bottomRepeater, s.top, s.bottom);
}
Ext.destroy(
this.el,
this.focusEl,
this.ul
);
}
});
Ext.reg('menu', Ext.menu.Menu);
Ext.menu.MenuNav = Ext.extend(Ext.KeyNav, function(){
function up(e, m){
if(!m.tryActivate(m.items.indexOf(m.activeItem)-1, -1)){
m.tryActivate(m.items.length-1, -1);
}
}
function down(e, m){
if(!m.tryActivate(m.items.indexOf(m.activeItem)+1, 1)){
m.tryActivate(0, 1);
}
}
return {
constructor : function(menu){
Ext.menu.MenuNav.superclass.constructor.call(this, menu.el);
this.scope = this.menu = menu;
},
doRelay : function(e, h){
var k = e.getKey();
if (this.menu.activeItem && this.menu.activeItem.isFormField && k != e.TAB) {
return false;
}
if(!this.menu.activeItem && e.isNavKeyPress() && k != e.SPACE && k != e.RETURN){
this.menu.tryActivate(0, 1);
return false;
}
return h.call(this.scope || this, e, this.menu);
},
tab: function(e, m) {
e.stopEvent();
if (e.shiftKey) {
up(e, m);
} else {
down(e, m);
}
},
up : up,
down : down,
right : function(e, m){
if(m.activeItem){
m.activeItem.expandMenu(true);
}
},
left : function(e, m){
m.hide();
if(m.parentMenu && m.parentMenu.activeItem){
m.parentMenu.activeItem.activate();
}
},
enter : function(e, m){
if(m.activeItem){
e.stopPropagation();
m.activeItem.onClick(e);
m.fireEvent('click', this, m.activeItem);
return true;
}
}
};
}());
Ext.menu.MenuMgr = function(){
var menus, active, groups = {}, attached = false, lastShow = new Date();
function init(){
menus = {};
active = new Ext.util.MixedCollection();
Ext.getDoc().addKeyListener(27, function(){
if(active.length > 0){
hideAll();
}
});
}
function hideAll(){
if(active && active.length > 0){
var c = active.clone();
c.each(function(m){
m.hide();
});
return true;
}
return false;
}
function onHide(m){
active.remove(m);
if(active.length < 1){
Ext.getDoc().un("mousedown", onMouseDown);
attached = false;
}
}
function onShow(m){
var last = active.last();
lastShow = new Date();
active.add(m);
if(!attached){
Ext.getDoc().on("mousedown", onMouseDown);
attached = true;
}
if(m.parentMenu){
m.getEl().setZIndex(parseInt(m.parentMenu.getEl().getStyle("z-index"), 10) + 3);
m.parentMenu.activeChild = m;
}else if(last && !last.isDestroyed && last.isVisible()){
m.getEl().setZIndex(parseInt(last.getEl().getStyle("z-index"), 10) + 3);
}
}
function onBeforeHide(m){
if(m.activeChild){
m.activeChild.hide();
}
if(m.autoHideTimer){
clearTimeout(m.autoHideTimer);
delete m.autoHideTimer;
}
}
function onBeforeShow(m){
var pm = m.parentMenu;
if(!pm && !m.allowOtherMenus){
hideAll();
}else if(pm && pm.activeChild){
pm.activeChild.hide();
}
}
function onMouseDown(e){
if(lastShow.getElapsed() > 50 && active.length > 0 && !e.getTarget(".x-menu")){
hideAll();
}
}
return {
hideAll : function(){
return hideAll();
},
register : function(menu){
if(!menus){
init();
}
menus[menu.id] = menu;
menu.on({
beforehide: onBeforeHide,
hide: onHide,
beforeshow: onBeforeShow,
show: onShow
});
},
get : function(menu){
if(typeof menu == "string"){
if(!menus){
return null;
}
return menus[menu];
}else if(menu.events){
return menu;
}else if(typeof menu.length == 'number'){
return new Ext.menu.Menu({items:menu});
}else{
return Ext.create(menu, 'menu');
}
},
unregister : function(menu){
delete menus[menu.id];
menu.un("beforehide", onBeforeHide);
menu.un("hide", onHide);
menu.un("beforeshow", onBeforeShow);
menu.un("show", onShow);
},
registerCheckable : function(menuItem){
var g = menuItem.group;
if(g){
if(!groups[g]){
groups[g] = [];
}
groups[g].push(menuItem);
}
},
unregisterCheckable : function(menuItem){
var g = menuItem.group;
if(g){
groups[g].remove(menuItem);
}
},
onCheckChange: function(item, state){
if(item.group && state){
var group = groups[item.group],
i = 0,
len = group.length,
current;
for(; i < len; i++){
current = group[i];
if(current != item){
current.setChecked(false);
}
}
}
},
getCheckedItem : function(groupId){
var g = groups[groupId];
if(g){
for(var i = 0, l = g.length; i < l; i++){
if(g[i].checked){
return g[i];
}
}
}
return null;
},
setCheckedItem : function(groupId, itemId){
var g = groups[groupId];
if(g){
for(var i = 0, l = g.length; i < l; i++){
if(g[i].id == itemId){
g[i].setChecked(true);
}
}
}
return null;
}
};
}();
Ext.menu.BaseItem = Ext.extend(Ext.Component, {
canActivate : false,
activeClass : "x-menu-item-active",
hideOnClick : true,
clickHideDelay : 1,
ctype : "Ext.menu.BaseItem",
actionMode : "container",
initComponent : function(){
Ext.menu.BaseItem.superclass.initComponent.call(this);
this.addEvents(
'click',
'activate',
'deactivate'
);
if(this.handler){
this.on("click", this.handler, this.scope);
}
},
onRender : function(container, position){
Ext.menu.BaseItem.superclass.onRender.apply(this, arguments);
if(this.ownerCt && this.ownerCt instanceof Ext.menu.Menu){
this.parentMenu = this.ownerCt;
}else{
this.container.addClass('x-menu-list-item');
this.mon(this.el, {
scope: this,
click: this.onClick,
mouseenter: this.activate,
mouseleave: this.deactivate
});
}
},
setHandler : function(handler, scope){
if(this.handler){
this.un("click", this.handler, this.scope);
}
this.on("click", this.handler = handler, this.scope = scope);
},
onClick : function(e){
if(!this.disabled && this.fireEvent("click", this, e) !== false
&& (this.parentMenu && this.parentMenu.fireEvent("itemclick", this, e) !== false)){
this.handleClick(e);
}else{
e.stopEvent();
}
},
activate : function(){
if(this.disabled){
return false;
}
var li = this.container;
li.addClass(this.activeClass);
this.region = li.getRegion().adjust(2, 2, -2, -2);
this.fireEvent("activate", this);
return true;
},
deactivate : function(){
this.container.removeClass(this.activeClass);
this.fireEvent("deactivate", this);
},
shouldDeactivate : function(e){
return !this.region || !this.region.contains(e.getPoint());
},
handleClick : function(e){
var pm = this.parentMenu;
if(this.hideOnClick){
if(pm.floating){
pm.hide.defer(this.clickHideDelay, pm, [true]);
}else{
pm.deactivateActive();
}
}
},
expandMenu : Ext.emptyFn,
hideMenu : Ext.emptyFn
});
Ext.reg('menubaseitem', Ext.menu.BaseItem);
Ext.menu.TextItem = Ext.extend(Ext.menu.BaseItem, {
hideOnClick : false,
itemCls : "x-menu-text",
constructor : function(config) {
if (typeof config == 'string') {
config = {
text: config
};
}
Ext.menu.TextItem.superclass.constructor.call(this, config);
},
onRender : function() {
var s = document.createElement("span");
s.className = this.itemCls;
s.innerHTML = this.text;
this.el = s;
Ext.menu.TextItem.superclass.onRender.apply(this, arguments);
}
});
Ext.reg('menutextitem', Ext.menu.TextItem);
Ext.menu.Separator = Ext.extend(Ext.menu.BaseItem, {
itemCls : "x-menu-sep",
hideOnClick : false,
activeClass: '',
onRender : function(li){
var s = document.createElement("span");
s.className = this.itemCls;
s.innerHTML = " ";
this.el = s;
li.addClass("x-menu-sep-li");
Ext.menu.Separator.superclass.onRender.apply(this, arguments);
}
});
Ext.reg('menuseparator', Ext.menu.Separator);
Ext.menu.Item = Ext.extend(Ext.menu.BaseItem, {
itemCls : 'x-menu-item',
canActivate : true,
showDelay: 200,
altText: '',
hideDelay: 200,
ctype: 'Ext.menu.Item',
initComponent : function(){
Ext.menu.Item.superclass.initComponent.call(this);
if(this.menu){
this.menu = Ext.menu.MenuMgr.get(this.menu);
this.menu.ownerCt = this;
}
},
onRender : function(container, position){
if (!this.itemTpl) {
this.itemTpl = Ext.menu.Item.prototype.itemTpl = new Ext.XTemplate(
'<a id="{id}" class="{cls}" hidefocus="true" unselectable="on" href="{href}"',
'<tpl if="hrefTarget">',
' target="{hrefTarget}"',
'</tpl>',
'>',
'<img alt="{altText}" src="{icon}" class="x-menu-item-icon {iconCls}"/>',
'<span class="x-menu-item-text">{text}</span>',
'</a>'
);
}
var a = this.getTemplateArgs();
this.el = position ? this.itemTpl.insertBefore(position, a, true) : this.itemTpl.append(container, a, true);
this.iconEl = this.el.child('img.x-menu-item-icon');
this.textEl = this.el.child('.x-menu-item-text');
if(!this.href) {
this.mon(this.el, 'click', Ext.emptyFn, null, { preventDefault: true });
}
Ext.menu.Item.superclass.onRender.call(this, container, position);
},
getTemplateArgs: function() {
return {
id: this.id,
cls: this.itemCls + (this.menu ? ' x-menu-item-arrow' : '') + (this.cls ? ' ' + this.cls : ''),
href: this.href || '#',
hrefTarget: this.hrefTarget,
icon: this.icon || Ext.BLANK_IMAGE_URL,
iconCls: this.iconCls || '',
text: this.itemText||this.text||' ',
altText: this.altText || ''
};
},
setText : function(text){
this.text = text||' ';
if(this.rendered){
this.textEl.update(this.text);
this.parentMenu.layout.doAutoSize();
}
},
setIconClass : function(cls){
var oldCls = this.iconCls;
this.iconCls = cls;
if(this.rendered){
this.iconEl.replaceClass(oldCls, this.iconCls);
}
},
beforeDestroy: function(){
if (this.menu){
delete this.menu.ownerCt;
this.menu.destroy();
}
Ext.menu.Item.superclass.beforeDestroy.call(this);
},
handleClick : function(e){
if(!this.href){
e.stopEvent();
}
Ext.menu.Item.superclass.handleClick.apply(this, arguments);
},
activate : function(autoExpand){
if(Ext.menu.Item.superclass.activate.apply(this, arguments)){
this.focus();
if(autoExpand){
this.expandMenu();
}
}
return true;
},
shouldDeactivate : function(e){
if(Ext.menu.Item.superclass.shouldDeactivate.call(this, e)){
if(this.menu && this.menu.isVisible()){
return !this.menu.getEl().getRegion().contains(e.getPoint());
}
return true;
}
return false;
},
deactivate : function(){
Ext.menu.Item.superclass.deactivate.apply(this, arguments);
this.hideMenu();
},
expandMenu : function(autoActivate){
if(!this.disabled && this.menu){
clearTimeout(this.hideTimer);
delete this.hideTimer;
if(!this.menu.isVisible() && !this.showTimer){
this.showTimer = this.deferExpand.defer(this.showDelay, this, [autoActivate]);
}else if (this.menu.isVisible() && autoActivate){
this.menu.tryActivate(0, 1);
}
}
},
deferExpand : function(autoActivate){
delete this.showTimer;
this.menu.show(this.container, this.parentMenu.subMenuAlign || 'tl-tr?', this.parentMenu);
if(autoActivate){
this.menu.tryActivate(0, 1);
}
},
hideMenu : function(){
clearTimeout(this.showTimer);
delete this.showTimer;
if(!this.hideTimer && this.menu && this.menu.isVisible()){
this.hideTimer = this.deferHide.defer(this.hideDelay, this);
}
},
deferHide : function(){
delete this.hideTimer;
if(this.menu.over){
this.parentMenu.setActiveItem(this, false);
}else{
this.menu.hide();
}
}
});
Ext.reg('menuitem', Ext.menu.Item);
Ext.menu.CheckItem = Ext.extend(Ext.menu.Item, {
itemCls : "x-menu-item x-menu-check-item",
groupClass : "x-menu-group-item",
checked: false,
ctype: "Ext.menu.CheckItem",
initComponent : function(){
Ext.menu.CheckItem.superclass.initComponent.call(this);
this.addEvents(
"beforecheckchange" ,
"checkchange"
);
if(this.checkHandler){
this.on('checkchange', this.checkHandler, this.scope);
}
Ext.menu.MenuMgr.registerCheckable(this);
},
onRender : function(c){
Ext.menu.CheckItem.superclass.onRender.apply(this, arguments);
if(this.group){
this.el.addClass(this.groupClass);
}
if(this.checked){
this.checked = false;
this.setChecked(true, true);
}
},
destroy : function(){
Ext.menu.MenuMgr.unregisterCheckable(this);
Ext.menu.CheckItem.superclass.destroy.apply(this, arguments);
},
setChecked : function(state, suppressEvent){
var suppress = suppressEvent === true;
if(this.checked != state && (suppress || this.fireEvent("beforecheckchange", this, state) !== false)){
Ext.menu.MenuMgr.onCheckChange(this, state);
if(this.container){
this.container[state ? "addClass" : "removeClass"]("x-menu-item-checked");
}
this.checked = state;
if(!suppress){
this.fireEvent("checkchange", this, state);
}
}
},
handleClick : function(e){
if(!this.disabled && !(this.checked && this.group)){
this.setChecked(!this.checked);
}
Ext.menu.CheckItem.superclass.handleClick.apply(this, arguments);
}
});
Ext.reg('menucheckitem', Ext.menu.CheckItem);
Ext.menu.DateMenu = Ext.extend(Ext.menu.Menu, {
enableScrolling : false,
hideOnClick : true,
pickerId : null,
cls : 'x-date-menu',
initComponent : function(){
this.on('beforeshow', this.onBeforeShow, this);
if(this.strict = (Ext.isIE7 && Ext.isStrict)){
this.on('show', this.onShow, this, {single: true, delay: 20});
}
Ext.apply(this, {
plain: true,
showSeparator: false,
items: this.picker = new Ext.DatePicker(Ext.applyIf({
internalRender: this.strict || !Ext.isIE,
ctCls: 'x-menu-date-item',
id: this.pickerId
}, this.initialConfig))
});
this.picker.purgeListeners();
Ext.menu.DateMenu.superclass.initComponent.call(this);
this.relayEvents(this.picker, ['select']);
this.on('show', this.picker.focus, this.picker);
this.on('select', this.menuHide, this);
if(this.handler){
this.on('select', this.handler, this.scope || this);
}
},
menuHide : function() {
if(this.hideOnClick){
this.hide(true);
}
},
onBeforeShow : function(){
if(this.picker){
this.picker.hideMonthPicker(true);
}
},
onShow : function(){
var el = this.picker.getEl();
el.setWidth(el.getWidth());
}
});
Ext.reg('datemenu', Ext.menu.DateMenu);
Ext.menu.ColorMenu = Ext.extend(Ext.menu.Menu, {
enableScrolling : false,
hideOnClick : true,
cls : 'x-color-menu',
paletteId : null,
initComponent : function(){
Ext.apply(this, {
plain: true,
showSeparator: false,
items: this.palette = new Ext.ColorPalette(Ext.applyIf({
id: this.paletteId
}, this.initialConfig))
});
this.palette.purgeListeners();
Ext.menu.ColorMenu.superclass.initComponent.call(this);
this.relayEvents(this.palette, ['select']);
this.on('select', this.menuHide, this);
if(this.handler){
this.on('select', this.handler, this.scope || this);
}
},
menuHide : function(){
if(this.hideOnClick){
this.hide(true);
}
}
});
Ext.reg('colormenu', Ext.menu.ColorMenu);
Ext.form.Field = Ext.extend(Ext.BoxComponent, {
invalidClass : 'x-form-invalid',
invalidText : 'The value in this field is invalid',
focusClass : 'x-form-focus',
validationEvent : 'keyup',
validateOnBlur : true,
validationDelay : 250,
defaultAutoCreate : {tag: 'input', type: 'text', size: '20', autocomplete: 'off'},
fieldClass : 'x-form-field',
msgTarget : 'qtip',
msgFx : 'normal',
readOnly : false,
disabled : false,
submitValue: true,
isFormField : true,
msgDisplay: '',
hasFocus : false,
initComponent : function(){
Ext.form.Field.superclass.initComponent.call(this);
this.addEvents(
'focus',
'blur',
'specialkey',
'change',
'invalid',
share/ext/ext-all-debug.js view on Meta::CPAN
}
return errors;
},
validateBlur : function(){
return !this.menu || !this.menu.isVisible();
},
getValue : function(){
return this.parseDate(Ext.form.DateField.superclass.getValue.call(this)) || "";
},
setValue : function(date){
return Ext.form.DateField.superclass.setValue.call(this, this.formatDate(this.parseDate(date)));
},
parseDate : function(value) {
if(!value || Ext.isDate(value)){
return value;
}
var v = this.safeParse(value, this.format),
af = this.altFormats,
afa = this.altFormatsArray;
if (!v && af) {
afa = afa || af.split("|");
for (var i = 0, len = afa.length; i < len && !v; i++) {
v = this.safeParse(value, afa[i]);
}
}
return v;
},
onDestroy : function(){
Ext.destroy(this.menu, this.keyNav);
Ext.form.DateField.superclass.onDestroy.call(this);
},
formatDate : function(date){
return Ext.isDate(date) ? date.dateFormat(this.format) : date;
},
onTriggerClick : function(){
if(this.disabled){
return;
}
if(this.menu == null){
this.menu = new Ext.menu.DateMenu({
hideOnClick: false,
focusOnSelect: false
});
}
this.onFocus();
Ext.apply(this.menu.picker, {
minDate : this.minValue,
maxDate : this.maxValue,
disabledDatesRE : this.disabledDatesRE,
disabledDatesText : this.disabledDatesText,
disabledDays : this.disabledDays,
disabledDaysText : this.disabledDaysText,
format : this.format,
showToday : this.showToday,
startDay: this.startDay,
minText : String.format(this.minText, this.formatDate(this.minValue)),
maxText : String.format(this.maxText, this.formatDate(this.maxValue))
});
this.menu.picker.setValue(this.getValue() || new Date());
this.menu.show(this.el, "tl-bl?");
this.menuEvents('on');
},
menuEvents: function(method){
this.menu[method]('select', this.onSelect, this);
this.menu[method]('hide', this.onMenuHide, this);
this.menu[method]('show', this.onFocus, this);
},
onSelect: function(m, d){
this.setValue(d);
this.fireEvent('select', this, d);
this.menu.hide();
},
onMenuHide: function(){
this.focus(false, 60);
this.menuEvents('un');
},
beforeBlur : function(){
var v = this.parseDate(this.getRawValue());
if(v){
this.setValue(v);
}
}
});
Ext.reg('datefield', Ext.form.DateField);
Ext.form.DisplayField = Ext.extend(Ext.form.Field, {
validationEvent : false,
validateOnBlur : false,
defaultAutoCreate : {tag: "div"},
fieldClass : "x-form-display-field",
htmlEncode: false,
initEvents : Ext.emptyFn,
isValid : function(){
return true;
},
validate : function(){
return true;
},
getRawValue : function(){
var v = this.rendered ? this.el.dom.innerHTML : Ext.value(this.value, '');
if(v === this.emptyText){
v = '';
}
if(this.htmlEncode){
v = Ext.util.Format.htmlDecode(v);
}
return v;
},
getValue : function(){
return this.getRawValue();
},
getName: function() {
return this.name;
},
setRawValue : function(v){
if(this.htmlEncode){
share/ext/ext-all-debug.js view on Meta::CPAN
var items = [];
var tipsEnabled = Ext.QuickTips && Ext.QuickTips.isEnabled();
function btn(id, toggle, handler){
return {
itemId : id,
cls : 'x-btn-icon',
iconCls: 'x-edit-'+id,
enableToggle:toggle !== false,
scope: editor,
handler:handler||editor.relayBtnCmd,
clickEvent:'mousedown',
tooltip: tipsEnabled ? editor.buttonTips[id] || undefined : undefined,
overflowText: editor.buttonTips[id].title || undefined,
tabIndex:-1
};
}
if(this.enableFont && !Ext.isSafari2){
var fontSelectItem = new Ext.Toolbar.Item({
autoEl: {
tag:'select',
cls:'x-font-select',
html: this.createFontOptions()
}
});
items.push(
fontSelectItem,
'-'
);
}
if(this.enableFormat){
items.push(
btn('bold'),
btn('italic'),
btn('underline')
);
}
if(this.enableFontSize){
items.push(
'-',
btn('increasefontsize', false, this.adjustFont),
btn('decreasefontsize', false, this.adjustFont)
);
}
if(this.enableColors){
items.push(
'-', {
itemId:'forecolor',
cls:'x-btn-icon',
iconCls: 'x-edit-forecolor',
clickEvent:'mousedown',
tooltip: tipsEnabled ? editor.buttonTips.forecolor || undefined : undefined,
tabIndex:-1,
menu : new Ext.menu.ColorMenu({
allowReselect: true,
focus: Ext.emptyFn,
value:'000000',
plain:true,
listeners: {
scope: this,
select: function(cp, color){
this.execCmd('forecolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
this.deferFocus();
}
},
clickEvent:'mousedown'
})
}, {
itemId:'backcolor',
cls:'x-btn-icon',
iconCls: 'x-edit-backcolor',
clickEvent:'mousedown',
tooltip: tipsEnabled ? editor.buttonTips.backcolor || undefined : undefined,
tabIndex:-1,
menu : new Ext.menu.ColorMenu({
focus: Ext.emptyFn,
value:'FFFFFF',
plain:true,
allowReselect: true,
listeners: {
scope: this,
select: function(cp, color){
if(Ext.isGecko){
this.execCmd('useCSS', false);
this.execCmd('hilitecolor', color);
this.execCmd('useCSS', true);
this.deferFocus();
}else{
this.execCmd(Ext.isOpera ? 'hilitecolor' : 'backcolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
this.deferFocus();
}
}
},
clickEvent:'mousedown'
})
}
);
}
if(this.enableAlignments){
items.push(
'-',
btn('justifyleft'),
btn('justifycenter'),
btn('justifyright')
);
}
if(!Ext.isSafari2){
if(this.enableLinks){
items.push(
'-',
btn('createlink', false, this.createLink)
);
}
if(this.enableLists){
items.push(
'-',
btn('insertorderedlist'),
btn('insertunorderedlist')
);
}
if(this.enableSourceEdit){
items.push(
'-',
btn('sourceedit', true, function(btn){
this.toggleSourceEdit(!this.sourceEditMode);
})
);
}
}
var tb = new Ext.Toolbar({
share/ext/ext-all-debug.js view on Meta::CPAN
v = 3 + adjust;
}else if(v <= 18){
v = 4 + adjust;
}else if(v <= 24){
v = 5 + adjust;
}else {
v = 6 + adjust;
}
v = v.constrain(1, 6);
}else{
if(Ext.isSafari){
adjust *= 2;
}
v = Math.max(1, v+adjust) + (Ext.isSafari ? 'px' : 0);
}
this.execCmd('FontSize', v);
},
onEditorEvent : function(e){
this.updateToolbar();
},
updateToolbar: function(){
if(this.readOnly){
return;
}
if(!this.activated){
this.onFirstFocus();
return;
}
var btns = this.tb.items.map,
doc = this.getDoc();
if(this.enableFont && !Ext.isSafari2){
var name = (doc.queryCommandValue('FontName')||this.defaultFont).toLowerCase();
if(name != this.fontSelect.dom.value){
this.fontSelect.dom.value = name;
}
}
if(this.enableFormat){
btns.bold.toggle(doc.queryCommandState('bold'));
btns.italic.toggle(doc.queryCommandState('italic'));
btns.underline.toggle(doc.queryCommandState('underline'));
}
if(this.enableAlignments){
btns.justifyleft.toggle(doc.queryCommandState('justifyleft'));
btns.justifycenter.toggle(doc.queryCommandState('justifycenter'));
btns.justifyright.toggle(doc.queryCommandState('justifyright'));
}
if(!Ext.isSafari2 && this.enableLists){
btns.insertorderedlist.toggle(doc.queryCommandState('insertorderedlist'));
btns.insertunorderedlist.toggle(doc.queryCommandState('insertunorderedlist'));
}
Ext.menu.MenuMgr.hideAll();
this.syncValue();
},
relayBtnCmd : function(btn){
this.relayCmd(btn.getItemId());
},
relayCmd : function(cmd, value){
(function(){
this.focus();
this.execCmd(cmd, value);
this.updateToolbar();
}).defer(10, this);
},
execCmd : function(cmd, value){
var doc = this.getDoc();
doc.execCommand(cmd, false, value === undefined ? null : value);
this.syncValue();
},
applyCommand : function(e){
if(e.ctrlKey){
var c = e.getCharCode(), cmd;
if(c > 0){
c = String.fromCharCode(c);
switch(c){
case 'b':
cmd = 'bold';
break;
case 'i':
cmd = 'italic';
break;
case 'u':
cmd = 'underline';
break;
}
if(cmd){
this.win.focus();
this.execCmd(cmd);
this.deferFocus();
e.preventDefault();
}
}
}
},
insertAtCursor : function(text){
if(!this.activated){
return;
}
if(Ext.isIE){
this.win.focus();
var doc = this.getDoc(),
share/ext/ext-all-debug.js view on Meta::CPAN
return url.test(v);
},
'urlText' : 'This field should be a URL in the format "http:/'+'/www.example.com"',
'alpha' : function(v){
return alpha.test(v);
},
'alphaText' : 'This field should only contain letters and _',
'alphaMask' : /[a-z_]/i,
'alphanum' : function(v){
return alphanum.test(v);
},
'alphanumText' : 'This field should only contain letters, numbers and _',
'alphanumMask' : /[a-z0-9_]/i
};
}();
Ext.grid.GridPanel = Ext.extend(Ext.Panel, {
autoExpandColumn : false,
autoExpandMax : 1000,
autoExpandMin : 50,
columnLines : false,
ddText : '{0} selected row{1}',
deferRowRender : true,
enableColumnHide : true,
enableColumnMove : true,
enableDragDrop : false,
enableHdMenu : true,
loadMask : false,
minColumnWidth : 25,
stripeRows : false,
trackMouseOver : true,
stateEvents : ['columnmove', 'columnresize', 'sortchange', 'groupchange'],
view : null,
bubbleEvents: [],
rendered : false,
viewReady : false,
initComponent : function() {
Ext.grid.GridPanel.superclass.initComponent.call(this);
if (this.columnLines) {
this.cls = (this.cls || '') + ' x-grid-with-col-lines';
}
this.autoScroll = false;
this.autoWidth = false;
if(Ext.isArray(this.columns)){
this.colModel = new Ext.grid.ColumnModel(this.columns);
delete this.columns;
}
if(this.ds){
this.store = this.ds;
delete this.ds;
}
if(this.cm){
this.colModel = this.cm;
delete this.cm;
share/ext/ext-all-debug.js view on Meta::CPAN
'headerclick',
'headerdblclick',
'groupclick',
'groupdblclick',
'containerclick',
'containerdblclick',
'rowbodyclick',
'rowbodydblclick',
'rowcontextmenu',
'cellcontextmenu',
'headercontextmenu',
'groupcontextmenu',
'containercontextmenu',
'rowbodycontextmenu',
'bodyscroll',
'columnresize',
'columnmove',
'sortchange',
'groupchange',
'reconfigure',
'viewready'
);
},
onRender : function(ct, position){
Ext.grid.GridPanel.superclass.onRender.apply(this, arguments);
var c = this.getGridEl();
this.el.addClass('x-grid-panel');
this.mon(c, {
scope: this,
mousedown: this.onMouseDown,
click: this.onClick,
dblclick: this.onDblClick,
contextmenu: this.onContextMenu
});
this.relayEvents(c, ['mousedown','mouseup','mouseover','mouseout','keypress', 'keydown']);
var view = this.getView();
view.init(this);
view.render();
this.getSelectionModel().init(this);
},
initEvents : function(){
Ext.grid.GridPanel.superclass.initEvents.call(this);
if(this.loadMask){
this.loadMask = new Ext.LoadMask(this.bwrap,
Ext.apply({store:this.store}, this.loadMask));
}
},
initStateEvents : function(){
Ext.grid.GridPanel.superclass.initStateEvents.call(this);
this.mon(this.colModel, 'hiddenchange', this.saveState, this, {delay: 100});
},
applyState : function(state){
var cm = this.colModel,
cs = state.columns,
store = this.store,
s,
c,
colIndex;
if(cs){
for(var i = 0, len = cs.length; i < len; i++){
s = cs[i];
c = cm.getColumnById(s.id);
if(c){
colIndex = cm.getIndexById(s.id);
cm.setState(colIndex, {
hidden: s.hidden,
width: s.width,
sortable: s.sortable
});
if(colIndex != i){
cm.moveColumn(colIndex, i);
}
}
}
}
if(store){
s = state.sort;
if(s){
store[store.remoteSort ? 'setDefaultSort' : 'sort'](s.field, s.direction);
}
s = state.group;
if(store.groupBy){
if(s){
store.groupBy(s);
}else{
share/ext/ext-all-debug.js view on Meta::CPAN
}
this.deferRowRenderTask.delay(10);
}else{
v.afterRender();
}
this.viewReady = true;
},
reconfigure : function(store, colModel){
var rendered = this.rendered;
if(rendered){
if(this.loadMask){
this.loadMask.destroy();
this.loadMask = new Ext.LoadMask(this.bwrap,
Ext.apply({}, {store:store}, this.initialConfig.loadMask));
}
}
if(this.view){
this.view.initData(store, colModel);
}
this.store = store;
this.colModel = colModel;
if(rendered){
this.view.refresh(true);
}
this.fireEvent('reconfigure', this, store, colModel);
},
onDestroy : function(){
if (this.deferRowRenderTask && this.deferRowRenderTask.cancel){
this.deferRowRenderTask.cancel();
}
if(this.rendered){
Ext.destroy(this.view, this.loadMask);
}else if(this.store && this.store.autoDestroy){
this.store.destroy();
}
Ext.destroy(this.colModel, this.selModel);
this.store = this.selModel = this.colModel = this.view = this.loadMask = null;
Ext.grid.GridPanel.superclass.onDestroy.call(this);
},
processEvent : function(name, e){
this.view.processEvent(name, e);
},
onClick : function(e){
this.processEvent('click', e);
},
onMouseDown : function(e){
this.processEvent('mousedown', e);
},
onContextMenu : function(e, t){
this.processEvent('contextmenu', e);
},
onDblClick : function(e){
this.processEvent('dblclick', e);
},
walkCells : function(row, col, step, fn, scope){
var cm = this.colModel,
clen = cm.getColumnCount(),
ds = this.store,
rlen = ds.getCount(),
first = true;
if(step < 0){
if(col < 0){
row--;
first = false;
}
while(row >= 0){
if(!first){
col = clen-1;
}
first = false;
while(col >= 0){
if(fn.call(scope || this, row, col, cm) === true){
return [row, col];
}
col--;
}
row--;
}
} else {
if(col >= clen){
row++;
first = false;
}
while(row < rlen){
if(!first){
col = 0;
}
first = false;
while(col < clen){
if(fn.call(scope || this, row, col, cm) === true){
return [row, col];
}
col++;
}
row++;
}
}
return null;
},
getGridEl : function(){
return this.body;
},
share/ext/ext-all-debug.js view on Meta::CPAN
deferEmptyText : true,
scrollOffset : undefined,
autoFill : false,
forceFit : false,
sortClasses : ['sort-asc', 'sort-desc'],
sortAscText : 'Sort Ascending',
sortDescText : 'Sort Descending',
columnsText : 'Columns',
selectedRowClass : 'x-grid3-row-selected',
borderWidth : 2,
tdClass : 'x-grid3-cell',
hdCls : 'x-grid3-hd',
markDirty : true,
cellSelectorDepth : 4,
rowSelectorDepth : 10,
rowBodySelectorDepth : 10,
cellSelector : 'td.x-grid3-cell',
rowSelector : 'div.x-grid3-row',
rowBodySelector : 'div.x-grid3-row-body',
firstRowCls: 'x-grid3-row-first',
lastRowCls: 'x-grid3-row-last',
rowClsRe: /(?:^|\s+)x-grid3-row-(first|last|alt)(?:\s+|$)/g,
headerMenuOpenCls: 'x-grid3-hd-menu-open',
rowOverCls: 'x-grid3-row-over',
constructor : function(config) {
Ext.apply(this, config);
this.addEvents(
'beforerowremoved',
'beforerowsinserted',
'beforerefresh',
'rowremoved',
'rowsinserted',
'rowupdated',
'refresh'
);
Ext.grid.GridView.superclass.constructor.call(this);
},
masterTpl: new Ext.Template(
'<div class="x-grid3" hidefocus="true">',
'<div class="x-grid3-viewport">',
'<div class="x-grid3-header">',
'<div class="x-grid3-header-inner">',
'<div class="x-grid3-header-offset" style="{ostyle}">{header}</div>',
'</div>',
'<div class="x-clear"></div>',
'</div>',
'<div class="x-grid3-scroller">',
'<div class="x-grid3-body" style="{bstyle}">{body}</div>',
'<a href="#" class="x-grid3-focus" tabIndex="-1"></a>',
'</div>',
'</div>',
'<div class="x-grid3-resize-marker"> </div>',
'<div class="x-grid3-resize-proxy"> </div>',
'</div>'
),
headerTpl: new Ext.Template(
'<table border="0" cellspacing="0" cellpadding="0" style="{tstyle}">',
'<thead>',
'<tr class="x-grid3-hd-row">{cells}</tr>',
'</thead>',
'</table>'
),
bodyTpl: new Ext.Template('{rows}'),
cellTpl: new Ext.Template(
'<td class="x-grid3-col x-grid3-cell x-grid3-td-{id} {css}" style="{style}" tabIndex="0" {cellAttr}>',
'<div class="x-grid3-cell-inner x-grid3-col-{id}" unselectable="on" {attr}>{value}</div>',
'</td>'
),
initTemplates : function() {
var templates = this.templates || {},
template, name,
headerCellTpl = new Ext.Template(
'<td class="x-grid3-hd x-grid3-cell x-grid3-td-{id} {css}" style="{style}">',
'<div {tooltip} {attr} class="x-grid3-hd-inner x-grid3-hd-{id}" unselectable="on" style="{istyle}">',
this.grid.enableHdMenu ? '<a class="x-grid3-hd-btn" href="#"></a>' : '',
'{value}',
'<img alt="" class="x-grid3-sort-icon" src="', Ext.BLANK_IMAGE_URL, '" />',
'</div>',
'</td>'
),
rowBodyText = [
'<tr class="x-grid3-row-body-tr" style="{bodyStyle}">',
'<td colspan="{cols}" class="x-grid3-body-cell" tabIndex="0" hidefocus="on">',
'<div class="x-grid3-row-body">{body}</div>',
'</td>',
'</tr>'
].join(""),
innerText = [
'<table class="x-grid3-row-table" border="0" cellspacing="0" cellpadding="0" style="{tstyle}">',
'<tbody>',
'<tr>{cells}</tr>',
this.enableRowBody ? rowBodyText : '',
'</tbody>',
'</table>'
].join("");
Ext.applyIf(templates, {
hcell : headerCellTpl,
cell : this.cellTpl,
body : this.bodyTpl,
header : this.headerTpl,
master : this.masterTpl,
row : new Ext.Template('<div class="x-grid3-row {alt}" style="{tstyle}">' + innerText + '</div>'),
rowInner: new Ext.Template(innerText)
});
for (name in templates) {
template = templates[name];
if (template && Ext.isFunction(template.compile) && !template.compiled) {
template.disableFormats = true;
template.compile();
}
}
this.templates = templates;
this.colRe = new RegExp('x-grid3-td-([^\\s]+)', '');
},
fly : function(el) {
if (!this._flyweight) {
this._flyweight = new Ext.Element.Flyweight(document.body);
}
this._flyweight.dom = el;
return this._flyweight;
},
getEditorParent : function() {
return this.scroller.dom;
},
share/ext/ext-all-debug.js view on Meta::CPAN
if (!skipStripe) {
row.className = row.className.replace(this.rowClsRe, ' ');
if ((i + 1) % 2 === 0){
row.className += ' x-grid3-row-alt';
}
}
}
}
if (startRow === 0) {
Ext.fly(rows[0]).addClass(this.firstRowCls);
}
Ext.fly(rows[length - 1]).addClass(this.lastRowCls);
},
afterRender : function() {
if (!this.ds || !this.cm) {
return;
}
this.mainBody.dom.innerHTML = this.renderBody() || ' ';
this.processRows(0, true);
if (this.deferEmptyText !== true) {
this.applyEmptyText();
}
this.grid.fireEvent('viewready', this.grid);
},
afterRenderUI: function() {
var grid = this.grid;
this.initElements();
Ext.fly(this.innerHd).on('click', this.handleHdDown, this);
this.mainHd.on({
scope : this,
mouseover: this.handleHdOver,
mouseout : this.handleHdOut,
mousemove: this.handleHdMove
});
this.scroller.on('scroll', this.syncScroll, this);
if (grid.enableColumnResize !== false) {
this.splitZone = new Ext.grid.GridView.SplitDragZone(grid, this.mainHd.dom);
}
if (grid.enableColumnMove) {
this.columnDrag = new Ext.grid.GridView.ColumnDragZone(grid, this.innerHd);
this.columnDrop = new Ext.grid.HeaderDropZone(grid, this.mainHd.dom);
}
if (grid.enableHdMenu !== false) {
this.hmenu = new Ext.menu.Menu({id: grid.id + '-hctx'});
this.hmenu.add(
{itemId:'asc', text: this.sortAscText, cls: 'xg-hmenu-sort-asc'},
{itemId:'desc', text: this.sortDescText, cls: 'xg-hmenu-sort-desc'}
);
if (grid.enableColumnHide !== false) {
this.colMenu = new Ext.menu.Menu({id:grid.id + '-hcols-menu'});
this.colMenu.on({
scope : this,
beforeshow: this.beforeColMenuShow,
itemclick : this.handleHdMenuClick
});
this.hmenu.add('-', {
itemId:'columns',
hideOnClick: false,
text: this.columnsText,
menu: this.colMenu,
iconCls: 'x-cols-icon'
});
}
this.hmenu.on('itemclick', this.handleHdMenuClick, this);
}
if (grid.trackMouseOver) {
this.mainBody.on({
scope : this,
mouseover: this.onRowOver,
mouseout : this.onRowOut
});
}
if (grid.enableDragDrop || grid.enableDrag) {
this.dragZone = new Ext.grid.GridDragZone(grid, {
ddGroup : grid.ddGroup || 'GridDD'
});
}
this.updateHeaderSortState();
},
renderUI : function() {
var templates = this.templates;
return templates.master.apply({
body : templates.body.apply({rows:' '}),
header: this.renderHeaders(),
ostyle: 'width:' + this.getOffsetWidth() + ';',
bstyle: 'width:' + this.getTotalWidth() + ';'
});
},
processEvent : function(name, e) {
var target = e.getTarget(),
grid = this.grid,
header = this.findHeaderIndex(target),
row, cell, col, body;
grid.fireEvent(name, e);
if (header !== false) {
grid.fireEvent('header' + name, grid, header, e);
} else {
row = this.findRowIndex(target);
if (row !== false) {
cell = this.findCellIndex(target);
if (cell !== false) {
col = grid.colModel.getColumnAt(cell);
if (grid.fireEvent('cell' + name, grid, row, cell, e) !== false) {
if (!col || (col.processEvent && (col.processEvent(name, e, grid, row, cell) !== false))) {
grid.fireEvent('row' + name, grid, row, e);
}
}
} else {
if (grid.fireEvent('row' + name, grid, row, e) !== false) {
(body = this.findRowBody(target)) && grid.fireEvent('rowbody' + name, grid, row, e);
share/ext/ext-all-debug.js view on Meta::CPAN
this.processRows(0, true);
this.layout();
this.applyEmptyText();
this.fireEvent('refresh', this);
},
applyEmptyText : function() {
if (this.emptyText && !this.hasRows()) {
this.mainBody.update('<div class="x-grid-empty">' + this.emptyText + '</div>');
}
},
updateHeaderSortState : function() {
var state = this.ds.getSortState();
if (!state) {
return;
}
if (!this.sortState || (this.sortState.field != state.field || this.sortState.direction != state.direction)) {
this.grid.fireEvent('sortchange', this.grid, state);
}
this.sortState = state;
var sortColumn = this.cm.findColumnIndex(state.field);
if (sortColumn != -1) {
var sortDir = state.direction;
this.updateSortIcon(sortColumn, sortDir);
}
},
clearHeaderSortState : function() {
if (!this.sortState) {
return;
}
this.grid.fireEvent('sortchange', this.grid, null);
this.mainHd.select('td').removeClass(this.sortClasses);
delete this.sortState;
},
destroy : function() {
var me = this,
grid = me.grid,
gridEl = grid.getGridEl(),
dragZone = me.dragZone,
splitZone = me.splitZone,
columnDrag = me.columnDrag,
columnDrop = me.columnDrop,
scrollToTopTask = me.scrollToTopTask,
columnDragData,
columnDragProxy;
if (scrollToTopTask && scrollToTopTask.cancel) {
scrollToTopTask.cancel();
}
Ext.destroyMembers(me, 'colMenu', 'hmenu');
me.initData(null, null);
me.purgeListeners();
Ext.fly(me.innerHd).un("click", me.handleHdDown, me);
if (grid.enableColumnMove) {
columnDragData = columnDrag.dragData;
columnDragProxy = columnDrag.proxy;
Ext.destroy(
columnDrag.el,
columnDragProxy.ghost,
columnDragProxy.el,
columnDrop.el,
columnDrop.proxyTop,
columnDrop.proxyBottom,
columnDragData.ddel,
columnDragData.header
);
if (columnDragProxy.anim) {
Ext.destroy(columnDragProxy.anim);
}
delete columnDragProxy.ghost;
delete columnDragData.ddel;
delete columnDragData.header;
columnDrag.destroy();
delete Ext.dd.DDM.locationCache[columnDrag.id];
delete columnDrag._domRef;
delete columnDrop.proxyTop;
delete columnDrop.proxyBottom;
columnDrop.destroy();
delete Ext.dd.DDM.locationCache["gridHeader" + gridEl.id];
delete columnDrop._domRef;
delete Ext.dd.DDM.ids[columnDrop.ddGroup];
}
if (splitZone) {
splitZone.destroy();
delete splitZone._domRef;
delete Ext.dd.DDM.ids["gridSplitters" + gridEl.id];
}
Ext.fly(me.innerHd).removeAllListeners();
Ext.removeNode(me.innerHd);
delete me.innerHd;
Ext.destroy(
me.el,
me.mainWrap,
me.mainHd,
me.scroller,
me.mainBody,
me.focusEl,
me.resizeMarker,
me.resizeProxy,
me.activeHdBtn,
share/ext/ext-all-debug.js view on Meta::CPAN
}
},
onRowOut : function(e, target) {
var row = this.findRowIndex(target);
if (row !== false && !e.within(this.getRow(row), true)) {
this.removeRowClass(row, this.rowOverCls);
}
},
onRowSelect : function(row) {
this.addRowClass(row, this.selectedRowClass);
},
onRowDeselect : function(row) {
this.removeRowClass(row, this.selectedRowClass);
},
onCellSelect : function(row, col) {
var cell = this.getCell(row, col);
if (cell) {
this.fly(cell).addClass('x-grid3-cell-selected');
}
},
onCellDeselect : function(row, col) {
var cell = this.getCell(row, col);
if (cell) {
this.fly(cell).removeClass('x-grid3-cell-selected');
}
},
handleWheel : function(e) {
e.stopPropagation();
},
onColumnSplitterMoved : function(cellIndex, width) {
this.userResized = true;
this.grid.colModel.setColumnWidth(cellIndex, width, true);
if (this.forceFit) {
this.fitColumns(true, false, cellIndex);
this.updateAllColumnWidths();
} else {
this.updateColumnWidth(cellIndex, width);
this.syncHeaderScroll();
}
this.grid.fireEvent('columnresize', cellIndex, width);
},
beforeColMenuShow : function() {
var colModel = this.cm,
colCount = colModel.getColumnCount(),
colMenu = this.colMenu,
i;
colMenu.removeAll();
for (i = 0; i < colCount; i++) {
if (colModel.config[i].hideable !== false) {
colMenu.add(new Ext.menu.CheckItem({
text : colModel.getColumnHeader(i),
itemId : 'col-' + colModel.getColumnId(i),
checked : !colModel.isHidden(i),
disabled : colModel.config[i].hideable === false,
hideOnClick: false
}));
}
}
},
handleHdMenuClick : function(item) {
var store = this.ds,
dataIndex = this.cm.getDataIndex(this.hdCtxIndex);
switch (item.getItemId()) {
case 'asc':
store.sort(dataIndex, 'ASC');
break;
case 'desc':
store.sort(dataIndex, 'DESC');
break;
default:
this.handleHdMenuClickDefault(item);
}
return true;
},
handleHdMenuClickDefault: function(item) {
var colModel = this.cm,
itemId = item.getItemId(),
index = colModel.getIndexById(itemId.substr(4));
if (index != -1) {
if (item.checked && colModel.getColumnsBy(this.isHideableColumn, this).length <= 1) {
this.onDenyColumnHide();
return;
}
colModel.setHidden(index, item.checked);
}
},
handleHdDown : function(e, target) {
if (Ext.fly(target).hasClass('x-grid3-hd-btn')) {
e.stopEvent();
var colModel = this.cm,
header = this.findHeaderCell(target),
index = this.getCellIndex(header),
sortable = colModel.isSortable(index),
menu = this.hmenu,
menuItems = menu.items,
menuCls = this.headerMenuOpenCls;
this.hdCtxIndex = index;
Ext.fly(header).addClass(menuCls);
menuItems.get('asc').setDisabled(!sortable);
menuItems.get('desc').setDisabled(!sortable);
menu.on('hide', function() {
Ext.fly(header).removeClass(menuCls);
}, this, {single:true});
menu.show(target, 'tl-bl?');
}
},
handleHdMove : function(e) {
var header = this.findHeaderCell(this.activeHdRef);
if (header && !this.headersDisabled) {
var handleWidth = this.splitHandleWidth || 5,
activeRegion = this.activeHdRegion,
headerStyle = header.style,
colModel = this.cm,
cursor = '',
pageX = e.getPageX();
if (this.grid.enableColumnResize !== false) {
var activeHeaderIndex = this.activeHdIndex,
previousVisible = this.getPreviousVisible(activeHeaderIndex),
currentResizable = colModel.isResizable(activeHeaderIndex),
previousResizable = previousVisible && colModel.isResizable(previousVisible),
inLeftResizer = pageX - activeRegion.left <= handleWidth,
inRightResizer = activeRegion.right - pageX <= (!this.activeHdBtn ? handleWidth : 2);
if (inLeftResizer && previousResizable) {
cursor = Ext.isAir ? 'move' : Ext.isWebKit ? 'e-resize' : 'col-resize';
} else if (inRightResizer && currentResizable) {
cursor = Ext.isAir ? 'move' : Ext.isWebKit ? 'w-resize' : 'col-resize';
}
}
headerStyle.cursor = cursor;
}
},
getPreviousVisible: function(index) {
while (index > 0) {
if (!this.cm.isHidden(index - 1)) {
return index;
}
index--;
}
return undefined;
},
handleHdOver : function(e, target) {
var header = this.findHeaderCell(target);
if (header && !this.headersDisabled) {
var fly = this.fly(header);
this.activeHdRef = target;
this.activeHdIndex = this.getCellIndex(header);
this.activeHdRegion = fly.getRegion();
if (!this.isMenuDisabled(this.activeHdIndex, fly)) {
fly.addClass('x-grid3-hd-over');
this.activeHdBtn = fly.child('.x-grid3-hd-btn');
if (this.activeHdBtn) {
this.activeHdBtn.dom.style.height = (header.firstChild.offsetHeight - 1) + 'px';
}
}
}
},
handleHdOut : function(e, target) {
var header = this.findHeaderCell(target);
if (header && (!Ext.isIE || !e.within(header, true))) {
this.activeHdRef = null;
this.fly(header).removeClass('x-grid3-hd-over');
header.style.cursor = '';
}
},
isMenuDisabled: function(cellIndex, el) {
return this.cm.isMenuDisabled(cellIndex);
},
hasRows : function() {
var fc = this.mainBody.dom.firstChild;
return fc && fc.nodeType == 1 && fc.className != 'x-grid-empty';
},
isHideableColumn : function(c) {
return !c.hidden;
},
bind : function(d, c) {
this.initData(d, c);
}
});
Ext.grid.GridView.SplitDragZone = Ext.extend(Ext.dd.DDProxy, {
constructor: function(grid, hd){
this.grid = grid;
this.view = grid.getView();
this.marker = this.view.resizeMarker;
this.proxy = this.view.resizeProxy;
Ext.grid.GridView.SplitDragZone.superclass.constructor.call(this, hd,
'gridSplitters' + this.grid.getGridEl().id, {
dragElId : Ext.id(this.proxy.dom), resizeFrame:false
});
this.scroll = false;
this.hw = this.view.splitHandleWidth || 5;
},
b4StartDrag : function(x, y){
this.dragHeadersDisabled = this.view.headersDisabled;
this.view.headersDisabled = true;
var h = this.view.mainWrap.getHeight();
this.marker.setHeight(h);
this.marker.show();
this.marker.alignTo(this.view.getHeaderCell(this.cellIndex), 'tl-tl', [-2, 0]);
this.proxy.setHeight(h);
var w = this.cm.getColumnWidth(this.cellIndex),
minw = Math.max(w-this.grid.minColumnWidth, 0);
this.resetConstraints();
this.setXConstraint(minw, 1000);
this.setYConstraint(0, 0);
this.minX = x - minw;
this.maxX = x + 1000;
this.startPos = x;
Ext.dd.DDProxy.prototype.b4StartDrag.call(this, x, y);
},
allowHeaderDrag : function(e){
return true;
},
share/ext/ext-all-debug.js view on Meta::CPAN
meta.attr = meta.cellAttr = '';
meta.value = cell;
if (Ext.isEmpty(meta.value)) {
meta.value = ' ';
}
if (hasRenderer) {
meta.value = renderer(meta.value);
}
if (hasGetCellCls) {
meta.css += getCellCls(meta.value) + ' ';
}
colBuffer[colBuffer.length] = cellTemplate.apply(meta);
}
rowBuffer[rowBuffer.length] = rowTemplate.apply({
tstyle: tstyle,
cols : colCount,
cells : colBuffer.join(""),
alt : ''
});
}
return rowBuffer.join("");
},
masterTpl: new Ext.Template(
'<div class="x-grid3 x-pivotgrid" hidefocus="true">',
'<div class="x-grid3-viewport">',
'<div class="x-grid3-header">',
'<div class="x-grid3-header-title"><span>{title}</span></div>',
'<div class="x-grid3-header-inner">',
'<div class="x-grid3-header-offset" style="{ostyle}"></div>',
'</div>',
'<div class="x-clear"></div>',
'</div>',
'<div class="x-grid3-scroller">',
'<div class="x-grid3-row-headers"></div>',
'<div class="x-grid3-body" style="{bstyle}">{body}</div>',
'<a href="#" class="x-grid3-focus" tabIndex="-1"></a>',
'</div>',
'</div>',
'<div class="x-grid3-resize-marker"> </div>',
'<div class="x-grid3-resize-proxy"> </div>',
'</div>'
),
initTemplates: function() {
Ext.grid.PivotGridView.superclass.initTemplates.apply(this, arguments);
var templates = this.templates || {};
if (!templates.gcell) {
templates.gcell = new Ext.XTemplate(
'<td class="x-grid3-hd x-grid3-gcell x-grid3-td-{id} ux-grid-hd-group-row-{row} ' + this.colHeaderCellCls + '" style="{style}">',
'<div {tooltip} class="x-grid3-hd-inner x-grid3-hd-{id}" unselectable="on" style="{istyle}">',
this.grid.enableHdMenu ? '<a class="x-grid3-hd-btn" href="#"></a>' : '', '{value}',
'</div>',
'</td>'
);
}
this.templates = templates;
this.hrowRe = new RegExp("ux-grid-hd-group-row-(\\d+)", "");
},
initElements: function() {
Ext.grid.PivotGridView.superclass.initElements.apply(this, arguments);
this.rowHeadersEl = new Ext.Element(this.scroller.child('div.x-grid3-row-headers'));
this.headerTitleEl = new Ext.Element(this.mainHd.child('div.x-grid3-header-title'));
},
getGridInnerWidth: function() {
var previousWidth = Ext.grid.PivotGridView.superclass.getGridInnerWidth.apply(this, arguments);
return previousWidth - this.getTotalRowHeaderWidth();
},
getTotalRowHeaderWidth: function() {
var headers = this.getRowHeaders(),
length = headers.length,
total = 0,
i;
for (i = 0; i< length; i++) {
total += headers[i].width;
}
return total;
},
getTotalColumnHeaderHeight: function() {
return this.getColumnHeaders().length * 21;
},
renderUI : function() {
var templates = this.templates,
innerWidth = this.getGridInnerWidth();
return templates.master.apply({
body : templates.body.apply({rows:' '}),
ostyle: 'width:' + innerWidth + 'px',
bstyle: 'width:' + innerWidth + 'px'
});
},
onLayout: function(width, height) {
share/ext/ext-all-debug.js view on Meta::CPAN
topAxis.el.setWidth(width);
}
},
resizeRowHeaders: function() {
var rowHeaderWidth = this.getTotalRowHeaderWidth(),
marginStyle = String.format("margin-left: {0}px;", rowHeaderWidth);
this.rowHeadersEl.setWidth(rowHeaderWidth);
this.mainBody.applyStyles(marginStyle);
Ext.fly(this.innerHd).applyStyles(marginStyle);
this.headerTitleEl.setWidth(rowHeaderWidth);
this.headerTitleEl.setHeight(this.getTotalColumnHeaderHeight());
},
resizeAllRows: function(width) {
var rows = this.getRows(),
length = rows.length,
i;
for (i = 0; i < length; i++) {
Ext.fly(rows[i]).setWidth(width);
Ext.fly(rows[i]).child('table').setWidth(width);
}
},
updateHeaders: function() {
this.renderGroupRowHeaders();
this.renderGroupColumnHeaders();
},
renderGroupRowHeaders: function() {
var leftAxis = this.grid.leftAxis;
this.resizeRowHeaders();
leftAxis.rendered = false;
leftAxis.render(this.rowHeadersEl);
this.setTitle(this.title);
},
setTitle: function(title) {
this.headerTitleEl.child('span').dom.innerHTML = title;
},
renderGroupColumnHeaders: function() {
var topAxis = this.grid.topAxis;
topAxis.rendered = false;
topAxis.render(this.innerHd.firstChild);
},
isMenuDisabled: function(cellIndex, el) {
return true;
}
});
Ext.grid.PivotAxis = Ext.extend(Ext.Component, {
orientation: 'horizontal',
defaultHeaderWidth: 80,
paddingWidth: 7,
setDimensions: function(dimensions) {
this.dimensions = dimensions;
},
onRender: function(ct, position) {
var rows = this.orientation == 'horizontal'
? this.renderHorizontalRows()
: this.renderVerticalRows();
this.el = Ext.DomHelper.overwrite(ct.dom, {tag: 'table', cn: rows}, true);
},
renderHorizontalRows: function() {
var headers = this.buildHeaders(),
rowCount = headers.length,
rows = [],
cells, cols, colCount, i, j;
for (i = 0; i < rowCount; i++) {
cells = [];
cols = headers[i].items;
colCount = cols.length;
for (j = 0; j < colCount; j++) {
cells.push({
tag: 'td',
html: cols[j].header,
colspan: cols[j].span
});
}
rows[i] = {
tag: 'tr',
cn: cells
};
}
return rows;
},
renderVerticalRows: function() {
var headers = this.buildHeaders(),
colCount = headers.length,
share/ext/ext-all-debug.js view on Meta::CPAN
return i;
}
}
return -1;
},
moveColumn : function(oldIndex, newIndex) {
var config = this.config,
c = config[oldIndex];
config.splice(oldIndex, 1);
config.splice(newIndex, 0, c);
this.dataMap = null;
this.fireEvent("columnmoved", this, oldIndex, newIndex);
},
getColumnCount : function(visibleOnly) {
var length = this.config.length,
c = 0,
i;
if (visibleOnly === true) {
for (i = 0; i < length; i++) {
if (!this.isHidden(i)) {
c++;
}
}
return c;
}
return length;
},
getColumnsBy : function(fn, scope) {
var config = this.config,
length = config.length,
result = [],
i, c;
for (i = 0; i < length; i++){
c = config[i];
if (fn.call(scope || this, c, i) === true) {
result[result.length] = c;
}
}
return result;
},
isSortable : function(col) {
return !!this.config[col].sortable;
},
isMenuDisabled : function(col) {
return !!this.config[col].menuDisabled;
},
getRenderer : function(col) {
return this.config[col].renderer || Ext.grid.ColumnModel.defaultRenderer;
},
getRendererScope : function(col) {
return this.config[col].scope;
},
setRenderer : function(col, fn) {
this.config[col].renderer = fn;
},
getColumnWidth : function(col) {
var width = this.config[col].width;
if(typeof width != 'number'){
width = this.defaultWidth;
}
return width;
},
setColumnWidth : function(col, width, suppressEvent) {
this.config[col].width = width;
this.totalWidth = null;
if (!suppressEvent) {
this.fireEvent("widthchange", this, col, width);
}
},
getTotalWidth : function(includeHidden) {
if (!this.totalWidth) {
this.totalWidth = 0;
for (var i = 0, len = this.config.length; i < len; i++) {
if (includeHidden || !this.isHidden(i)) {
this.totalWidth += this.getColumnWidth(i);
}
}
}
return this.totalWidth;
},
getColumnHeader : function(col) {
return this.config[col].header;
},
setColumnHeader : function(col, header) {
this.config[col].header = header;
this.fireEvent("headerchange", this, col, header);
},
share/ext/ext-all-debug.js view on Meta::CPAN
if(Ext.isDate(val)){
rv = this.renderDate(val);
}else if(typeof val == 'boolean'){
rv = this.renderBool(val);
}
return Ext.util.Format.htmlEncode(rv);
},
getPropertyName : function(name){
var pn = this.grid.propertyNames;
return pn && pn[name] ? pn[name] : name;
},
getCellEditor : function(colIndex, rowIndex){
var p = this.store.getProperty(rowIndex),
n = p.data.name,
val = p.data.value;
if(this.grid.customEditors[n]){
return this.grid.customEditors[n];
}
if(Ext.isDate(val)){
return this.editors.date;
}else if(typeof val == 'number'){
return this.editors.number;
}else if(typeof val == 'boolean'){
return this.editors['boolean'];
}else{
return this.editors.string;
}
},
destroy : function(){
Ext.grid.PropertyColumnModel.superclass.destroy.call(this);
this.destroyEditors(this.editors);
this.destroyEditors(this.grid.customEditors);
},
destroyEditors: function(editors){
for(var ed in editors){
Ext.destroy(editors[ed]);
}
}
});
Ext.grid.PropertyGrid = Ext.extend(Ext.grid.EditorGridPanel, {
enableColumnMove:false,
stripeRows:false,
trackMouseOver: false,
clicksToEdit:1,
enableHdMenu : false,
viewConfig : {
forceFit:true
},
initComponent : function(){
this.customRenderers = this.customRenderers || {};
this.customEditors = this.customEditors || {};
this.lastEditRow = null;
var store = new Ext.grid.PropertyStore(this);
this.propStore = store;
var cm = new Ext.grid.PropertyColumnModel(this, store);
store.store.sort('name', 'ASC');
this.addEvents(
'beforepropertychange',
'propertychange'
);
this.cm = cm;
this.ds = store.store;
Ext.grid.PropertyGrid.superclass.initComponent.call(this);
this.mon(this.selModel, 'beforecellselect', function(sm, rowIndex, colIndex){
if(colIndex === 0){
this.startEditing.defer(200, this, [rowIndex, 1]);
return false;
}
}, this);
},
onRender : function(){
Ext.grid.PropertyGrid.superclass.onRender.apply(this, arguments);
this.getGridEl().addClass('x-props-grid');
},
afterRender: function(){
Ext.grid.PropertyGrid.superclass.afterRender.apply(this, arguments);
if(this.source){
this.setSource(this.source);
}
},
setSource : function(source){
this.propStore.setSource(source);
},
getSource : function(){
return this.propStore.getSource();
},
setProperty : function(prop, value, create){
this.propStore.setValue(prop, value, create);
},
removeProperty : function(prop){
this.propStore.remove(prop);
}
});
Ext.reg("propertygrid", Ext.grid.PropertyGrid);
Ext.grid.GroupingView = Ext.extend(Ext.grid.GridView, {
groupByText : 'Group By This Field',
showGroupsText : 'Show in Groups',
hideGroupedColumn : false,
showGroupName : true,
startCollapsed : false,
enableGrouping : true,
enableGroupingMenu : true,
enableNoGroups : true,
emptyGroupText : '(None)',
ignoreAdd : false,
groupTextTpl : '{text}',
groupMode: 'value',
cancelEditOnToggle: true,
initTemplates : function(){
Ext.grid.GroupingView.superclass.initTemplates.call(this);
this.state = {};
var sm = this.grid.getSelectionModel();
sm.on(sm.selectRow ? 'beforerowselect' : 'beforecellselect',
this.onBeforeRowSelect, this);
if(!this.startGroup){
this.startGroup = new Ext.XTemplate(
'<div id="{groupId}" class="x-grid-group {cls}">',
'<div id="{groupId}-hd" class="x-grid-group-hd" style="{style}"><div class="x-grid-group-title">', this.groupTextTpl ,'</div></div>',
'<div id="{groupId}-bd" class="x-grid-group-body">'
);
}
this.startGroup.compile();
if (!this.endGroup) {
this.endGroup = '</div></div>';
}
},
findGroup : function(el){
return Ext.fly(el).up('.x-grid-group', this.mainBody.dom);
},
getGroups : function(){
return this.hasRows() ? this.mainBody.dom.childNodes : [];
},
onAdd : function(ds, records, index) {
if (this.canGroup() && !this.ignoreAdd) {
var ss = this.getScrollState();
this.fireEvent('beforerowsinserted', ds, index, index + (records.length-1));
this.refresh();
this.restoreScroll(ss);
this.fireEvent('rowsinserted', ds, index, index + (records.length-1));
} else if (!this.canGroup()) {
Ext.grid.GroupingView.superclass.onAdd.apply(this, arguments);
}
},
onRemove : function(ds, record, index, isUpdate){
Ext.grid.GroupingView.superclass.onRemove.apply(this, arguments);
var g = document.getElementById(record._groupId);
if(g && g.childNodes[1].childNodes.length < 1){
Ext.removeNode(g);
}
this.applyEmptyText();
},
refreshRow : function(record){
if(this.ds.getCount()==1){
this.refresh();
}else{
this.isUpdating = true;
Ext.grid.GroupingView.superclass.refreshRow.apply(this, arguments);
this.isUpdating = false;
}
},
beforeMenuShow : function(){
var item, items = this.hmenu.items, disabled = this.cm.config[this.hdCtxIndex].groupable === false;
if((item = items.get('groupBy'))){
item.setDisabled(disabled);
}
if((item = items.get('showGroups'))){
item.setDisabled(disabled);
item.setChecked(this.canGroup(), true);
}
},
renderUI : function(){
var markup = Ext.grid.GroupingView.superclass.renderUI.call(this);
if(this.enableGroupingMenu && this.hmenu){
this.hmenu.add('-',{
itemId:'groupBy',
text: this.groupByText,
handler: this.onGroupByClick,
scope: this,
iconCls:'x-group-by-icon'
});
if(this.enableNoGroups){
this.hmenu.add({
itemId:'showGroups',
text: this.showGroupsText,
checked: true,
checkHandler: this.onShowGroupsClick,
scope: this
});
}
this.hmenu.on('beforeshow', this.beforeMenuShow, this);
}
return markup;
},
processEvent: function(name, e){
Ext.grid.GroupingView.superclass.processEvent.call(this, name, e);
var hd = e.getTarget('.x-grid-group-hd', this.mainBody);
if(hd){
var field = this.getGroupField(),
prefix = this.getPrefix(field),
groupValue = hd.id.substring(prefix.length),
emptyRe = new RegExp('gp-' + Ext.escapeRe(field) + '--hd');
groupValue = groupValue.substr(0, groupValue.length - 3);
if(groupValue || emptyRe.test(hd.id)){
this.grid.fireEvent('group' + name, this.grid, field, groupValue, e);
}
if(name == 'mousedown' && e.button == 0){
this.toggleGroup(hd.parentNode);
}
}
},
onGroupByClick : function(){
var grid = this.grid;
this.enableGrouping = true;
grid.store.groupBy(this.cm.getDataIndex(this.hdCtxIndex));
grid.fireEvent('groupchange', grid, grid.store.getGroupState());
this.beforeMenuShow();
this.refresh();
},
onShowGroupsClick : function(mi, checked){
this.enableGrouping = checked;
if(checked){
this.onGroupByClick();
}else{
this.grid.store.clearGrouping();
this.grid.fireEvent('groupchange', this, null);
}
},
toggleRowIndex : function(rowIndex, expanded){
if(!this.canGroup()){
return;
}
var row = this.getRow(rowIndex);
if(row){
this.toggleGroup(this.findGroup(row), expanded);
}
},
toggleGroup : function(group, expanded){
var gel = Ext.get(group);
expanded = Ext.isDefined(expanded) ? expanded : gel.hasClass('x-grid-group-collapsed');
if(this.state[gel.id] !== expanded){
if (this.cancelEditOnToggle !== false) {
this.grid.stopEditing(true);
}
this.state[gel.id] = expanded;
gel[expanded ? 'removeClass' : 'addClass']('x-grid-group-collapsed');
}
},
toggleAllGroups : function(expanded){
var groups = this.getGroups();
for(var i = 0, len = groups.length; i < len; i++){
this.toggleGroup(groups[i], expanded);
}
},
expandAllGroups : function(){
this.toggleAllGroups(true);
},
collapseAllGroups : function(){
this.toggleAllGroups(false);
},
getGroup : function(v, r, groupRenderer, rowIndex, colIndex, ds){
var column = this.cm.config[colIndex],
g = groupRenderer ? groupRenderer.call(column.scope, v, {}, r, rowIndex, colIndex, ds) : String(v);
if(g === '' || g === ' '){
g = column.emptyGroupText || this.emptyGroupText;
}
return g;
},
getGroupField : function(){
return this.grid.store.getGroupState();
},
afterRender : function(){
if(!this.ds || !this.cm){
return;
}
Ext.grid.GroupingView.superclass.afterRender.call(this);
if(this.grid.deferRowRender){
this.updateGroupWidths();
}
},
afterRenderUI: function () {
Ext.grid.GroupingView.superclass.afterRenderUI.call(this);
if (this.enableGroupingMenu && this.hmenu) {
this.hmenu.add('-',{
itemId:'groupBy',
text: this.groupByText,
handler: this.onGroupByClick,
scope: this,
iconCls:'x-group-by-icon'
});
if (this.enableNoGroups) {
this.hmenu.add({
itemId:'showGroups',
text: this.showGroupsText,
checked: true,
checkHandler: this.onShowGroupsClick,
scope: this
});
}
this.hmenu.on('beforeshow', this.beforeMenuShow, this);
}
},
renderRows : function(){
var groupField = this.getGroupField();
var eg = !!groupField;
if(this.hideGroupedColumn) {
var colIndex = this.cm.findColumnIndex(groupField),
hasLastGroupField = Ext.isDefined(this.lastGroupField);
if(!eg && hasLastGroupField){
this.mainBody.update('');
this.cm.setHidden(this.cm.findColumnIndex(this.lastGroupField), false);
delete this.lastGroupField;
}else if (eg && !hasLastGroupField){
this.lastGroupField = groupField;
this.cm.setHidden(colIndex, true);
}else if (eg && hasLastGroupField && groupField !== this.lastGroupField) {
this.mainBody.update('');
var oldIndex = this.cm.findColumnIndex(this.lastGroupField);
this.cm.setHidden(oldIndex, false);
this.lastGroupField = groupField;
this.cm.setHidden(colIndex, true);
}
}
return Ext.grid.GroupingView.superclass.renderRows.apply(
this, arguments);
},
doRender : function(cs, rs, ds, startRow, colCount, stripe){
if(rs.length < 1){
return '';
}
if(!this.canGroup() || this.isUpdating){
return Ext.grid.GroupingView.superclass.doRender.apply(this, arguments);
}
var groupField = this.getGroupField(),
colIndex = this.cm.findColumnIndex(groupField),
g,
gstyle = 'width:' + this.getTotalWidth() + ';',
cfg = this.cm.config[colIndex],
groupRenderer = cfg.groupRenderer || cfg.renderer,
prefix = this.showGroupName ? (cfg.groupName || cfg.header)+': ' : '',
groups = [],
curGroup, i, len, gid;
for(i = 0, len = rs.length; i < len; i++){
var rowIndex = startRow + i,
r = rs[i],
gvalue = r.data[groupField];
g = this.getGroup(gvalue, r, groupRenderer, rowIndex, colIndex, ds);
if(!curGroup || curGroup.group != g){
gid = this.constructId(gvalue, groupField, colIndex);
( run in 1.289 second using v1.01-cache-2.11-cpan-df04353d9ac )