'); + }, + + + capitalize: Ext.String.capitalize, + + + ellipsis: Ext.String.ellipsis, + + + format: Ext.String.format, + + + htmlDecode: Ext.String.htmlDecode, + + + htmlEncode: Ext.String.htmlEncode, + + + leftPad: Ext.String.leftPad, + + + trim : Ext.String.trim, + + + parseBox : function(box) { + if (Ext.isNumber(box)) { + box = box.toString(); + } + var parts = box.split(' '), + ln = parts.length; + + if (ln == 1) { + parts[1] = parts[2] = parts[3] = parts[0]; + } + else if (ln == 2) { + parts[2] = parts[0]; + parts[3] = parts[1]; + } + else if (ln == 3) { + parts[3] = parts[1]; + } + + return { + top :parseInt(parts[0], 10) || 0, + right :parseInt(parts[1], 10) || 0, + bottom:parseInt(parts[2], 10) || 0, + left :parseInt(parts[3], 10) || 0 + }; + }, + + + escapeRegex : function(s) { + return s.replace(/([\-.*+?\^${}()|\[\]\/\\])/g, "\\$1"); + } + }); +})(); + + +Ext.ns('Ext.util'); + +Ext.util.TaskRunner = function(interval) { + interval = interval || 10; + var tasks = [], + removeQueue = [], + id = 0, + running = false, + + + stopThread = function() { + running = false; + clearInterval(id); + id = 0; + }, + + + startThread = function() { + if (!running) { + running = true; + id = setInterval(runTasks, interval); + } + }, + + + removeTask = function(t) { + removeQueue.push(t); + if (t.onStop) { + t.onStop.apply(t.scope || t); + } + }, + + + runTasks = function() { + var rqLen = removeQueue.length, + now = new Date().getTime(), + i; + + if (rqLen > 0) { + for (i = 0; i < rqLen; i++) { + Ext.Array.remove(tasks, removeQueue[i]); + } + removeQueue = []; + if (tasks.length < 1) { + stopThread(); + return; + } + } + i = 0; + var t, + itime, + rt, + len = tasks.length; + for (; i < len; ++i) { + t = tasks[i]; + itime = now - t.taskRunTime; + if (t.interval <= itime) { + rt = t.run.apply(t.scope || t, t.args || [++t.taskRunCount]); + t.taskRunTime = now; + if (rt === false || t.taskRunCount === t.repeat) { + removeTask(t); + return; + } + } + if (t.duration && t.duration <= (now - t.taskStartTime)) { + removeTask(t); + } + } + }; + + + this.start = function(task) { + tasks.push(task); + task.taskStartTime = new Date().getTime(); + task.taskRunTime = 0; + task.taskRunCount = 0; + startThread(); + return task; + }; + + + this.stop = function(task) { + removeTask(task); + return task; + }; + + + this.stopAll = function() { + stopThread(); + for (var i = 0, len = tasks.length; i < len; i++) { + if (tasks[i].onStop) { + tasks[i].onStop(); + } + } + tasks = []; + removeQueue = []; + }; +}; + + +Ext.TaskManager = Ext.create('Ext.util.TaskRunner'); + +Ext.is = { + init : function(navigator) { + var platforms = this.platforms, + ln = platforms.length, + i, platform; + + navigator = navigator || window.navigator; + + for (i = 0; i < ln; i++) { + platform = platforms[i]; + this[platform.identity] = platform.regex.test(navigator[platform.property]); + } + + + this.Desktop = this.Mac || this.Windows || (this.Linux && !this.Android); + + this.Tablet = this.iPad; + + this.Phone = !this.Desktop && !this.Tablet; + + this.iOS = this.iPhone || this.iPad || this.iPod; + + + this.Standalone = !!window.navigator.standalone; + }, + + + platforms: [{ + property: 'platform', + regex: /iPhone/i, + identity: 'iPhone' + }, + + + { + property: 'platform', + regex: /iPod/i, + identity: 'iPod' + }, + + + { + property: 'userAgent', + regex: /iPad/i, + identity: 'iPad' + }, + + + { + property: 'userAgent', + regex: /Blackberry/i, + identity: 'Blackberry' + }, + + + { + property: 'userAgent', + regex: /Android/i, + identity: 'Android' + }, + + + { + property: 'platform', + regex: /Mac/i, + identity: 'Mac' + }, + + + { + property: 'platform', + regex: /Win/i, + identity: 'Windows' + }, + + + { + property: 'platform', + regex: /Linux/i, + identity: 'Linux' + }] +}; + +Ext.is.init(); + + +Ext.supports = { + init : function() { + var doc = document, + div = doc.createElement('div'), + tests = this.tests, + ln = tests.length, + i, test; + + div.innerHTML = [ + '
',
+ '',
+ '
',
+ '',
+ '',
+ '
',
+ ''
+ ].join('');
+
+ doc.body.appendChild(div);
+
+ for (i = 0; i < ln; i++) {
+ test = tests[i];
+ this[test.identity] = test.fn.call(this, doc, div);
+ }
+
+ doc.body.removeChild(div);
+ },
+
+
+ CSS3BoxShadow: Ext.isDefined(document.documentElement.style.boxShadow),
+
+
+ ClassList: !!document.documentElement.classList,
+
+
+ OrientationChange: ((typeof window.orientation != 'undefined') && ('onorientationchange' in window)),
+
+
+ DeviceMotion: ('ondevicemotion' in window),
+
+
+
+
+ Touch: ('ontouchstart' in window) && (!Ext.is.Desktop),
+
+ tests: [
+
+ {
+ identity: 'Transitions',
+ fn: function(doc, div) {
+ var prefix = [
+ 'webkit',
+ 'Moz',
+ 'o',
+ 'ms',
+ 'khtml'
+ ],
+ TE = 'TransitionEnd',
+ transitionEndName = [
+ prefix[0] + TE,
+ 'transitionend',
+ prefix[2] + TE,
+ prefix[3] + TE,
+ prefix[4] + TE
+ ],
+ ln = prefix.length,
+ i = 0,
+ out = false;
+ div = Ext.get(div);
+ for (; i < ln; i++) {
+ if (div.getStyle(prefix[i] + "TransitionProperty")) {
+ Ext.supports.CSS3Prefix = prefix[i];
+ Ext.supports.CSS3TransitionEnd = transitionEndName[i];
+ out = true;
+ break;
+ }
+ }
+ return out;
+ }
+ },
+
+
+ {
+ identity: 'RightMargin',
+ fn: function(doc, div, view) {
+ view = doc.defaultView;
+ return !(view && view.getComputedStyle(div.firstChild.firstChild, null).marginRight != '0px');
+ }
+ },
+
+
+ {
+ identity: 'TransparentColor',
+ fn: function(doc, div, view) {
+ view = doc.defaultView;
+ return !(view && view.getComputedStyle(div.lastChild, null).backgroundColor != 'transparent');
+ }
+ },
+
+
+ {
+ identity: 'ComputedStyle',
+ fn: function(doc, div, view) {
+ view = doc.defaultView;
+ return view && view.getComputedStyle;
+ }
+ },
+
+
+ {
+ identity: 'Svg',
+ fn: function(doc) {
+ return !!doc.createElementNS && !!doc.createElementNS( "http:/" + "/www.w3.org/2000/svg", "svg").createSVGRect;
+ }
+ },
+
+
+ {
+ identity: 'Canvas',
+ fn: function(doc) {
+ return !!doc.createElement('canvas').getContext;
+ }
+ },
+
+
+ {
+ identity: 'Vml',
+ fn: function(doc) {
+ var d = doc.createElement("div");
+ d.innerHTML = "";
+ return (d.childNodes.length == 2);
+ }
+ },
+
+
+ {
+ identity: 'Float',
+ fn: function(doc, div) {
+ return !!div.lastChild.style.cssFloat;
+ }
+ },
+
+
+ {
+ identity: 'AudioTag',
+ fn: function(doc) {
+ return !!doc.createElement('audio').canPlayType;
+ }
+ },
+
+
+ {
+ identity: 'History',
+ fn: function() {
+ return !!(window.history && history.pushState);
+ }
+ },
+
+
+ {
+ identity: 'CSS3DTransform',
+ fn: function() {
+ return (typeof WebKitCSSMatrix != 'undefined' && new WebKitCSSMatrix().hasOwnProperty('m41'));
+ }
+ },
+
+
+ {
+ identity: 'CSS3LinearGradient',
+ fn: function(doc, div) {
+ var property = 'background-image:',
+ webkit = '-webkit-gradient(linear, left top, right bottom, from(black), to(white))',
+ w3c = 'linear-gradient(left top, black, white)',
+ moz = '-moz-' + w3c,
+ options = [property + webkit, property + w3c, property + moz];
+
+ div.style.cssText = options.join(';');
+
+ return ("" + div.style.backgroundImage).indexOf('gradient') !== -1;
+ }
+ },
+
+
+ {
+ identity: 'CSS3BorderRadius',
+ fn: function(doc, div) {
+ var domPrefixes = ['borderRadius', 'BorderRadius', 'MozBorderRadius', 'WebkitBorderRadius', 'OBorderRadius', 'KhtmlBorderRadius'],
+ pass = false,
+ i;
+ for (i = 0; i < domPrefixes.length; i++) {
+ if (document.body.style[domPrefixes[i]] !== undefined) {
+ return true;
+ }
+ }
+ return pass;
+ }
+ },
+
+
+ {
+ identity: 'GeoLocation',
+ fn: function() {
+ return (typeof navigator != 'undefined' && typeof navigator.geolocation != 'undefined') || (typeof google != 'undefined' && typeof google.gears != 'undefined');
+ }
+ },
+
+ {
+ identity: 'MouseEnterLeave',
+ fn: function(doc, div){
+ return ('onmouseenter' in div && 'onmouseleave' in div);
+ }
+ },
+
+ {
+ identity: 'MouseWheel',
+ fn: function(doc, div) {
+ return ('onmousewheel' in div);
+ }
+ },
+
+ {
+ identity: 'Opacity',
+ fn: function(doc, div){
+
+ if (Ext.isIE6 || Ext.isIE7 || Ext.isIE8) {
+ return false;
+ }
+ div.firstChild.style.cssText = 'opacity:0.73';
+ return div.firstChild.style.opacity == '0.73';
+ }
+ },
+
+ {
+ identity: 'Placeholder',
+ fn: function(doc) {
+ return 'placeholder' in doc.createElement('input');
+ }
+ },
+
+
+ {
+ identity: 'Direct2DBug',
+ fn: function() {
+ return Ext.isString(document.body.style.msTransformOrigin);
+ }
+ },
+
+ {
+ identity: 'BoundingClientRect',
+ fn: function(doc, div) {
+ return Ext.isFunction(div.getBoundingClientRect);
+ }
+ },
+ {
+ identity: 'IncludePaddingInWidthCalculation',
+ fn: function(doc, div){
+ var el = Ext.get(div.childNodes[1].firstChild);
+ return el.getWidth() == 210;
+ }
+ },
+ {
+ identity: 'IncludePaddingInHeightCalculation',
+ fn: function(doc, div){
+ var el = Ext.get(div.childNodes[1].firstChild);
+ return el.getHeight() == 210;
+ }
+ },
+
+
+ {
+ identity: 'ArraySort',
+ fn: function() {
+ var a = [1,2,3,4,5].sort(function(){ return 0; });
+ return a[0] === 1 && a[1] === 2 && a[2] === 3 && a[3] === 4 && a[4] === 5;
+ }
+ },
+
+ {
+ identity: 'Range',
+ fn: function() {
+ return !!document.createRange;
+ }
+ },
+
+ {
+ identity: 'CreateContextualFragment',
+ fn: function() {
+ var range = Ext.supports.Range ? document.createRange() : false;
+
+ return range && !!range.createContextualFragment;
+ }
+ }
+
+ ]
+};
+
+
+
+
+
+Ext.ns('Ext.core');
+Ext.core.DomHelper = function(){
+ var tempTableEl = null,
+ emptyTags = /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,
+ tableRe = /^table|tbody|tr|td$/i,
+ confRe = /tag|children|cn|html$/i,
+ tableElRe = /td|tr|tbody/i,
+ endRe = /end/i,
+ pub,
+
+ afterbegin = 'afterbegin',
+ afterend = 'afterend',
+ beforebegin = 'beforebegin',
+ beforeend = 'beforeend',
+ ts = '" + Ext.String.format(Ext.core.Element.boxMarkup, cls) + "
"));
+ Ext.DomQuery.selectNode('.' + cls + '-mc', el.dom).appendChild(this.dom);
+ return el;
+ },
+
+
+ setSize : function(width, height, animate){
+ var me = this;
+ if (Ext.isObject(width)){
+ height = width.height;
+ width = width.width;
+ }
+ width = me.adjustWidth(width);
+ height = me.adjustHeight(height);
+ if(!animate || !me.anim){
+ me.dom.style.width = me.addUnits(width);
+ me.dom.style.height = me.addUnits(height);
+ }
+ else {
+ if (!Ext.isObject(animate)) {
+ animate = {};
+ }
+ me.animate(Ext.applyIf({
+ to: {
+ width: width,
+ height: height
+ }
+ }, animate));
+ }
+ return me;
+ },
+
+
+ getComputedHeight : function(){
+ var me = this,
+ h = Math.max(me.dom.offsetHeight, me.dom.clientHeight);
+ if(!h){
+ h = parseFloat(me.getStyle('height')) || 0;
+ if(!me.isBorderBox()){
+ h += me.getFrameWidth('tb');
+ }
+ }
+ return h;
+ },
+
+
+ getComputedWidth : function(){
+ var me = this,
+ w = Math.max(me.dom.offsetWidth, me.dom.clientWidth);
+
+ if(!w){
+ w = parseFloat(me.getStyle('width')) || 0;
+ if(!me.isBorderBox()){
+ w += me.getFrameWidth('lr');
+ }
+ }
+ return w;
+ },
+
+
+ getFrameWidth : function(sides, onlyContentBox){
+ return onlyContentBox && this.isBorderBox() ? 0 : (this.getPadding(sides) + this.getBorderWidth(sides));
+ },
+
+
+ addClsOnOver : function(className){
+ var dom = this.dom;
+ this.hover(
+ function(){
+ Ext.fly(dom, INTERNAL).addCls(className);
+ },
+ function(){
+ Ext.fly(dom, INTERNAL).removeCls(className);
+ }
+ );
+ return this;
+ },
+
+
+ addClsOnFocus : function(className){
+ var me = this,
+ dom = me.dom;
+ me.on("focus", function(){
+ Ext.fly(dom, INTERNAL).addCls(className);
+ });
+ me.on("blur", function(){
+ Ext.fly(dom, INTERNAL).removeCls(className);
+ });
+ return me;
+ },
+
+
+ addClsOnClick : function(className){
+ var dom = this.dom;
+ this.on("mousedown", function(){
+ Ext.fly(dom, INTERNAL).addCls(className);
+ var d = Ext.getDoc(),
+ fn = function(){
+ Ext.fly(dom, INTERNAL).removeCls(className);
+ d.removeListener("mouseup", fn);
+ };
+ d.on("mouseup", fn);
+ });
+ return this;
+ },
+
+
+
+ getViewSize : function(){
+ var me = this,
+ dom = me.dom,
+ isDoc = (dom == Ext.getDoc().dom || dom == Ext.getBody().dom),
+ style, overflow, ret;
+
+
+ if (isDoc) {
+ ret = {
+ width : Ext.core.Element.getViewWidth(),
+ height : Ext.core.Element.getViewHeight()
+ };
+
+
+ }
+ else {
+
+
+ if (Ext.isIE6 || Ext.isIEQuirks) {
+ style = dom.style;
+ overflow = style.overflow;
+ me.setStyle({ overflow: 'hidden'});
+ }
+ ret = {
+ width : dom.clientWidth,
+ height : dom.clientHeight
+ };
+ if (Ext.isIE6 || Ext.isIEQuirks) {
+ me.setStyle({ overflow: overflow });
+ }
+ }
+ return ret;
+ },
+
+
+
+ getStyleSize : function(){
+ var me = this,
+ doc = document,
+ d = this.dom,
+ isDoc = (d == doc || d == doc.body),
+ s = d.style,
+ w, h;
+
+
+ if (isDoc) {
+ return {
+ width : Ext.core.Element.getViewWidth(),
+ height : Ext.core.Element.getViewHeight()
+ };
+ }
+
+ if(s.width && s.width != 'auto'){
+ w = parseFloat(s.width);
+ if(me.isBorderBox()){
+ w -= me.getFrameWidth('lr');
+ }
+ }
+
+ if(s.height && s.height != 'auto'){
+ h = parseFloat(s.height);
+ if(me.isBorderBox()){
+ h -= me.getFrameWidth('tb');
+ }
+ }
+
+ return {width: w || me.getWidth(true), height: h || me.getHeight(true)};
+ },
+
+
+ getSize : function(contentSize){
+ return {width: this.getWidth(contentSize), height: this.getHeight(contentSize)};
+ },
+
+
+ repaint : function(){
+ var dom = this.dom;
+ this.addCls(Ext.baseCSSPrefix + 'repaint');
+ setTimeout(function(){
+ Ext.fly(dom).removeCls(Ext.baseCSSPrefix + 'repaint');
+ }, 1);
+ return this;
+ },
+
+
+ unselectable : function(){
+ var me = this;
+ me.dom.unselectable = "on";
+
+ me.swallowEvent("selectstart", true);
+ me.applyStyles("-moz-user-select:none;-khtml-user-select:none;");
+ me.addCls(Ext.baseCSSPrefix + 'unselectable');
+
+ return me;
+ },
+
+
+ getMargin : function(side){
+ var me = this,
+ hash = {t:"top", l:"left", r:"right", b: "bottom"},
+ o = {},
+ key;
+
+ if (!side) {
+ for (key in me.margins){
+ o[hash[key]] = parseFloat(me.getStyle(me.margins[key])) || 0;
+ }
+ return o;
+ } else {
+ return me.addStyles.call(me, side, me.margins);
+ }
+ }
+ });
+})();
+
+
+Ext.core.Element.VISIBILITY = 1;
+
+Ext.core.Element.DISPLAY = 2;
+
+
+Ext.core.Element.OFFSETS = 3;
+
+
+Ext.core.Element.ASCLASS = 4;
+
+
+Ext.core.Element.visibilityCls = Ext.baseCSSPrefix + 'hide-nosize';
+
+Ext.core.Element.addMethods(function(){
+ var El = Ext.core.Element,
+ OPACITY = "opacity",
+ VISIBILITY = "visibility",
+ DISPLAY = "display",
+ HIDDEN = "hidden",
+ OFFSETS = "offsets",
+ ASCLASS = "asclass",
+ NONE = "none",
+ NOSIZE = 'nosize',
+ ORIGINALDISPLAY = 'originalDisplay',
+ VISMODE = 'visibilityMode',
+ ISVISIBLE = 'isVisible',
+ data = El.data,
+ getDisplay = function(dom){
+ var d = data(dom, ORIGINALDISPLAY);
+ if(d === undefined){
+ data(dom, ORIGINALDISPLAY, d = '');
+ }
+ return d;
+ },
+ getVisMode = function(dom){
+ var m = data(dom, VISMODE);
+ if(m === undefined){
+ data(dom, VISMODE, m = 1);
+ }
+ return m;
+ };
+
+ return {
+
+ originalDisplay : "",
+ visibilityMode : 1,
+
+
+ setVisibilityMode : function(visMode){
+ data(this.dom, VISMODE, visMode);
+ return this;
+ },
+
+
+ isVisible : function() {
+ var me = this,
+ dom = me.dom,
+ visible = data(dom, ISVISIBLE);
+
+ if(typeof visible == 'boolean'){
+ return visible;
+ }
+
+ visible = !me.isStyle(VISIBILITY, HIDDEN) &&
+ !me.isStyle(DISPLAY, NONE) &&
+ !((getVisMode(dom) == El.ASCLASS) && me.hasCls(me.visibilityCls || El.visibilityCls));
+
+ data(dom, ISVISIBLE, visible);
+ return visible;
+ },
+
+
+ setVisible : function(visible, animate){
+ var me = this, isDisplay, isVisibility, isOffsets, isNosize,
+ dom = me.dom,
+ visMode = getVisMode(dom);
+
+
+
+ if (typeof animate == 'string'){
+ switch (animate) {
+ case DISPLAY:
+ visMode = El.DISPLAY;
+ break;
+ case VISIBILITY:
+ visMode = El.VISIBILITY;
+ break;
+ case OFFSETS:
+ visMode = El.OFFSETS;
+ break;
+ case NOSIZE:
+ case ASCLASS:
+ visMode = El.ASCLASS;
+ break;
+ }
+ me.setVisibilityMode(visMode);
+ animate = false;
+ }
+
+ if (!animate || !me.anim) {
+ if(visMode == El.ASCLASS ){
+
+ me[visible?'removeCls':'addCls'](me.visibilityCls || El.visibilityCls);
+
+ } else if (visMode == El.DISPLAY){
+
+ return me.setDisplayed(visible);
+
+ } else if (visMode == El.OFFSETS){
+
+ if (!visible){
+
+ if (!me.hideModeStyles) {
+ me.hideModeStyles = {
+ position: me.getStyle('position'),
+ top: me.getStyle('top'),
+ left: me.getStyle('left')
+ };
+ }
+ me.applyStyles({position: 'absolute', top: '-10000px', left: '-10000px'});
+ }
+
+
+
+ else if (me.hideModeStyles) {
+ me.applyStyles(me.hideModeStyles || {position: '', top: '', left: ''});
+ delete me.hideModeStyles;
+ }
+
+ }else{
+ me.fixDisplay();
+
+ dom.style.visibility = visible ? '' : HIDDEN;
+ }
+ }else{
+
+ if(visible){
+ me.setOpacity(0.01);
+ me.setVisible(true);
+ }
+ if (!Ext.isObject(animate)) {
+ animate = {
+ duration: 350,
+ easing: 'ease-in'
+ };
+ }
+ me.animate(Ext.applyIf({
+ callback: function() {
+ visible || me.setVisible(false).setOpacity(1);
+ },
+ to: {
+ opacity: (visible) ? 1 : 0
+ }
+ }, animate));
+ }
+ data(dom, ISVISIBLE, visible);
+ return me;
+ },
+
+
+
+ hasMetrics : function(){
+ var dom = this.dom;
+ return this.isVisible() || (getVisMode(dom) == El.OFFSETS) || (getVisMode(dom) == El.VISIBILITY);
+ },
+
+
+ toggle : function(animate){
+ var me = this;
+ me.setVisible(!me.isVisible(), me.anim(animate));
+ return me;
+ },
+
+
+ setDisplayed : function(value) {
+ if(typeof value == "boolean"){
+ value = value ? getDisplay(this.dom) : NONE;
+ }
+ this.setStyle(DISPLAY, value);
+ return this;
+ },
+
+
+ fixDisplay : function(){
+ var me = this;
+ if (me.isStyle(DISPLAY, NONE)) {
+ me.setStyle(VISIBILITY, HIDDEN);
+ me.setStyle(DISPLAY, getDisplay(this.dom));
+ if (me.isStyle(DISPLAY, NONE)) {
+ me.setStyle(DISPLAY, "block");
+ }
+ }
+ },
+
+
+ hide : function(animate){
+
+ if (typeof animate == 'string'){
+ this.setVisible(false, animate);
+ return this;
+ }
+ this.setVisible(false, this.anim(animate));
+ return this;
+ },
+
+
+ show : function(animate){
+
+ if (typeof animate == 'string'){
+ this.setVisible(true, animate);
+ return this;
+ }
+ this.setVisible(true, this.anim(animate));
+ return this;
+ }
+ };
+}());
+
+Ext.applyIf(Ext.core.Element.prototype, {
+
+ animate: function(config) {
+ var me = this;
+ if (!me.id) {
+ me = Ext.get(me.dom);
+ }
+ if (Ext.fx.Manager.hasFxBlock(me.id)) {
+ return me;
+ }
+ Ext.fx.Manager.queueFx(Ext.create('Ext.fx.Anim', me.anim(config)));
+ return this;
+ },
+
+
+ anim: function(config) {
+ if (!Ext.isObject(config)) {
+ return (config) ? {} : false;
+ }
+
+ var me = this,
+ duration = config.duration || Ext.fx.Anim.prototype.duration,
+ easing = config.easing || 'ease',
+ animConfig;
+
+ if (config.stopAnimation) {
+ me.stopAnimation();
+ }
+
+ Ext.applyIf(config, Ext.fx.Manager.getFxDefaults(me.id));
+
+
+ Ext.fx.Manager.setFxDefaults(me.id, {
+ delay: 0
+ });
+
+ animConfig = {
+ target: me,
+ remove: config.remove,
+ alternate: config.alternate || false,
+ duration: duration,
+ easing: easing,
+ callback: config.callback,
+ listeners: config.listeners,
+ iterations: config.iterations || 1,
+ scope: config.scope,
+ block: config.block,
+ concurrent: config.concurrent,
+ delay: config.delay || 0,
+ paused: true,
+ keyframes: config.keyframes,
+ from: config.from || {},
+ to: Ext.apply({}, config)
+ };
+ Ext.apply(animConfig.to, config.to);
+
+
+ delete animConfig.to.to;
+ delete animConfig.to.from;
+ delete animConfig.to.remove;
+ delete animConfig.to.alternate;
+ delete animConfig.to.keyframes;
+ delete animConfig.to.iterations;
+ delete animConfig.to.listeners;
+ delete animConfig.to.target;
+ delete animConfig.to.paused;
+ delete animConfig.to.callback;
+ delete animConfig.to.scope;
+ delete animConfig.to.duration;
+ delete animConfig.to.easing;
+ delete animConfig.to.concurrent;
+ delete animConfig.to.block;
+ delete animConfig.to.stopAnimation;
+ delete animConfig.to.delay;
+ return animConfig;
+ },
+
+
+ slideIn: function(anchor, obj, slideOut) {
+ var me = this,
+ elStyle = me.dom.style,
+ beforeAnim, wrapAnim;
+
+ anchor = anchor || "t";
+ obj = obj || {};
+
+ beforeAnim = function() {
+ var animScope = this,
+ listeners = obj.listeners,
+ box, position, restoreSize, wrap, anim;
+
+ if (!slideOut) {
+ me.fixDisplay();
+ }
+
+ box = me.getBox();
+ if ((anchor == 't' || anchor == 'b') && box.height == 0) {
+ box.height = me.dom.scrollHeight;
+ }
+ else if ((anchor == 'l' || anchor == 'r') && box.width == 0) {
+ box.width = me.dom.scrollWidth;
+ }
+
+ position = me.getPositioning();
+ me.setSize(box.width, box.height);
+
+ wrap = me.wrap({
+ style: {
+ visibility: slideOut ? 'visible' : 'hidden'
+ }
+ });
+ wrap.setPositioning(position);
+ if (wrap.isStyle('position', 'static')) {
+ wrap.position('relative');
+ }
+ me.clearPositioning('auto');
+ wrap.clip();
+
+
+
+
+ me.setStyle({
+ visibility: '',
+ position: 'absolute'
+ });
+ if (slideOut) {
+ wrap.setSize(box.width, box.height);
+ }
+
+ switch (anchor) {
+ case 't':
+ anim = {
+ from: {
+ width: box.width + 'px',
+ height: '0px'
+ },
+ to: {
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ elStyle.bottom = '0px';
+ break;
+ case 'l':
+ anim = {
+ from: {
+ width: '0px',
+ height: box.height + 'px'
+ },
+ to: {
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ elStyle.right = '0px';
+ break;
+ case 'r':
+ anim = {
+ from: {
+ x: box.x + box.width,
+ width: '0px',
+ height: box.height + 'px'
+ },
+ to: {
+ x: box.x,
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ break;
+ case 'b':
+ anim = {
+ from: {
+ y: box.y + box.height,
+ width: box.width + 'px',
+ height: '0px'
+ },
+ to: {
+ y: box.y,
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ break;
+ case 'tl':
+ anim = {
+ from: {
+ x: box.x,
+ y: box.y,
+ width: '0px',
+ height: '0px'
+ },
+ to: {
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ elStyle.bottom = '0px';
+ elStyle.right = '0px';
+ break;
+ case 'bl':
+ anim = {
+ from: {
+ x: box.x + box.width,
+ width: '0px',
+ height: '0px'
+ },
+ to: {
+ x: box.x,
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ elStyle.right = '0px';
+ break;
+ case 'br':
+ anim = {
+ from: {
+ x: box.x + box.width,
+ y: box.y + box.height,
+ width: '0px',
+ height: '0px'
+ },
+ to: {
+ x: box.x,
+ y: box.y,
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ break;
+ case 'tr':
+ anim = {
+ from: {
+ y: box.y + box.height,
+ width: '0px',
+ height: '0px'
+ },
+ to: {
+ y: box.y,
+ width: box.width + 'px',
+ height: box.height + 'px'
+ }
+ };
+ elStyle.bottom = '0px';
+ break;
+ }
+
+ wrap.show();
+ wrapAnim = Ext.apply({}, obj);
+ delete wrapAnim.listeners;
+ wrapAnim = Ext.create('Ext.fx.Anim', Ext.applyIf(wrapAnim, {
+ target: wrap,
+ duration: 500,
+ easing: 'ease-out',
+ from: slideOut ? anim.to : anim.from,
+ to: slideOut ? anim.from : anim.to
+ }));
+
+
+ wrapAnim.on('afteranimate', function() {
+ if (slideOut) {
+ me.setPositioning(position);
+ if (obj.useDisplay) {
+ me.setDisplayed(false);
+ } else {
+ me.hide();
+ }
+ }
+ else {
+ me.clearPositioning();
+ me.setPositioning(position);
+ }
+ if (wrap.dom) {
+ wrap.dom.parentNode.insertBefore(me.dom, wrap.dom);
+ wrap.remove();
+ }
+ me.setSize(box.width, box.height);
+ animScope.end();
+ });
+
+ if (listeners) {
+ wrapAnim.on(listeners);
+ }
+ };
+
+ me.animate({
+ duration: obj.duration ? obj.duration * 2 : 1000,
+ listeners: {
+ beforeanimate: {
+ fn: beforeAnim
+ },
+ afteranimate: {
+ fn: function() {
+ if (wrapAnim && wrapAnim.running) {
+ wrapAnim.end();
+ }
+ }
+ }
+ }
+ });
+ return me;
+ },
+
+
+
+ slideOut: function(anchor, o) {
+ return this.slideIn(anchor, o, true);
+ },
+
+
+
+ puff: function(obj) {
+ var me = this,
+ beforeAnim;
+ obj = Ext.applyIf(obj || {}, {
+ easing: 'ease-out',
+ duration: 500,
+ useDisplay: false
+ });
+
+ beforeAnim = function() {
+ me.clearOpacity();
+ me.show();
+
+ var box = me.getBox(),
+ fontSize = me.getStyle('fontSize'),
+ position = me.getPositioning();
+ this.to = {
+ width: box.width * 2,
+ height: box.height * 2,
+ x: box.x - (box.width / 2),
+ y: box.y - (box.height /2),
+ opacity: 0,
+ fontSize: '200%'
+ };
+ this.on('afteranimate',function() {
+ if (me.dom) {
+ if (obj.useDisplay) {
+ me.setDisplayed(false);
+ } else {
+ me.hide();
+ }
+ me.clearOpacity();
+ me.setPositioning(position);
+ me.setStyle({fontSize: fontSize});
+ }
+ });
+ };
+
+ me.animate({
+ duration: obj.duration,
+ easing: obj.easing,
+ listeners: {
+ beforeanimate: {
+ fn: beforeAnim
+ }
+ }
+ });
+ return me;
+ },
+
+
+ switchOff: function(obj) {
+ var me = this,
+ beforeAnim;
+
+ obj = Ext.applyIf(obj || {}, {
+ easing: 'ease-in',
+ duration: 500,
+ remove: false,
+ useDisplay: false
+ });
+
+ beforeAnim = function() {
+ var animScope = this,
+ size = me.getSize(),
+ xy = me.getXY(),
+ keyframe, position;
+ me.clearOpacity();
+ me.clip();
+ position = me.getPositioning();
+
+ keyframe = Ext.create('Ext.fx.Animator', {
+ target: me,
+ duration: obj.duration,
+ easing: obj.easing,
+ keyframes: {
+ 33: {
+ opacity: 0.3
+ },
+ 66: {
+ height: 1,
+ y: xy[1] + size.height / 2
+ },
+ 100: {
+ width: 1,
+ x: xy[0] + size.width / 2
+ }
+ }
+ });
+ keyframe.on('afteranimate', function() {
+ if (obj.useDisplay) {
+ me.setDisplayed(false);
+ } else {
+ me.hide();
+ }
+ me.clearOpacity();
+ me.setPositioning(position);
+ me.setSize(size);
+ animScope.end();
+ });
+ };
+ me.animate({
+ duration: (obj.duration * 2),
+ listeners: {
+ beforeanimate: {
+ fn: beforeAnim
+ }
+ }
+ });
+ return me;
+ },
+
+
+ frame : function(color, count, obj){
+ var me = this,
+ beforeAnim;
+
+ color = color || '#C3DAF9';
+ count = count || 1;
+ obj = obj || {};
+
+ beforeAnim = function() {
+ me.show();
+ var animScope = this,
+ box = me.getBox(),
+ proxy = Ext.getBody().createChild({
+ style: {
+ position : 'absolute',
+ 'pointer-events': 'none',
+ 'z-index': 35000,
+ border : '0px solid ' + color
+ }
+ }),
+ proxyAnim;
+ proxyAnim = Ext.create('Ext.fx.Anim', {
+ target: proxy,
+ duration: obj.duration || 1000,
+ iterations: count,
+ from: {
+ top: box.y,
+ left: box.x,
+ borderWidth: 0,
+ opacity: 1,
+ height: box.height,
+ width: box.width
+ },
+ to: {
+ top: box.y - 20,
+ left: box.x - 20,
+ borderWidth: 10,
+ opacity: 0,
+ height: box.height + 40,
+ width: box.width + 40
+ }
+ });
+ proxyAnim.on('afteranimate', function() {
+ proxy.remove();
+ animScope.end();
+ });
+ };
+
+ me.animate({
+ duration: (obj.duration * 2) || 2000,
+ listeners: {
+ beforeanimate: {
+ fn: beforeAnim
+ }
+ }
+ });
+ return me;
+ },
+
+
+ ghost: function(anchor, obj) {
+ var me = this,
+ beforeAnim;
+
+ anchor = anchor || "b";
+ beforeAnim = function() {
+ var width = me.getWidth(),
+ height = me.getHeight(),
+ xy = me.getXY(),
+ position = me.getPositioning(),
+ to = {
+ opacity: 0
+ };
+ switch (anchor) {
+ case 't':
+ to.y = xy[1] - height;
+ break;
+ case 'l':
+ to.x = xy[0] - width;
+ break;
+ case 'r':
+ to.x = xy[0] + width;
+ break;
+ case 'b':
+ to.y = xy[1] + height;
+ break;
+ case 'tl':
+ to.x = xy[0] - width;
+ to.y = xy[1] - height;
+ break;
+ case 'bl':
+ to.x = xy[0] - width;
+ to.y = xy[1] + height;
+ break;
+ case 'br':
+ to.x = xy[0] + width;
+ to.y = xy[1] + height;
+ break;
+ case 'tr':
+ to.x = xy[0] + width;
+ to.y = xy[1] - height;
+ break;
+ }
+ this.to = to;
+ this.on('afteranimate', function () {
+ if (me.dom) {
+ me.hide();
+ me.clearOpacity();
+ me.setPositioning(position);
+ }
+ });
+ };
+
+ me.animate(Ext.applyIf(obj || {}, {
+ duration: 500,
+ easing: 'ease-out',
+ listeners: {
+ beforeanimate: {
+ fn: beforeAnim
+ }
+ }
+ }));
+ return me;
+ },
+
+
+ highlight: function(color, o) {
+ var me = this,
+ dom = me.dom,
+ from = {},
+ restore, to, attr, lns, event, fn;
+
+ o = o || {};
+ lns = o.listeners || {};
+ attr = o.attr || 'backgroundColor';
+ from[attr] = color || 'ffff9c';
+
+ if (!o.to) {
+ to = {};
+ to[attr] = o.endColor || me.getColor(attr, 'ffffff', '');
+ }
+ else {
+ to = o.to;
+ }
+
+
+ o.listeners = Ext.apply(Ext.apply({}, lns), {
+ beforeanimate: function() {
+ restore = dom.style[attr];
+ me.clearOpacity();
+ me.show();
+
+ event = lns.beforeanimate;
+ if (event) {
+ fn = event.fn || event;
+ return fn.apply(event.scope || lns.scope || window, arguments);
+ }
+ },
+ afteranimate: function() {
+ if (dom) {
+ dom.style[attr] = restore;
+ }
+
+ event = lns.afteranimate;
+ if (event) {
+ fn = event.fn || event;
+ fn.apply(event.scope || lns.scope || window, arguments);
+ }
+ }
+ });
+
+ me.animate(Ext.apply({}, o, {
+ duration: 1000,
+ easing: 'ease-in',
+ from: from,
+ to: to
+ }));
+ return me;
+ },
+
+
+ pause: function(ms) {
+ var me = this;
+ Ext.fx.Manager.setFxDefaults(me.id, {
+ delay: ms
+ });
+ return me;
+ },
+
+
+ fadeIn: function(o) {
+ this.animate(Ext.apply({}, o, {
+ opacity: 1
+ }));
+ return this;
+ },
+
+
+ fadeOut: function(o) {
+ this.animate(Ext.apply({}, o, {
+ opacity: 0
+ }));
+ return this;
+ },
+
+
+ scale: function(w, h, o) {
+ this.animate(Ext.apply({}, o, {
+ width: w,
+ height: h
+ }));
+ return this;
+ },
+
+
+ shift: function(config) {
+ this.animate(config);
+ return this;
+ }
+});
+
+
+Ext.applyIf(Ext.core.Element, {
+ unitRe: /\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i,
+ camelRe: /(-[a-z])/gi,
+ opacityRe: /alpha\(opacity=(.*)\)/i,
+ cssRe: /([a-z0-9-]+)\s*:\s*([^;\s]+(?:\s*[^;\s]+)*);?/gi,
+ propertyCache: {},
+ defaultUnit : "px",
+ borders: {l: 'border-left-width', r: 'border-right-width', t: 'border-top-width', b: 'border-bottom-width'},
+ paddings: {l: 'padding-left', r: 'padding-right', t: 'padding-top', b: 'padding-bottom'},
+ margins: {l: 'margin-left', r: 'margin-right', t: 'margin-top', b: 'margin-bottom'},
+
+
+ addUnits : Ext.core.Element.prototype.addUnits,
+
+
+ parseBox : function(box) {
+ if (Ext.isObject(box)) {
+ return {
+ top: box.top || 0,
+ right: box.right || 0,
+ bottom: box.bottom || 0,
+ left: box.left || 0
+ };
+ } else {
+ if (typeof box != 'string') {
+ box = box.toString();
+ }
+ var parts = box.split(' '),
+ ln = parts.length;
+
+ if (ln == 1) {
+ parts[1] = parts[2] = parts[3] = parts[0];
+ }
+ else if (ln == 2) {
+ parts[2] = parts[0];
+ parts[3] = parts[1];
+ }
+ else if (ln == 3) {
+ parts[3] = parts[1];
+ }
+
+ return {
+ top :parseFloat(parts[0]) || 0,
+ right :parseFloat(parts[1]) || 0,
+ bottom:parseFloat(parts[2]) || 0,
+ left :parseFloat(parts[3]) || 0
+ };
+ }
+
+ },
+
+
+ unitizeBox : function(box, units) {
+ var A = this.addUnits,
+ B = this.parseBox(box);
+
+ return A(B.top, units) + ' ' +
+ A(B.right, units) + ' ' +
+ A(B.bottom, units) + ' ' +
+ A(B.left, units);
+
+ },
+
+
+ camelReplaceFn : function(m, a) {
+ return a.charAt(1).toUpperCase();
+ },
+
+
+ normalize : function(prop) {
+ if (prop == 'float') {
+ prop = Ext.supports.Float ? 'cssFloat' : 'styleFloat';
+ }
+ return this.propertyCache[prop] || (this.propertyCache[prop] = prop.replace(this.camelRe, this.camelReplaceFn));
+ },
+
+
+ getDocumentHeight: function() {
+ return Math.max(!Ext.isStrict ? document.body.scrollHeight : document.documentElement.scrollHeight, this.getViewportHeight());
+ },
+
+
+ getDocumentWidth: function() {
+ return Math.max(!Ext.isStrict ? document.body.scrollWidth : document.documentElement.scrollWidth, this.getViewportWidth());
+ },
+
+
+ getViewportHeight: function(){
+ return window.innerHeight;
+ },
+
+
+ getViewportWidth : function() {
+ return window.innerWidth;
+ },
+
+
+ getViewSize : function() {
+ return {
+ width: window.innerWidth,
+ height: window.innerHeight
+ };
+ },
+
+
+ getOrientation : function() {
+ if (Ext.supports.OrientationChange) {
+ return (window.orientation == 0) ? 'portrait' : 'landscape';
+ }
+
+ return (window.innerHeight > window.innerWidth) ? 'portrait' : 'landscape';
+ },
+
+
+ fromPoint: function(x, y) {
+ return Ext.get(document.elementFromPoint(x, y));
+ },
+
+
+ parseStyles: function(styles){
+ var out = {},
+ cssRe = this.cssRe,
+ matches;
+
+ if (styles) {
+
+
+
+
+ cssRe.lastIndex = 0;
+ while ((matches = cssRe.exec(styles))) {
+ out[matches[1]] = matches[2];
+ }
+ }
+ return out;
+ }
+});
+
+
+Ext.CompositeElementLite = function(els, root){
+
+ this.elements = [];
+ this.add(els, root);
+ this.el = new Ext.core.Element.Flyweight();
+};
+
+Ext.CompositeElementLite.prototype = {
+ isComposite: true,
+
+
+ getElement : function(el){
+
+ var e = this.el;
+ e.dom = el;
+ e.id = el.id;
+ return e;
+ },
+
+
+ transformElement : function(el){
+ return Ext.getDom(el);
+ },
+
+
+ getCount : function(){
+ return this.elements.length;
+ },
+
+ add : function(els, root){
+ var me = this,
+ elements = me.elements;
+ if(!els){
+ return this;
+ }
+ if(typeof els == "string"){
+ els = Ext.core.Element.selectorFunction(els, root);
+ }else if(els.isComposite){
+ els = els.elements;
+ }else if(!Ext.isIterable(els)){
+ els = [els];
+ }
+
+ for(var i = 0, len = els.length; i < len; ++i){
+ elements.push(me.transformElement(els[i]));
+ }
+ return me;
+ },
+
+ invoke : function(fn, args){
+ var me = this,
+ els = me.elements,
+ len = els.length,
+ e,
+ i;
+
+ for(i = 0; i < len; i++) {
+ e = els[i];
+ if(e){
+ Ext.core.Element.prototype[fn].apply(me.getElement(e), args);
+ }
+ }
+ return me;
+ },
+
+ item : function(index){
+ var me = this,
+ el = me.elements[index],
+ out = null;
+
+ if(el){
+ out = me.getElement(el);
+ }
+ return out;
+ },
+
+
+ addListener : function(eventName, handler, scope, opt){
+ var els = this.elements,
+ len = els.length,
+ i, e;
+
+ for(i = 0; ivalues to the template and appends
+ * the new node(s) to the specified el.
+ * For example usage {@link #Template see the constructor}.
+ * @param {Mixed} el The context element + * @param {Object/Array} values + * The template values. Can be an array if the params are numeric (i.e.{0})
+ * or an object (i.e. {foo: 'bar'}).
+ * @param {Boolean} returnElement (optional) true to return an Ext.core.Element (defaults to undefined)
+ * @return {HTMLElement/Ext.core.Element} The new node or Element
+ */
+ append: function(el, values, returnElement) {
+ return this.doInsert('beforeEnd', el, values, returnElement);
+ },
+
+ doInsert: function(where, el, values, returnEl) {
+ el = Ext.getDom(el);
+ var newNode = Ext.core.DomHelper.insertHtml(where, el, this.applyTemplate(values));
+ return returnEl ? Ext.get(newNode, true) : newNode;
+ },
+
+ /**
+ * Applies the supplied values to the template and overwrites the content of el with the new node(s).
+ * @param {Mixed} el The context element
+ * @param {Object/Array} values The template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})
+ * @param {Boolean} returnElement (optional) true to return a Ext.core.Element (defaults to undefined)
+ * @return {HTMLElement/Ext.core.Element} The new node or Element
+ */
+ overwrite: function(el, values, returnElement) {
+ el = Ext.getDom(el);
+ el.innerHTML = this.applyTemplate(values);
+ return returnElement ? Ext.get(el.firstChild, true) : el.firstChild;
+ }
+}, function() {
+
+ /**
+ * Alias for {@link #applyTemplate}
+ * Returns an HTML fragment of this template with the specified values applied.
+ * @param {Object/Array} values
+ * The template values. Can be an array if the params are numeric (i.e. {0})
+ * or an object (i.e. {foo: 'bar'}).
+ * @return {String} The HTML fragment
+ * @member Ext.Template
+ * @method apply
+ */
+ this.createAlias('apply', 'applyTemplate');
+});
+
+/**
+ * @class Ext.ComponentQuery
+ * @extends Object
+ *
+ * Provides searching of Components within Ext.ComponentManager (globally) or a specific
+ * Ext.container.Container on the document with a similar syntax to a CSS selector.
+ *
+ * Components can be retrieved by using their {@link Ext.Component xtype} with an optional . prefix
+-
+
- component or .component +
- gridpanel or .gridpanel +
-
+
- #myContainer +
-
+
- component[autoScroll] +
- panel[title="Test"] +
+var disabledFields = myFormPanel.query("{isDisabled()}");
+
+// Function receives array and returns a filtered array.
+Ext.ComponentQuery.pseudos.invalid = function(items) {
+ var i = 0, l = items.length, c, result = [];
+ for (; i < l; i++) {
+ if (!(c = items[i]).isValid()) {
+ result.push(c);
+ }
+ }
+ return result;
+};
+
+var invalidFields = myFormPanel.query('field:invalid');
+if (invalidFields.length) {
+ invalidFields[0].getEl().scrollIntoView(myFormPanel.body);
+ for (var i = 0, l = invalidFields.length; i < l; i++) {
+ invalidFields[i].getEl().frame("red");
+ }
+}
+
+ * Default pseudos include:
+ * - not
+ *
+ // retrieve all Ext.Panels in the document by xtype
+ var panelsArray = Ext.ComponentQuery.query('panel');
+
+ // retrieve all Ext.Panels within the container with an id myCt
+ var panelsWithinmyCt = Ext.ComponentQuery.query('#myCt panel');
+
+ // retrieve all direct children which are Ext.Panels within myCt
+ var directChildPanel = Ext.ComponentQuery.query('#myCt > panel');
+
+ // retrieve all gridpanels and listviews
+ var gridsAndLists = Ext.ComponentQuery.query('gridpanel, listview');
+Returns an array of matched Components from within the passed root object.
+ *This method filters returned Components in a similar way to how CSS selector based DOM + * queries work using a textual selector string.
+ *See class summary for details.
+ * @param selector The selector string to filter returned Components + * @param rootThe Container within which to perform the query. If omitted, all Components + * within the document are included in the search.
+ *This parameter may also be an array of Components to filter according to the selector.
+ * @returns {Array} The matched Components. + * @member Ext.ComponentQuery + * @method query + */ + query: function(selector, root) { + var selectors = selector.split(','), + length = selectors.length, + i = 0, + results = [], + noDupResults = [], + dupMatcher = {}, + query, resultsLn, cmp; + + for (; i < length; i++) { + selector = Ext.String.trim(selectors[i]); + query = this.cache[selector]; + if (!query) { + this.cache[selector] = query = this.parse(selector); + } + results = results.concat(query.execute(root)); + } + + // multiple selectors, potential to find duplicates + // lets filter them out. + if (length > 1) { + resultsLn = results.length; + for (i = 0; i < resultsLn; i++) { + cmp = results[i]; + if (!dupMatcher[cmp.id]) { + noDupResults.push(cmp); + dupMatcher[cmp.id] = true; + } + } + results = noDupResults; + } + return results; + }, + + /** + * Tests whether the passed Component matches the selector string. + * @param component The Component to test + * @param selector The selector string to test against. + * @return {Boolean} True if the Component matches the selector. + * @member Ext.ComponentQuery + * @method query + */ + is: function(component, selector) { + if (!selector) { + return true; + } + var query = this.cache[selector]; + if (!query) { + this.cache[selector] = query = this.parse(selector); + } + return query.is(component); + }, + + parse: function(selector) { + var operations = [], + length = matchers.length, + lastSelector, + tokenMatch, + matchedChar, + modeMatch, + selectorMatch, + i, matcher, method; + + // We are going to parse the beginning of the selector over and + // over again, slicing off the selector any portions we converted into an + // operation, until it is an empty string. + while (selector && lastSelector !== selector) { + lastSelector = selector; + + // First we check if we are dealing with a token like #, * or an xtype + tokenMatch = selector.match(tokenRe); + + if (tokenMatch) { + matchedChar = tokenMatch[1]; + + // If the token is prefixed with a # we push a filterById operation to our stack + if (matchedChar === '#') { + operations.push({ + method: filterById, + args: [Ext.String.trim(tokenMatch[2])] + }); + } + // If the token is prefixed with a . we push a filterByClassName operation to our stack + // FIXME: Not enabled yet. just needs \. adding to the tokenRe prefix + else if (matchedChar === '.') { + operations.push({ + method: filterByClassName, + args: [Ext.String.trim(tokenMatch[2])] + }); + } + // If the token is a * or an xtype string, we push a filterByXType + // operation to the stack. + else { + operations.push({ + method: filterByXType, + args: [Ext.String.trim(tokenMatch[2]), Boolean(tokenMatch[3])] + }); + } + + // Now we slice of the part we just converted into an operation + selector = selector.replace(tokenMatch[0], ''); + } + + // If the next part of the query is not a space or > or ^, it means we + // are going to check for more things that our current selection + // has to comply to. + while (!(modeMatch = selector.match(modeRe))) { + // Lets loop over each type of matcher and execute it + // on our current selector. + for (i = 0; selector && i < length; i++) { + matcher = matchers[i]; + selectorMatch = selector.match(matcher.re); + method = matcher.method; + + // If we have a match, add an operation with the method + // associated with this matcher, and pass the regular + // expression matches are arguments to the operation. + if (selectorMatch) { + operations.push({ + method: Ext.isString(matcher.method) + // Turn a string method into a function by formatting the string with our selector matche expression + // A new method is created for different match expressions, eg {id=='textfield-1024'} + // Every expression may be different in different selectors. + ? Ext.functionFactory('items', Ext.String.format.apply(Ext.String, [method].concat(selectorMatch.slice(1)))) + : matcher.method, + args: selectorMatch.slice(1) + }); + selector = selector.replace(selectorMatch[0], ''); + break; // Break on match + } + // Exhausted all matches: It's an error + if (i === (length - 1)) { + Ext.Error.raise('Invalid ComponentQuery selector: "' + arguments[0] + '"'); + } + } + } + + // Now we are going to check for a mode change. This means a space + // or a > to determine if we are going to select all the children + // of the currently matched items, or a ^ if we are going to use the + // ownerCt axis as the candidate source. + if (modeMatch[1]) { // Assignment, and test for truthiness! + operations.push({ + mode: modeMatch[2]||modeMatch[1] + }); + selector = selector.replace(modeMatch[0], ''); + } + } + + // Now that we have all our operations in an array, we are going + // to create a new Query using these operations. + return new cq.Query({ + operations: operations + }); + } + }); +}); +/** + * @class Ext.util.Filter + * @extends Object + *Represents a filter that can be applied to a {@link Ext.util.MixedCollection MixedCollection}. Can either simply + * filter on a property/value pair or pass in a filter function with custom logic. Filters are always used in the context + * of MixedCollections, though {@link Ext.data.Store Store}s frequently create them when filtering and searching on their + * records. Example usage:
+
+//set up a fictional MixedCollection containing a few people to filter on
+var allNames = new Ext.util.MixedCollection();
+allNames.addAll([
+ {id: 1, name: 'Ed', age: 25},
+ {id: 2, name: 'Jamie', age: 37},
+ {id: 3, name: 'Abe', age: 32},
+ {id: 4, name: 'Aaron', age: 26},
+ {id: 5, name: 'David', age: 32}
+]);
+
+var ageFilter = new Ext.util.Filter({
+ property: 'age',
+ value : 32
+});
+
+var longNameFilter = new Ext.util.Filter({
+ filterFn: function(item) {
+ return item.name.length > 4;
+ }
+});
+
+//a new MixedCollection with the 3 names longer than 4 characters
+var longNames = allNames.filter(longNameFilter);
+
+//a new MixedCollection with the 2 people of age 24:
+var youngFolk = allNames.filter(ageFilter);
+
+Ext.get('el').load({
+ url: 'myPage.php',
+ scripts: true,
+ params: {
+ id: 1
+ }
+});
+ * + * In general this class will not be instanced directly, rather the {@link Ext.core.Element#load} method + * will be used. + *
+ */ +Ext.define('Ext.ElementLoader', { + + /* Begin Definitions */ + + mixins: { + observable: 'Ext.util.Observable' + }, + + uses: [ + 'Ext.data.Connection', + 'Ext.Ajax' + ], + + statics: { + Renderer: { + Html: function(loader, response, active){ + loader.getTarget().update(response.responseText, active.scripts === true); + return true; + } + } + }, + + /* End Definitions */ + + /** + * @cfg {String} url The url to retrieve the content from. Defaults to null. + */ + url: null, + + /** + * @cfg {Object} params Any params to be attached to the Ajax request. These parameters will + * be overridden by any params in the load options. Defaults to null. + */ + params: null, + + /** + * @cfg {Object} baseParams Params that will be attached to every request. These parameters + * will not be overridden by any params in the load options. Defaults to null. + */ + baseParams: null, + + /** + * @cfg {Boolean/Object} autoLoad True to have the loader make a request as soon as it is created. Defaults to false. + * This argument can also be a set of options that will be passed to {@link #load} is called. + */ + autoLoad: false, + + /** + * @cfg {Mixed} target The target element for the loader. It can be the DOM element, the id or an Ext.Element. + */ + target: null, + + /** + * @cfg {Mixed} loadMask True or a string to show when the element is loading. + */ + loadMask: false, + + /** + * @cfg {Object} ajaxOptions Any additional options to be passed to the request, for example timeout or headers. Defaults to null. + */ + ajaxOptions: null, + + /** + * @cfg {Boolean} scripts True to parse any inline script tags in the response. + */ + scripts: false, + + /** + * @cfg {Function} success A function to be called when a load request is successful. + */ + + /** + * @cfg {Function} failure A function to be called when a load request fails. + */ + + /** + * @cfg {Object} scope The scope to execute the {@link #success} and {@link #failure} functions in. + */ + + /** + * @cfg {Function} renderer A custom function to render the content to the element. The passed parameters + * are + *-
+ *
- The loader + *
- The response + *
- The active request + *
This class is intended to be extended or created via the {@link Ext.Component#componentLayout layout} + * configuration property. See {@link Ext.Component#componentLayout} for additional details.
+ */ + +Ext.define('Ext.layout.component.Component', { + + /* Begin Definitions */ + + extend: 'Ext.layout.Layout', + + /* End Definitions */ + + type: 'component', + + monitorChildren: true, + + initLayout : function() { + var me = this, + owner = me.owner, + ownerEl = owner.el; + + if (!me.initialized) { + if (owner.frameSize) { + me.frameSize = owner.frameSize; + } + else { + owner.frameSize = me.frameSize = { + top: 0, + left: 0, + bottom: 0, + right: 0 + }; + } + } + me.callParent(arguments); + }, + + beforeLayout : function(width, height, isSetSize, layoutOwner) { + this.callParent(arguments); + + var me = this, + owner = me.owner, + ownerCt = owner.ownerCt, + layout = owner.layout, + isVisible = owner.isVisible(true), + ownerElChild = owner.el.child, + layoutCollection; + + /** + * Do not layout calculatedSized components for fixedLayouts unless the ownerCt == layoutOwner + * fixedLayouts means layouts which are never auto/auto in the sizing that comes from their ownerCt. + * Currently 3 layouts MAY be auto/auto (Auto, Border, and Box) + * The reason for not allowing component layouts is to stop component layouts from things such as Updater and + * form Validation. + */ + if (!isSetSize && !(Ext.isNumber(width) && Ext.isNumber(height)) && ownerCt && ownerCt.layout && ownerCt.layout.fixedLayout && ownerCt != layoutOwner) { + me.doContainerLayout(); + return false; + } + + // If an ownerCt is hidden, add my reference onto the layoutOnShow stack. Set the needsLayout flag. + // If the owner itself is a directly hidden floater, set the needsLayout object on that for when it is shown. + if (!isVisible && (owner.hiddenAncestor || owner.floating)) { + if (owner.hiddenAncestor) { + layoutCollection = owner.hiddenAncestor.layoutOnShow; + layoutCollection.remove(owner); + layoutCollection.add(owner); + } + owner.needsLayout = { + width: width, + height: height, + isSetSize: false + }; + } + + if (isVisible && this.needsLayout(width, height)) { + me.rawWidth = width; + me.rawHeight = height; + return owner.beforeComponentLayout(width, height, isSetSize, layoutOwner); + } + else { + return false; + } + }, + + /** + * Check if the new size is different from the current size and only + * trigger a layout if it is necessary. + * @param {Mixed} width The new width to set. + * @param {Mixed} height The new height to set. + */ + needsLayout : function(width, height) { + this.lastComponentSize = this.lastComponentSize || { + width: -Infinity, + height: -Infinity + }; + return (this.childrenChanged || this.lastComponentSize.width !== width || this.lastComponentSize.height !== height); + }, + + /** + * Set the size of any element supporting undefined, null, and values. + * @param {Mixed} width The new width to set. + * @param {Mixed} height The new height to set. + */ + setElementSize: function(el, width, height) { + if (width !== undefined && height !== undefined) { + el.setSize(width, height); + } + else if (height !== undefined) { + el.setHeight(height); + } + else if (width !== undefined) { + el.setWidth(width); + } + }, + + /** + * Returns the owner component's resize element. + * @return {Ext.core.Element} + */ + getTarget : function() { + return this.owner.el; + }, + + /** + *Returns the element into which rendering must take place. Defaults to the owner Component's encapsulating element.
+ * May be overridden in Component layout managers which implement an inner element. + * @return {Ext.core.Element} + */ + getRenderTarget : function() { + return this.owner.el; + }, + + /** + * Set the size of the target element. + * @param {Mixed} width The new width to set. + * @param {Mixed} height The new height to set. + */ + setTargetSize : function(width, height) { + var me = this; + me.setElementSize(me.owner.el, width, height); + + if (me.owner.frameBody) { + var targetInfo = me.getTargetInfo(), + padding = targetInfo.padding, + border = targetInfo.border, + frameSize = me.frameSize; + + me.setElementSize(me.owner.frameBody, + Ext.isNumber(width) ? (width - frameSize.left - frameSize.right - padding.left - padding.right - border.left - border.right) : width, + Ext.isNumber(height) ? (height - frameSize.top - frameSize.bottom - padding.top - padding.bottom - border.top - border.bottom) : height + ); + } + + me.autoSized = { + width: !Ext.isNumber(width), + height: !Ext.isNumber(height) + }; + + me.lastComponentSize = { + width: width, + height: height + }; + }, + + getTargetInfo : function() { + if (!this.targetInfo) { + var target = this.getTarget(), + body = this.owner.getTargetEl(); + + this.targetInfo = { + padding: { + top: target.getPadding('t'), + right: target.getPadding('r'), + bottom: target.getPadding('b'), + left: target.getPadding('l') + }, + border: { + top: target.getBorderWidth('t'), + right: target.getBorderWidth('r'), + bottom: target.getBorderWidth('b'), + left: target.getBorderWidth('l') + }, + bodyMargin: { + top: body.getMargin('t'), + right: body.getMargin('r'), + bottom: body.getMargin('b'), + left: body.getMargin('l') + } + }; + } + return this.targetInfo; + }, + + // Start laying out UP the ownerCt's layout when flagged to do so. + doOwnerCtLayouts: function() { + var owner = this.owner, + ownerCt = owner.ownerCt, + ownerCtComponentLayout, ownerCtContainerLayout; + + if (!ownerCt) { + return; + } + + ownerCtComponentLayout = ownerCt.componentLayout; + ownerCtContainerLayout = ownerCt.layout; + + if (!owner.floating && ownerCtComponentLayout && ownerCtComponentLayout.monitorChildren && !ownerCtComponentLayout.layoutBusy) { + if (!ownerCt.suspendLayout && ownerCtContainerLayout && !ownerCtContainerLayout.layoutBusy) { + // AutoContainer Layout and Dock with auto in some dimension + if (ownerCtContainerLayout.bindToOwnerCtComponent === true) { + ownerCt.doComponentLayout(); + } + // Box Layouts + else if (ownerCtContainerLayout.bindToOwnerCtContainer === true) { + ownerCtContainerLayout.layout(); + } + } + } + }, + + doContainerLayout: function() { + var me = this, + owner = me.owner, + ownerCt = owner.ownerCt, + layout = owner.layout, + ownerCtComponentLayout; + + // Run the container layout if it exists (layout for child items) + // **Unless automatic laying out is suspended, or the layout is currently running** + if (!owner.suspendLayout && layout && layout.isLayout && !layout.layoutBusy) { + layout.layout(); + } + + // Tell the ownerCt that it's child has changed and can be re-layed by ignoring the lastComponentSize cache. + if (ownerCt && ownerCt.componentLayout) { + ownerCtComponentLayout = ownerCt.componentLayout; + if (!owner.floating && ownerCtComponentLayout.monitorChildren && !ownerCtComponentLayout.layoutBusy) { + ownerCtComponentLayout.childrenChanged = true; + } + } + }, + + afterLayout : function(width, height, isSetSize, layoutOwner) { + this.doContainerLayout(); + this.owner.afterComponentLayout(width, height, isSetSize, layoutOwner); + } +}); + +/** + * @class Ext.state.Manager + * This is the global state manager. By default all components that are "state aware" check this class + * for state information if you don't pass them a custom state provider. In order for this class + * to be useful, it must be initialized with a provider when your application initializes. Example usage: +
+// in your initialization function
+init : function(){
+ Ext.state.Manager.setProvider(new Ext.state.CookieProvider());
+ var win = new Window(...);
+ win.restoreState();
+}
+ A flag which causes the object to attempt to restore the state of
+ * internal properties from a saved state on startup. The object must have
+ * a {@link #stateId} for state to be managed.
+ * Auto-generated ids are not guaranteed to be stable across page loads and
+ * cannot be relied upon to save and restore the same state for a object.
+ *
For state saving to work, the state manager's provider must have been + * set to an implementation of {@link Ext.state.Provider} which overrides the + * {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} + * methods to save and recall name/value pairs. A built-in implementation, + * {@link Ext.state.CookieProvider} is available.
+ *To set the state provider for the current page:
+ *
+Ext.state.Manager.setProvider(new Ext.state.CookieProvider({
+ expires: new Date(new Date().getTime()+(1000*60*60*24*7)), //7 days from now
+}));
+ * A stateful object attempts to save state when one of the events
+ * listed in the {@link #stateEvents} configuration fires.
To save state, a stateful object first serializes its state by
+ * calling {@link #getState}. By default, this function does
+ * nothing. The developer must provide an implementation which returns an
+ * object hash which represents the restorable state of the object.
The value yielded by getState is passed to {@link Ext.state.Manager#set}
+ * which uses the configured {@link Ext.state.Provider} to save the object
+ * keyed by the {@link stateId}
During construction, a stateful object attempts to restore
+ * its state by calling {@link Ext.state.Manager#get} passing the
+ * {@link #stateId}
The resulting object is passed to {@link #applyState}.
+ * The default implementation of {@link #applyState} simply copies
+ * properties into the object, but a developer may override this to support
+ * more behaviour.
You can perform extra processing on state save and restore by attaching + * handlers to the {@link #beforestaterestore}, {@link #staterestore}, + * {@link #beforestatesave} and {@link #statesave} events.
+ */ + stateful: true, + + /** + * @cfg {String} stateId + * The unique id for this object to use for state management purposes. + *See {@link #stateful} for an explanation of saving and restoring state.
+ */ + + /** + * @cfg {Array} stateEvents + *An array of events that, when fired, should trigger this object to
+ * save its state (defaults to none). stateEvents may be any type
+ * of event supported by this object, including browser or custom events
+ * (e.g., ['click', 'customerchange']).
See {@link #stateful} for an explanation of saving and
+ * restoring object state.
undefined if not found.
+ */
+ get : function(id) {
+ return this.all.get(id);
+ },
+
+ /**
+ * Registers an item to be managed
+ * @param {Mixed} item The item to register
+ */
+ register: function(item) {
+ this.all.add(item);
+ },
+
+ /**
+ * Unregisters an item by removing it from this manager
+ * @param {Mixed} item The item to unregister
+ */
+ unregister: function(item) {
+ this.all.remove(item);
+ },
+
+ /**
+ * Registers a new item constructor, keyed by a type key.
+ * @param {String} type The mnemonic string by which the class may be looked up.
+ * @param {Constructor} cls The new instance class.
+ */
+ registerType : function(type, cls) {
+ this.types[type] = cls;
+ cls[this.typeName] = type;
+ },
+
+ /**
+ * Checks if an item type is registered.
+ * @param {String} type The mnemonic string by which the class may be looked up
+ * @return {Boolean} Whether the type is registered.
+ */
+ isRegistered : function(type){
+ return this.types[type] !== undefined;
+ },
+
+ /**
+ * Creates and returns an instance of whatever this manager manages, based on the supplied type and config object
+ * @param {Object} config The config object
+ * @param {String} defaultType If no type is discovered in the config object, we fall back to this type
+ * @return {Mixed} The instance of whatever this manager is managing
+ */
+ create: function(config, defaultType) {
+ var type = config[this.typeName] || config.type || defaultType,
+ Constructor = this.types[type];
+
+ if (Constructor == undefined) {
+ Ext.Error.raise("The '" + type + "' type has not been registered with this manager");
+ }
+
+ return new Constructor(config);
+ },
+
+ /**
+ * Registers a function that will be called when an item with the specified id is added to the manager. This will happen on instantiation.
+ * @param {String} id The item id
+ * @param {Function} fn The callback function. Called with a single parameter, the item.
+ * @param {Object} scope The scope (this reference) in which the callback is executed. Defaults to the item.
+ */
+ onAvailable : function(id, fn, scope){
+ var all = this.all,
+ item;
+
+ if (all.containsKey(id)) {
+ item = all.get(id);
+ fn.call(scope || item, item);
+ } else {
+ all.on('add', function(map, key, item){
+ if (key == id) {
+ fn.call(scope || item, item);
+ all.un('add', fn, scope);
+ }
+ });
+ }
+ },
+
+ /**
+ * Executes the specified function once for each item in the collection.
+ * Returning false from the function will cease iteration.
+ *
+ * The paramaters passed to the function are:
+ *
-
+ *
- key : String
The key of the item
+ * - value : Number
The value of the item
+ * - length : Number
The total number of items in the collection
+ *
Provides a registry of available Plugin classes indexed by a mnemonic code known as the Plugin's ptype.
+ * The {@link Ext.Component#xtype xtype} provides a way to avoid instantiating child Components
+ * when creating a full, nested config object for a complete Ext page.
A child Component may be specified simply as a config object
+ * as long as the correct {@link Ext.Component#xtype xtype} is specified so that if and when the Component
+ * needs rendering, the correct type can be looked up for lazy instantiation.
For a list of all available {@link Ext.Component#xtype xtypes}, see {@link Ext.Component}.
ptype. (Optional if the config contains a ptype).
+ * @return {Ext.Component} The newly instantiated Plugin.
+ */
+ //create: function(plugin, defaultType) {
+ // if (plugin instanceof this) {
+ // return plugin;
+ // } else {
+ // var type, config = {};
+ //
+ // if (Ext.isString(plugin)) {
+ // type = plugin;
+ // }
+ // else {
+ // type = plugin[this.typeName] || defaultType;
+ // config = plugin;
+ // }
+ //
+ // return Ext.createByAlias('plugin.' + type, config);
+ // }
+ //},
+
+ create : function(config, defaultType){
+ if (config.init) {
+ return config;
+ } else {
+ return Ext.createByAlias('plugin.' + (config.ptype || defaultType), config);
+ }
+
+ // Prior system supported Singleton plugins.
+ //var PluginCls = this.types[config.ptype || defaultType];
+ //if (PluginCls.init) {
+ // return PluginCls;
+ //} else {
+ // return new PluginCls(config);
+ //}
+ },
+
+ /**
+ * Returns all plugins registered with the given type. Here, 'type' refers to the type of plugin, not its ptype.
+ * @param {String} type The type to search for
+ * @param {Boolean} defaultsOnly True to only return plugins of this type where the plugin's isDefault property is truthy
+ * @return {Array} All matching plugins
+ */
+ findByType: function(type, defaultsOnly) {
+ var matches = [],
+ types = this.types;
+
+ for (var name in types) {
+ if (!types.hasOwnProperty(name)) {
+ continue;
+ }
+ var item = types[name];
+
+ if (item.type == type && (!defaultsOnly || (defaultsOnly === true && item.isDefault))) {
+ matches.push(item);
+ }
+ }
+
+ return matches;
+ }
+}, function() {
+ /**
+ * Shorthand for {@link Ext.PluginManager#registerType}
+ * @param {String} ptype The ptype mnemonic string by which the Plugin class
+ * may be looked up.
+ * @param {Constructor} cls The new Plugin class.
+ * @member Ext
+ * @method preg
+ */
+ Ext.preg = function() {
+ return Ext.PluginManager.registerType.apply(Ext.PluginManager, arguments);
+ };
+});
+
+/**
+ * @class Ext.ComponentManager
+ * @extends Ext.AbstractManager
+ * Provides a registry of all Components (instances of {@link Ext.Component} or any subclass + * thereof) on a page so that they can be easily accessed by {@link Ext.Component component} + * {@link Ext.Component#id id} (see {@link #get}, or the convenience method {@link Ext#getCmp Ext.getCmp}).
+ *This object also provides a registry of available Component classes
+ * indexed by a mnemonic code known as the Component's {@link Ext.Component#xtype xtype}.
+ * The xtype provides a way to avoid instantiating child Components
+ * when creating a full, nested config object for a complete Ext page.
A child Component may be specified simply as a config object
+ * as long as the correct {@link Ext.Component#xtype xtype} is specified so that if and when the Component
+ * needs rendering, the correct type can be looked up for lazy instantiation.
For a list of all available {@link Ext.Component#xtype xtypes}, see {@link Ext.Component}.
xtype. (Optional if the config contains a xtype).
+ * @return {Ext.Component} The newly instantiated Component.
+ */
+ create: function(component, defaultType){
+ if (component instanceof Ext.AbstractComponent) {
+ return component;
+ }
+ else if (Ext.isString(component)) {
+ return Ext.createByAlias('widget.' + component);
+ }
+ else {
+ var type = component.xtype || defaultType,
+ config = component;
+
+ return Ext.createByAlias('widget.' + type, config);
+ }
+ },
+
+ registerType: function(type, cls) {
+ this.types[type] = cls;
+ cls[this.typeName] = type;
+ cls.prototype[this.typeName] = type;
+ }
+});
+/**
+ * @class Ext.XTemplate
+ * @extends Ext.Template
+ * A template class that supports advanced functionality like:
-
+ *
- Autofilling arrays using templates and sub-templates + *
- Conditional processing with basic comparison operators + *
- Basic math function support + *
- Execute arbitrary inline code with special built-in template variables + *
- Custom member functions + *
- Many special tags and built-in operators that aren't defined as part of + * the API, but are supported in the templates that can be created + *
XTemplate provides the templating mechanism built into:
-
+ *
- {@link Ext.view.View} + *
-
+ *
+ *
- Sample Data
+ * + *+ *
This is the data object used for reference in each code example:
+ *
+ *+var data = { +name: 'Tommy Maintz', +title: 'Lead Developer', +company: 'Sencha Inc.', +email: 'tommy@sencha.com', +address: '5 Cups Drive', +city: 'Palo Alto', +state: 'CA', +zip: '44102', +drinks: ['Coffee', 'Soda', 'Water'], +kids: [{ + name: 'Joshua', + age:3 + },{ + name: 'Matthew', + age:2 + },{ + name: 'Solomon', + age:0 +}] +}; +
+ *
+ *
+ * - Auto filling of arrays
+ * + *+ *
The tpl tag and the for operator are used + * to process the provided data object: + *
-
+ *
- If the value specified in for is an array, it will auto-fill, + * repeating the template block inside the tpl tag for each item in the + * array. + *
- If for="." is specified, the data object provided is examined. + *
- While processing an array, the special variable {#} + * will provide the current array index + 1 (starts at 1, not 0). + *
+ * Using the sample data above: + *+<tpl for=".">...</tpl> // loop through array at root node +<tpl for="foo">...</tpl> // loop through array at foo node +<tpl for="foo.bar">...</tpl> // loop through array at foo.bar node +
+ *+var tpl = new Ext.XTemplate( + '<p>Kids: ', + '<tpl for=".">', // process the data.kids node + '<p>{#}. {name}</p>', // use current array index to autonumber + '</tpl></p>' +); +tpl.overwrite(panel.body, data.kids); // pass the kids property of the data object +An example illustrating how the for property can be leveraged + * to access specified members of the provided data object to populate the template:
+ *
+ *+var tpl = new Ext.XTemplate( + '<p>Name: {name}</p>', + '<p>Title: {title}</p>', + '<p>Company: {company}</p>', + '<p>Kids: ', + '<tpl for="kids">', // interrogate the kids property within the data + '<p>{name}</p>', + '</tpl></p>' +); +tpl.overwrite(panel.body, data); // pass the root node of the data object +Flat arrays that contain values (and not objects) can be auto-rendered + * using the special {.} variable inside a loop. This variable + * will represent the value of the array at the current index:
+ *
+ *+var tpl = new Ext.XTemplate( + '<p>{name}\'s favorite beverages:</p>', + '<tpl for="drinks">', + '<div> - {.}</div>', + '</tpl>' +); +tpl.overwrite(panel.body, data); +When processing a sub-template, for example while looping through a child array, + * you can access the parent object's members via the parent object:
+ *
+ *+var tpl = new Ext.XTemplate( + '<p>Name: {name}</p>', + '<p>Kids: ', + '<tpl for="kids">', + '<tpl if="age > 1">', + '<p>{name}</p>', + '<p>Dad: {parent.name}</p>', + '</tpl>', + '</tpl></p>' +); +tpl.overwrite(panel.body, data); +
+ *
+ *
+ * - Conditional processing with basic comparison operators
+ * + *+ *
The tpl tag and the if operator are used + * to provide conditional checks for deciding whether or not to render specific + * parts of the template. Notes:
+ *-
+ *
- Double quotes must be encoded if used within the conditional + *
- There is no else operator — if needed, two opposite + * if statements should be used. + *
+ * Using the sample data above: + *+<tpl if="age > 1 && age < 10">Child</tpl> +<tpl if="age >= 10 && age < 18">Teenager</tpl> +<tpl if="this.isGirl(name)">...</tpl> +<tpl if="id==\'download\'">...</tpl> +<tpl if="needsIcon"><img src="{icon}" class="{iconCls}"/></tpl> +// no good: +<tpl if="name == "Tommy"">Hello</tpl> +// encode " if it is part of the condition, e.g. +<tpl if="name == "Tommy"">Hello</tpl> + *
+ *+var tpl = new Ext.XTemplate( + '<p>Name: {name}</p>', + '<p>Kids: ', + '<tpl for="kids">', + '<tpl if="age > 1">', + '<p>{name}</p>', + '</tpl>', + '</tpl></p>' +); +tpl.overwrite(panel.body, data); +
+ *
+ *
+ * - Basic math support
+ * + *+ *
The following basic math operators may be applied directly on numeric + * data values:
+ * + - * / + *
+ * For example: + *
+ *+var tpl = new Ext.XTemplate( + '<p>Name: {name}</p>', + '<p>Kids: ', + '<tpl for="kids">', + '<tpl if="age > 1">', // <-- Note that the > is encoded + '<p>{#}: {name}</p>', // <-- Auto-number each item + '<p>In 5 Years: {age+5}</p>', // <-- Basic math + '<p>Dad: {parent.name}</p>', + '</tpl>', + '</tpl></p>' +); +tpl.overwrite(panel.body, data); +
+ *
+ *
+ * - Execute arbitrary inline code with special built-in template variables
+ * + *+ *
Anything between
{[ ... ]}is considered code to be executed + * in the scope of the template. There are some special variables available in that code: + *-
+ *
- values: The values in the current scope. If you are using + * scope changing sub-templates, you can change what values is. + *
- parent: The scope (values) of the ancestor template. + *
- xindex: If you are in a looping template, the index of the + * loop you are in (1-based). + *
- xcount: If you are in a looping template, the total length + * of the array you are looping. + *
+ *+var tpl = new Ext.XTemplate( + '<p>Name: {name}</p>', + '<p>Company: {[values.company.toUpperCase() + ", " + values.title]}</p>', + '<p>Kids: ', + '<tpl for="kids">', + '<div class="{[xindex % 2 === 0 ? "even" : "odd"]}">', + '{name}', + '</div>', + '</tpl></p>' + ); +tpl.overwrite(panel.body, data); +
+ *
+ * - Template member functions
+ * + *+ *
One or more member functions can be specified in a configuration + * object passed into the XTemplate constructor for more complex processing:
+ *
+ *+var tpl = new Ext.XTemplate( + '<p>Name: {name}</p>', + '<p>Kids: ', + '<tpl for="kids">', + '<tpl if="this.isGirl(name)">', + '<p>Girl: {name} - {age}</p>', + '</tpl>', + // use opposite if statement to simulate 'else' processing: + '<tpl if="this.isGirl(name) == false">', + '<p>Boy: {name} - {age}</p>', + '</tpl>', + '<tpl if="this.isBaby(age)">', + '<p>{name} is a baby!</p>', + '</tpl>', + '</tpl></p>', + { + // XTemplate configuration: + compiled: true, + // member functions: + isGirl: function(name){ + return name == 'Sara Grace'; + }, + isBaby: function(age){ + return age < 1; + } + } +); +tpl.overwrite(panel.body, data); +
+ *
+ *
{bodyCls} {baseCls}-body-{ui} {parent.baseCls}-body-{parent.ui}-{.} style="{bodyStyle}" >
'],
+
+
+
+
+ border: true,
+
+ initComponent : function() {
+ var me = this;
+
+ me.addEvents(
+
+ 'bodyresize'
+
+
+
+
+ );
+
+ Ext.applyIf(me.renderSelectors, {
+ body: '.' + me.baseCls + '-body'
+ });
+
+
+
+
+ if (me.frame && me.border && me.bodyBorder === undefined) {
+ me.bodyBorder = false;
+ }
+ if (me.frame && me.border && (me.bodyBorder === false || me.bodyBorder === 0)) {
+ me.manageBodyBorders = true;
+ }
+
+ me.callParent();
+ },
+
+
+ initItems : function() {
+ var me = this,
+ items = me.dockedItems;
+
+ me.callParent();
+ me.dockedItems = Ext.create('Ext.util.MixedCollection', false, me.getComponentId);
+ if (items) {
+ me.addDocked(items);
+ }
+ },
+
+
+ getDockedComponent: function(comp) {
+ if (Ext.isObject(comp)) {
+ comp = comp.getItemId();
+ }
+ return this.dockedItems.get(comp);
+ },
+
+
+ getComponent: function(comp) {
+ var component = this.callParent(arguments);
+ if (component === undefined && !Ext.isNumber(comp)) {
+
+ component = this.getDockedComponent(comp);
+ }
+ return component;
+ },
+
+
+ initBodyStyles: function() {
+ var me = this,
+ bodyStyle = me.bodyStyle,
+ styles = [],
+ Element = Ext.core.Element,
+ prop;
+
+ if (Ext.isFunction(bodyStyle)) {
+ bodyStyle = bodyStyle();
+ }
+ if (Ext.isString(bodyStyle)) {
+ styles = bodyStyle.split(';');
+ } else {
+ for (prop in bodyStyle) {
+ if (bodyStyle.hasOwnProperty(prop)) {
+ styles.push(prop + ':' + bodyStyle[prop]);
+ }
+ }
+ }
+
+ if (me.bodyPadding !== undefined) {
+ styles.push('padding: ' + Element.unitizeBox((me.bodyPadding === true) ? 5 : me.bodyPadding));
+ }
+ if (me.frame && me.bodyBorder) {
+ if (!Ext.isNumber(me.bodyBorder)) {
+ me.bodyBorder = 1;
+ }
+ styles.push('border-width: ' + Element.unitizeBox(me.bodyBorder));
+ }
+ delete me.bodyStyle;
+ return styles.length ? styles.join(';') : undefined;
+ },
+
+
+ initBodyCls: function() {
+ var me = this,
+ cls = '',
+ bodyCls = me.bodyCls;
+
+ if (bodyCls) {
+ Ext.each(bodyCls, function(v) {
+ cls += " " + v;
+ });
+ delete me.bodyCls;
+ }
+ return cls.length > 0 ? cls : undefined;
+ },
+
+
+ initRenderData: function() {
+ return Ext.applyIf(this.callParent(), {
+ bodyStyle: this.initBodyStyles(),
+ bodyCls: this.initBodyCls()
+ });
+ },
+
+
+ addDocked : function(items, pos) {
+ var me = this,
+ i = 0,
+ item, length;
+
+ items = me.prepareItems(items);
+ length = items.length;
+
+ for (; i < length; i++) {
+ item = items[i];
+ item.dock = item.dock || 'top';
+
+
+ if (me.border === false) {
+
+ }
+
+ if (pos !== undefined) {
+ me.dockedItems.insert(pos + i, item);
+ }
+ else {
+ me.dockedItems.add(item);
+ }
+ item.onAdded(me, i);
+ me.onDockedAdd(item);
+ }
+ if (me.rendered) {
+ me.doComponentLayout();
+ }
+ return items;
+ },
+
+
+ onDockedAdd : Ext.emptyFn,
+ onDockedRemove : Ext.emptyFn,
+
+
+ insertDocked : function(pos, items) {
+ this.addDocked(items, pos);
+ },
+
+
+ removeDocked : function(item, autoDestroy) {
+ var me = this,
+ layout,
+ hasLayout;
+
+ if (!me.dockedItems.contains(item)) {
+ return item;
+ }
+
+ layout = me.componentLayout;
+ hasLayout = layout && me.rendered;
+
+ if (hasLayout) {
+ layout.onRemove(item);
+ }
+
+ me.dockedItems.remove(item);
+ item.onRemoved();
+ me.onDockedRemove(item);
+
+ if (autoDestroy === true || (autoDestroy !== false && me.autoDestroy)) {
+ item.destroy();
+ }
+
+ if (hasLayout && !autoDestroy) {
+ layout.afterRemove(item);
+ }
+
+ if (!this.destroying) {
+ me.doComponentLayout();
+ }
+
+ return item;
+ },
+
+
+ getDockedItems : function(cqSelector) {
+ var me = this,
+
+
+ defaultWeight = { top: 1, left: 3, right: 5, bottom: 7 },
+ dockedItems;
+
+ if (me.dockedItems && me.dockedItems.items.length) {
+
+ if (cqSelector) {
+ dockedItems = Ext.ComponentQuery.query(cqSelector, me.dockedItems.items);
+ } else {
+ dockedItems = me.dockedItems.items.slice();
+ }
+
+ Ext.Array.sort(dockedItems, function(a, b) {
+
+
+ var aw = a.weight || defaultWeight[a.dock],
+ bw = b.weight || defaultWeight[b.dock];
+ if (Ext.isNumber(aw) && Ext.isNumber(bw)) {
+ return aw - bw;
+ }
+ return 0;
+ });
+
+ return dockedItems;
+ }
+ return [];
+ },
+
+
+ addUIClsToElement: function(cls, force) {
+ var me = this;
+
+ me.callParent(arguments);
+
+ if (!force && me.rendered) {
+ me.body.addCls(Ext.baseCSSPrefix + cls);
+ me.body.addCls(me.baseCls + '-body-' + cls);
+ me.body.addCls(me.baseCls + '-body-' + me.ui + '-' + cls);
+ }
+ },
+
+
+ removeUIClsFromElement: function(cls, force) {
+ var me = this;
+
+ me.callParent(arguments);
+
+ if (!force && me.rendered) {
+ me.body.removeCls(Ext.baseCSSPrefix + cls);
+ me.body.removeCls(me.baseCls + '-body-' + cls);
+ me.body.removeCls(me.baseCls + '-body-' + me.ui + '-' + cls);
+ }
+ },
+
+
+ addUIToElement: function(force) {
+ var me = this;
+
+ me.callParent(arguments);
+
+ if (!force && me.rendered) {
+ me.body.addCls(me.baseCls + '-body-' + me.ui);
+ }
+ },
+
+
+ removeUIFromElement: function() {
+ var me = this;
+
+ me.callParent(arguments);
+
+ if (me.rendered) {
+ me.body.removeCls(me.baseCls + '-body-' + me.ui);
+ }
+ },
+
+
+ getTargetEl : function() {
+ return this.body;
+ },
+
+ getRefItems: function(deep) {
+ var items = this.callParent(arguments),
+
+ dockedItems = this.getDockedItems(deep ? '*,* *' : undefined),
+ ln = dockedItems.length,
+ i = 0,
+ item;
+
+
+ for (; i < ln; i++) {
+ item = dockedItems[i];
+ if (item.dock === 'right' || item.dock === 'bottom') {
+ break;
+ }
+ }
+
+
+
+
+ return dockedItems.splice(0, i).concat(items).concat(dockedItems);
+ },
+
+ beforeDestroy: function(){
+ var docked = this.dockedItems,
+ c;
+
+ if (docked) {
+ while ((c = docked.first())) {
+ this.removeDocked(c, true);
+ }
+ }
+ this.callParent();
+ },
+
+ setBorder: function(border) {
+ var me = this;
+ me.border = (border !== undefined) ? border : true;
+ if (me.rendered) {
+ me.doComponentLayout();
+ }
+ }
+});
+
+Ext.define('Ext.panel.Header', {
+ extend: 'Ext.container.Container',
+ uses: ['Ext.panel.Tool', 'Ext.draw.Component', 'Ext.util.CSS'],
+ alias: 'widget.header',
+
+ isHeader : true,
+ defaultType : 'tool',
+ indicateDrag : false,
+ weight : -1,
+
+ renderTpl: [' {bodyCls} {parent.baseCls}-body-{parent.ui}-{.} style="{bodyStyle}" >
'],
+
+ initComponent: function() {
+ var me = this,
+ rule,
+ style,
+ titleTextEl,
+ ui;
+
+ me.indicateDragCls = me.baseCls + '-draggable';
+ me.title = me.title || ' ';
+ me.tools = me.tools || [];
+ me.items = me.items || [];
+ me.orientation = me.orientation || 'horizontal';
+ me.dock = (me.dock) ? me.dock : (me.orientation == 'horizontal') ? 'top' : 'left';
+
+
+
+ me.addClsWithUI(me.orientation);
+ me.addClsWithUI(me.dock);
+
+ Ext.applyIf(me.renderSelectors, {
+ body: '.' + me.baseCls + '-body'
+ });
+
+
+ if (!Ext.isEmpty(me.iconCls)) {
+ me.initIconCmp();
+ me.items.push(me.iconCmp);
+ }
+
+
+ if (me.orientation == 'vertical') {
+
+ if (Ext.isIE6 || Ext.isIE7) {
+ me.width = this.width || 24;
+ } else if (Ext.isIEQuirks) {
+ me.width = this.width || 25;
+ }
+
+ me.layout = {
+ type : 'vbox',
+ align: 'center',
+ clearInnerCtOnLayout: true,
+ bindToOwnerCtContainer: false
+ };
+ me.textConfig = {
+ cls: me.baseCls + '-text',
+ type: 'text',
+ text: me.title,
+ rotate: {
+ degrees: 90
+ }
+ };
+ ui = me.ui;
+ if (Ext.isArray(ui)) {
+ ui = ui[0];
+ }
+ rule = Ext.util.CSS.getRule('.' + me.baseCls + '-text-' + ui);
+ if (rule) {
+ style = rule.style;
+ }
+ if (style) {
+ Ext.apply(me.textConfig, {
+ 'font-family': style.fontFamily,
+ 'font-weight': style.fontWeight,
+ 'font-size': style.fontSize,
+ fill: style.color
+ });
+ }
+ me.titleCmp = Ext.create('Ext.draw.Component', {
+ ariaRole : 'heading',
+ focusable: false,
+ viewBox: false,
+ autoSize: true,
+ margins: '5 0 0 0',
+ items: [ me.textConfig ],
+ renderSelectors: {
+ textEl: '.' + me.baseCls + '-text'
+ }
+ });
+ } else {
+ me.layout = {
+ type : 'hbox',
+ align: 'middle',
+ clearInnerCtOnLayout: true,
+ bindToOwnerCtContainer: false
+ };
+ me.titleCmp = Ext.create('Ext.Component', {
+ xtype : 'component',
+ ariaRole : 'heading',
+ focusable: false,
+ renderTpl : ['{title}'],
+ renderData: {
+ title: me.title,
+ cls : me.baseCls,
+ ui : me.ui
+ },
+ renderSelectors: {
+ textEl: '.' + me.baseCls + '-text'
+ }
+ });
+ }
+ me.items.push(me.titleCmp);
+
+
+ me.items.push({
+ xtype: 'component',
+ html : ' ',
+ flex : 1,
+ focusable: false
+ });
+
+
+ me.items = me.items.concat(me.tools);
+ this.callParent();
+ },
+
+ initIconCmp: function() {
+ this.iconCmp = Ext.create('Ext.Component', {
+ focusable: false,
+ renderTpl : [''+o.indicatorText+"
";
+ theme: 'Base',
+ themeAttrs: false,
+
+ initTheme: function(theme) {
+ var me = this,
+ themes = Ext.chart.theme,
+ key, gradients;
+ if (theme) {
+ theme = theme.split(':');
+ for (key in themes) {
+ if (key == theme[0]) {
+ gradients = theme[1] == 'gradients';
+ me.themeAttrs = new themes[key]({
+ useGradients: gradients
+ });
+ if (gradients) {
+ me.gradients = me.themeAttrs.gradients;
}
- if(me.indicatorText) {
- Ext.getDom(o.el).innerHTML = me.indicatorText;
+ if (me.themeAttrs.background) {
+ me.background = me.themeAttrs.background;
}
- o.success = (Ext.isFunction(o.success) ? o.success : function(){}).createInterceptor(function(response) {
- Ext.getDom(o.el).innerHTML = response.responseText;
- });
+ return;
}
+ }
+ Ext.Error.raise('No theme found named "' + theme + '"');
+ }
+ }
+},
- var p = o.params,
- url = o.url || me.url,
- method,
- cb = {success: me.handleResponse,
- failure: me.handleFailure,
- scope: me,
- argument: {options: o},
- timeout : Ext.num(o.timeout, me.timeout)
- },
- form,
- serForm;
-
+function() {
+
- if (Ext.isFunction(p)) {
- p = p.call(o.scope||WINDOW, o);
+(function() {
+ Ext.chart.theme = function(config, base) {
+ config = config || {};
+ var i = 0, l, colors, color,
+ seriesThemes, markerThemes,
+ seriesTheme, markerTheme,
+ key, gradients = [],
+ midColor, midL;
+
+ if (config.baseColor) {
+ midColor = Ext.draw.Color.fromString(config.baseColor);
+ midL = midColor.getHSL()[2];
+ if (midL < 0.15) {
+ midColor = midColor.getLighter(0.3);
+ } else if (midL < 0.3) {
+ midColor = midColor.getLighter(0.15);
+ } else if (midL > 0.85) {
+ midColor = midColor.getDarker(0.3);
+ } else if (midL > 0.7) {
+ midColor = midColor.getDarker(0.15);
+ }
+ config.colors = [ midColor.getDarker(0.3).toString(),
+ midColor.getDarker(0.15).toString(),
+ midColor.toString(),
+ midColor.getLighter(0.15).toString(),
+ midColor.getLighter(0.3).toString()];
+
+ delete config.baseColor;
+ }
+ if (config.colors) {
+ colors = config.colors.slice();
+ markerThemes = base.markerThemes;
+ seriesThemes = base.seriesThemes;
+ l = colors.length;
+ base.colors = colors;
+ for (; i < l; i++) {
+ color = colors[i];
+ markerTheme = markerThemes[i] || {};
+ seriesTheme = seriesThemes[i] || {};
+ markerTheme.fill = seriesTheme.fill = markerTheme.stroke = seriesTheme.stroke = color;
+ markerThemes[i] = markerTheme;
+ seriesThemes[i] = seriesTheme;
+ }
+ base.markerThemes = markerThemes.slice(0, l);
+ base.seriesThemes = seriesThemes.slice(0, l);
+
+ }
+ for (key in base) {
+ if (key in config) {
+ if (Ext.isObject(config[key]) && Ext.isObject(base[key])) {
+ Ext.apply(base[key], config[key]);
+ } else {
+ base[key] = config[key];
}
-
- p = Ext.urlEncode(me.extraParams, Ext.isObject(p) ? Ext.urlEncode(p) : p);
-
- if (Ext.isFunction(url)) {
- url = url.call(o.scope || WINDOW, o);
+ }
+ }
+ if (config.useGradients) {
+ colors = base.colors || (function () {
+ var ans = [];
+ for (i = 0, seriesThemes = base.seriesThemes, l = seriesThemes.length; i < l; i++) {
+ ans.push(seriesThemes[i].fill || seriesThemes[i].stroke);
}
-
- if((form = Ext.getDom(o.form))){
- url = url || form.action;
- if(o.isUpload || (/multipart\/form-data/i.test(form.getAttribute("enctype")))) {
- return me.doFormUpload.call(me, o, p, url);
- }
- serForm = Ext.lib.Ajax.serializeForm(form);
- p = p ? (p + '&' + serForm) : serForm;
+ return ans;
+ })();
+ for (i = 0, l = colors.length; i < l; i++) {
+ midColor = Ext.draw.Color.fromString(colors[i]);
+ if (midColor) {
+ color = midColor.getDarker(0.1).toString();
+ midColor = midColor.toString();
+ key = 'theme-' + midColor.substr(1) + '-' + color.substr(1);
+ gradients.push({
+ id: key,
+ angle: 45,
+ stops: {
+ 0: {
+ color: midColor.toString()
+ },
+ 100: {
+ color: color.toString()
+ }
+ }
+ });
+ colors[i] = 'url(#' + key + ')';
}
+ }
+ base.gradients = gradients;
+ base.colors = colors;
+ }
+
+ Ext.apply(this, base);
+ };
+})();
+});
- method = o.method || me.method || ((p || o.xmlData || o.jsonData) ? POST : GET);
- if(method === GET && (me.disableCaching && o.disableCaching !== false) || o.disableCaching === true){
- var dcp = o.disableCachingParam || me.disableCachingParam;
- url = Ext.urlAppend(url, dcp + '=' + (new Date().getTime()));
- }
+Ext.define('Ext.chart.Mask', {
+ constructor: function(config) {
+ var me = this;
- o.headers = Ext.apply(o.headers || {}, me.defaultHeaders || {});
+ me.addEvents('select');
- if(o.autoAbort === true || me.autoAbort) {
- me.abort();
- }
+ if (config) {
+ Ext.apply(me, config);
+ }
+ if (me.mask) {
+ me.on('afterrender', function() {
+
+ var comp = Ext.create('Ext.chart.MaskLayer', {
+ renderTo: me.el
+ });
+ comp.el.on({
+ 'mousemove': function(e) {
+ me.onMouseMove(e);
+ },
+ 'mouseup': function(e) {
+ me.resized(e);
+ }
+ });
+
+ var resizeHandler = Ext.create('Ext.resizer.Resizer', {
+ el: comp.el,
+ handles: 'all',
+ pinned: true
+ });
+ resizeHandler.on({
+ 'resize': function(e) {
+ me.resized(e);
+ }
+ });
+ comp.initDraggable();
+ me.maskType = me.mask;
+ me.mask = comp;
+ me.maskSprite = me.surface.add({
+ type: 'path',
+ path: ['M', 0, 0],
+ zIndex: 1001,
+ opacity: 0.7,
+ hidden: true,
+ stroke: '#444'
+ });
+ }, me, { single: true });
+ }
+ },
+
+ resized: function(e) {
+ var me = this,
+ bbox = me.bbox || me.chartBBox,
+ x = bbox.x,
+ y = bbox.y,
+ width = bbox.width,
+ height = bbox.height,
+ box = me.mask.getBox(true),
+ max = Math.max,
+ min = Math.min,
+ staticX = box.x - x,
+ staticY = box.y - y;
+
+ staticX = max(staticX, x);
+ staticY = max(staticY, y);
+ staticX = min(staticX, width);
+ staticY = min(staticY, height);
+ box.x = staticX;
+ box.y = staticY;
+ me.fireEvent('select', me, box);
+ },
- if((method == GET || o.xmlData || o.jsonData) && p){
- url = Ext.urlAppend(url, p);
- p = '';
- }
- return (me.transId = Ext.lib.Ajax.request(method, url, cb, p, o));
- }else{
- return o.callback ? o.callback.apply(o.scope, [o,UNDEFINED,UNDEFINED]) : null;
- }
- },
+ onMouseUp: function(e) {
+ var me = this,
+ bbox = me.bbox || me.chartBBox,
+ sel = me.maskSelection;
+ me.maskMouseDown = false;
+ me.mouseDown = false;
+ if (me.mouseMoved) {
+ me.onMouseMove(e);
+ me.mouseMoved = false;
+ me.fireEvent('select', me, {
+ x: sel.x - bbox.x,
+ y: sel.y - bbox.y,
+ width: sel.width,
+ height: sel.height
+ });
+ }
+ },
-
- isLoading : function(transId){
- return transId ? Ext.lib.Ajax.isCallInProgress(transId) : !! this.transId;
- },
+ onMouseDown: function(e) {
+ var me = this;
+ me.mouseDown = true;
+ me.mouseMoved = false;
+ me.maskMouseDown = {
+ x: e.getPageX() - me.el.getX(),
+ y: e.getPageY() - me.el.getY()
+ };
+ },
-
- abort : function(transId){
- if(transId || this.isLoading()){
- Ext.lib.Ajax.abort(transId || this.transId);
+ onMouseMove: function(e) {
+ var me = this,
+ mask = me.maskType,
+ bbox = me.bbox || me.chartBBox,
+ x = bbox.x,
+ y = bbox.y,
+ math = Math,
+ floor = math.floor,
+ abs = math.abs,
+ min = math.min,
+ max = math.max,
+ height = floor(y + bbox.height),
+ width = floor(x + bbox.width),
+ posX = e.getPageX(),
+ posY = e.getPageY(),
+ staticX = posX - me.el.getX(),
+ staticY = posY - me.el.getY(),
+ maskMouseDown = me.maskMouseDown,
+ path;
+
+ me.mouseMoved = me.mouseDown;
+ staticX = max(staticX, x);
+ staticY = max(staticY, y);
+ staticX = min(staticX, width);
+ staticY = min(staticY, height);
+ if (maskMouseDown && me.mouseDown) {
+ if (mask == 'horizontal') {
+ staticY = y;
+ maskMouseDown.y = height;
+ posY = me.el.getY() + bbox.height + me.insetPadding;
+ }
+ else if (mask == 'vertical') {
+ staticX = x;
+ maskMouseDown.x = width;
+ }
+ width = maskMouseDown.x - staticX;
+ height = maskMouseDown.y - staticY;
+ path = ['M', staticX, staticY, 'l', width, 0, 0, height, -width, 0, 'z'];
+ me.maskSelection = {
+ x: width > 0 ? staticX : staticX + width,
+ y: height > 0 ? staticY : staticY + height,
+ width: abs(width),
+ height: abs(height)
+ };
+ me.mask.updateBox({
+ x: posX - abs(width),
+ y: posY - abs(height),
+ width: abs(width),
+ height: abs(height)
+ });
+ me.mask.show();
+ me.maskSprite.setAttributes({
+ hidden: true
+ }, true);
+ }
+ else {
+ if (mask == 'horizontal') {
+ path = ['M', staticX, y, 'L', staticX, height];
}
- },
-
-
- handleResponse : function(response){
- this.transId = false;
- var options = response.argument.options;
- response.argument = options ? options.argument : null;
- this.fireEvent(REQUESTCOMPLETE, this, response, options);
- if(options.success){
- options.success.call(options.scope, response, options);
+ else if (mask == 'vertical') {
+ path = ['M', x, staticY, 'L', width, staticY];
}
- if(options.callback){
- options.callback.call(options.scope, options, true, response);
+ else {
+ path = ['M', staticX, y, 'L', staticX, height, 'M', x, staticY, 'L', width, staticY];
}
- },
+ me.maskSprite.setAttributes({
+ path: path,
+ fill: me.maskMouseDown ? me.maskSprite.stroke : false,
+ 'stroke-width': mask === true ? 1 : 3,
+ hidden: false
+ }, true);
+ }
+ },
-
- handleFailure : function(response, e){
- this.transId = false;
- var options = response.argument.options;
- response.argument = options ? options.argument : null;
- this.fireEvent(REQUESTEXCEPTION, this, response, options, e);
- if(options.failure){
- options.failure.call(options.scope, response, options);
- }
- if(options.callback){
- options.callback.call(options.scope, options, false, response);
- }
- },
+ onMouseLeave: function(e) {
+ var me = this;
+ me.mouseMoved = false;
+ me.mouseDown = false;
+ me.maskMouseDown = false;
+ me.mask.hide();
+ me.maskSprite.hide(true);
+ }
+});
+
-
- doFormUpload : function(o, ps, url){
- var id = Ext.id(),
- doc = document,
- frame = doc.createElement('iframe'),
- form = Ext.getDom(o.form),
- hiddens = [],
- hd,
- encoding = 'multipart/form-data',
- buf = {
- target: form.target,
- method: form.method,
- encoding: form.encoding,
- enctype: form.enctype,
- action: form.action
- };
+Ext.define('Ext.chart.Navigation', {
+ constructor: function() {
+ this.originalStore = this.store;
+ },
+
+
+ setZoom: function(zoomConfig) {
+ var me = this,
+ store = me.substore || me.store,
+ bbox = me.chartBBox,
+ len = store.getCount(),
+ from = (zoomConfig.x / bbox.width * len) >> 0,
+ to = Math.ceil(((zoomConfig.x + zoomConfig.width) / bbox.width * len)),
+ recFieldsLen, recFields = [], curField, json = [], obj;
+
+ store.each(function(rec, i) {
+ if (i < from || i > to) {
+ return;
+ }
+ obj = {};
- Ext.fly(frame).set({
- id: id,
- name: id,
- cls: 'x-hidden',
- src: Ext.SSL_SECURE_URL
- });
-
- doc.body.appendChild(frame);
-
+ if (!recFields.length) {
+ rec.fields.each(function(f) {
+ recFields.push(f.name);
+ });
+ recFieldsLen = recFields.length;
+ }
- if(Ext.isIE){
- document.frames[id].name = id;
+ for (i = 0; i < recFieldsLen; i++) {
+ curField = recFields[i];
+ obj[curField] = rec.get(curField);
}
+ json.push(obj);
+ });
+ me.store = me.substore = Ext.create('Ext.data.JsonStore', {
+ fields: recFields,
+ data: json
+ });
+ me.redraw(true);
+ },
+ restoreZoom: function() {
+ this.store = this.substore = this.originalStore;
+ this.redraw(true);
+ }
+
+});
- Ext.fly(form).set({
- target: id,
- method: POST,
- enctype: encoding,
- encoding: encoding,
- action: url || buf.action
- });
+Ext.define('Ext.chart.Shape', {
+
+
+
+ singleton: true,
+
+
+
+ circle: function (surface, opts) {
+ return surface.add(Ext.apply({
+ type: 'circle',
+ x: opts.x,
+ y: opts.y,
+ stroke: null,
+ radius: opts.radius
+ }, opts));
+ },
+ line: function (surface, opts) {
+ return surface.add(Ext.apply({
+ type: 'rect',
+ x: opts.x - opts.radius,
+ y: opts.y - opts.radius,
+ height: 2 * opts.radius,
+ width: 2 * opts.radius / 5
+ }, opts));
+ },
+ square: function (surface, opts) {
+ return surface.add(Ext.applyIf({
+ type: 'rect',
+ x: opts.x - opts.radius,
+ y: opts.y - opts.radius,
+ height: 2 * opts.radius,
+ width: 2 * opts.radius,
+ radius: null
+ }, opts));
+ },
+ triangle: function (surface, opts) {
+ opts.radius *= 1.75;
+ return surface.add(Ext.apply({
+ type: 'path',
+ stroke: null,
+ path: "M".concat(opts.x, ",", opts.y, "m0-", opts.radius * 0.58, "l", opts.radius * 0.5, ",", opts.radius * 0.87, "-", opts.radius, ",0z")
+ }, opts));
+ },
+ diamond: function (surface, opts) {
+ var r = opts.radius;
+ r *= 1.5;
+ return surface.add(Ext.apply({
+ type: 'path',
+ stroke: null,
+ path: ["M", opts.x, opts.y - r, "l", r, r, -r, r, -r, -r, r, -r, "z"]
+ }, opts));
+ },
+ cross: function (surface, opts) {
+ var r = opts.radius;
+ r = r / 1.7;
+ return surface.add(Ext.apply({
+ type: 'path',
+ stroke: null,
+ path: "M".concat(opts.x - r, ",", opts.y, "l", [-r, -r, r, -r, r, r, r, -r, r, r, -r, r, r, r, -r, r, -r, -r, -r, r, -r, -r, "z"])
+ }, opts));
+ },
+ plus: function (surface, opts) {
+ var r = opts.radius / 1.3;
+ return surface.add(Ext.apply({
+ type: 'path',
+ stroke: null,
+ path: "M".concat(opts.x - r / 2, ",", opts.y - r / 2, "l", [0, -r, r, 0, 0, r, r, 0, 0, r, -r, 0, 0, r, -r, 0, 0, -r, -r, 0, 0, -r, "z"])
+ }, opts));
+ },
+ arrow: function (surface, opts) {
+ var r = opts.radius;
+ return surface.add(Ext.apply({
+ type: 'path',
+ path: "M".concat(opts.x - r * 0.7, ",", opts.y - r * 0.4, "l", [r * 0.6, 0, 0, -r * 0.4, r, r * 0.8, -r, r * 0.8, 0, -r * 0.4, -r * 0.6, 0], "z")
+ }, opts));
+ },
+ drop: function (surface, x, y, text, size, angle) {
+ size = size || 30;
+ angle = angle || 0;
+ surface.add({
+ type: 'path',
+ path: ['M', x, y, 'l', size, 0, 'A', size * 0.4, size * 0.4, 0, 1, 0, x + size * 0.7, y - size * 0.7, 'z'],
+ fill: '#000',
+ stroke: 'none',
+ rotate: {
+ degrees: 22.5 - angle,
+ x: x,
+ y: y
+ }
+ });
+ angle = (angle + 90) * Math.PI / 180;
+ surface.add({
+ type: 'text',
+ x: x + size * Math.sin(angle) - 10,
+ y: y + size * Math.cos(angle) + 5,
+ text: text,
+ 'font-size': size * 12 / 40,
+ stroke: 'none',
+ fill: '#fff'
+ });
+ }
+});
-
- Ext.iterate(Ext.urlDecode(ps, false), function(k, v){
- hd = doc.createElement('input');
- Ext.fly(hd).set({
- type: 'hidden',
- value: v,
- name: k
- });
- form.appendChild(hd);
- hiddens.push(hd);
- });
+Ext.define('Ext.draw.Surface', {
- function cb(){
- var me = this,
-
- r = {responseText : '',
- responseXML : null,
- argument : o.argument},
- doc,
- firstChild;
+
- try{
- doc = frame.contentWindow.document || frame.contentDocument || WINDOW.frames[id].document;
- if(doc){
- if(doc.body){
- if(/textarea/i.test((firstChild = doc.body.firstChild || {}).tagName)){
- r.responseText = firstChild.value;
- }else{
- r.responseText = doc.body.innerHTML;
- }
- }
-
- r.responseXML = doc.XMLDocument || doc;
- }
- }
- catch(e) {}
+ mixins: {
+ observable: 'Ext.util.Observable'
+ },
- Ext.EventManager.removeListener(frame, LOAD, cb, me);
+ requires: ['Ext.draw.CompositeSprite'],
+ uses: ['Ext.draw.engine.Svg', 'Ext.draw.engine.Vml'],
- me.fireEvent(REQUESTCOMPLETE, me, r, o);
+ separatorRe: /[, ]+/,
- function runCallback(fn, scope, args){
- if(Ext.isFunction(fn)){
- fn.apply(scope, args);
- }
- }
+ statics: {
+
+ create: function(config, enginePriority) {
+ enginePriority = enginePriority || ['Svg', 'Vml'];
- runCallback(o.success, o.scope, [r, o]);
- runCallback(o.callback, o.scope, [o, true, r]);
+ var i = 0,
+ len = enginePriority.length,
+ surfaceClass;
- if(!me.debugUploads){
- setTimeout(function(){Ext.removeNode(frame);}, 100);
+ for (; i < len; i++) {
+ if (Ext.supports[enginePriority[i]]) {
+ return Ext.create('Ext.draw.engine.' + enginePriority[i], config);
}
}
-
- Ext.EventManager.on(frame, LOAD, cb, this);
- form.submit();
-
- Ext.fly(form).set(buf);
- Ext.each(hiddens, function(h) {
- Ext.removeNode(h);
- });
+ return false;
}
- });
-})();
-
+ },
-Ext.Ajax = new Ext.data.Connection({
-
-
-
-
-
+ availableAttrs: {
+ blur: 0,
+ "clip-rect": "0 0 1e9 1e9",
+ cursor: "default",
+ cx: 0,
+ cy: 0,
+ 'dominant-baseline': 'auto',
+ fill: "none",
+ "fill-opacity": 1,
+ font: '10px "Arial"',
+ "font-family": '"Arial"',
+ "font-size": "10",
+ "font-style": "normal",
+ "font-weight": 400,
+ gradient: "",
+ height: 0,
+ hidden: false,
+ href: "http://sencha.com/",
+ opacity: 1,
+ path: "M0,0",
+ radius: 0,
+ rx: 0,
+ ry: 0,
+ scale: "1 1",
+ src: "",
+ stroke: "#000",
+ "stroke-dasharray": "",
+ "stroke-linecap": "butt",
+ "stroke-linejoin": "butt",
+ "stroke-miterlimit": 0,
+ "stroke-opacity": 1,
+ "stroke-width": 1,
+ target: "_blank",
+ text: "",
+ "text-anchor": "middle",
+ title: "Ext Draw",
+ width: 0,
+ x: 0,
+ y: 0,
+ zIndex: 0
+ },
+
+
+
+ container: undefined,
+ height: 352,
+ width: 512,
+ x: 0,
+ y: 0,
+
+ constructor: function(config) {
+ var me = this;
+ config = config || {};
+ Ext.apply(me, config);
+
+ me.domRef = Ext.getDoc().dom;
+
+ me.customAttributes = {};
+
+ me.addEvents(
+ 'mousedown',
+ 'mouseup',
+ 'mouseover',
+ 'mouseout',
+ 'mousemove',
+ 'mouseenter',
+ 'mouseleave',
+ 'click'
+ );
+
+ me.mixins.observable.constructor.call(me);
+
+ me.getId();
+ me.initGradients();
+ me.initItems();
+ if (me.renderTo) {
+ me.render(me.renderTo);
+ delete me.renderTo;
+ }
+ me.initBackground(config.background);
+ },
+ initSurface: Ext.emptyFn,
+
-
-
+ renderItem: Ext.emptyFn,
- autoAbort : false,
+ renderItems: Ext.emptyFn,
- serializeForm : function(form){
- return Ext.lib.Ajax.serializeForm(form);
- }
-});
+ setViewBox: Ext.emptyFn,
-Ext.util.JSON = new (function(){
- var useHasOwn = !!{}.hasOwnProperty,
- isNative = function() {
- var useNative = null;
-
- return function() {
- if (useNative === null) {
- useNative = Ext.USE_NATIVE_JSON && window.JSON && JSON.toString() == '[object JSON]';
- }
-
- return useNative;
- };
- }(),
- pad = function(n) {
- return n < 10 ? "0" + n : n;
- },
- doDecode = function(json){
- return eval("(" + json + ")");
- },
- doEncode = function(o){
- if(!Ext.isDefined(o) || o === null){
- return "null";
- }else if(Ext.isArray(o)){
- return encodeArray(o);
- }else if(Ext.isDate(o)){
- return Ext.util.JSON.encodeDate(o);
- }else if(Ext.isString(o)){
- return encodeString(o);
- }else if(typeof o == "number"){
-
- return isFinite(o) ? String(o) : "null";
- }else if(Ext.isBoolean(o)){
- return String(o);
- }else {
- var a = ["{"], b, i, v;
- for (i in o) {
-
- if(!o.getElementsByTagName){
- if(!useHasOwn || o.hasOwnProperty(i)) {
- v = o[i];
- switch (typeof v) {
- case "undefined":
- case "function":
- case "unknown":
- break;
- default:
- if(b){
- a.push(',');
- }
- a.push(doEncode(i), ":",
- v === null ? "null" : doEncode(v));
- b = true;
- }
- }
- }
- }
- a.push("}");
- return a.join("");
- }
- },
- m = {
- "\b": '\\b',
- "\t": '\\t',
- "\n": '\\n',
- "\f": '\\f',
- "\r": '\\r',
- '"' : '\\"',
- "\\": '\\\\'
- },
- encodeString = function(s){
- if (/["\\\x00-\x1f]/.test(s)) {
- return '"' + s.replace(/([\x00-\x1f\\"])/g, function(a, b) {
- var c = m[b];
- if(c){
- return c;
- }
- c = b.charCodeAt();
- return "\\u00" +
- Math.floor(c / 16).toString(16) +
- (c % 16).toString(16);
- }) + '"';
- }
- return '"' + s + '"';
- },
- encodeArray = function(o){
- var a = ["["], b, i, l = o.length, v;
- for (i = 0; i < l; i += 1) {
- v = o[i];
- switch (typeof v) {
- case "undefined":
- case "function":
- case "unknown":
- break;
- default:
- if (b) {
- a.push(',');
- }
- a.push(v === null ? "null" : Ext.util.JSON.encode(v));
- b = true;
- }
- }
- a.push("]");
- return a.join("");
- };
+
+ addCls: Ext.emptyFn,
- this.encodeDate = function(o){
- return '"' + o.getFullYear() + "-" +
- pad(o.getMonth() + 1) + "-" +
- pad(o.getDate()) + "T" +
- pad(o.getHours()) + ":" +
- pad(o.getMinutes()) + ":" +
- pad(o.getSeconds()) + '"';
- };
+ removeCls: Ext.emptyFn,
- this.encode = function() {
- var ec;
- return function(o) {
- if (!ec) {
-
- ec = isNative() ? JSON.stringify : doEncode;
- }
- return ec(o);
- };
- }();
+ setStyle: Ext.emptyFn,
+
+ initGradients: function() {
+ var gradients = this.gradients;
+ if (gradients) {
+ Ext.each(gradients, this.addGradient, this);
+ }
+ },
- this.decode = function() {
- var dc;
- return function(json) {
- if (!dc) {
-
- dc = isNative() ? JSON.parse : doDecode;
+ initItems: function() {
+ var items = this.items;
+ this.items = Ext.create('Ext.draw.CompositeSprite');
+ this.groups = Ext.create('Ext.draw.CompositeSprite');
+ if (items) {
+ this.add(items);
+ }
+ },
+
+
+ initBackground: function(config) {
+ var gradientId,
+ gradient,
+ backgroundSprite,
+ width = this.width,
+ height = this.height;
+ if (config) {
+ if (config.gradient) {
+ gradient = config.gradient;
+ gradientId = gradient.id;
+ this.addGradient(gradient);
+ this.background = this.add({
+ type: 'rect',
+ x: 0,
+ y: 0,
+ width: width,
+ height: height,
+ fill: 'url(#' + gradientId + ')'
+ });
+ } else if (config.fill) {
+ this.background = this.add({
+ type: 'rect',
+ x: 0,
+ y: 0,
+ width: width,
+ height: height,
+ fill: config.fill
+ });
+ } else if (config.image) {
+ this.background = this.add({
+ type: 'image',
+ x: 0,
+ y: 0,
+ width: width,
+ height: height,
+ src: config.image
+ });
}
- return dc(json);
- };
- }();
-
-})();
-
-Ext.encode = Ext.util.JSON.encode;
-
-Ext.decode = Ext.util.JSON.decode;
-
-Ext.EventManager = function(){
- var docReadyEvent,
- docReadyProcId,
- docReadyState = false,
- DETECT_NATIVE = Ext.isGecko || Ext.isWebKit || Ext.isSafari,
- E = Ext.lib.Event,
- D = Ext.lib.Dom,
- DOC = document,
- WINDOW = window,
- DOMCONTENTLOADED = "DOMContentLoaded",
- COMPLETE = 'complete',
- propRe = /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/,
-
- specialElCache = [];
+ }
+ },
+
+
+ setSize: function(w, h) {
+ if (this.background) {
+ this.background.setAttributes({
+ width: w,
+ height: h,
+ hidden: false
+ }, true);
+ }
+ },
- function getId(el){
- var id = false,
- i = 0,
- len = specialElCache.length,
- skip = false,
- o;
+
+ scrubAttrs: function(sprite) {
+ var i,
+ attrs = {},
+ exclude = {},
+ sattr = sprite.attr;
+ for (i in sattr) {
- if (el) {
- if (el.getElementById || el.navigator) {
+ if (this.translateAttrs.hasOwnProperty(i)) {
- for(; i < len; ++i){
- o = specialElCache[i];
- if(o.el === el){
- id = o.id;
- break;
- }
- }
- if(!id){
-
- id = Ext.id(el);
- specialElCache.push({
- id: id,
- el: el
- });
- skip = true;
- }
- }else{
- id = Ext.id(el);
+ attrs[this.translateAttrs[i]] = sattr[i];
+ exclude[this.translateAttrs[i]] = true;
}
- if(!Ext.elCache[id]){
- Ext.Element.addToCache(new Ext.Element(el), id);
- if(skip){
- Ext.elCache[id].skipGC = true;
- }
+ else if (this.availableAttrs.hasOwnProperty(i) && !exclude[i]) {
+
+ attrs[i] = sattr[i];
}
}
- return id;
- }
+ return attrs;
+ },
- function addListener(el, ename, fn, task, wrap, scope){
- el = Ext.getDom(el);
- var id = getId(el),
- es = Ext.elCache[id].events,
- wfn;
+ onClick: function(e) {
+ this.processEvent('click', e);
+ },
- wfn = E.on(el, ename, wrap);
- es[ename] = es[ename] || [];
+
+ onMouseUp: function(e) {
+ this.processEvent('mouseup', e);
+ },
-
- es[ename].push([fn, wrap, scope, wfn, task]);
+
+ onMouseDown: function(e) {
+ this.processEvent('mousedown', e);
+ },
-
-
+
+ onMouseOver: function(e) {
+ this.processEvent('mouseover', e);
+ },
-
- if(el.addEventListener && ename == "mousewheel"){
- var args = ["DOMMouseScroll", wrap, false];
- el.addEventListener.apply(el, args);
- Ext.EventManager.addListener(WINDOW, 'unload', function(){
- el.removeEventListener.apply(el, args);
- });
- }
+
+ onMouseOut: function(e) {
+ this.processEvent('mouseout', e);
+ },
-
- if(el == DOC && ename == "mousedown"){
- Ext.EventManager.stoppedMouseDownEvent.addListener(wrap);
- }
- }
+
+ onMouseMove: function(e) {
+ this.fireEvent('mousemove', e);
+ },
- function doScrollChk(){
-
- if(window != top){
- return false;
- }
+
+ onMouseEnter: Ext.emptyFn,
- try{
- DOC.documentElement.doScroll('left');
- }catch(e){
- return false;
- }
+
+ onMouseLeave: Ext.emptyFn,
- fireDocReady();
- return true;
- }
- function checkReadyState(e){
+ addGradient: Ext.emptyFn,
- if(Ext.isIE && doScrollChk()){
- return true;
- }
- if(DOC.readyState == COMPLETE){
- fireDocReady();
- return true;
- }
- docReadyState || (docReadyProcId = setTimeout(arguments.callee, 2));
- return false;
- }
+
+ add: function() {
+ var args = Array.prototype.slice.call(arguments),
+ sprite,
+ index;
- var styles;
- function checkStyleSheets(e){
- styles || (styles = Ext.query('style, link[rel=stylesheet]'));
- if(styles.length == DOC.styleSheets.length){
- fireDocReady();
- return true;
- }
- docReadyState || (docReadyProcId = setTimeout(arguments.callee, 2));
- return false;
- }
+ var hasMultipleArgs = args.length > 1;
+ if (hasMultipleArgs || Ext.isArray(args[0])) {
+ var items = hasMultipleArgs ? args : args[0],
+ results = [],
+ i, ln, item;
- function OperaDOMContentLoaded(e){
- DOC.removeEventListener(DOMCONTENTLOADED, arguments.callee, false);
- checkStyleSheets();
- }
+ for (i = 0, ln = items.length; i < ln; i++) {
+ item = items[i];
+ item = this.add(item);
+ results.push(item);
+ }
- function fireDocReady(e){
- if(!docReadyState){
- docReadyState = true;
+ return results;
+ }
+ sprite = this.prepareItems(args[0], true)[0];
+ this.normalizeSpriteCollection(sprite);
+ this.onAdd(sprite);
+ return sprite;
+ },
- if(docReadyProcId){
- clearTimeout(docReadyProcId);
- }
- if(DETECT_NATIVE) {
- DOC.removeEventListener(DOMCONTENTLOADED, fireDocReady, false);
- }
- if(Ext.isIE && checkReadyState.bindIE){
- DOC.detachEvent('onreadystatechange', checkReadyState);
+
+ normalizeSpriteCollection: function(sprite) {
+ var items = this.items,
+ zIndex = sprite.attr.zIndex,
+ idx = items.indexOf(sprite);
+
+ if (idx < 0 || (idx > 0 && items.getAt(idx - 1).attr.zIndex > zIndex) ||
+ (idx < items.length - 1 && items.getAt(idx + 1).attr.zIndex < zIndex)) {
+ items.removeAt(idx);
+ idx = items.findIndexBy(function(otherSprite) {
+ return otherSprite.attr.zIndex > zIndex;
+ });
+ if (idx < 0) {
+ idx = items.length;
}
- E.un(WINDOW, "load", arguments.callee);
+ items.insert(idx, sprite);
}
- if(docReadyEvent && !Ext.isReady){
- Ext.isReady = true;
- docReadyEvent.fire();
- docReadyEvent.listeners = [];
- }
-
- }
+ return idx;
+ },
- function initDocReady(){
- docReadyEvent || (docReadyEvent = new Ext.util.Event());
- if (DETECT_NATIVE) {
- DOC.addEventListener(DOMCONTENTLOADED, fireDocReady, false);
- }
-
- if (Ext.isIE){
-
-
- if(!checkReadyState()){
- checkReadyState.bindIE = true;
- DOC.attachEvent('onreadystatechange', checkReadyState);
+ onAdd: function(sprite) {
+ var group = sprite.group,
+ draggable = sprite.draggable,
+ groups, ln, i;
+ if (group) {
+ groups = [].concat(group);
+ ln = groups.length;
+ for (i = 0; i < ln; i++) {
+ group = groups[i];
+ this.getGroup(group).add(sprite);
}
-
- }else if(Ext.isOpera ){
-
-
-
- (DOC.readyState == COMPLETE && checkStyleSheets()) ||
- DOC.addEventListener(DOMCONTENTLOADED, OperaDOMContentLoaded, false);
-
- }else if (Ext.isWebKit){
-
- checkReadyState();
+ delete sprite.group;
}
-
- E.on(WINDOW, "load", fireDocReady);
- }
+ if (draggable) {
+ sprite.initDraggable();
+ }
+ },
- function createTargeted(h, o){
- return function(){
- var args = Ext.toArray(arguments);
- if(o.target == Ext.EventObject.setEvent(args[0]).target){
- h.apply(this, args);
+
+ remove: function(sprite, destroySprite) {
+ if (sprite) {
+ this.items.remove(sprite);
+ this.groups.each(function(item) {
+ item.remove(sprite);
+ });
+ sprite.onRemove();
+ if (destroySprite === true) {
+ sprite.destroy();
}
- };
- }
-
- function createBuffered(h, o, task){
- return function(e){
-
- task.delay(o.buffer, h, null, [new Ext.EventObjectImpl(e)]);
- };
- }
+ }
+ },
- function createSingle(h, el, ename, fn, scope){
- return function(e){
- Ext.EventManager.removeListener(el, ename, fn, scope);
- h(e);
- };
- }
+
+ removeAll: function(destroySprites) {
+ var items = this.items.items,
+ ln = items.length,
+ i;
+ for (i = ln - 1; i > -1; i--) {
+ this.remove(items[i], destroySprites);
+ }
+ },
- function createDelayed(h, o, fn){
- return function(e){
- var task = new Ext.util.DelayedTask(h);
- if(!fn.tasks) {
- fn.tasks = [];
- }
- fn.tasks.push(task);
- task.delay(o.delay || 10, h, null, [new Ext.EventObjectImpl(e)]);
- };
- }
+ onRemove: Ext.emptyFn,
- function listen(element, ename, opt, fn, scope){
- var o = (!opt || typeof opt == "boolean") ? {} : opt,
- el = Ext.getDom(element), task;
+ onDestroy: Ext.emptyFn,
- fn = fn || o.fn;
- scope = scope || o.scope;
+
+ applyTransformations: function(sprite) {
+ sprite.bbox.transform = 0;
+ this.transform(sprite);
- if(!el){
- throw "Error listening for \"" + ename + '\". Element "' + element + '" doesn\'t exist.';
- }
- function h(e){
-
- if(!Ext){
- return;
- }
- e = Ext.EventObject.setEvent(e);
- var t;
- if (o.delegate) {
- if(!(t = e.getTarget(o.delegate, el))){
- return;
- }
- } else {
- t = e.target;
- }
- if (o.stopEvent) {
- e.stopEvent();
- }
- if (o.preventDefault) {
- e.preventDefault();
- }
- if (o.stopPropagation) {
- e.stopPropagation();
- }
- if (o.normalized === false) {
- e = e.browserEvent;
- }
+ var me = this,
+ dirty = false,
+ attr = sprite.attr;
- fn.call(scope || el, e, t, o);
- }
- if(o.target){
- h = createTargeted(h, o);
+ if (attr.translation.x != null || attr.translation.y != null) {
+ me.translate(sprite);
+ dirty = true;
}
- if(o.delay){
- h = createDelayed(h, o, fn);
+ if (attr.scaling.x != null || attr.scaling.y != null) {
+ me.scale(sprite);
+ dirty = true;
}
- if(o.single){
- h = createSingle(h, el, ename, fn, scope);
+ if (attr.rotation.degrees != null) {
+ me.rotate(sprite);
+ dirty = true;
}
- if(o.buffer){
- task = new Ext.util.DelayedTask(h);
- h = createBuffered(h, o, task);
+ if (dirty) {
+ sprite.bbox.transform = 0;
+ this.transform(sprite);
+ sprite.transformations = [];
}
+ },
- addListener(el, ename, fn, task, h, scope);
- return h;
- }
-
- var pub = {
-
- addListener : function(element, eventName, fn, scope, options){
- if(typeof eventName == 'object'){
- var o = eventName, e, val;
- for(e in o){
- val = o[e];
- if(!propRe.test(e)){
- if(Ext.isFunction(val)){
-
- listen(element, e, o, val, o.scope);
- }else{
-
- listen(element, e, val);
- }
- }
- }
- } else {
- listen(element, eventName, options, fn, scope);
- }
- },
+
+ rotate: function (sprite) {
+ var bbox,
+ deg = sprite.attr.rotation.degrees,
+ centerX = sprite.attr.rotation.x,
+ centerY = sprite.attr.rotation.y;
+ if (!Ext.isNumber(centerX) || !Ext.isNumber(centerY)) {
+ bbox = this.getBBox(sprite);
+ centerX = !Ext.isNumber(centerX) ? bbox.x + bbox.width / 2 : centerX;
+ centerY = !Ext.isNumber(centerY) ? bbox.y + bbox.height / 2 : centerY;
+ }
+ sprite.transformations.push({
+ type: "rotate",
+ degrees: deg,
+ x: centerX,
+ y: centerY
+ });
+ },
-
- removeListener : function(el, eventName, fn, scope){
- el = Ext.getDom(el);
- var id = getId(el),
- f = el && (Ext.elCache[id].events)[eventName] || [],
- wrap, i, l, k, len, fnc;
+
+ translate: function(sprite) {
+ var x = sprite.attr.translation.x || 0,
+ y = sprite.attr.translation.y || 0;
+ sprite.transformations.push({
+ type: "translate",
+ x: x,
+ y: y
+ });
+ },
- for (i = 0, len = f.length; i < len; i++) {
+
+ scale: function(sprite) {
+ var bbox,
+ x = sprite.attr.scaling.x || 1,
+ y = sprite.attr.scaling.y || 1,
+ centerX = sprite.attr.scaling.centerX,
+ centerY = sprite.attr.scaling.centerY;
-
- if (Ext.isArray(fnc = f[i]) && fnc[0] == fn && (!scope || fnc[2] == scope)) {
- if(fnc[4]) {
- fnc[4].cancel();
- }
- k = fn.tasks && fn.tasks.length;
- if(k) {
- while(k--) {
- fn.tasks[k].cancel();
- }
- delete fn.tasks;
- }
- wrap = fnc[1];
- E.un(el, eventName, E.extAdapter ? fnc[3] : wrap);
+ if (!Ext.isNumber(centerX) || !Ext.isNumber(centerY)) {
+ bbox = this.getBBox(sprite);
+ centerX = !Ext.isNumber(centerX) ? bbox.x + bbox.width / 2 : centerX;
+ centerY = !Ext.isNumber(centerY) ? bbox.y + bbox.height / 2 : centerY;
+ }
+ sprite.transformations.push({
+ type: "scale",
+ x: x,
+ y: y,
+ centerX: centerX,
+ centerY: centerY
+ });
+ },
-
- if(wrap && el.addEventListener && eventName == "mousewheel"){
- el.removeEventListener("DOMMouseScroll", wrap, false);
- }
+
+ rectPath: function (x, y, w, h, r) {
+ if (r) {
+ return [["M", x + r, y], ["l", w - r * 2, 0], ["a", r, r, 0, 0, 1, r, r], ["l", 0, h - r * 2], ["a", r, r, 0, 0, 1, -r, r], ["l", r * 2 - w, 0], ["a", r, r, 0, 0, 1, -r, -r], ["l", 0, r * 2 - h], ["a", r, r, 0, 0, 1, r, -r], ["z"]];
+ }
+ return [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]];
+ },
-
- if(wrap && el == DOC && eventName == "mousedown"){
- Ext.EventManager.stoppedMouseDownEvent.removeListener(wrap);
- }
+
+ ellipsePath: function (x, y, rx, ry) {
+ if (ry == null) {
+ ry = rx;
+ }
+ return [["M", x, y], ["m", 0, -ry], ["a", rx, ry, 0, 1, 1, 0, 2 * ry], ["a", rx, ry, 0, 1, 1, 0, -2 * ry], ["z"]];
+ },
- f.splice(i, 1);
- if (f.length === 0) {
- delete Ext.elCache[id].events[eventName];
- }
- for (k in Ext.elCache[id].events) {
- return false;
- }
- Ext.elCache[id].events = {};
- return false;
- }
- }
- },
+
+ getPathpath: function (el) {
+ return el.attr.path;
+ },
-
- removeAll : function(el){
- el = Ext.getDom(el);
- var id = getId(el),
- ec = Ext.elCache[id] || {},
- es = ec.events || {},
- f, i, len, ename, fn, k, wrap;
-
- for(ename in es){
- if(es.hasOwnProperty(ename)){
- f = es[ename];
-
- for (i = 0, len = f.length; i < len; i++) {
- fn = f[i];
- if(fn[4]) {
- fn[4].cancel();
- }
- if(fn[0].tasks && (k = fn[0].tasks.length)) {
- while(k--) {
- fn[0].tasks[k].cancel();
- }
- delete fn.tasks;
- }
- wrap = fn[1];
- E.un(el, ename, E.extAdapter ? fn[3] : wrap);
+
+ getPathcircle: function (el) {
+ var a = el.attr;
+ return this.ellipsePath(a.x, a.y, a.radius, a.radius);
+ },
-
- if(el.addEventListener && wrap && ename == "mousewheel"){
- el.removeEventListener("DOMMouseScroll", wrap, false);
- }
+
+ getPathellipse: function (el) {
+ var a = el.attr;
+ return this.ellipsePath(a.x, a.y, a.radiusX, a.radiusY);
+ },
-
- if(wrap && el == DOC && ename == "mousedown"){
- Ext.EventManager.stoppedMouseDownEvent.removeListener(wrap);
- }
- }
- }
- }
- if (Ext.elCache[id]) {
- Ext.elCache[id].events = {};
- }
- },
+
+ getPathrect: function (el) {
+ var a = el.attr;
+ return this.rectPath(a.x, a.y, a.width, a.height, a.r);
+ },
- getListeners : function(el, eventName) {
- el = Ext.getDom(el);
- var id = getId(el),
- ec = Ext.elCache[id] || {},
- es = ec.events || {},
- results = [];
- if (es && es[eventName]) {
- return es[eventName];
- } else {
- return null;
- }
- },
+
+ getPathimage: function (el) {
+ var a = el.attr;
+ return this.rectPath(a.x || 0, a.y || 0, a.width, a.height);
+ },
- purgeElement : function(el, recurse, eventName) {
- el = Ext.getDom(el);
- var id = getId(el),
- ec = Ext.elCache[id] || {},
- es = ec.events || {},
- i, f, len;
- if (eventName) {
- if (es && es.hasOwnProperty(eventName)) {
- f = es[eventName];
- for (i = 0, len = f.length; i < len; i++) {
- Ext.EventManager.removeListener(el, eventName, f[i][0]);
- }
- }
- } else {
- Ext.EventManager.removeAll(el);
- }
- if (recurse && el && el.childNodes) {
- for (i = 0, len = el.childNodes.length; i < len; i++) {
- Ext.EventManager.purgeElement(el.childNodes[i], recurse, eventName);
- }
- }
- },
+
+ getPathtext: function (el) {
+ var bbox = this.getBBoxText(el);
+ return this.rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
+ },
- _unload : function() {
- var el;
- for (el in Ext.elCache) {
- Ext.EventManager.removeAll(el);
- }
- delete Ext.elCache;
- delete Ext.Element._flyweights;
+ createGroup: function(id) {
+ var group = this.groups.get(id);
+ if (!group) {
+ group = Ext.create('Ext.draw.CompositeSprite', {
+ surface: this
+ });
+ group.id = id || Ext.id(null, 'ext-surface-group-');
+ this.groups.add(group);
+ }
+ return group;
+ },
-
- var c,
- conn,
- tid,
- ajax = Ext.lib.Ajax;
- (typeof ajax.conn == 'object') ? conn = ajax.conn : conn = {};
- for (tid in conn) {
- c = conn[tid];
- if (c) {
- ajax.abort({conn: c, tId: tid});
- }
+
+ getGroup: function(id) {
+ if (typeof id == "string") {
+ var group = this.groups.get(id);
+ if (!group) {
+ group = this.createGroup(id);
}
- },
+ } else {
+ group = id;
+ }
+ return group;
+ },
+
+
+ prepareItems: function(items, applyDefaults) {
+ items = [].concat(items);
- onDocumentReady : function(fn, scope, options){
- if (Ext.isReady) {
- docReadyEvent || (docReadyEvent = new Ext.util.Event());
- docReadyEvent.addListener(fn, scope, options);
- docReadyEvent.fire();
- docReadyEvent.listeners = [];
+ var item, i, ln;
+ for (i = 0, ln = items.length; i < ln; i++) {
+ item = items[i];
+ if (!(item instanceof Ext.draw.Sprite)) {
+
+ item.surface = this;
+ items[i] = this.createItem(item);
} else {
- if (!docReadyEvent) {
- initDocReady();
- }
- options = options || {};
- options.delay = options.delay || 1;
- docReadyEvent.addListener(fn, scope, options);
+ item.surface = this;
}
- },
+ }
+ return items;
+ },
+
+
+ setText: Ext.emptyFn,
+
+ //@private Creates an item and appends it to the surface. Called
-
- fireDocReady : fireDocReady
- };
-
- pub.on = pub.addListener;
- pub.un = pub.removeListener;
+ createItem: Ext.emptyFn,
- pub.stoppedMouseDownEvent = new Ext.util.Event();
- return pub;
-}();
+
+ getId: function() {
+ return this.id || (this.id = Ext.id(null, 'ext-surface-'));
+ },
-Ext.onReady = Ext.EventManager.onDocumentReady;
+
+ destroy: function() {
+ delete this.domRef;
+ this.removeAll();
+ }
+});
+Ext.define('Ext.draw.Component', {
+
-(function(){
- var initExtCss = function() {
-
- var bd = document.body || document.getElementsByTagName('body')[0];
- if (!bd) {
- return false;
- }
-
- var cls = [' ',
- Ext.isIE ? "ext-ie " + (Ext.isIE6 ? 'ext-ie6' : (Ext.isIE7 ? 'ext-ie7' : 'ext-ie8'))
- : Ext.isGecko ? "ext-gecko " + (Ext.isGecko2 ? 'ext-gecko2' : 'ext-gecko3')
- : Ext.isOpera ? "ext-opera"
- : Ext.isWebKit ? "ext-webkit" : ""];
+ alias: 'widget.draw',
- if (Ext.isSafari) {
- cls.push("ext-safari " + (Ext.isSafari2 ? 'ext-safari2' : (Ext.isSafari3 ? 'ext-safari3' : 'ext-safari4')));
- } else if(Ext.isChrome) {
- cls.push("ext-chrome");
- }
+ extend: 'Ext.Component',
- if (Ext.isMac) {
- cls.push("ext-mac");
- }
- if (Ext.isLinux) {
- cls.push("ext-linux");
- }
+ requires: [
+ 'Ext.draw.Surface',
+ 'Ext.layout.component.Draw'
+ ],
-
- if (Ext.isStrict || Ext.isBorderBox) {
- var p = bd.parentNode;
- if (p) {
- Ext.fly(p, '_internal').addClass(((Ext.isStrict && Ext.isIE ) || (!Ext.enableForcedBoxModel && !Ext.isIE)) ? ' ext-strict' : ' ext-border-box');
- }
- }
-
-
- if (Ext.enableForcedBoxModel && !Ext.isIE) {
- Ext.isForcedBorderBox = true;
- cls.push("ext-forced-border-box");
- }
-
- Ext.fly(bd, '_internal').addClass(cls);
- return true;
- };
- if (!initExtCss()) {
- Ext.onReady(initExtCss);
- }
-})();
+
+ enginePriority: ['Svg', 'Vml'],
+
+ baseCls: Ext.baseCSSPrefix + 'surface',
+
+ componentLayout: 'draw',
-(function(){
- var supports = Ext.apply(Ext.supports, {
-
- correctRightMargin: true,
-
-
- correctTransparentColor: true,
-
-
- cssFloat: true
- });
- var supportTests = function(){
- var div = document.createElement('div'),
- doc = document,
- view,
- last;
-
- div.innerHTML = '';
- doc.body.appendChild(div);
- last = div.lastChild;
-
- if((view = doc.defaultView)){
- if(view.getComputedStyle(div.firstChild.firstChild, null).marginRight != '0px'){
- supports.correctRightMargin = false;
- }
- if(view.getComputedStyle(last, null).backgroundColor != 'transparent'){
- supports.correctTransparentColor = false;
- }
- }
- supports.cssFloat = !!last.style.cssFloat;
- doc.body.removeChild(div);
- };
+ viewBox: true,
+
+
+ autoSize: false,
+
- if (Ext.isReady) {
- supportTests();
- } else {
- Ext.onReady(supportTests);
- }
-})();
+ initComponent: function() {
+ this.callParent(arguments);
+ this.addEvents(
+ 'mousedown',
+ 'mouseup',
+ 'mousemove',
+ 'mouseenter',
+ 'mouseleave',
+ 'click'
+ );
+ },
-Ext.EventObject = function(){
- var E = Ext.lib.Event,
- clickRe = /(dbl)?click/,
-
- safariKeys = {
- 3 : 13,
- 63234 : 37,
- 63235 : 39,
- 63232 : 38,
- 63233 : 40,
- 63276 : 33,
- 63277 : 34,
- 63272 : 46,
- 63273 : 36,
- 63275 : 35
- },
-
- btnMap = Ext.isIE ? {1:0,4:1,2:2} : {0:0,1:1,2:2};
+
+ onRender: function() {
+ var me = this,
+ viewBox = me.viewBox,
+ autoSize = me.autoSize,
+ bbox, items, width, height, x, y;
+ me.callParent(arguments);
- Ext.EventObjectImpl = function(e){
- if(e){
- this.setEvent(e.browserEvent || e);
- }
- };
+ me.createSurface();
- Ext.EventObjectImpl.prototype = {
-
- setEvent : function(e){
- var me = this;
- if(e == me || (e && e.browserEvent)){
- return e;
+ items = me.surface.items;
+
+ if (viewBox || autoSize) {
+ bbox = items.getBBox();
+ width = bbox.width;
+ height = bbox.height;
+ x = bbox.x;
+ y = bbox.y;
+ if (me.viewBox) {
+ me.surface.setViewBox(x, y, width, height);
}
- me.browserEvent = e;
- if(e){
-
- me.button = e.button ? btnMap[e.button] : (e.which ? e.which - 1 : -1);
- if(clickRe.test(e.type) && me.button == -1){
- me.button = 0;
- }
- me.type = e.type;
- me.shiftKey = e.shiftKey;
-
- me.ctrlKey = e.ctrlKey || e.metaKey || false;
- me.altKey = e.altKey;
-
- me.keyCode = e.keyCode;
- me.charCode = e.charCode;
-
- me.target = E.getTarget(e);
+ else {
- me.xy = E.getXY(e);
- }else{
- me.button = -1;
- me.shiftKey = false;
- me.ctrlKey = false;
- me.altKey = false;
- me.keyCode = 0;
- me.charCode = 0;
- me.target = null;
- me.xy = [0, 0];
+ me.autoSizeSurface();
}
- return me;
- },
+ }
+ },
-
- stopEvent : function(){
- var me = this;
- if(me.browserEvent){
- if(me.browserEvent.type == 'mousedown'){
- Ext.EventManager.stoppedMouseDownEvent.fire(me);
- }
- E.stopEvent(me.browserEvent);
- }
- },
+ //@private
-
- preventDefault : function(){
- if(this.browserEvent){
- E.preventDefault(this.browserEvent);
+ autoSizeSurface: function() {
+ var me = this,
+ items = me.surface.items,
+ bbox = items.getBBox(),
+ width = bbox.width,
+ height = bbox.height;
+ items.setAttributes({
+ translate: {
+ x: -bbox.x,
+
+ y: -bbox.y + (+Ext.isOpera)
}
- },
+ }, true);
+ if (me.rendered) {
+ me.setSize(width, height);
+ }
+ else {
+ me.surface.setSize(width, height);
+ }
+ me.el.setSize(width, height);
+ },
-
- stopPropagation : function(){
- var me = this;
- if(me.browserEvent){
- if(me.browserEvent.type == 'mousedown'){
- Ext.EventManager.stoppedMouseDownEvent.fire(me);
- }
- E.stopPropagation(me.browserEvent);
- }
- },
+
+ createSurface: function() {
+ var surface = Ext.draw.Surface.create(Ext.apply({}, {
+ width: this.width,
+ height: this.height,
+ renderTo: this.el
+ }, this.initialConfig));
+ this.surface = surface;
-
- getCharCode : function(){
- return this.charCode || this.keyCode;
- },
+ function refire(eventName) {
+ return function(e) {
+ this.fireEvent(eventName, e);
+ };
+ }
-
- getKey : function(){
- return this.normalizeKey(this.keyCode || this.charCode);
- },
+ surface.on({
+ scope: this,
+ mouseup: refire('mouseup'),
+ mousedown: refire('mousedown'),
+ mousemove: refire('mousemove'),
+ mouseenter: refire('mouseenter'),
+ mouseleave: refire('mouseleave'),
+ click: refire('click')
+ });
+ },
-
- normalizeKey: function(k){
- return Ext.isSafari ? (safariKeys[k] || k) : k;
- },
-
- getPageX : function(){
- return this.xy[0];
- },
+
+ onDestroy: function() {
+ var surface = this.surface;
+ if (surface) {
+ surface.destroy();
+ }
+ this.callParent(arguments);
+ }
-
- getPageY : function(){
- return this.xy[1];
- },
+});
-
- getXY : function(){
- return this.xy;
- },
-
- getTarget : function(selector, maxDepth, returnEl){
- return selector ? Ext.fly(this.target).findParent(selector, maxDepth, returnEl) : (returnEl ? Ext.get(this.target) : this.target);
- },
+Ext.define('Ext.chart.LegendItem', {
-
- getRelatedTarget : function(){
- return this.browserEvent ? E.getRelatedTarget(this.browserEvent) : null;
- },
+
-
- getWheelDelta : function(){
- var e = this.browserEvent;
- var delta = 0;
- if(e.wheelDelta){
- delta = e.wheelDelta/120;
- }else if(e.detail){
- delta = -e.detail/3;
- }
- return delta;
- },
+ extend: 'Ext.draw.CompositeSprite',
-
- within : function(el, related, allowEl){
- if(el){
- var t = this[related ? "getRelatedTarget" : "getTarget"]();
- return t && ((allowEl ? (t == Ext.getDom(el)) : false) || Ext.fly(el).contains(t));
- }
- return false;
- }
- };
+ requires: ['Ext.chart.Shape'],
- return new Ext.EventObjectImpl();
-}();
+
+
+
+ x: 0,
+ y: 0,
+ zIndex: 500,
+
+ constructor: function(config) {
+ this.callParent(arguments);
+ this.createLegend(config);
+ },
-Ext.Loader = Ext.apply({}, {
- load: function(fileList, callback, scope, preserveOrder) {
- var scope = scope || this,
- head = document.getElementsByTagName("head")[0],
- fragment = document.createDocumentFragment(),
- numFiles = fileList.length,
- loadedFiles = 0,
- me = this;
+ createLegend: function(config) {
+ var me = this,
+ index = config.yFieldIndex,
+ series = me.series,
+ seriesType = series.type,
+ idx = me.yFieldIndex,
+ legend = me.legend,
+ surface = me.surface,
+ refX = legend.x + me.x,
+ refY = legend.y + me.y,
+ bbox, z = me.zIndex,
+ markerConfig, label, mask,
+ radius, toggle = false,
+ seriesStyle = Ext.apply(series.seriesStyle, series.style);
+
+ function getSeriesProp(name) {
+ var val = series[name];
+ return (Ext.isArray(val) ? val[idx] : val);
+ }
+
+ label = me.add('label', surface.add({
+ type: 'text',
+ x: 20,
+ y: 0,
+ zIndex: z || 0,
+ font: legend.labelFont,
+ text: getSeriesProp('title') || getSeriesProp('yField')
+ }));
+
+ if (seriesType === 'line' || seriesType === 'scatter') {
+ if(seriesType === 'line') {
+ me.add('line', surface.add({
+ type: 'path',
+ path: 'M0.5,0.5L16.5,0.5',
+ zIndex: z,
+ "stroke-width": series.lineWidth,
+ "stroke-linejoin": "round",
+ "stroke-dasharray": series.dash,
+ stroke: seriesStyle.stroke || '#000',
+ style: {
+ cursor: 'pointer'
+ }
+ }));
+ }
+ if (series.showMarkers || seriesType === 'scatter') {
+ markerConfig = Ext.apply(series.markerStyle, series.markerConfig || {});
+ me.add('marker', Ext.chart.Shape[markerConfig.type](surface, {
+ fill: markerConfig.fill,
+ x: 8.5,
+ y: 0.5,
+ zIndex: z,
+ radius: markerConfig.radius || markerConfig.size,
+ style: {
+ cursor: 'pointer'
+ }
+ }));
+ }
+ }
- var loadFileIndex = function(index) {
- head.appendChild(
- me.buildScriptTag(fileList[index], onFileLoaded)
- );
- };
+ else {
+ me.add('box', surface.add({
+ type: 'rect',
+ zIndex: z,
+ x: 0,
+ y: 0,
+ width: 12,
+ height: 12,
+ fill: series.getLegendColor(index),
+ style: {
+ cursor: 'pointer'
+ }
+ }));
+ }
+ me.setAttributes({
+ hidden: false
+ }, true);
- var onFileLoaded = function() {
- loadedFiles ++;
-
-
- if (numFiles == loadedFiles && typeof callback == 'function') {
- callback.call(scope);
- } else {
- if (preserveOrder === true) {
- loadFileIndex(loadedFiles);
- }
+ bbox = me.getBBox();
+
+ mask = me.add('mask', surface.add({
+ type: 'rect',
+ x: bbox.x,
+ y: bbox.y,
+ width: bbox.width || 20,
+ height: bbox.height || 20,
+ zIndex: (z || 0) + 1000,
+ fill: '#f00',
+ opacity: 0,
+ style: {
+ 'cursor': 'pointer'
}
- };
+ }));
+
- if (preserveOrder === true) {
- loadFileIndex.call(this, 0);
- } else {
-
- Ext.each(fileList, function(file, index) {
- fragment.appendChild(
- this.buildScriptTag(file, onFileLoaded)
- );
- }, this);
-
- head.appendChild(fragment);
- }
+ me.on('mouseover', function() {
+ label.setStyle({
+ 'font-weight': 'bold'
+ });
+ mask.setStyle({
+ 'cursor': 'pointer'
+ });
+ series._index = index;
+ series.highlightItem();
+ }, me);
+
+ me.on('mouseout', function() {
+ label.setStyle({
+ 'font-weight': 'normal'
+ });
+ series._index = index;
+ series.unHighlightItem();
+ }, me);
+
+ if (!series.visibleInLegend(index)) {
+ toggle = true;
+ label.setAttributes({
+ opacity: 0.5
+ }, true);
+ }
+
+ me.on('mousedown', function() {
+ if (!toggle) {
+ series.hideAll();
+ label.setAttributes({
+ opacity: 0.5
+ }, true);
+ } else {
+ series.showAll();
+ label.setAttributes({
+ opacity: 1
+ }, true);
+ }
+ toggle = !toggle;
+ }, me);
+ me.updatePosition({x:0, y:0});
},
+
-
- buildScriptTag: function(filename, callback) {
- var script = document.createElement('script');
- script.type = "text/javascript";
- script.src = filename;
-
-
- if (script.readyState) {
- script.onreadystatechange = function() {
- if (script.readyState == "loaded" || script.readyState == "complete") {
- script.onreadystatechange = null;
- callback();
- }
- };
- } else {
- script.onload = callback;
- }
-
- return script;
+ updatePosition: function(relativeTo) {
+ var me = this,
+ items = me.items,
+ ln = items.length,
+ i = 0,
+ item;
+ if (!relativeTo) {
+ relativeTo = me.legend;
+ }
+ for (; i < ln; i++) {
+ item = items[i];
+ switch (item.type) {
+ case 'text':
+ item.setAttributes({
+ x: 20 + relativeTo.x + me.x,
+ y: relativeTo.y + me.y
+ }, true);
+ break;
+ case 'rect':
+ item.setAttributes({
+ translate: {
+ x: relativeTo.x + me.x,
+ y: relativeTo.y + me.y - 6
+ }
+ }, true);
+ break;
+ default:
+ item.setAttributes({
+ translate: {
+ x: relativeTo.x + me.x,
+ y: relativeTo.y + me.y
+ }
+ }, true);
+ }
+ }
}
});
+Ext.define('Ext.chart.Legend', {
-Ext.ns("Ext.grid", "Ext.list", "Ext.dd", "Ext.tree", "Ext.form", "Ext.menu",
- "Ext.state", "Ext.layout", "Ext.app", "Ext.ux", "Ext.chart", "Ext.direct");
-Ext.apply(Ext, function(){
- var E = Ext,
- idSeed = 0,
- scrollWidth = null;
+ requires: ['Ext.chart.LegendItem'],
- return {
-
- emptyFn : function(){},
+
-
- BLANK_IMAGE_URL : Ext.isIE6 || Ext.isIE7 || Ext.isAir ?
- 'http:/' + '/www.extjs.com/s.gif' :
- 'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',
+
+ visible: true,
- extendX : function(supr, fn){
- return Ext.extend(supr, fn(supr.prototype));
- },
+
+ position: 'bottom',
-
- getDoc : function(){
- return Ext.get(document);
- },
+
+ x: 0,
-
- num : function(v, defaultValue){
- v = Number(Ext.isEmpty(v) || Ext.isArray(v) || typeof v == 'boolean' || (typeof v == 'string' && v.trim().length == 0) ? NaN : v);
- return isNaN(v) ? defaultValue : v;
- },
+
+ y: 0,
-
- value : function(v, defaultValue, allowBlank){
- return Ext.isEmpty(v, allowBlank) ? defaultValue : v;
- },
+
+ labelFont: '12px Helvetica, sans-serif',
-
- escapeRe : function(s) {
- return s.replace(/([-.*+?^${}()|[\]\/\\])/g, "\\$1");
- },
+
+ boxStroke: '#000',
- sequence : function(o, name, fn, scope){
- o[name] = o[name].createSequence(fn, scope);
- },
+
+ boxStrokeWidth: 1,
+
+
+ boxFill: '#FFF',
+
+
+ itemSpacing: 10,
+
+
+ padding: 5,
+
+
+ width: 0,
+
+ height: 0,
+
+
+ boxZIndex: 100,
+ constructor: function(config) {
+ var me = this;
+ if (config) {
+ Ext.apply(me, config);
+ }
+ me.items = [];
- addBehaviors : function(o){
- if(!Ext.isReady){
- Ext.onReady(function(){
- Ext.addBehaviors(o);
+ me.isVertical = ("left|right|float".indexOf(me.position) !== -1);
+
+
+ me.origX = me.x;
+ me.origY = me.y;
+ },
+
+
+ create: function() {
+ var me = this;
+ me.createItems();
+ if (!me.created && me.isDisplayed()) {
+ me.createBox();
+ me.created = true;
+
+
+ me.chart.series.each(function(series) {
+ series.on('titlechange', function() {
+ me.create();
+ me.updatePosition();
});
- } else {
- var cache = {},
- parts,
- b,
- s;
- for (b in o) {
- if ((parts = b.split('@'))[1]) {
- s = parts[0];
- if(!cache[s]){
- cache[s] = Ext.select(s);
- }
- cache[s].on(parts[1], o[b]);
- }
- }
- cache = null;
- }
- },
+ });
+ }
+ },
+
+
+ isDisplayed: function() {
+ return this.visible && this.chart.series.findIndex('showInLegend', true) !== -1;
+ },
+
+
+ createItems: function() {
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ items = me.items,
+ padding = me.padding,
+ itemSpacing = me.itemSpacing,
+ spacingOffset = 2,
+ maxWidth = 0,
+ maxHeight = 0,
+ totalWidth = 0,
+ totalHeight = 0,
+ vertical = me.isVertical,
+ math = Math,
+ mfloor = math.floor,
+ mmax = math.max,
+ index = 0,
+ i = 0,
+ len = items ? items.length : 0,
+ x, y, spacing, item, bbox, height, width;
- getScrollBarWidth: function(force){
- if(!Ext.isReady){
- return 0;
+ if (len) {
+ for (; i < len; i++) {
+ items[i].destroy();
}
+ }
+
+ items.length = [];
+
+
+ chart.series.each(function(series, i) {
+ if (series.showInLegend) {
+ Ext.each([].concat(series.yField), function(field, j) {
+ item = Ext.create('Ext.chart.LegendItem', {
+ legend: this,
+ series: series,
+ surface: chart.surface,
+ yFieldIndex: j
+ });
+ bbox = item.getBBox();
- if(force === true || scrollWidth === null){
- var div = Ext.getBody().createChild(''),
- child = div.child('div', true);
- var w1 = child.offsetWidth;
- div.setStyle('overflow', (Ext.isWebKit || Ext.isGecko) ? 'auto' : 'scroll');
- var w2 = child.offsetWidth;
- div.remove();
-
- scrollWidth = w1 - w2 + 2;
- }
- return scrollWidth;
- },
+ width = bbox.width;
+ height = bbox.height;
+ if (i + j === 0) {
+ spacing = vertical ? padding + height / 2 : padding;
+ }
+ else {
+ spacing = itemSpacing / (vertical ? 2 : 1);
+ }
+
+ item.x = mfloor(vertical ? padding : totalWidth + spacing);
+ item.y = mfloor(vertical ? totalHeight + spacing : padding + height / 2);
-
- combine : function(){
- var as = arguments, l = as.length, r = [];
- for(var i = 0; i < l; i++){
- var a = as[i];
- if(Ext.isArray(a)){
- r = r.concat(a);
- }else if(a.length !== undefined && !a.substr){
- r = r.concat(Array.prototype.slice.call(a, 0));
- }else{
- r.push(a);
- }
- }
- return r;
- },
+
+ totalWidth += width + spacing;
+ totalHeight += height + spacing;
+ maxWidth = mmax(maxWidth, width);
+ maxHeight = mmax(maxHeight, height);
-
- copyTo : function(dest, source, names){
- if(typeof names == 'string'){
- names = names.split(/[,;\s]/);
+ items.push(item);
+ }, this);
}
- Ext.each(names, function(name){
- if(source.hasOwnProperty(name)){
- dest[name] = source[name];
- }
- }, this);
- return dest;
- },
+ }, me);
- destroy : function(){
- Ext.each(arguments, function(arg){
- if(arg){
- if(Ext.isArray(arg)){
- this.destroy.apply(this, arg);
- }else if(typeof arg.destroy == 'function'){
- arg.destroy();
- }else if(arg.dom){
- arg.remove();
- }
- }
- }, this);
- },
+ me.width = mfloor((vertical ? maxWidth : totalWidth) + padding * 2);
+ if (vertical && items.length === 1) {
+ spacingOffset = 1;
+ }
+ me.height = mfloor((vertical ? totalHeight - spacingOffset * spacing : maxHeight) + (padding * 2));
+ me.itemHeight = maxHeight;
+ },
-
- destroyMembers : function(o, arg1, arg2, etc){
- for(var i = 1, a = arguments, len = a.length; i < len; i++) {
- Ext.destroy(o[a[i]]);
- delete o[a[i]];
+
+ getBBox: function() {
+ var me = this;
+ return {
+ x: Math.round(me.x) - me.boxStrokeWidth / 2,
+ y: Math.round(me.y) - me.boxStrokeWidth / 2,
+ width: me.width,
+ height: me.height
+ };
+ },
+
+
+ createBox: function() {
+ var me = this,
+ box = me.boxSprite = me.chart.surface.add(Ext.apply({
+ type: 'rect',
+ stroke: me.boxStroke,
+ "stroke-width": me.boxStrokeWidth,
+ fill: me.boxFill,
+ zIndex: me.boxZIndex
+ }, me.getBBox()));
+ box.redraw();
+ },
+
+
+ updatePosition: function() {
+ var me = this,
+ x, y,
+ legendWidth = me.width,
+ legendHeight = me.height,
+ padding = me.padding,
+ chart = me.chart,
+ chartBBox = chart.chartBBox,
+ insets = chart.insetPadding,
+ chartWidth = chartBBox.width - (insets * 2),
+ chartHeight = chartBBox.height - (insets * 2),
+ chartX = chartBBox.x + insets,
+ chartY = chartBBox.y + insets,
+ surface = chart.surface,
+ mfloor = Math.floor;
+
+ if (me.isDisplayed()) {
+
+ switch(me.position) {
+ case "left":
+ x = insets;
+ y = mfloor(chartY + chartHeight / 2 - legendHeight / 2);
+ break;
+ case "right":
+ x = mfloor(surface.width - legendWidth) - insets;
+ y = mfloor(chartY + chartHeight / 2 - legendHeight / 2);
+ break;
+ case "top":
+ x = mfloor(chartX + chartWidth / 2 - legendWidth / 2);
+ y = insets;
+ break;
+ case "bottom":
+ x = mfloor(chartX + chartWidth / 2 - legendWidth / 2);
+ y = mfloor(surface.height - legendHeight) - insets;
+ break;
+ default:
+ x = mfloor(me.origX) + insets;
+ y = mfloor(me.origY) + insets;
}
- },
+ me.x = x;
+ me.y = y;
-
- clean : function(arr){
- var ret = [];
- Ext.each(arr, function(v){
- if(!!v){
- ret.push(v);
- }
+
+ Ext.each(me.items, function(item) {
+ item.updatePosition();
});
- return ret;
- },
+
+ me.boxSprite.setAttributes(me.getBBox(), true);
+ }
+ }
+});
-
- unique : function(arr){
- var ret = [],
- collect = {};
- Ext.each(arr, function(v) {
- if(!collect[v]){
- ret.push(v);
- }
- collect[v] = true;
- });
- return ret;
- },
+Ext.define('Ext.chart.Chart', {
-
- flatten : function(arr){
- var worker = [];
- function rFlatten(a) {
- Ext.each(a, function(v) {
- if(Ext.isArray(v)){
- rFlatten(v);
- }else{
- worker.push(v);
- }
- });
- return worker;
- }
- return rFlatten(arr);
- },
+
-
- min : function(arr, comp){
- var ret = arr[0];
- comp = comp || function(a,b){ return a < b ? -1 : 1; };
- Ext.each(arr, function(v) {
- ret = comp(ret, v) == -1 ? ret : v;
- });
- return ret;
- },
+ alias: 'widget.chart',
-
- max : function(arr, comp){
- var ret = arr[0];
- comp = comp || function(a,b){ return a > b ? 1 : -1; };
- Ext.each(arr, function(v) {
- ret = comp(ret, v) == 1 ? ret : v;
- });
- return ret;
- },
+ extend: 'Ext.draw.Component',
+
+ mixins: {
+ themeManager: 'Ext.chart.theme.Theme',
+ mask: 'Ext.chart.Mask',
+ navigation: 'Ext.chart.Navigation'
+ },
-
- mean : function(arr){
- return arr.length > 0 ? Ext.sum(arr) / arr.length : undefined;
- },
+ requires: [
+ 'Ext.util.MixedCollection',
+ 'Ext.data.StoreManager',
+ 'Ext.chart.Legend',
+ 'Ext.util.DelayedTask'
+ ],
-
- sum : function(arr){
- var ret = 0;
- Ext.each(arr, function(v) {
- ret += v;
- });
- return ret;
- },
+
-
- partition : function(arr, truth){
- var ret = [[],[]];
- Ext.each(arr, function(v, i, a) {
- ret[ (truth && truth(v, i, a)) || (!truth && v) ? 0 : 1].push(v);
- });
- return ret;
- },
+
+ viewBox: false,
-
- invoke : function(arr, methodName){
- var ret = [],
- args = Array.prototype.slice.call(arguments, 2);
- Ext.each(arr, function(v,i) {
- if (v && typeof v[methodName] == 'function') {
- ret.push(v[methodName].apply(v, args));
- } else {
- ret.push(undefined);
- }
- });
- return ret;
- },
+
-
- pluck : function(arr, prop){
- var ret = [];
- Ext.each(arr, function(v) {
- ret.push( v[prop] );
- });
- return ret;
- },
+
+ animate: false,
-
- zip : function(){
- var parts = Ext.partition(arguments, function( val ){ return typeof val != 'function'; }),
- arrs = parts[0],
- fn = parts[1][0],
- len = Ext.max(Ext.pluck(arrs, "length")),
- ret = [];
+
+ legend: false,
- for (var i = 0; i < len; i++) {
- ret[i] = [];
- if(fn){
- ret[i] = fn.apply(fn, Ext.pluck(arrs, i));
- }else{
- for (var j = 0, aLen = arrs.length; j < aLen; j++){
- ret[i].push( arrs[j][i] );
- }
- }
+
+ insetPadding: 10,
+
+
+ enginePriority: ['Svg', 'Vml'],
+
+
+ background: false,
+
+
+
+
+ constructor: function(config) {
+ var me = this,
+ defaultAnim;
+ me.initTheme(config.theme || me.theme);
+ if (me.gradients) {
+ Ext.apply(config, { gradients: me.gradients });
+ }
+ if (me.background) {
+ Ext.apply(config, { background: me.background });
+ }
+ if (config.animate) {
+ defaultAnim = {
+ easing: 'ease',
+ duration: 500
+ };
+ if (Ext.isObject(config.animate)) {
+ config.animate = Ext.applyIf(config.animate, defaultAnim);
}
- return ret;
- },
+ else {
+ config.animate = defaultAnim;
+ }
+ }
+ me.mixins.mask.constructor.call(me, config);
+ me.mixins.navigation.constructor.call(me, config);
+ me.callParent([config]);
+ },
+
+ initComponent: function() {
+ var me = this,
+ axes,
+ series;
+ me.callParent();
+ me.addEvents(
+ 'itemmousedown',
+ 'itemmouseup',
+ 'itemmouseover',
+ 'itemmouseout',
+ 'itemclick',
+ 'itemdoubleclick',
+ 'itemdragstart',
+ 'itemdrag',
+ 'itemdragend',
+
+ 'beforerefresh',
+
+ 'refresh'
+ );
+ Ext.applyIf(me, {
+ zoom: {
+ width: 1,
+ height: 1,
+ x: 0,
+ y: 0
+ }
+ });
+ me.maxGutter = [0, 0];
+ me.store = Ext.data.StoreManager.lookup(me.store);
+ axes = me.axes;
+ me.axes = Ext.create('Ext.util.MixedCollection', false, function(a) { return a.position; });
+ if (axes) {
+ me.axes.addAll(axes);
+ }
+ series = me.series;
+ me.series = Ext.create('Ext.util.MixedCollection', false, function(a) { return a.seriesId || (a.seriesId = Ext.id(null, 'ext-chart-series-')); });
+ if (series) {
+ me.series.addAll(series);
+ }
+ if (me.legend !== false) {
+ me.legend = Ext.create('Ext.chart.Legend', Ext.applyIf({chart:me}, me.legend));
+ }
+
+ me.on({
+ mousemove: me.onMouseMove,
+ mouseleave: me.onMouseLeave,
+ mousedown: me.onMouseDown,
+ mouseup: me.onMouseUp,
+ scope: me
+ });
+ },
+
+
+ afterComponentLayout: function(width, height) {
+ var me = this;
+ if (Ext.isNumber(width) && Ext.isNumber(height)) {
+ me.curWidth = width;
+ me.curHeight = height;
+ me.redraw(true);
+ }
+ this.callParent(arguments);
+ },
+
+ redraw: function(resize) {
+ var me = this,
+ chartBBox = me.chartBBox = {
+ x: 0,
+ y: 0,
+ height: me.curHeight,
+ width: me.curWidth
+ },
+ legend = me.legend;
+ me.surface.setSize(chartBBox.width, chartBBox.height);
+
+ me.series.each(me.initializeSeries, me);
+ me.axes.each(me.initializeAxis, me);
- getCmp : function(id){
- return Ext.ComponentMgr.get(id);
- },
+
+ me.axes.each(function(axis) {
+ axis.processView();
+ });
+ me.axes.each(function(axis) {
+ axis.drawAxis(true);
+ });
- useShims: E.isIE6 || (E.isMac && E.isGecko2),
+ if (legend !== false) {
+ legend.create();
+ }
+ me.alignAxes();
+
- type : function(o){
- if(o === undefined || o === null){
- return false;
- }
- if(o.htmlElement){
- return 'element';
- }
- var t = typeof o;
- if(t == 'object' && o.nodeName) {
- switch(o.nodeType) {
- case 1: return 'element';
- case 3: return (/\S/).test(o.nodeValue) ? 'textnode' : 'whitespace';
- }
- }
- if(t == 'object' || t == 'function') {
- switch(o.constructor) {
- case Array: return 'array';
- case RegExp: return 'regexp';
- case Date: return 'date';
- }
- if(typeof o.length == 'number' && typeof o.item == 'function') {
- return 'nodelist';
- }
- }
- return t;
- },
+ if (me.legend !== false) {
+ legend.updatePosition();
+ }
- intercept : function(o, name, fn, scope){
- o[name] = o[name].createInterceptor(fn, scope);
- },
+
+ me.getMaxGutter();
- callback : function(cb, scope, args, delay){
- if(typeof cb == 'function'){
- if(delay){
- cb.defer(delay, scope, args || []);
- }else{
- cb.apply(scope, args || []);
- }
- }
- }
- };
-}());
+ me.resizing = !!resize;
+ me.axes.each(me.drawAxis, me);
+ me.series.each(me.drawCharts, me);
+ me.resizing = false;
+ },
-Ext.apply(Function.prototype, {
- createSequence : function(fcn, scope){
- var method = this;
- return (typeof fcn != 'function') ?
- this :
- function(){
- var retval = method.apply(this || window, arguments);
- fcn.apply(scope || this || window, arguments);
- return retval;
- };
- }
-});
-
+ afterRender: function() {
+ var ref,
+ me = this;
+ this.callParent();
+ if (me.categoryNames) {
+ me.setCategoryNames(me.categoryNames);
+ }
-Ext.applyIf(String, {
+ if (me.tipRenderer) {
+ ref = me.getFunctionRef(me.tipRenderer);
+ me.setTipRenderer(ref.fn, ref.scope);
+ }
+ me.bindStore(me.store, true);
+ me.refresh();
+ },
- escape : function(string) {
- return string.replace(/('|\\)/g, "\\$1");
+ getEventXY: function(e) {
+ var me = this,
+ box = this.surface.getRegion(),
+ pageXY = e.getXY(),
+ x = pageXY[0] - box.left,
+ y = pageXY[1] - box.top;
+ return [x, y];
},
- leftPad : function (val, size, ch) {
- var result = String(val);
- if(!ch) {
- ch = " ";
- }
- while (result.length < size) {
- result = ch + result;
- }
- return result;
- }
-});
+ onClick: function(e) {
+ var me = this,
+ position = me.getEventXY(e),
+ item;
+
+
+ me.series.each(function(series) {
+ if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+ if (series.getItemForPoint) {
+ item = series.getItemForPoint(position[0], position[1]);
+ if (item) {
+ series.fireEvent('itemclick', item);
+ }
+ }
+ }
+ }, me);
+ },
-String.prototype.toggle = function(value, other){
- return this == value ? other : value;
-};
+
+ onMouseDown: function(e) {
+ var me = this,
+ position = me.getEventXY(e),
+ item;
+ if (me.mask) {
+ me.mixins.mask.onMouseDown.call(me, e);
+ }
+
+
+ me.series.each(function(series) {
+ if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+ if (series.getItemForPoint) {
+ item = series.getItemForPoint(position[0], position[1]);
+ if (item) {
+ series.fireEvent('itemmousedown', item);
+ }
+ }
+ }
+ }, me);
+ },
-String.prototype.trim = function(){
- var re = /^\s+|\s+$/g;
- return function(){ return this.replace(re, ""); };
-}();
+
+ onMouseUp: function(e) {
+ var me = this,
+ position = me.getEventXY(e),
+ item;
+ if (me.mask) {
+ me.mixins.mask.onMouseUp.call(me, e);
+ }
+
+
+ me.series.each(function(series) {
+ if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+ if (series.getItemForPoint) {
+ item = series.getItemForPoint(position[0], position[1]);
+ if (item) {
+ series.fireEvent('itemmouseup', item);
+ }
+ }
+ }
+ }, me);
+ },
+
+ onMouseMove: function(e) {
+ var me = this,
+ position = me.getEventXY(e),
+ item, last, storeItem, storeField;
-Date.prototype.getElapsed = function(date) {
- return Math.abs((date || new Date()).getTime()-this.getTime());
-};
+ if (me.mask) {
+ me.mixins.mask.onMouseMove.call(me, e);
+ }
+
+
+ me.series.each(function(series) {
+ if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
+ if (series.getItemForPoint) {
+ item = series.getItemForPoint(position[0], position[1]);
+ last = series._lastItemForPoint;
+ storeItem = series._lastStoreItem;
+ storeField = series._lastStoreField;
+ if (item !== last || item && (item.storeItem != storeItem || item.storeField != storeField)) {
+ if (last) {
+ series.fireEvent('itemmouseout', last);
+ delete series._lastItemForPoint;
+ delete series._lastStoreField;
+ delete series._lastStoreItem;
+ }
+ if (item) {
+ series.fireEvent('itemmouseover', item);
+ series._lastItemForPoint = item;
+ series._lastStoreItem = item.storeItem;
+ series._lastStoreField = item.storeField;
+ }
+ }
+ }
+ } else {
+ last = series._lastItemForPoint;
+ if (last) {
+ series.fireEvent('itemmouseout', last);
+ delete series._lastItemForPoint;
+ delete series._lastStoreField;
+ delete series._lastStoreItem;
+ }
+ }
+ }, me);
+ },
-Ext.applyIf(Number.prototype, {
- constrain : function(min, max){
- return Math.min(Math.max(this, min), max);
- }
-});
-Ext.lib.Dom.getRegion = function(el) {
- return Ext.lib.Region.getRegion(el);
-}; Ext.lib.Region = function(t, r, b, l) {
- var me = this;
- me.top = t;
- me[1] = t;
- me.right = r;
- me.bottom = b;
- me.left = l;
- me[0] = l;
- };
-
- Ext.lib.Region.prototype = {
- contains : function(region) {
- var me = this;
- return ( region.left >= me.left &&
- region.right <= me.right &&
- region.top >= me.top &&
- region.bottom <= me.bottom );
-
- },
+ onMouseLeave: function(e) {
+ var me = this;
+ if (me.mask) {
+ me.mixins.mask.onMouseLeave.call(me, e);
+ }
+ me.series.each(function(series) {
+ delete series._lastItemForPoint;
+ });
+ },
- getArea : function() {
- var me = this;
- return ( (me.bottom - me.top) * (me.right - me.left) );
- },
+
+ delayRefresh: function() {
+ var me = this;
+ if (!me.refreshTask) {
+ me.refreshTask = Ext.create('Ext.util.DelayedTask', me.refresh, me);
+ }
+ me.refreshTask.delay(me.refreshBuffer);
+ },
- intersect : function(region) {
- var me = this,
- t = Math.max(me.top, region.top),
- r = Math.min(me.right, region.right),
- b = Math.min(me.bottom, region.bottom),
- l = Math.max(me.left, region.left);
+
+ refresh: function() {
+ var me = this;
+ if (me.rendered && me.curWidth != undefined && me.curHeight != undefined) {
+ if (me.fireEvent('beforerefresh', me) !== false) {
+ me.redraw();
+ me.fireEvent('refresh', me);
+ }
+ }
+ },
- if (b >= t && r >= l) {
- return new Ext.lib.Region(t, r, b, l);
+
+ bindStore: function(store, initial) {
+ var me = this;
+ if (!initial && me.store) {
+ if (store !== me.store && me.store.autoDestroy) {
+ me.store.destroy();
}
- },
-
- union : function(region) {
- var me = this,
- t = Math.min(me.top, region.top),
- r = Math.max(me.right, region.right),
- b = Math.max(me.bottom, region.bottom),
- l = Math.min(me.left, region.left);
+ else {
+ me.store.un('datachanged', me.refresh, me);
+ me.store.un('add', me.delayRefresh, me);
+ me.store.un('remove', me.delayRefresh, me);
+ me.store.un('update', me.delayRefresh, me);
+ me.store.un('clear', me.refresh, me);
+ }
+ }
+ if (store) {
+ store = Ext.data.StoreManager.lookup(store);
+ store.on({
+ scope: me,
+ datachanged: me.refresh,
+ add: me.delayRefresh,
+ remove: me.delayRefresh,
+ update: me.delayRefresh,
+ clear: me.refresh
+ });
+ }
+ me.store = store;
+ if (store && !initial) {
+ me.refresh();
+ }
+ },
- return new Ext.lib.Region(t, r, b, l);
- },
+
+ initializeAxis: function(axis) {
+ var me = this,
+ chartBBox = me.chartBBox,
+ w = chartBBox.width,
+ h = chartBBox.height,
+ x = chartBBox.x,
+ y = chartBBox.y,
+ themeAttrs = me.themeAttrs,
+ config = {
+ chart: me
+ };
+ if (themeAttrs) {
+ config.axisStyle = Ext.apply({}, themeAttrs.axis);
+ config.axisLabelLeftStyle = Ext.apply({}, themeAttrs.axisLabelLeft);
+ config.axisLabelRightStyle = Ext.apply({}, themeAttrs.axisLabelRight);
+ config.axisLabelTopStyle = Ext.apply({}, themeAttrs.axisLabelTop);
+ config.axisLabelBottomStyle = Ext.apply({}, themeAttrs.axisLabelBottom);
+ config.axisTitleLeftStyle = Ext.apply({}, themeAttrs.axisTitleLeft);
+ config.axisTitleRightStyle = Ext.apply({}, themeAttrs.axisTitleRight);
+ config.axisTitleTopStyle = Ext.apply({}, themeAttrs.axisTitleTop);
+ config.axisTitleBottomStyle = Ext.apply({}, themeAttrs.axisTitleBottom);
+ }
+ switch (axis.position) {
+ case 'top':
+ Ext.apply(config, {
+ length: w,
+ width: h,
+ x: x,
+ y: y
+ });
+ break;
+ case 'bottom':
+ Ext.apply(config, {
+ length: w,
+ width: h,
+ x: x,
+ y: h
+ });
+ break;
+ case 'left':
+ Ext.apply(config, {
+ length: h,
+ width: w,
+ x: x,
+ y: h
+ });
+ break;
+ case 'right':
+ Ext.apply(config, {
+ length: h,
+ width: w,
+ x: w,
+ y: h
+ });
+ break;
+ }
+ if (!axis.chart) {
+ Ext.apply(config, axis);
+ axis = me.axes.replace(Ext.createByAlias('axis.' + axis.type.toLowerCase(), config));
+ }
+ else {
+ Ext.apply(axis, config);
+ }
+ },
- constrainTo : function(r) {
- var me = this;
- me.top = me.top.constrain(r.top, r.bottom);
- me.bottom = me.bottom.constrain(r.top, r.bottom);
- me.left = me.left.constrain(r.left, r.right);
- me.right = me.right.constrain(r.left, r.right);
- return me;
- },
- adjust : function(t, l, b, r) {
- var me = this;
- me.top += t;
- me.left += l;
- me.right += r;
- me.bottom += b;
- return me;
+
+ alignAxes: function() {
+ var me = this,
+ axes = me.axes,
+ legend = me.legend,
+ edges = ['top', 'right', 'bottom', 'left'],
+ chartBBox,
+ insetPadding = me.insetPadding,
+ insets = {
+ top: insetPadding,
+ right: insetPadding,
+ bottom: insetPadding,
+ left: insetPadding
+ };
+
+ function getAxis(edge) {
+ var i = axes.findIndex('position', edge);
+ return (i < 0) ? null : axes.getAt(i);
}
- };
- Ext.lib.Region.getRegion = function(el) {
- var p = Ext.lib.Dom.getXY(el),
- t = p[1],
- r = p[0] + el.offsetWidth,
- b = p[1] + el.offsetHeight,
- l = p[0];
+
+ Ext.each(edges, function(edge) {
+ var isVertical = (edge === 'left' || edge === 'right'),
+ axis = getAxis(edge),
+ bbox;
- return new Ext.lib.Region(t, r, b, l);
- }; Ext.lib.Point = function(x, y) {
- if (Ext.isArray(x)) {
- y = x[1];
- x = x[0];
- }
- var me = this;
- me.x = me.right = me.left = me[0] = x;
- me.y = me.top = me.bottom = me[1] = y;
- };
+
+ if (legend !== false) {
+ if (legend.position === edge) {
+ bbox = legend.getBBox();
+ insets[edge] += (isVertical ? bbox.width : bbox.height) + insets[edge];
+ }
+ }
+
+
+
+ if (axis && axis.bbox) {
+ bbox = axis.bbox;
+ insets[edge] += (isVertical ? bbox.width : bbox.height);
+ }
+ });
+
+ chartBBox = {
+ x: insets.left,
+ y: insets.top,
+ width: me.curWidth - insets.left - insets.right,
+ height: me.curHeight - insets.top - insets.bottom
+ };
+ me.chartBBox = chartBBox;
- Ext.lib.Point.prototype = new Ext.lib.Region();
+
+
+ axes.each(function(axis) {
+ var pos = axis.position,
+ isVertical = (pos === 'left' || pos === 'right');
-Ext.apply(Ext.DomHelper,
-function(){
- var pub,
- afterbegin = 'afterbegin',
- afterend = 'afterend',
- beforebegin = 'beforebegin',
- beforeend = 'beforeend',
- confRe = /tag|children|cn|html$/i;
+ axis.x = (pos === 'right' ? chartBBox.x + chartBBox.width : chartBBox.x);
+ axis.y = (pos === 'top' ? chartBBox.y : chartBBox.y + chartBBox.height);
+ axis.width = (isVertical ? chartBBox.width : chartBBox.height);
+ axis.length = (isVertical ? chartBBox.height : chartBBox.width);
+ });
+ },
- function doInsert(el, o, returnElement, pos, sibling, append){
- el = Ext.getDom(el);
- var newNode;
- if (pub.useDom) {
- newNode = createDom(o, null);
- if (append) {
- el.appendChild(newNode);
+ initializeSeries: function(series, idx) {
+ var me = this,
+ themeAttrs = me.themeAttrs,
+ seriesObj, markerObj, seriesThemes, st,
+ markerThemes, colorArrayStyle = [],
+ i = 0, l,
+ config = {
+ chart: me,
+ seriesId: series.seriesId
+ };
+ if (themeAttrs) {
+ seriesThemes = themeAttrs.seriesThemes;
+ markerThemes = themeAttrs.markerThemes;
+ seriesObj = Ext.apply({}, themeAttrs.series);
+ markerObj = Ext.apply({}, themeAttrs.marker);
+ config.seriesStyle = Ext.apply(seriesObj, seriesThemes[idx % seriesThemes.length]);
+ config.seriesLabelStyle = Ext.apply({}, themeAttrs.seriesLabel);
+ config.markerStyle = Ext.apply(markerObj, markerThemes[idx % markerThemes.length]);
+ if (themeAttrs.colors) {
+ config.colorArrayStyle = themeAttrs.colors;
} else {
- (sibling == 'firstChild' ? el : el.parentNode).insertBefore(newNode, el[sibling] || el);
+ colorArrayStyle = [];
+ for (l = seriesThemes.length; i < l; i++) {
+ st = seriesThemes[i];
+ if (st.fill || st.stroke) {
+ colorArrayStyle.push(st.fill || st.stroke);
+ }
+ }
+ if (colorArrayStyle.length) {
+ config.colorArrayStyle = colorArrayStyle;
+ }
}
+ config.seriesIdx = idx;
+ }
+ if (series instanceof Ext.chart.series.Series) {
+ Ext.apply(series, config);
} else {
- newNode = Ext.DomHelper.insertHtml(pos, el, Ext.DomHelper.createHtml(o));
+ Ext.applyIf(config, series);
+ series = me.series.replace(Ext.createByAlias('series.' + series.type.toLowerCase(), config));
}
- return returnElement ? Ext.get(newNode, true) : newNode;
- }
+ if (series.initialize) {
+ series.initialize();
+ }
+ },
-
- function createDom(o, parentNode){
- var el,
- doc = document,
- useSet,
- attr,
- val,
- cn;
+ getMaxGutter: function() {
+ var me = this,
+ maxGutter = [0, 0];
+ me.series.each(function(s) {
+ var gutter = s.getGutters && s.getGutters() || [0, 0];
+ maxGutter[0] = Math.max(maxGutter[0], gutter[0]);
+ maxGutter[1] = Math.max(maxGutter[1], gutter[1]);
+ });
+ me.maxGutter = maxGutter;
+ },
- if (Ext.isArray(o)) {
- el = doc.createDocumentFragment();
- for (var i = 0, l = o.length; i < l; i++) {
- createDom(o[i], el);
- }
- } else if (typeof o == 'string') {
- el = doc.createTextNode(o);
- } else {
- el = doc.createElement( o.tag || 'div' );
- useSet = !!el.setAttribute;
- for (var attr in o) {
- if(!confRe.test(attr)){
- val = o[attr];
- if(attr == 'cls'){
- el.className = val;
- }else{
- if(useSet){
- el.setAttribute(attr, val);
- }else{
- el[attr] = val;
- }
- }
- }
- }
- Ext.DomHelper.applyStyles(el, o.style);
+
+ drawAxis: function(axis) {
+ axis.drawAxis();
+ },
- if ((cn = o.children || o.cn)) {
- createDom(cn, el);
- } else if (o.html) {
- el.innerHTML = o.html;
- }
- }
- if(parentNode){
- parentNode.appendChild(el);
+
+ drawCharts: function(series) {
+ series.triggerafterrender = false;
+ series.drawSeries();
+ if (!this.animate) {
+ series.fireEvent('afterrender');
}
- return el;
+ },
+
+
+ destroy: function() {
+ this.surface.destroy();
+ this.bindStore(null);
+ this.callParent(arguments);
}
+});
- pub = {
-
- createTemplate : function(o){
- var html = Ext.DomHelper.createHtml(o);
- return new Ext.Template(html);
- },
-
- useDom : false,
+Ext.define('Ext.chart.Highlight', {
-
- insertBefore : function(el, o, returnElement){
- return doInsert(el, o, returnElement, beforebegin);
- },
+
-
- insertAfter : function(el, o, returnElement){
- return doInsert(el, o, returnElement, afterend, 'nextSibling');
- },
+ requires: ['Ext.fx.Anim'],
-
- insertFirst : function(el, o, returnElement){
- return doInsert(el, o, returnElement, afterbegin, 'firstChild');
- },
+
-
- append: function(el, o, returnElement){
- return doInsert(el, o, returnElement, beforeend, '', true);
- },
+
+ highlight: false,
-
- createDom: createDom
- };
- return pub;
-}());
+ highlightCfg : null,
-Ext.apply(Ext.Template.prototype, {
-
- disableFormats : false,
-
+ constructor: function(config) {
+ if (config.highlight) {
+ if (config.highlight !== true) {
+ this.highlightCfg = Ext.apply({}, config.highlight);
+ }
+ else {
+ this.highlightCfg = {
+ fill: '#fdd',
+ radius: 20,
+ lineWidth: 5,
+ stroke: '#f55'
+ };
+ }
+ }
+ },
- re : /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
- argsRe : /^\s*['"](.*)["']\s*$/,
- compileARe : /\\/g,
- compileBRe : /(\r\n|\n)/g,
- compileCRe : /'/g,
-
- /**
- * Returns an HTML fragment of this template with the specified values applied.
- * @param {Object/Array} values The template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})
- * @return {String} The HTML fragment
- * @hide repeat doc
- */
- applyTemplate : function(values){
+ highlightItem: function(item) {
+ if (!item) {
+ return;
+ }
+
var me = this,
- useF = me.disableFormats !== true,
- fm = Ext.util.Format,
- tpl = me;
-
- if(me.compiled){
- return me.compiled(values);
+ sprite = item.sprite,
+ opts = me.highlightCfg,
+ surface = me.chart.surface,
+ animate = me.chart.animate,
+ p,
+ from,
+ to,
+ pi;
+
+ if (!me.highlight || !sprite || sprite._highlighted) {
+ return;
}
- function fn(m, name, format, args){
- if (format && useF) {
- if (format.substr(0, 5) == "this.") {
- return tpl.call(format.substr(5), values[name], values);
- } else {
- if (args) {
- // quoted values are required for strings in compiled templates,
- // but for non compiled we need to strip them
- // quoted reversed for jsmin
- var re = me.argsRe;
- args = args.split(',');
- for(var i = 0, len = args.length; i < len; i++){
- args[i] = args[i].replace(re, "$1");
+ if (sprite._anim) {
+ sprite._anim.paused = true;
+ }
+ sprite._highlighted = true;
+ if (!sprite._defaults) {
+ sprite._defaults = Ext.apply(sprite._defaults || {},
+ sprite.attr);
+ from = {};
+ to = {};
+ for (p in opts) {
+ if (! (p in sprite._defaults)) {
+ sprite._defaults[p] = surface.availableAttrs[p];
+ }
+ from[p] = sprite._defaults[p];
+ to[p] = opts[p];
+ if (Ext.isObject(opts[p])) {
+ from[p] = {};
+ to[p] = {};
+ Ext.apply(sprite._defaults[p], sprite.attr[p]);
+ Ext.apply(from[p], sprite._defaults[p]);
+ for (pi in sprite._defaults[p]) {
+ if (! (pi in opts[p])) {
+ to[p][pi] = from[p][pi];
+ } else {
+ to[p][pi] = opts[p][pi];
+ }
+ }
+ for (pi in opts[p]) {
+ if (! (pi in to[p])) {
+ to[p][pi] = opts[p][pi];
}
- args = [values[name]].concat(args);
- } else {
- args = [values[name]];
}
- return fm[format].apply(fm, args);
}
- } else {
- return values[name] !== undefined ? values[name] : "";
}
+ sprite._from = from;
+ sprite._to = to;
+ }
+ if (animate) {
+ sprite._anim = Ext.create('Ext.fx.Anim', {
+ target: sprite,
+ from: sprite._from,
+ to: sprite._to,
+ duration: 150
+ });
+ } else {
+ sprite.setAttributes(sprite._to, true);
}
- return me.html.replace(me.re, fn);
},
- /**
- * Compiles the template into an internal function, eliminating the RegEx overhead.
- * @return {Ext.Template} this
- * @hide repeat doc
- */
- compile : function(){
+
+ unHighlightItem: function() {
+ if (!this.highlight || !this.items) {
+ return;
+ }
+
var me = this,
- fm = Ext.util.Format,
- useF = me.disableFormats !== true,
- sep = Ext.isGecko ? "+" : ",",
- body;
+ items = me.items,
+ len = items.length,
+ opts = me.highlightCfg,
+ animate = me.chart.animate,
+ i = 0,
+ obj,
+ p,
+ sprite;
- function fn(m, name, format, args){
- if(format && useF){
- args = args ? ',' + args : "";
- if(format.substr(0, 5) != "this."){
- format = "fm." + format + '(';
- }else{
- format = 'this.call("'+ format.substr(5) + '", ';
- args = ", values";
+ for (; i < len; i++) {
+ if (!items[i]) {
+ continue;
+ }
+ sprite = items[i].sprite;
+ if (sprite && sprite._highlighted) {
+ if (sprite._anim) {
+ sprite._anim.paused = true;
}
- }else{
- args= ''; format = "(values['" + name + "'] == undefined ? '' : ";
+ obj = {};
+ for (p in opts) {
+ if (Ext.isObject(sprite._defaults[p])) {
+ obj[p] = {};
+ Ext.apply(obj[p], sprite._defaults[p]);
+ }
+ else {
+ obj[p] = sprite._defaults[p];
+ }
+ }
+ if (animate) {
+ sprite._anim = Ext.create('Ext.fx.Anim', {
+ target: sprite,
+ to: obj,
+ duration: 150
+ });
+ }
+ else {
+ sprite.setAttributes(obj, true);
+ }
+ delete sprite._highlighted;
+
}
- return "'"+ sep + format + "values['" + name + "']" + args + ")"+sep+"'";
}
+ },
- // branched to use + in gecko and [].join() in others
- if(Ext.isGecko){
- body = "this.compiled = function(values){ return '" +
- me.html.replace(me.compileARe, '\\\\').replace(me.compileBRe, '\\n').replace(me.compileCRe, "\\'").replace(me.re, fn) +
- "';};";
- }else{
- body = ["this.compiled = function(values){ return ['"];
- body.push(me.html.replace(me.compileARe, '\\\\').replace(me.compileBRe, '\\n').replace(me.compileCRe, "\\'").replace(me.re, fn));
- body.push("'].join('');};");
- body = body.join('');
+ cleanHighlights: function() {
+ if (!this.highlight) {
+ return;
}
- eval(body);
- return me;
- },
- // private function used to call members
- call : function(fnName, value, allValues){
- return this[fnName](value, allValues);
+ var group = this.group,
+ markerGroup = this.markerGroup,
+ i = 0,
+ l;
+ for (l = group.getCount(); i < l; i++) {
+ delete group.getAt(i)._defaults;
+ }
+ if (markerGroup) {
+ for (l = markerGroup.getCount(); i < l; i++) {
+ delete markerGroup.getAt(i)._defaults;
+ }
+ }
}
});
-Ext.Template.prototype.apply = Ext.Template.prototype.applyTemplate;
-/**
- * @class Ext.util.Functions
- * @singleton
- */
-Ext.util.Functions = {
- /**
- * Creates an interceptor function. The passed function is called before the original one. If it returns false,
- * the original one is not called. The resulting function returns the results of the original function.
- * The passed function is called with the parameters of the original function. Example usage:
- * ]*)?>)((\n|\r|.)*?)(?:<\/script>)/ig,
- srcRe = /\ssrc=([\'\"])(.*?)\1/i,
- typeRe = /\stype=([\'\"])(.*?)\1/i,
- match,
- attrs,
- srcMatch,
- typeMatch,
- el,
- s;
-
- while ((match = re.exec(html))) {
- attrs = match[1];
- srcMatch = attrs ? attrs.match(srcRe) : false;
- if (srcMatch && srcMatch[2]) {
- s = DOC.createElement("script");
- s.src = srcMatch[2];
- typeMatch = attrs.match(typeRe);
- if (typeMatch && typeMatch[2]) {
- s.type = typeMatch[2];
- }
- hd.appendChild(s);
- } else if (match[2] && match[2].length > 0) {
- if (window.execScript) {
- window.execScript(match[2]);
- } else {
- window.eval(match[2]);
+ else {
+ currentY = Math.floor(y) + 0.5;
+ path = ["M", x, currentY, "l", length, 0];
+ trueLength = length - (gutterX * 2);
+ }
+
+ delta = trueLength / (steps || 1);
+ dashesX = Math.max(subDashesX +1, 0);
+ dashesY = Math.max(subDashesY +1, 0);
+ if (me.type == 'Numeric') {
+ calcLabels = true;
+ me.labels = [stepCalcs.from];
+ }
+ if (position == 'right' || position == 'left') {
+ currentY = y - gutterY;
+ currentX = x - ((position == 'left') * dashSize * 2);
+ while (currentY >= y - gutterY - trueLength) {
+ path.push("M", currentX, Math.floor(currentY) + 0.5, "l", dashSize * 2 + 1, 0);
+ if (currentY != y - gutterY) {
+ for (i = 1; i < dashesY; i++) {
+ path.push("M", currentX + dashSize, Math.floor(currentY + delta * i / dashesY) + 0.5, "l", dashSize + 1, 0);
}
}
+ inflections.push([ Math.floor(x), Math.floor(currentY) ]);
+ currentY -= delta;
+ if (calcLabels) {
+ me.labels.push(me.labels[me.labels.length -1] + step);
+ }
+ if (delta === 0) {
+ break;
+ }
}
-
- el = DOC.getElementById(id);
- if (el) {
- Ext.removeNode(el);
+ if (Math.round(currentY + delta - (y - gutterY - trueLength))) {
+ path.push("M", currentX, Math.floor(y - length + gutterY) + 0.5, "l", dashSize * 2 + 1, 0);
+ for (i = 1; i < dashesY; i++) {
+ path.push("M", currentX + dashSize, Math.floor(y - length + gutterY + delta * i / dashesY) + 0.5, "l", dashSize + 1, 0);
+ }
+ inflections.push([ Math.floor(x), Math.floor(currentY) ]);
+ if (calcLabels) {
+ me.labels.push(me.labels[me.labels.length -1] + step);
+ }
}
-
- if (typeof callback == 'function') {
- callback();
+ } else {
+ currentX = x + gutterX;
+ currentY = y - ((position == 'top') * dashSize * 2);
+ while (currentX <= x + gutterX + trueLength) {
+ path.push("M", Math.floor(currentX) + 0.5, currentY, "l", 0, dashSize * 2 + 1);
+ if (currentX != x + gutterX) {
+ for (i = 1; i < dashesX; i++) {
+ path.push("M", Math.floor(currentX - delta * i / dashesX) + 0.5, currentY, "l", 0, dashSize + 1);
+ }
+ }
+ inflections.push([ Math.floor(currentX), Math.floor(y) ]);
+ currentX += delta;
+ if (calcLabels) {
+ me.labels.push(me.labels[me.labels.length -1] + step);
+ }
+ if (delta === 0) {
+ break;
+ }
}
- });
- dom.innerHTML = html.replace(/(?:)((\n|\r|.)*?)(?:<\/script>)/ig, "");
- return this;
+ if (Math.round(currentX - delta - (x + gutterX + trueLength))) {
+ path.push("M", Math.floor(x + length - gutterX) + 0.5, currentY, "l", 0, dashSize * 2 + 1);
+ for (i = 1; i < dashesX; i++) {
+ path.push("M", Math.floor(x + length - gutterX - delta * i / dashesX) + 0.5, currentY, "l", 0, dashSize + 1);
+ }
+ inflections.push([ Math.floor(currentX), Math.floor(y) ]);
+ if (calcLabels) {
+ me.labels.push(me.labels[me.labels.length -1] + step);
+ }
+ }
+ }
+ if (!me.axis) {
+ me.axis = me.chart.surface.add(Ext.apply({
+ type: 'path',
+ path: path
+ }, me.axisStyle));
+ }
+ me.axis.setAttributes({
+ path: path
+ }, true);
+ me.inflections = inflections;
+ if (!init && me.grid) {
+ me.drawGrid();
+ }
+ me.axisBBox = me.axis.getBBox();
+ me.drawLabel();
},
- removeAllListeners : function() {
- this.removeAnchor();
- Ext.EventManager.removeAll(this.dom);
- return this;
+ drawGrid: function() {
+ var me = this,
+ surface = me.chart.surface,
+ grid = me.grid,
+ odd = grid.odd,
+ even = grid.even,
+ inflections = me.inflections,
+ ln = inflections.length - ((odd || even)? 0 : 1),
+ position = me.position,
+ gutter = me.chart.maxGutter,
+ width = me.width - 2,
+ vert = false,
+ point, prevPoint,
+ i = 1,
+ path = [], styles, lineWidth, dlineWidth,
+ oddPath = [], evenPath = [];
+
+ if ((gutter[1] !== 0 && (position == 'left' || position == 'right')) ||
+ (gutter[0] !== 0 && (position == 'top' || position == 'bottom'))) {
+ i = 0;
+ ln++;
+ }
+ for (; i < ln; i++) {
+ point = inflections[i];
+ prevPoint = inflections[i - 1];
+ if (odd || even) {
+ path = (i % 2)? oddPath : evenPath;
+ styles = ((i % 2)? odd : even) || {};
+ lineWidth = (styles.lineWidth || styles['stroke-width'] || 0) / 2;
+ dlineWidth = 2 * lineWidth;
+ if (position == 'left') {
+ path.push("M", prevPoint[0] + 1 + lineWidth, prevPoint[1] + 0.5 - lineWidth,
+ "L", prevPoint[0] + 1 + width - lineWidth, prevPoint[1] + 0.5 - lineWidth,
+ "L", point[0] + 1 + width - lineWidth, point[1] + 0.5 + lineWidth,
+ "L", point[0] + 1 + lineWidth, point[1] + 0.5 + lineWidth, "Z");
+ }
+ else if (position == 'right') {
+ path.push("M", prevPoint[0] - lineWidth, prevPoint[1] + 0.5 - lineWidth,
+ "L", prevPoint[0] - width + lineWidth, prevPoint[1] + 0.5 - lineWidth,
+ "L", point[0] - width + lineWidth, point[1] + 0.5 + lineWidth,
+ "L", point[0] - lineWidth, point[1] + 0.5 + lineWidth, "Z");
+ }
+ else if (position == 'top') {
+ path.push("M", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] + 1 + lineWidth,
+ "L", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] + 1 + width - lineWidth,
+ "L", point[0] + 0.5 - lineWidth, point[1] + 1 + width - lineWidth,
+ "L", point[0] + 0.5 - lineWidth, point[1] + 1 + lineWidth, "Z");
+ }
+ else {
+ path.push("M", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] - lineWidth,
+ "L", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] - width + lineWidth,
+ "L", point[0] + 0.5 - lineWidth, point[1] - width + lineWidth,
+ "L", point[0] + 0.5 - lineWidth, point[1] - lineWidth, "Z");
+ }
+ } else {
+ if (position == 'left') {
+ path = path.concat(["M", point[0] + 0.5, point[1] + 0.5, "l", width, 0]);
+ }
+ else if (position == 'right') {
+ path = path.concat(["M", point[0] - 0.5, point[1] + 0.5, "l", -width, 0]);
+ }
+ else if (position == 'top') {
+ path = path.concat(["M", point[0] + 0.5, point[1] + 0.5, "l", 0, width]);
+ }
+ else {
+ path = path.concat(["M", point[0] + 0.5, point[1] - 0.5, "l", 0, -width]);
+ }
+ }
+ }
+ if (odd || even) {
+ if (oddPath.length) {
+ if (!me.gridOdd && oddPath.length) {
+ me.gridOdd = surface.add({
+ type: 'path',
+ path: oddPath
+ });
+ }
+ me.gridOdd.setAttributes(Ext.apply({
+ path: oddPath,
+ hidden: false
+ }, odd || {}), true);
+ }
+ if (evenPath.length) {
+ if (!me.gridEven) {
+ me.gridEven = surface.add({
+ type: 'path',
+ path: evenPath
+ });
+ }
+ me.gridEven.setAttributes(Ext.apply({
+ path: evenPath,
+ hidden: false
+ }, even || {}), true);
+ }
+ }
+ else {
+ if (path.length) {
+ if (!me.gridLines) {
+ me.gridLines = me.chart.surface.add({
+ type: 'path',
+ path: path,
+ "stroke-width": me.lineWidth || 1,
+ stroke: me.gridColor || '#ccc'
+ });
+ }
+ me.gridLines.setAttributes({
+ hidden: false,
+ path: path
+ }, true);
+ }
+ else if (me.gridLines) {
+ me.gridLines.hide(true);
+ }
+ }
},
-
- createProxy : function(config, renderTo, matchBox) {
- config = (typeof config == 'object') ? config : {tag : "div", cls: config};
+ //@private
+ getOrCreateLabel: function(i, text) {
var me = this,
- proxy = renderTo ? Ext.DomHelper.append(renderTo, config, true) :
- Ext.DomHelper.insertBefore(me.dom, config, true);
-
- if (matchBox && me.setBox && me.getBox) {
- proxy.setBox(me.getBox());
+ labelGroup = me.labelGroup,
+ textLabel = labelGroup.getAt(i),
+ surface = me.chart.surface;
+ if (textLabel) {
+ if (text != textLabel.attr.text) {
+ textLabel.setAttributes(Ext.apply({
+ text: text
+ }, me.label), true);
+ textLabel._bbox = textLabel.getBBox();
+ }
}
- return proxy;
- }
-});
-
-Ext.Element.prototype.getUpdateManager = Ext.Element.prototype.getUpdater;
-
-Ext.Element.addMethods({
-
- getAnchorXY : function(anchor, local, s){
-
-
- anchor = (anchor || "tl").toLowerCase();
- s = s || {};
-
- var me = this,
- vp = me.dom == document.body || me.dom == document,
- w = s.width || vp ? Ext.lib.Dom.getViewWidth() : me.getWidth(),
- h = s.height || vp ? Ext.lib.Dom.getViewHeight() : me.getHeight(),
- xy,
- r = Math.round,
- o = me.getXY(),
- scroll = me.getScroll(),
- extraX = vp ? scroll.left : !local ? o[0] : 0,
- extraY = vp ? scroll.top : !local ? o[1] : 0,
- hash = {
- c : [r(w * 0.5), r(h * 0.5)],
- t : [r(w * 0.5), 0],
- l : [0, r(h * 0.5)],
- r : [w, r(h * 0.5)],
- b : [r(w * 0.5), h],
- tl : [0, 0],
- bl : [0, h],
- br : [w, h],
- tr : [w, 0]
- };
-
- xy = hash[anchor];
- return [xy[0] + extraX, xy[1] + extraY];
- },
-
-
- anchorTo : function(el, alignment, offsets, animate, monitorScroll, callback){
- var me = this,
- dom = me.dom,
- scroll = !Ext.isEmpty(monitorScroll),
- action = function(){
- Ext.fly(dom).alignTo(el, alignment, offsets, animate);
- Ext.callback(callback, Ext.fly(dom));
- },
- anchor = this.getAnchor();
+ else {
+ textLabel = surface.add(Ext.apply({
+ group: labelGroup,
+ type: 'text',
+ x: 0,
+ y: 0,
+ text: text
+ }, me.label));
+ surface.renderItem(textLabel);
+ textLabel._bbox = textLabel.getBBox();
+ }
+
+ if (me.label.rotation) {
+ textLabel.setAttributes({
+ rotation: {
+ degrees: 0
+ }
+ }, true);
+ textLabel._ubbox = textLabel.getBBox();
+ textLabel.setAttributes(me.label, true);
+ } else {
+ textLabel._ubbox = textLabel._bbox;
+ }
+ return textLabel;
+ },
+
+ rect2pointArray: function(sprite) {
+ var surface = this.chart.surface,
+ rect = surface.getBBox(sprite, true),
+ p1 = [rect.x, rect.y],
+ p1p = p1.slice(),
+ p2 = [rect.x + rect.width, rect.y],
+ p2p = p2.slice(),
+ p3 = [rect.x + rect.width, rect.y + rect.height],
+ p3p = p3.slice(),
+ p4 = [rect.x, rect.y + rect.height],
+ p4p = p4.slice(),
+ matrix = sprite.matrix;
+
+ p1[0] = matrix.x.apply(matrix, p1p);
+ p1[1] = matrix.y.apply(matrix, p1p);
+
+ p2[0] = matrix.x.apply(matrix, p2p);
+ p2[1] = matrix.y.apply(matrix, p2p);
+
+ p3[0] = matrix.x.apply(matrix, p3p);
+ p3[1] = matrix.y.apply(matrix, p3p);
+
+ p4[0] = matrix.x.apply(matrix, p4p);
+ p4[1] = matrix.y.apply(matrix, p4p);
+ return [p1, p2, p3, p4];
+ },
+
+ intersect: function(l1, l2) {
+ var r1 = this.rect2pointArray(l1),
+ r2 = this.rect2pointArray(l2);
+ return !!Ext.draw.Draw.intersect(r1, r2).length;
+ },
+
+ drawHorizontalLabels: function() {
+ var me = this,
+ labelConf = me.label,
+ floor = Math.floor,
+ max = Math.max,
+ axes = me.chart.axes,
+ position = me.position,
+ inflections = me.inflections,
+ ln = inflections.length,
+ labels = me.labels,
+ labelGroup = me.labelGroup,
+ maxHeight = 0,
+ ratio,
+ gutterY = me.chart.maxGutter[1],
+ ubbox, bbox, point, prevX, prevLabel,
+ projectedWidth = 0,
+ textLabel, attr, textRight, text,
+ label, last, x, y, i, firstLabel;
+
+ last = ln - 1;
+
+ point = inflections[0];
+ firstLabel = me.getOrCreateLabel(0, me.label.renderer(labels[0]));
+ ratio = Math.abs(Math.sin(labelConf.rotate && (labelConf.rotate.degrees * Math.PI / 180) || 0)) >> 0;
+
+ for (i = 0; i < ln; i++) {
+ point = inflections[i];
+ text = me.label.renderer(labels[i]);
+ textLabel = me.getOrCreateLabel(i, text);
+ bbox = textLabel._bbox;
+ maxHeight = max(maxHeight, bbox.height + me.dashSize + me.label.padding);
+ x = floor(point[0] - (ratio? bbox.height : bbox.width) / 2);
+ if (me.chart.maxGutter[0] == 0) {
+ if (i == 0 && axes.findIndex('position', 'left') == -1) {
+ x = point[0];
+ }
+ else if (i == last && axes.findIndex('position', 'right') == -1) {
+ x = point[0] - bbox.width;
+ }
+ }
+ if (position == 'top') {
+ y = point[1] - (me.dashSize * 2) - me.label.padding - (bbox.height / 2);
+ }
+ else {
+ y = point[1] + (me.dashSize * 2) + me.label.padding + (bbox.height / 2);
+ }
-
- this.removeAnchor();
- Ext.apply(anchor, {
- fn: action,
- scroll: scroll
- });
+ textLabel.setAttributes({
+ hidden: false,
+ x: x,
+ y: y
+ }, true);
- Ext.EventManager.onWindowResize(action, null);
-
- if(scroll){
- Ext.EventManager.on(window, 'scroll', action, null,
- {buffer: !isNaN(monitorScroll) ? monitorScroll : 50});
- }
- action.call(me);
- return me;
- },
-
-
- removeAnchor : function(){
- var me = this,
- anchor = this.getAnchor();
- if(anchor && anchor.fn){
- Ext.EventManager.removeResizeListener(anchor.fn);
- if(anchor.scroll){
- Ext.EventManager.un(window, 'scroll', anchor.fn);
+ if (i != 0 && (me.intersect(textLabel, prevLabel)
+ || me.intersect(textLabel, firstLabel))) {
+ textLabel.hide(true);
+ continue;
}
- delete anchor.fn;
+
+ prevLabel = textLabel;
}
- return me;
+
+ return maxHeight;
},
-
- getAnchor : function(){
- var data = Ext.Element.data,
- dom = this.dom;
- if (!dom) {
- return;
+ drawVerticalLabels: function() {
+ var me = this,
+ inflections = me.inflections,
+ position = me.position,
+ ln = inflections.length,
+ labels = me.labels,
+ maxWidth = 0,
+ max = Math.max,
+ floor = Math.floor,
+ ceil = Math.ceil,
+ axes = me.chart.axes,
+ gutterY = me.chart.maxGutter[1],
+ ubbox, bbox, point, prevLabel,
+ projectedWidth = 0,
+ textLabel, attr, textRight, text,
+ label, last, x, y, i;
+
+ last = ln;
+ for (i = 0; i < last; i++) {
+ point = inflections[i];
+ text = me.label.renderer(labels[i]);
+ textLabel = me.getOrCreateLabel(i, text);
+ bbox = textLabel._bbox;
+
+ maxWidth = max(maxWidth, bbox.width + me.dashSize + me.label.padding);
+ y = point[1];
+ if (gutterY < bbox.height / 2) {
+ if (i == last - 1 && axes.findIndex('position', 'top') == -1) {
+ y = me.y - me.length + ceil(bbox.height / 2);
+ }
+ else if (i == 0 && axes.findIndex('position', 'bottom') == -1) {
+ y = me.y - floor(bbox.height / 2);
+ }
}
- var anchor = data(dom, '_anchor');
-
- if(!anchor){
- anchor = data(dom, '_anchor', {});
+ if (position == 'left') {
+ x = point[0] - bbox.width - me.dashSize - me.label.padding - 2;
+ }
+ else {
+ x = point[0] + me.dashSize + me.label.padding + 2;
+ }
+ textLabel.setAttributes(Ext.apply({
+ hidden: false,
+ x: x,
+ y: y
+ }, me.label), true);
+
+ if (i != 0 && me.intersect(textLabel, prevLabel)) {
+ textLabel.hide(true);
+ continue;
+ }
+ prevLabel = textLabel;
}
- return anchor;
+
+ return maxWidth;
},
- getAlignToXY : function(el, p, o){
- el = Ext.get(el);
-
- if(!el || !el.dom){
- throw "Element.alignToXY with an element that doesn't exist";
- }
-
- o = o || [0,0];
- p = (!p || p == "?" ? "tl-bl?" : (!(/-/).test(p) && p !== "" ? "tl-" + p : p || "tl-bl")).toLowerCase();
-
- var me = this,
- d = me.dom,
- a1,
- a2,
- x,
- y,
-
- w,
- h,
- r,
- dw = Ext.lib.Dom.getViewWidth() -10,
- dh = Ext.lib.Dom.getViewHeight()-10,
- p1y,
- p1x,
- p2y,
- p2x,
- swapY,
- swapX,
- doc = document,
- docElement = doc.documentElement,
- docBody = doc.body,
- scrollX = (docElement.scrollLeft || docBody.scrollLeft || 0)+5,
- scrollY = (docElement.scrollTop || docBody.scrollTop || 0)+5,
- c = false,
- p1 = "",
- p2 = "",
- m = p.match(/^([a-z]+)-([a-z]+)(\?)?$/);
-
- if(!m){
- throw "Element.alignTo with an invalid alignment " + p;
+ drawLabel: function() {
+ var me = this,
+ position = me.position,
+ labelGroup = me.labelGroup,
+ inflections = me.inflections,
+ maxWidth = 0,
+ maxHeight = 0,
+ ln, i;
+
+ if (position == 'left' || position == 'right') {
+ maxWidth = me.drawVerticalLabels();
+ } else {
+ maxHeight = me.drawHorizontalLabels();
}
-
- p1 = m[1];
- p2 = m[2];
- c = !!m[3];
-
- a1 = me.getAnchorXY(p1, true);
- a2 = el.getAnchorXY(p2, false);
+ ln = labelGroup.getCount();
+ i = inflections.length;
+ for (; i < ln; i++) {
+ labelGroup.getAt(i).hide(true);
+ }
- x = a2[0] - a1[0] + o[0];
- y = a2[1] - a1[1] + o[1];
+ me.bbox = {};
+ Ext.apply(me.bbox, me.axisBBox);
+ me.bbox.height = maxHeight;
+ me.bbox.width = maxWidth;
+ if (Ext.isString(me.title)) {
+ me.drawTitle(maxWidth, maxHeight);
+ }
+ },
- if(c){
- w = me.getWidth();
- h = me.getHeight();
- r = el.getRegion();
-
-
-
- p1y = p1.charAt(0);
- p1x = p1.charAt(p1.length-1);
- p2y = p2.charAt(0);
- p2x = p2.charAt(p2.length-1);
- swapY = ((p1y=="t" && p2y=="b") || (p1y=="b" && p2y=="t"));
- swapX = ((p1x=="r" && p2x=="l") || (p1x=="l" && p2x=="r"));
-
+
+ elipsis: function(sprite, text, desiredWidth, minWidth, center) {
+ var bbox,
+ x;
- if (x + w > dw + scrollX) {
- x = swapX ? r.left-w : dw+scrollX-w;
- }
- if (x < scrollX) {
- x = swapX ? r.right : scrollX;
- }
- if (y + h > dh + scrollY) {
- y = swapY ? r.top-h : dh+scrollY-h;
+ if (desiredWidth < minWidth) {
+ sprite.hide(true);
+ return false;
+ }
+ while (text.length > 4) {
+ text = text.substr(0, text.length - 4) + "...";
+ sprite.setAttributes({
+ text: text
+ }, true);
+ bbox = sprite.getBBox();
+ if (bbox.width < desiredWidth) {
+ if (typeof center == 'number') {
+ sprite.setAttributes({
+ x: Math.floor(center - (bbox.width / 2))
+ }, true);
+ }
+ break;
}
- if (y < scrollY){
- y = swapY ? r.bottom : scrollY;
- }
}
- return [x,y];
+ return true;
},
- alignTo : function(element, position, offsets, animate){
- var me = this;
- return me.setXY(me.getAlignToXY(element, position, offsets),
- me.preanim && !!animate ? me.preanim(arguments, 3) : false);
- },
-
-
- adjustForConstraints : function(xy, parent, offsets){
- return this.getConstrainToXY(parent || document, false, offsets, xy) || xy;
+ setTitle: function(title) {
+ this.title = title;
+ this.drawLabel();
},
- getConstrainToXY : function(el, local, offsets, proposedXY){
- var os = {top:0, left:0, bottom:0, right: 0};
-
- return function(el, local, offsets, proposedXY){
- el = Ext.get(el);
- offsets = offsets ? Ext.applyIf(offsets, os) : os;
+ drawTitle: function(maxWidth, maxHeight) {
+ var me = this,
+ position = me.position,
+ surface = me.chart.surface,
+ displaySprite = me.displaySprite,
+ title = me.title,
+ rotate = (position == 'left' || position == 'right'),
+ x = me.x,
+ y = me.y,
+ base, bbox, pad;
+
+ if (displaySprite) {
+ displaySprite.setAttributes({text: title}, true);
+ } else {
+ base = {
+ type: 'text',
+ x: 0,
+ y: 0,
+ text: title
+ };
+ displaySprite = me.displaySprite = surface.add(Ext.apply(base, me.axisTitleStyle, me.labelTitle));
+ surface.renderItem(displaySprite);
+ }
+ bbox = displaySprite.getBBox();
+ pad = me.dashSize + me.label.padding;
- var vw, vh, vx = 0, vy = 0;
- if(el.dom == document.body || el.dom == document){
- vw =Ext.lib.Dom.getViewWidth();
- vh = Ext.lib.Dom.getViewHeight();
- }else{
- vw = el.dom.clientWidth;
- vh = el.dom.clientHeight;
- if(!local){
- var vxy = el.getXY();
- vx = vxy[0];
- vy = vxy[1];
- }
+ if (rotate) {
+ y -= ((me.length / 2) - (bbox.height / 2));
+ if (position == 'left') {
+ x -= (maxWidth + pad + (bbox.width / 2));
}
-
- var s = el.getScroll();
-
- vx += offsets.left + s.left;
- vy += offsets.top + s.top;
-
- vw -= offsets.right;
- vh -= offsets.bottom;
-
- var vr = vx + vw,
- vb = vy + vh,
- xy = proposedXY || (!local ? this.getXY() : [this.getLeft(true), this.getTop(true)]),
- x = xy[0], y = xy[1],
- offset = this.getConstrainOffset(),
- w = this.dom.offsetWidth + offset,
- h = this.dom.offsetHeight + offset;
-
-
- var moved = false;
-
-
- if((x + w) > vr){
- x = vr - w;
- moved = true;
+ else {
+ x += (maxWidth + pad + bbox.width - (bbox.width / 2));
}
- if((y + h) > vb){
- y = vb - h;
- moved = true;
+ me.bbox.width += bbox.width + 10;
+ }
+ else {
+ x += (me.length / 2) - (bbox.width * 0.5);
+ if (position == 'top') {
+ y -= (maxHeight + pad + (bbox.height * 0.3));
}
-
- if(x < vx){
- x = vx;
- moved = true;
+ else {
+ y += (maxHeight + pad + (bbox.height * 0.8));
}
- if(y < vy){
- y = vy;
- moved = true;
+ me.bbox.height += bbox.height + 10;
+ }
+ displaySprite.setAttributes({
+ translate: {
+ x: x,
+ y: y
}
- return moved ? [x, y] : false;
- };
- }(),
-
-
-
+ }, true);
+ }
+});
+Ext.define('Ext.chart.axis.Category', {
+
+ extend: 'Ext.chart.axis.Axis',
+ alternateClassName: 'Ext.chart.CategoryAxis',
+ alias: 'axis.category',
+
+
+ categoryNames: null,
+
+ calculateCategoryCount: false,
+
+ setLabels: function() {
+ var store = this.chart.store,
+ fields = this.fields,
+ ln = fields.length,
+ i;
+ this.labels = [];
+ store.each(function(record) {
+ for (i = 0; i < ln; i++) {
+ this.labels.push(record.get(fields[i]));
+ }
+ }, this);
+ },
+
+ applyData: function() {
+ this.callParent();
+ this.setLabels();
+ var count = this.chart.store.getCount();
+ return {
+ from: 0,
+ to: count,
+ power: 1,
+ step: 1,
+ steps: count - 1
+ };
+ }
+});
+Ext.define('Ext.chart.axis.Gauge', {
+
+ extend: 'Ext.chart.axis.Abstract',
+
+
+
+
+
+
+ position: 'gauge',
+ alias: 'axis.gauge',
+ drawAxis: function(init) {
+ var chart = this.chart,
+ surface = chart.surface,
+ bbox = chart.chartBBox,
+ centerX = bbox.x + (bbox.width / 2),
+ centerY = bbox.y + bbox.height,
+ margin = this.margin || 10,
+ rho = Math.min(bbox.width, 2 * bbox.height) /2 + margin,
+ sprites = [], sprite,
+ steps = this.steps,
+ i, pi = Math.PI,
+ cos = Math.cos,
+ sin = Math.sin;
+ if (this.sprites && !chart.resizing) {
+ this.drawLabel();
+ return;
+ }
+ if (this.margin >= 0) {
+ if (!this.sprites) {
+
+ for (i = 0; i <= steps; i++) {
+ sprite = surface.add({
+ type: 'path',
+ path: ['M', centerX + (rho - margin) * cos(i / steps * pi - pi),
+ centerY + (rho - margin) * sin(i / steps * pi - pi),
+ 'L', centerX + rho * cos(i / steps * pi - pi),
+ centerY + rho * sin(i / steps * pi - pi), 'Z'],
+ stroke: '#ccc'
+ });
+ sprite.setAttributes({
+ hidden: false
+ }, true);
+ sprites.push(sprite);
+ }
+ } else {
+ sprites = this.sprites;
+
+ for (i = 0; i <= steps; i++) {
+ sprites[i].setAttributes({
+ path: ['M', centerX + (rho - margin) * cos(i / steps * pi - pi),
+ centerY + (rho - margin) * sin(i / steps * pi - pi),
+ 'L', centerX + rho * cos(i / steps * pi - pi),
+ centerY + rho * sin(i / steps * pi - pi), 'Z'],
+ stroke: '#ccc'
+ }, true);
+ }
+ }
+ }
+ this.sprites = sprites;
+ this.drawLabel();
+ if (this.title) {
+ this.drawTitle();
+ }
+ },
+
+ drawTitle: function() {
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ bbox = chart.chartBBox,
+ labelSprite = me.titleSprite,
+ labelBBox;
+
+ if (!labelSprite) {
+ me.titleSprite = labelSprite = surface.add({
+ type: 'text',
+ zIndex: 2
+ });
+ }
+ labelSprite.setAttributes(Ext.apply({
+ text: me.title
+ }, me.label || {}), true);
+ labelBBox = labelSprite.getBBox();
+ labelSprite.setAttributes({
+ x: bbox.x + (bbox.width / 2) - (labelBBox.width / 2),
+ y: bbox.y + bbox.height - (labelBBox.height / 2) - 4
+ }, true);
+ },
+
+ setTitle: function(title) {
+ this.title = title;
+ this.drawTitle();
+ },
+
+ drawLabel: function() {
+ var chart = this.chart,
+ surface = chart.surface,
+ bbox = chart.chartBBox,
+ centerX = bbox.x + (bbox.width / 2),
+ centerY = bbox.y + bbox.height,
+ margin = this.margin || 10,
+ rho = Math.min(bbox.width, 2 * bbox.height) /2 + 2 * margin,
+ round = Math.round,
+ labelArray = [], label,
+ maxValue = this.maximum || 0,
+ steps = this.steps, i = 0,
+ adjY,
+ pi = Math.PI,
+ cos = Math.cos,
+ sin = Math.sin,
+ labelConf = this.label,
+ renderer = labelConf.renderer || function(v) { return v; };
+
+ if (!this.labelArray) {
+
+ for (i = 0; i <= steps; i++) {
+
+ adjY = (i === 0 || i === steps) ? 7 : 0;
+ label = surface.add({
+ type: 'text',
+ text: renderer(round(i / steps * maxValue)),
+ x: centerX + rho * cos(i / steps * pi - pi),
+ y: centerY + rho * sin(i / steps * pi - pi) - adjY,
+ 'text-anchor': 'middle',
+ 'stroke-width': 0.2,
+ zIndex: 10,
+ stroke: '#333'
+ });
+ label.setAttributes({
+ hidden: false
+ }, true);
+ labelArray.push(label);
+ }
+ }
+ else {
+ labelArray = this.labelArray;
+
+ for (i = 0; i <= steps; i++) {
+
+ adjY = (i === 0 || i === steps) ? 7 : 0;
+ labelArray[i].setAttributes({
+ text: renderer(round(i / steps * maxValue)),
+ x: centerX + rho * cos(i / steps * pi - pi),
+ y: centerY + rho * sin(i / steps * pi - pi) - adjY
+ }, true);
+ }
+ }
+ this.labelArray = labelArray;
+ }
+});
+Ext.define('Ext.chart.axis.Numeric', {
+
+ extend: 'Ext.chart.axis.Axis',
+ alternateClassName: 'Ext.chart.NumericAxis',
+
+ type: 'numeric',
+ alias: 'axis.numeric',
+ constructor: function(config) {
+ var me = this, label, f;
+ me.callParent([config]);
+ label = me.label;
+ if (me.roundToDecimal === false) {
+ return;
+ }
+ if (label.renderer) {
+ f = label.renderer;
+ label.renderer = function(v) {
+ return me.roundToDecimal( f(v), me.decimals );
+ };
+ } else {
+ label.renderer = function(v) {
+ return me.roundToDecimal(v, me.decimals);
+ };
+ }
+ },
+
+ roundToDecimal: function(v, dec) {
+ var val = Math.pow(10, dec || 0);
+ return ((v * val) >> 0) / val;
+ },
+
+
+ minimum: NaN,
+
+ maximum: NaN,
+
+ decimals: 2,
+
+ scale: "linear",
+
+ position: 'left',
+
+ adjustMaximumByMajorUnit: false,
+
+ adjustMinimumByMajorUnit: false,
+
+ applyData: function() {
+ this.callParent();
+ return this.calcEnds();
+ }
+});
+Ext.define('Ext.chart.axis.Radial', {
+
+ extend: 'Ext.chart.axis.Abstract',
+
+ position: 'radial',
+ alias: 'axis.radial',
+ drawAxis: function(init) {
+ var chart = this.chart,
+ surface = chart.surface,
+ bbox = chart.chartBBox,
+ store = chart.store,
+ l = store.getCount(),
+ centerX = bbox.x + (bbox.width / 2),
+ centerY = bbox.y + (bbox.height / 2),
+ rho = Math.min(bbox.width, bbox.height) /2,
+ sprites = [], sprite,
+ steps = this.steps,
+ i, j, pi2 = Math.PI * 2,
+ cos = Math.cos, sin = Math.sin;
+ if (this.sprites && !chart.resizing) {
+ this.drawLabel();
+ return;
+ }
+ if (!this.sprites) {
+
+ for (i = 1; i <= steps; i++) {
+ sprite = surface.add({
+ type: 'circle',
+ x: centerX,
+ y: centerY,
+ radius: Math.max(rho * i / steps, 0),
+ stroke: '#ccc'
+ });
+ sprite.setAttributes({
+ hidden: false
+ }, true);
+ sprites.push(sprite);
+ }
+
+ store.each(function(rec, i) {
+ sprite = surface.add({
+ type: 'path',
+ path: ['M', centerX, centerY, 'L', centerX + rho * cos(i / l * pi2), centerY + rho * sin(i / l * pi2), 'Z'],
+ stroke: '#ccc'
+ });
+ sprite.setAttributes({
+ hidden: false
+ }, true);
+ sprites.push(sprite);
+ });
+ } else {
+ sprites = this.sprites;
+
+ for (i = 0; i < steps; i++) {
+ sprites[i].setAttributes({
+ x: centerX,
+ y: centerY,
+ radius: Math.max(rho * (i + 1) / steps, 0),
+ stroke: '#ccc'
+ }, true);
+ }
+
+ store.each(function(rec, j) {
+ sprites[i + j].setAttributes({
+ path: ['M', centerX, centerY, 'L', centerX + rho * cos(j / l * pi2), centerY + rho * sin(j / l * pi2), 'Z'],
+ stroke: '#ccc'
+ }, true);
+ });
+ }
+ this.sprites = sprites;
+
+ this.drawLabel();
+ },
+
+ drawLabel: function() {
+ var chart = this.chart,
+ surface = chart.surface,
+ bbox = chart.chartBBox,
+ store = chart.store,
+ centerX = bbox.x + (bbox.width / 2),
+ centerY = bbox.y + (bbox.height / 2),
+ rho = Math.min(bbox.width, bbox.height) /2,
+ max = Math.max, round = Math.round,
+ labelArray = [], label,
+ fields = [], nfields,
+ categories = [], xField,
+ aggregate = !this.maximum,
+ maxValue = this.maximum || 0,
+ steps = this.steps, i = 0, j, dx, dy,
+ pi2 = Math.PI * 2,
+ cos = Math.cos, sin = Math.sin,
+ display = this.label.display,
+ draw = display !== 'none',
+ margin = 10;
+
+ if (!draw) {
+ return;
+ }
+
+ chart.series.each(function(series) {
+ fields.push(series.yField);
+ xField = series.xField;
+ });
+
+
+ store.each(function(record, i) {
+ if (aggregate) {
+ for (i = 0, nfields = fields.length; i < nfields; i++) {
+ maxValue = max(+record.get(fields[i]), maxValue);
+ }
+ }
+ categories.push(record.get(xField));
+ });
+ if (!this.labelArray) {
+ if (display != 'categories') {
+
+ for (i = 1; i <= steps; i++) {
+ label = surface.add({
+ type: 'text',
+ text: round(i / steps * maxValue),
+ x: centerX,
+ y: centerY - rho * i / steps,
+ 'text-anchor': 'middle',
+ 'stroke-width': 0.1,
+ stroke: '#333'
+ });
+ label.setAttributes({
+ hidden: false
+ }, true);
+ labelArray.push(label);
+ }
+ }
+ if (display != 'scale') {
+
+ for (j = 0, steps = categories.length; j < steps; j++) {
+ dx = cos(j / steps * pi2) * (rho + margin);
+ dy = sin(j / steps * pi2) * (rho + margin);
+ label = surface.add({
+ type: 'text',
+ text: categories[j],
+ x: centerX + dx,
+ y: centerY + dy,
+ 'text-anchor': dx * dx <= 0.001? 'middle' : (dx < 0? 'end' : 'start')
+ });
+ label.setAttributes({
+ hidden: false
+ }, true);
+ labelArray.push(label);
+ }
+ }
+ }
+ else {
+ labelArray = this.labelArray;
+ if (display != 'categories') {
+
+ for (i = 0; i < steps; i++) {
+ labelArray[i].setAttributes({
+ text: round((i + 1) / steps * maxValue),
+ x: centerX,
+ y: centerY - rho * (i + 1) / steps,
+ 'text-anchor': 'middle',
+ 'stroke-width': 0.1,
+ stroke: '#333'
+ }, true);
+ }
+ }
+ if (display != 'scale') {
+
+ for (j = 0, steps = categories.length; j < steps; j++) {
+ dx = cos(j / steps * pi2) * (rho + margin);
+ dy = sin(j / steps * pi2) * (rho + margin);
+ if (labelArray[i + j]) {
+ labelArray[i + j].setAttributes({
+ type: 'text',
+ text: categories[j],
+ x: centerX + dx,
+ y: centerY + dy,
+ 'text-anchor': dx * dx <= 0.001? 'middle' : (dx < 0? 'end' : 'start')
+ }, true);
+ }
+ }
+ }
+ }
+ this.labelArray = labelArray;
+ }
+});
+Ext.define('Ext.data.AbstractStore', {
+ requires: ['Ext.util.MixedCollection', 'Ext.data.Operation', 'Ext.util.Filter'],
- getConstrainOffset : function(){
- return 0;
+ mixins: {
+ observable: 'Ext.util.Observable',
+ sortable: 'Ext.util.Sortable'
},
-
- getCenterXY : function(){
- return this.getAlignToXY(document, 'c-c');
+ statics: {
+ create: function(store){
+ if (!store.isStore) {
+ if (!store.type) {
+ store.type = 'store';
+ }
+ store = Ext.createByAlias('store.' + store.type, store);
+ }
+ return store;
+ }
},
+
+ remoteSort : false,
+ remoteFilter: false,
- center : function(centerIn){
- return this.alignTo(centerIn || document, 'c-c');
- }
-});
-Ext.Element.addMethods({
- select : function(selector, unique){
- return Ext.Element.select(selector, unique, this.dom);
- }
-});
-Ext.apply(Ext.Element.prototype, function() {
- var GETDOM = Ext.getDom,
- GET = Ext.get,
- DH = Ext.DomHelper;
-
- return {
-
- insertSibling: function(el, where, returnDom){
- var me = this,
- rt,
- isAfter = (where || 'before').toLowerCase() == 'after',
- insertEl;
-
- if(Ext.isArray(el)){
- insertEl = me;
- Ext.each(el, function(e) {
- rt = Ext.fly(insertEl, '_internal').insertSibling(e, where, returnDom);
- if(isAfter){
- insertEl = rt;
- }
- });
- return rt;
- }
-
- el = el || {};
-
- if(el.nodeType || el.dom){
- rt = me.dom.parentNode.insertBefore(GETDOM(el), isAfter ? me.dom.nextSibling : me.dom);
- if (!returnDom) {
- rt = GET(rt);
- }
- }else{
- if (isAfter && !me.dom.nextSibling) {
- rt = DH.append(me.dom.parentNode, el, !returnDom);
- } else {
- rt = DH[isAfter ? 'insertAfter' : 'insertBefore'](me.dom, el, !returnDom);
- }
- }
- return rt;
- }
- };
-}());
+ autoLoad: false,
+
+ autoSync: false,
-Ext.Element.boxMarkup = '';
+
+ batchUpdateMode: 'operation',
-Ext.Element.addMethods(function(){
- var INTERNAL = "_internal",
- pxMatch = /(\d+\.?\d+)px/;
- return {
-
- applyStyles : function(style){
- Ext.DomHelper.applyStyles(this.dom, style);
- return this;
- },
+
+ filterOnLoad: true,
-
- getStyles : function(){
- var ret = {};
- Ext.each(arguments, function(v) {
- ret[v] = this.getStyle(v);
- },
- this);
- return ret;
- },
+
+ sortOnLoad: true,
-
- setOverflow : function(v){
- var dom = this.dom;
- if(v=='auto' && Ext.isMac && Ext.isGecko2){
- dom.style.overflow = 'hidden';
- (function(){dom.style.overflow = 'auto';}).defer(1);
- }else{
- dom.style.overflow = v;
- }
- },
+
+ implicitModel: false,
-
- boxWrap : function(cls){
- cls = cls || 'x-box';
- var el = Ext.get(this.insertHtml("beforeBegin", ")((\n|\r|.)*?)(?:<\/script>)/ig,
- nl2brRe = /\r?\n/g;
- return {
-
- ellipsis : function(value, len, word) {
- if (value && value.length > len) {
- if (word) {
- var vs = value.substr(0, len - 2),
- index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
- if (index == -1 || index < (len - 15)) {
- return value.substr(0, len - 3) + "...";
- } else {
- return vs.substr(0, index) + "...";
- }
- } else {
- return value.substr(0, len - 3) + "...";
- }
- }
- return value;
- },
-
- undef : function(value) {
- return value !== undefined ? value : "";
- },
+Ext.define('Ext.chart.series.Cartesian', {
-
- defaultValue : function(value, defaultValue) {
- return value !== undefined && value !== '' ? value : defaultValue;
- },
+
-
- htmlEncode : function(value) {
- return !value ? value : String(value).replace(/&/g, "&").replace(/>/g, ">").replace(/").replace(/</g, "<").replace(/"/g, '"').replace(/&/g, "&");
- },
+ alternateClassName: ['Ext.chart.CartesianSeries', 'Ext.chart.CartesianChart'],
-
- trim : function(value) {
- return String(value).replace(trimRe, "");
- },
+
-
- substr : function(value, start, length) {
- return String(value).substr(start, length);
- },
+
+ xField: null,
-
- lowercase : function(value) {
- return String(value).toLowerCase();
- },
+
+ yField: null,
-
- uppercase : function(value) {
- return String(value).toUpperCase();
- },
+
+ axis: 'left'
+});
-
- capitalize : function(value) {
- return !value ? value : value.charAt(0).toUpperCase() + value.substr(1).toLowerCase();
- },
-
- call : function(value, fn) {
- if (arguments.length > 2) {
- var args = Array.prototype.slice.call(arguments, 2);
- args.unshift(value);
- return eval(fn).apply(window, args);
- } else {
- return eval(fn).call(window, value);
- }
- },
+Ext.define('Ext.chart.series.Area', {
-
- usMoney : function(v) {
- v = (Math.round((v-0)*100))/100;
- v = (v == Math.floor(v)) ? v + ".00" : ((v*10 == Math.floor(v*10)) ? v + "0" : v);
- v = String(v);
- var ps = v.split('.'),
- whole = ps[0],
- sub = ps[1] ? '.'+ ps[1] : '.00',
- r = /(\d+)(\d{3})/;
- while (r.test(whole)) {
- whole = whole.replace(r, '$1' + ',' + '$2');
- }
- v = whole + sub;
- if (v.charAt(0) == '-') {
- return '-$' + v.substr(1);
- }
- return "$" + v;
- },
+
-
- date : function(v, format) {
- if (!v) {
- return "";
- }
- if (!Ext.isDate(v)) {
- v = new Date(Date.parse(v));
- }
- return v.dateFormat(format || "m/d/Y");
- },
+ extend: 'Ext.chart.series.Cartesian',
+
+ alias: 'series.area',
-
- dateRenderer : function(format) {
- return function(v) {
- return Ext.util.Format.date(v, format);
- };
- },
+ requires: ['Ext.chart.axis.Axis', 'Ext.draw.Color', 'Ext.fx.Anim'],
-
- stripTags : function(v) {
- return !v ? v : String(v).replace(stripTagsRE, "");
- },
+
-
- stripScripts : function(v) {
- return !v ? v : String(v).replace(stripScriptsRe, "");
- },
+ type: 'area',
-
- fileSize : function(size) {
- if (size < 1024) {
- return size + " bytes";
- } else if (size < 1048576) {
- return (Math.round(((size*10) / 1024))/10) + " KB";
- } else {
- return (Math.round(((size*10) / 1048576))/10) + " MB";
- }
- },
+
+ stacked: true,
-
- math : function(){
- var fns = {};
-
- return function(v, a){
- if (!fns[a]) {
- fns[a] = new Function('v', 'return v ' + a + ';');
- }
- return fns[a](v);
- };
- }(),
+
+ style: {},
-
- round : function(value, precision) {
- var result = Number(value);
- if (typeof precision == 'number') {
- precision = Math.pow(10, precision);
- result = Math.round(value * precision) / precision;
+ constructor: function(config) {
+ this.callParent(arguments);
+ var me = this,
+ surface = me.chart.surface,
+ i, l;
+ Ext.apply(me, config, {
+ __excludes: [],
+ highlightCfg: {
+ lineWidth: 3,
+ stroke: '#55c',
+ opacity: 0.8,
+ color: '#f00'
}
- return result;
- },
+ });
+ if (me.highlight) {
+ me.highlightSprite = surface.add({
+ type: 'path',
+ path: ['M', 0, 0],
+ zIndex: 1000,
+ opacity: 0.3,
+ lineWidth: 5,
+ hidden: true,
+ stroke: '#444'
+ });
+ }
+ me.group = surface.getGroup(me.seriesId);
+ },
+
+ shrink: function(xValues, yValues, size) {
+ var len = xValues.length,
+ ratio = Math.floor(len / size),
+ i, j,
+ xSum = 0,
+ yCompLen = this.areas.length,
+ ySum = [],
+ xRes = [],
+ yRes = [];
- number: function(v, format) {
- if (!format) {
- return v;
+ for (j = 0; j < yCompLen; ++j) {
+ ySum[j] = 0;
+ }
+ for (i = 0; i < len; ++i) {
+ xSum += xValues[i];
+ for (j = 0; j < yCompLen; ++j) {
+ ySum[j] += yValues[i][j];
}
- v = Ext.num(v, NaN);
- if (isNaN(v)) {
- return '';
+ if (i % ratio == 0) {
+
+ xRes.push(xSum/ratio);
+ for (j = 0; j < yCompLen; ++j) {
+ ySum[j] /= ratio;
+ }
+ yRes.push(ySum);
+
+ xSum = 0;
+ for (j = 0, ySum = []; j < yCompLen; ++j) {
+ ySum[j] = 0;
+ }
}
- var comma = ',',
- dec = '.',
- i18n = false,
- neg = v < 0;
+ }
+ return {
+ x: xRes,
+ y: yRes
+ };
+ },
- v = Math.abs(v);
- if (format.substr(format.length - 2) == '/i') {
- format = format.substr(0, format.length - 2);
- i18n = true;
- comma = '.';
- dec = ',';
- }
+
+ getBounds: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ areas = [].concat(me.yField),
+ areasLen = areas.length,
+ xValues = [],
+ yValues = [],
+ infinity = Infinity,
+ minX = infinity,
+ minY = infinity,
+ maxX = -infinity,
+ maxY = -infinity,
+ math = Math,
+ mmin = math.min,
+ mmax = math.max,
+ bbox, xScale, yScale, xValue, yValue, areaIndex, acumY, ln, sumValues, clipBox, areaElem;
+
+ me.setBBox();
+ bbox = me.bbox;
+
+
+ if (me.axis) {
+ axis = chart.axes.get(me.axis);
+ if (axis) {
+ out = axis.calcEnds();
+ minY = out.from || axis.prevMin;
+ maxY = mmax(out.to || axis.prevMax, 0);
+ }
+ }
+
+ if (me.yField && !Ext.isNumber(minY)) {
+ axis = Ext.create('Ext.chart.axis.Axis', {
+ chart: chart,
+ fields: [].concat(me.yField)
+ });
+ out = axis.calcEnds();
+ minY = out.from || axis.prevMin;
+ maxY = mmax(out.to || axis.prevMax, 0);
+ }
- var hasComma = format.indexOf(comma) != -1,
- psplit = (i18n ? format.replace(/[^\d\,]/g, '') : format.replace(/[^\d\.]/g, '')).split(dec);
+ if (!Ext.isNumber(minY)) {
+ minY = 0;
+ }
+ if (!Ext.isNumber(maxY)) {
+ maxY = 0;
+ }
- if (1 < psplit.length) {
- v = v.toFixed(psplit[1].length);
- } else if(2 < psplit.length) {
- throw ('NumberFormatException: invalid format, formats should have no more than 1 period: ' + format);
- } else {
- v = v.toFixed(0);
+ store.each(function(record, i) {
+ xValue = record.get(me.xField);
+ yValue = [];
+ if (typeof xValue != 'number') {
+ xValue = i;
+ }
+ xValues.push(xValue);
+ acumY = 0;
+ for (areaIndex = 0; areaIndex < areasLen; areaIndex++) {
+ areaElem = record.get(areas[areaIndex]);
+ if (typeof areaElem == 'number') {
+ minY = mmin(minY, areaElem);
+ yValue.push(areaElem);
+ acumY += areaElem;
+ }
}
+ minX = mmin(minX, xValue);
+ maxX = mmax(maxX, xValue);
+ maxY = mmax(maxY, acumY);
+ yValues.push(yValue);
+ }, me);
- var fnum = v.toString();
+ xScale = bbox.width / (maxX - minX);
+ yScale = bbox.height / (maxY - minY);
- psplit = fnum.split('.');
+ ln = xValues.length;
+ if ((ln > bbox.width) && me.areas) {
+ sumValues = me.shrink(xValues, yValues, bbox.width);
+ xValues = sumValues.x;
+ yValues = sumValues.y;
+ }
- if (hasComma) {
- var cnum = psplit[0],
- parr = [],
- j = cnum.length,
- m = Math.floor(j / 3),
- n = cnum.length % 3 || 3,
- i;
+ return {
+ bbox: bbox,
+ minX: minX,
+ minY: minY,
+ xValues: xValues,
+ yValues: yValues,
+ xScale: xScale,
+ yScale: yScale,
+ areasLen: areasLen
+ };
+ },
- for (i = 0; i < j; i += n) {
- if (i != 0) {
- n = 3;
- }
-
- parr[parr.length] = cnum.substr(i, n);
- m -= 1;
+
+ getPaths: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ first = true,
+ bounds = me.getBounds(),
+ bbox = bounds.bbox,
+ items = me.items = [],
+ componentPaths = [],
+ componentPath,
+ paths = [],
+ i, ln, x, y, xValue, yValue, acumY, areaIndex, prevAreaIndex, areaElem, path;
+
+ ln = bounds.xValues.length;
+
+ for (i = 0; i < ln; i++) {
+ xValue = bounds.xValues[i];
+ yValue = bounds.yValues[i];
+ x = bbox.x + (xValue - bounds.minX) * bounds.xScale;
+ acumY = 0;
+ for (areaIndex = 0; areaIndex < bounds.areasLen; areaIndex++) {
+
+ if (me.__excludes[areaIndex]) {
+ continue;
}
- fnum = parr.join(comma);
- if (psplit[1]) {
- fnum += dec + psplit[1];
+ if (!componentPaths[areaIndex]) {
+ componentPaths[areaIndex] = [];
}
- } else {
- if (psplit[1]) {
- fnum = psplit[0] + dec + psplit[1];
+ areaElem = yValue[areaIndex];
+ acumY += areaElem;
+ y = bbox.y + bbox.height - (acumY - bounds.minY) * bounds.yScale;
+ if (!paths[areaIndex]) {
+ paths[areaIndex] = ['M', x, y];
+ componentPaths[areaIndex].push(['L', x, y]);
+ } else {
+ paths[areaIndex].push('L', x, y);
+ componentPaths[areaIndex].push(['L', x, y]);
+ }
+ if (!items[areaIndex]) {
+ items[areaIndex] = {
+ pointsUp: [],
+ pointsDown: [],
+ series: me
+ };
}
+ items[areaIndex].pointsUp.push([x, y]);
}
-
- return (neg ? '-' : '') + format.replace(/[\d,?\.?]+/, fnum);
- },
-
-
- numberRenderer : function(format) {
- return function(v) {
- return Ext.util.Format.number(v, format);
- };
- },
-
+ }
- plural : function(v, s, p) {
- return v +' ' + (v == 1 ? s : (p ? p : s+'s'));
- },
-
- nl2br : function(v) {
- return Ext.isEmpty(v) ? '' : v.replace(nl2brRe, '
'); + for (areaIndex = 0; areaIndex < bounds.areasLen; areaIndex++) { + + if (me.__excludes[areaIndex]) { + continue; + } + path = paths[areaIndex]; + + if (areaIndex == 0 || first) { + first = false; + path.push('L', x, bbox.y + bbox.height, + 'L', bbox.x, bbox.y + bbox.height, + 'Z'); + } + + else { + componentPath = componentPaths[prevAreaIndex]; + componentPath.reverse(); + path.push('L', x, componentPath[0][2]); + for (i = 0; i < ln; i++) { + path.push(componentPath[i][0], + componentPath[i][1], + componentPath[i][2]); + items[areaIndex].pointsDown[ln -i -1] = [componentPath[i][1], componentPath[i][2]]; + } + path.push('L', bbox.x, path[2], 'Z'); + } + prevAreaIndex = areaIndex; } - }; -}(); - -Ext.XTemplate = function(){ - Ext.XTemplate.superclass.constructor.apply(this, arguments); - - var me = this, - s = me.html, - re = /]*>((?:(?=([^<]+))\2|<(?!tpl\b[^>]*>))*?)<\/tpl>/,
- nameRe = /^]*?for="(.*?)"/,
- ifRe = /^]*?if="(.*?)"/,
- execRe = /^]*?exec="(.*?)"/,
- m,
- id = 0,
- tpls = [],
- VALUES = 'values',
- PARENT = 'parent',
- XINDEX = 'xindex',
- XCOUNT = 'xcount',
- RETURN = 'return ',
- WITHVALUES = 'with(values){ ';
-
- s = ['', s, ' '].join('');
-
- while((m = s.match(re))){
- var m2 = m[0].match(nameRe),
- m3 = m[0].match(ifRe),
- m4 = m[0].match(execRe),
- exp = null,
- fn = null,
- exec = null,
- name = m2 && m2[1] ? m2[1] : '';
-
- if (m3) {
- exp = m3 && m3[1] ? m3[1] : null;
- if(exp){
- fn = new Function(VALUES, PARENT, XINDEX, XCOUNT, WITHVALUES + RETURN +(Ext.util.Format.htmlDecode(exp))+'; }');
- }
- }
- if (m4) {
- exp = m4 && m4[1] ? m4[1] : null;
- if(exp){
- exec = new Function(VALUES, PARENT, XINDEX, XCOUNT, WITHVALUES +(Ext.util.Format.htmlDecode(exp))+'; }');
- }
- }
- if(name){
- switch(name){
- case '.': name = new Function(VALUES, PARENT, WITHVALUES + RETURN + VALUES + '; }'); break;
- case '..': name = new Function(VALUES, PARENT, WITHVALUES + RETURN + PARENT + '; }'); break;
- default: name = new Function(VALUES, PARENT, WITHVALUES + RETURN + name + '; }');
- }
- }
- tpls.push({
- id: id,
- target: name,
- exec: exec,
- test: fn,
- body: m[1]||''
- });
- s = s.replace(m[0], '{xtpl'+ id + '}');
- ++id;
- }
- for(var i = tpls.length-1; i >= 0; --i){
- me.compileTpl(tpls[i]);
- }
- me.master = tpls[tpls.length-1];
- me.tpls = tpls;
-};
-Ext.extend(Ext.XTemplate, Ext.Template, {
-
- re : /\{([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\\]\s?[\d\.\+\-\*\\\(\)]+)?\}/g,
-
- codeRe : /\{\[((?:\\\]|.|\n)*?)\]\}/g,
+ return {
+ paths: paths,
+ areasLen: bounds.areasLen
+ };
+ },
- applySubTemplate : function(id, values, parent, xindex, xcount){
+ drawSeries: function() {
var me = this,
- len,
- t = me.tpls[id],
- vs,
- buf = [];
- if ((t.test && !t.test.call(me, values, parent, xindex, xcount)) ||
- (t.exec && t.exec.call(me, values, parent, xindex, xcount))) {
- return '';
- }
- vs = t.target ? t.target.call(me, values, parent) : values;
- len = vs.length;
- parent = t.target ? values : parent;
- if(t.target && Ext.isArray(vs)){
- for(var i = 0, len = vs.length; i < len; i++){
- buf[buf.length] = t.compiled.call(me, vs[i], parent, i+1, len);
- }
- return buf.join('');
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ surface = chart.surface,
+ animate = chart.animate,
+ group = me.group,
+ endLineStyle = Ext.apply(me.seriesStyle, me.style),
+ colorArrayStyle = me.colorArrayStyle,
+ colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+ areaIndex, areaElem, paths, path, rendererAttributes;
+
+ me.unHighlightItem();
+ me.cleanHighlights();
+
+ if (!store || !store.getCount()) {
+ return;
}
- return t.compiled.call(me, vs, parent, xindex, xcount);
- },
+
+ paths = me.getPaths();
-
- compileTpl : function(tpl){
- var fm = Ext.util.Format,
- useF = this.disableFormats !== true,
- sep = Ext.isGecko ? "+" : ",",
- body;
+ if (!me.areas) {
+ me.areas = [];
+ }
- function fn(m, name, format, args, math){
- if(name.substr(0, 4) == 'xtpl'){
- return "'"+ sep +'this.applySubTemplate('+name.substr(4)+', values, parent, xindex, xcount)'+sep+"'";
- }
- var v;
- if(name === '.'){
- v = 'values';
- }else if(name === '#'){
- v = 'xindex';
- }else if(name.indexOf('.') != -1){
- v = name;
- }else{
- v = "values['" + name + "']";
+ for (areaIndex = 0; areaIndex < paths.areasLen; areaIndex++) {
+
+ if (me.__excludes[areaIndex]) {
+ continue;
}
- if(math){
- v = '(' + v + math + ')';
+ if (!me.areas[areaIndex]) {
+ me.items[areaIndex].sprite = me.areas[areaIndex] = surface.add(Ext.apply({}, {
+ type: 'path',
+ group: group,
+
+ path: paths.paths[areaIndex],
+ stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength],
+ fill: colorArrayStyle[areaIndex % colorArrayLength]
+ }, endLineStyle || {}));
}
- if (format && useF) {
- args = args ? ',' + args : "";
- if(format.substr(0, 5) != "this."){
- format = "fm." + format + '(';
- }else{
- format = 'this.call("'+ format.substr(5) + '", ';
- args = ", values";
- }
+ areaElem = me.areas[areaIndex];
+ path = paths.paths[areaIndex];
+ if (animate) {
+
+ rendererAttributes = me.renderer(areaElem, false, {
+ path: path,
+
+ fill: colorArrayStyle[areaIndex % colorArrayLength],
+ stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength]
+ }, areaIndex, store);
+
+ me.animation = me.onAnimate(areaElem, {
+ to: rendererAttributes
+ });
} else {
- args= ''; format = "("+v+" === undefined ? '' : ";
+ rendererAttributes = me.renderer(areaElem, false, {
+ path: path,
+
+ hidden: false,
+ fill: colorArrayStyle[areaIndex % colorArrayLength],
+ stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength]
+ }, areaIndex, store);
+ me.areas[areaIndex].setAttributes(rendererAttributes, true);
}
- return "'"+ sep + format + v + args + ")"+sep+"'";
- }
-
- function codeFn(m, code){
-
- return "'" + sep + '(' + code.replace(/\\'/g, "'") + ')' + sep + "'";
- }
-
-
- if(Ext.isGecko){
- body = "tpl.compiled = function(values, parent, xindex, xcount){ return '" +
- tpl.body.replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn).replace(this.codeRe, codeFn) +
- "';};";
- }else{
- body = ["tpl.compiled = function(values, parent, xindex, xcount){ return ['"];
- body.push(tpl.body.replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn).replace(this.codeRe, codeFn));
- body.push("'].join('');};");
- body = body.join('');
}
- eval(body);
- return this;
+ me.renderLabels();
+ me.renderCallouts();
},
- applyTemplate : function(values){
- return this.master.compiled.call(this, values, {}, 1, 1);
+ onAnimate: function(sprite, attr) {
+ sprite.show();
+ return this.callParent(arguments);
},
- compile : function(){return this;}
-
-
-
-
-
-});
-
-Ext.XTemplate.prototype.apply = Ext.XTemplate.prototype.applyTemplate;
-
-
-Ext.XTemplate.from = function(el){
- el = Ext.getDom(el);
- return new Ext.XTemplate(el.value || el.innerHTML);
-};
-
-Ext.util.CSS = function(){
- var rules = null;
- var doc = document;
-
- var camelRe = /(-[a-z])/gi;
- var camelFn = function(m, a){ return a.charAt(1).toUpperCase(); };
-
- return {
-
- createStyleSheet : function(cssText, id){
- var ss;
- var head = doc.getElementsByTagName("head")[0];
- var rules = doc.createElement("style");
- rules.setAttribute("type", "text/css");
- if(id){
- rules.setAttribute("id", id);
- }
- if(Ext.isIE){
- head.appendChild(rules);
- ss = rules.styleSheet;
- ss.cssText = cssText;
- }else{
- try{
- rules.appendChild(doc.createTextNode(cssText));
- }catch(e){
- rules.cssText = cssText;
- }
- head.appendChild(rules);
- ss = rules.styleSheet ? rules.styleSheet : (rules.sheet || doc.styleSheets[doc.styleSheets.length-1]);
- }
- this.cacheStyleSheet(ss);
- return ss;
- },
-
-
- removeStyleSheet : function(id){
- var existing = doc.getElementById(id);
- if(existing){
- existing.parentNode.removeChild(existing);
- }
- },
+ onCreateLabel: function(storeItem, item, i, display) {
+ var me = this,
+ group = me.labelsGroup,
+ config = me.label,
+ bbox = me.bbox,
+ endLabelStyle = Ext.apply(config, me.seriesLabelStyle);
-
- swapStyleSheet : function(id, url){
- this.removeStyleSheet(id);
- var ss = doc.createElement("link");
- ss.setAttribute("rel", "stylesheet");
- ss.setAttribute("type", "text/css");
- ss.setAttribute("id", id);
- ss.setAttribute("href", url);
- doc.getElementsByTagName("head")[0].appendChild(ss);
- },
-
-
- refreshCache : function(){
- return this.getRules(true);
- },
+ return me.chart.surface.add(Ext.apply({
+ 'type': 'text',
+ 'text-anchor': 'middle',
+ 'group': group,
+ 'x': item.point[0],
+ 'y': bbox.y + bbox.height / 2
+ }, endLabelStyle || {}));
+ },
-
- cacheStyleSheet : function(ss){
- if(!rules){
- rules = {};
- }
- try{
- var ssRules = ss.cssRules || ss.rules;
- for(var j = ssRules.length-1; j >= 0; --j){
- rules[ssRules[j].selectorText.toLowerCase()] = ssRules[j];
- }
- }catch(e){}
- },
-
-
- getRules : function(refreshCache){
- if(rules === null || refreshCache){
- rules = {};
- var ds = doc.styleSheets;
- for(var i =0, len = ds.length; i < len; i++){
- try{
- this.cacheStyleSheet(ds[i]);
- }catch(e){}
- }
- }
- return rules;
- },
-
-
- getRule : function(selector, refreshCache){
- var rs = this.getRules(refreshCache);
- if(!Ext.isArray(selector)){
- return rs[selector.toLowerCase()];
- }
- for(var i = 0; i < selector.length; i++){
- if(rs[selector[i]]){
- return rs[selector[i].toLowerCase()];
- }
- }
- return null;
- },
-
-
-
- updateRule : function(selector, property, value){
- if(!Ext.isArray(selector)){
- var rule = this.getRule(selector);
- if(rule){
- rule.style[property.replace(camelRe, camelFn)] = value;
- return true;
- }
- }else{
- for(var i = 0; i < selector.length; i++){
- if(this.updateRule(selector[i], property, value)){
- return true;
- }
- }
- }
- return false;
- }
- };
-}();
-Ext.util.ClickRepeater = Ext.extend(Ext.util.Observable, {
- constructor : function(el, config){
- this.el = Ext.get(el);
- this.el.unselectable();
+ onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {
+ var me = this,
+ chart = me.chart,
+ resizing = chart.resizing,
+ config = me.label,
+ format = config.renderer,
+ field = config.field,
+ bbox = me.bbox,
+ x = item.point[0],
+ y = item.point[1],
+ bb, width, height;
+
+ label.setAttributes({
+ text: format(storeItem.get(field[index])),
+ hidden: true
+ }, true);
+
+ bb = label.getBBox();
+ width = bb.width / 2;
+ height = bb.height / 2;
+
+ x = x - width < bbox.x? bbox.x + width : x;
+ x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
+ y = y - height < bbox.y? bbox.y + height : y;
+ y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
+
+ if (me.chart.animate && !me.chart.resizing) {
+ label.show(true);
+ me.onAnimate(label, {
+ to: {
+ x: x,
+ y: y
+ }
+ });
+ } else {
+ label.setAttributes({
+ x: x,
+ y: y
+ }, true);
+ if (resizing) {
+ me.animation.on('afteranimate', function() {
+ label.show(true);
+ });
+ } else {
+ label.show(true);
+ }
+ }
+ },
- Ext.apply(this, config);
+
+ onPlaceCallout : function(callout, storeItem, item, i, display, animate, index) {
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ resizing = chart.resizing,
+ config = me.callouts,
+ items = me.items,
+ prev = (i == 0) ? false : items[i -1].point,
+ next = (i == items.length -1) ? false : items[i +1].point,
+ cur = item.point,
+ dir, norm, normal, a, aprev, anext,
+ bbox = callout.label.getBBox(),
+ offsetFromViz = 30,
+ offsetToSide = 10,
+ offsetBox = 3,
+ boxx, boxy, boxw, boxh,
+ p, clipRect = me.clipRect,
+ x, y;
- this.addEvents(
- "mousedown",
+ if (!prev) {
+ prev = cur;
+ }
+ if (!next) {
+ next = cur;
+ }
+ a = (next[1] - prev[1]) / (next[0] - prev[0]);
+ aprev = (cur[1] - prev[1]) / (cur[0] - prev[0]);
+ anext = (next[1] - cur[1]) / (next[0] - cur[0]);
- "click",
+ norm = Math.sqrt(1 + a * a);
+ dir = [1 / norm, a / norm];
+ normal = [-dir[1], dir[0]];
- "mouseup"
- );
-
- if(!this.disabled){
- this.disabled = true;
- this.enable();
+
+ if (aprev > 0 && anext < 0 && normal[1] < 0 || aprev < 0 && anext > 0 && normal[1] > 0) {
+ normal[0] *= -1;
+ normal[1] *= -1;
+ } else if (Math.abs(aprev) < Math.abs(anext) && normal[0] < 0 || Math.abs(aprev) > Math.abs(anext) && normal[0] > 0) {
+ normal[0] *= -1;
+ normal[1] *= -1;
}
- if(this.handler){
- this.on("click", this.handler, this.scope || this);
+ x = cur[0] + normal[0] * offsetFromViz;
+ y = cur[1] + normal[1] * offsetFromViz;
+
+
+ boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+ boxy = y - bbox.height /2 - offsetBox;
+ boxw = bbox.width + 2 * offsetBox;
+ boxh = bbox.height + 2 * offsetBox;
+
+
+
+ if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
+ normal[0] *= -1;
+ }
+ if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
+ normal[1] *= -1;
}
- Ext.util.ClickRepeater.superclass.constructor.call(this);
+
+ x = cur[0] + normal[0] * offsetFromViz;
+ y = cur[1] + normal[1] * offsetFromViz;
+
+
+ boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+ boxy = y - bbox.height /2 - offsetBox;
+ boxw = bbox.width + 2 * offsetBox;
+ boxh = bbox.height + 2 * offsetBox;
+
+
+ callout.lines.setAttributes({
+ path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+ }, true);
+
+ callout.box.setAttributes({
+ x: boxx,
+ y: boxy,
+ width: boxw,
+ height: boxh
+ }, true);
+
+ callout.label.setAttributes({
+ x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
+ y: y
+ }, true);
+ for (p in callout) {
+ callout[p].show(true);
+ }
},
- interval : 20,
- delay: 250,
- preventDefault : true,
- stopDefault : false,
- timer : 0,
+ isItemInPoint: function(x, y, item, i) {
+ var me = this,
+ pointsUp = item.pointsUp,
+ pointsDown = item.pointsDown,
+ abs = Math.abs,
+ dist = Infinity, p, pln, point;
+
+ for (p = 0, pln = pointsUp.length; p < pln; p++) {
+ point = [pointsUp[p][0], pointsUp[p][1]];
+ if (dist > abs(x - point[0])) {
+ dist = abs(x - point[0]);
+ } else {
+ point = pointsUp[p -1];
+ if (y >= point[1] && (!pointsDown.length || y <= (pointsDown[p -1][1]))) {
+ item.storeIndex = p -1;
+ item.storeField = me.yField[i];
+ item.storeItem = me.chart.store.getAt(p -1);
+ item._points = pointsDown.length? [point, pointsDown[p -1]] : [point];
+ return true;
+ } else {
+ break;
+ }
+ }
+ }
+ return false;
+ },
- enable: function(){
- if(this.disabled){
- this.el.on('mousedown', this.handleMouseDown, this);
- if (Ext.isIE){
- this.el.on('dblclick', this.handleDblClick, this);
+ highlightSeries: function() {
+ var area, to, fillColor;
+ if (this._index !== undefined) {
+ area = this.areas[this._index];
+ if (area.__highlightAnim) {
+ area.__highlightAnim.paused = true;
}
- if(this.preventDefault || this.stopDefault){
- this.el.on('click', this.eventOptions, this);
+ area.__highlighted = true;
+ area.__prevOpacity = area.__prevOpacity || area.attr.opacity || 1;
+ area.__prevFill = area.__prevFill || area.attr.fill;
+ area.__prevLineWidth = area.__prevLineWidth || area.attr.lineWidth;
+ fillColor = Ext.draw.Color.fromString(area.__prevFill);
+ to = {
+ lineWidth: (area.__prevLineWidth || 0) + 2
+ };
+ if (fillColor) {
+ to.fill = fillColor.getLighter(0.2).toString();
+ }
+ else {
+ to.opacity = Math.max(area.__prevOpacity - 0.3, 0);
+ }
+ if (this.chart.animate) {
+ area.__highlightAnim = Ext.create('Ext.fx.Anim', Ext.apply({
+ target: area,
+ to: to
+ }, this.chart.animate));
+ }
+ else {
+ area.setAttributes(to, true);
}
}
- this.disabled = false;
},
- disable: function( force){
- if(force || !this.disabled){
- clearTimeout(this.timer);
- if(this.pressClass){
- this.el.removeClass(this.pressClass);
+ unHighlightSeries: function() {
+ var area;
+ if (this._index !== undefined) {
+ area = this.areas[this._index];
+ if (area.__highlightAnim) {
+ area.__highlightAnim.paused = true;
+ }
+ if (area.__highlighted) {
+ area.__highlighted = false;
+ area.__highlightAnim = Ext.create('Ext.fx.Anim', {
+ target: area,
+ to: {
+ fill: area.__prevFill,
+ opacity: area.__prevOpacity,
+ lineWidth: area.__prevLineWidth
+ }
+ });
}
- Ext.getDoc().un('mouseup', this.handleMouseUp, this);
- this.el.removeAllListeners();
}
- this.disabled = true;
},
- setDisabled: function(disabled){
- this[disabled ? 'disable' : 'enable']();
+ highlightItem: function(item) {
+ var me = this,
+ points, path;
+ if (!item) {
+ this.highlightSeries();
+ return;
+ }
+ points = item._points;
+ path = points.length == 2? ['M', points[0][0], points[0][1], 'L', points[1][0], points[1][1]]
+ : ['M', points[0][0], points[0][1], 'L', points[0][0], me.bbox.y + me.bbox.height];
+ me.highlightSprite.setAttributes({
+ path: path,
+ hidden: false
+ }, true);
},
- eventOptions: function(e){
- if(this.preventDefault){
- e.preventDefault();
+
+ unHighlightItem: function(item) {
+ if (!item) {
+ this.unHighlightSeries();
}
- if(this.stopDefault){
- e.stopEvent();
+
+ if (this.highlightSprite) {
+ this.highlightSprite.hide(true);
}
},
- destroy : function() {
- this.disable(true);
- Ext.destroy(this.el);
- this.purgeListeners();
- },
-
- handleDblClick : function(e){
- clearTimeout(this.timer);
- this.el.blur();
-
- this.fireEvent("mousedown", this, e);
- this.fireEvent("click", this, e);
+ hideAll: function() {
+ if (!isNaN(this._index)) {
+ this.__excludes[this._index] = true;
+ this.areas[this._index].hide(true);
+ this.drawSeries();
+ }
},
- handleMouseDown : function(e){
- clearTimeout(this.timer);
- this.el.blur();
- if(this.pressClass){
- this.el.addClass(this.pressClass);
+ showAll: function() {
+ if (!isNaN(this._index)) {
+ this.__excludes[this._index] = false;
+ this.areas[this._index].show(true);
+ this.drawSeries();
}
- this.mousedownTime = new Date();
+ },
- Ext.getDoc().on("mouseup", this.handleMouseUp, this);
- this.el.on("mouseout", this.handleMouseOut, this);
+
+ getLegendColor: function(index) {
+ var me = this;
+ return me.colorArrayStyle[index % me.colorArrayStyle.length];
+ }
+});
- this.fireEvent("mousedown", this, e);
- this.fireEvent("click", this, e);
-
- if (this.accelerate) {
- this.delay = 400;
- }
- this.timer = this.click.defer(this.delay || this.interval, this, [e]);
- },
+Ext.define('Ext.chart.series.Bar', {
- click : function(e){
- this.fireEvent("click", this, e);
- this.timer = this.click.defer(this.accelerate ?
- this.easeOutExpo(this.mousedownTime.getElapsed(),
- 400,
- -390,
- 12000) :
- this.interval, this, [e]);
- },
- easeOutExpo : function (t, b, c, d) {
- return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
- },
+ extend: 'Ext.chart.series.Cartesian',
-
- handleMouseOut : function(){
- clearTimeout(this.timer);
- if(this.pressClass){
- this.el.removeClass(this.pressClass);
- }
- this.el.on("mouseover", this.handleMouseReturn, this);
- },
+ alternateClassName: ['Ext.chart.BarSeries', 'Ext.chart.BarChart', 'Ext.chart.StackedBarChart'],
-
- handleMouseReturn : function(){
- this.el.un("mouseover", this.handleMouseReturn, this);
- if(this.pressClass){
- this.el.addClass(this.pressClass);
- }
- this.click();
- },
+ requires: ['Ext.chart.axis.Axis', 'Ext.fx.Anim'],
- handleMouseUp : function(e){
- clearTimeout(this.timer);
- this.el.un("mouseover", this.handleMouseReturn, this);
- this.el.un("mouseout", this.handleMouseOut, this);
- Ext.getDoc().un("mouseup", this.handleMouseUp, this);
- this.el.removeClass(this.pressClass);
- this.fireEvent("mouseup", this, e);
- }
-});
-Ext.KeyNav = function(el, config){
- this.el = Ext.get(el);
- Ext.apply(this, config);
- if(!this.disabled){
- this.disabled = true;
- this.enable();
- }
-};
-Ext.KeyNav.prototype = {
+ type: 'bar',
+
+ alias: 'series.bar',
- disabled : false,
+ column: false,
- defaultEventAction: "stopEvent",
- forceKeyDown : false,
-
+ style: {},
+
- relay : function(e){
- var k = e.getKey(),
- h = this.keyToHandler[k];
- if(h && this[h]){
- if(this.doRelay(e, this[h], h) !== true){
- e[this.defaultEventAction]();
- }
- }
- },
+ gutter: 38.2,
- doRelay : function(e, h, hname){
- return h.call(this.scope || this, e, hname);
- },
+ groupGutter: 38.2,
- enter : false,
- left : false,
- right : false,
- up : false,
- down : false,
- tab : false,
- esc : false,
- pageUp : false,
- pageDown : false,
- del : false,
- home : false,
- end : false,
+ xPadding: 0,
- keyToHandler : {
- 37 : "left",
- 39 : "right",
- 38 : "up",
- 40 : "down",
- 33 : "pageUp",
- 34 : "pageDown",
- 46 : "del",
- 36 : "home",
- 35 : "end",
- 13 : "enter",
- 27 : "esc",
- 9 : "tab"
- },
-
- stopKeyUp: function(e) {
- var k = e.getKey();
+ yPadding: 10,
- if (k >= 37 && k <= 40) {
-
+ constructor: function(config) {
+ this.callParent(arguments);
+ var me = this,
+ surface = me.chart.surface,
+ shadow = me.chart.shadow,
+ i, l;
+ Ext.apply(me, config, {
+ highlightCfg: {
+ lineWidth: 3,
+ stroke: '#55c',
+ opacity: 0.8,
+ color: '#f00'
+ },
- e.stopEvent();
+ shadowAttributes: [{
+ "stroke-width": 6,
+ "stroke-opacity": 0.05,
+ stroke: 'rgb(200, 200, 200)',
+ translate: {
+ x: 1.2,
+ y: 1.2
+ }
+ }, {
+ "stroke-width": 4,
+ "stroke-opacity": 0.1,
+ stroke: 'rgb(150, 150, 150)',
+ translate: {
+ x: 0.9,
+ y: 0.9
+ }
+ }, {
+ "stroke-width": 2,
+ "stroke-opacity": 0.15,
+ stroke: 'rgb(100, 100, 100)',
+ translate: {
+ x: 0.6,
+ y: 0.6
+ }
+ }]
+ });
+ me.group = surface.getGroup(me.seriesId + '-bars');
+ if (shadow) {
+ for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+ me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+ }
}
},
+
+ getBarGirth: function() {
+ var me = this,
+ store = me.chart.store,
+ column = me.column,
+ ln = store.getCount(),
+ gutter = me.gutter / 100;
+
+ return (me.chart.chartBBox[column ? 'width' : 'height'] - me[column ? 'xPadding' : 'yPadding'] * 2) / (ln * (gutter + 1) - gutter);
+ },
+
- destroy: function(){
- this.disable();
+ getGutters: function() {
+ var me = this,
+ column = me.column,
+ gutter = Math.ceil(me[column ? 'xPadding' : 'yPadding'] + me.getBarGirth() / 2);
+ return me.column ? [gutter, 0] : [0, gutter];
},
-
- enable: function() {
- if (this.disabled) {
- if (Ext.isSafari2) {
-
- this.el.on('keyup', this.stopKeyUp, this);
+
+ getBounds: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ bars = [].concat(me.yField),
+ barsLen = bars.length,
+ groupBarsLen = barsLen,
+ groupGutter = me.groupGutter / 100,
+ column = me.column,
+ xPadding = me.xPadding,
+ yPadding = me.yPadding,
+ stacked = me.stacked,
+ barWidth = me.getBarGirth(),
+ math = Math,
+ mmax = math.max,
+ mabs = math.abs,
+ groupBarWidth, bbox, minY, maxY, axis, out,
+ scale, zero, total, rec, j, plus, minus;
+
+ me.setBBox(true);
+ bbox = me.bbox;
+
+
+ if (me.__excludes) {
+ for (j = 0, total = me.__excludes.length; j < total; j++) {
+ if (me.__excludes[j]) {
+ groupBarsLen--;
+ }
}
-
- this.el.on(this.isKeydown()? 'keydown' : 'keypress', this.relay, this);
- this.disabled = false;
}
- },
-
- disable: function() {
- if (!this.disabled) {
- if (Ext.isSafari2) {
-
- this.el.un('keyup', this.stopKeyUp, this);
+ if (me.axis) {
+ axis = chart.axes.get(me.axis);
+ if (axis) {
+ out = axis.calcEnds();
+ minY = out.from || axis.prevMin;
+ maxY = mmax(out.to || axis.prevMax, 0);
}
+ }
- this.el.un(this.isKeydown()? 'keydown' : 'keypress', this.relay, this);
- this.disabled = true;
+ if (me.yField && !Ext.isNumber(minY)) {
+ axis = Ext.create('Ext.chart.axis.Axis', {
+ chart: chart,
+ fields: [].concat(me.yField)
+ });
+ out = axis.calcEnds();
+ minY = out.from || axis.prevMin;
+ maxY = mmax(out.to || axis.prevMax, 0);
}
- },
-
-
- setDisabled : function(disabled){
- this[disabled ? "disable" : "enable"]();
- },
-
-
- isKeydown: function(){
- return this.forceKeyDown || Ext.EventManager.useKeydown;
- }
-};
-Ext.KeyMap = function(el, config, eventName){
- this.el = Ext.get(el);
- this.eventName = eventName || "keydown";
- this.bindings = [];
- if(config){
- this.addBinding(config);
- }
- this.enable();
-};
+ if (!Ext.isNumber(minY)) {
+ minY = 0;
+ }
+ if (!Ext.isNumber(maxY)) {
+ maxY = 0;
+ }
+ scale = (column ? bbox.height - yPadding * 2 : bbox.width - xPadding * 2) / (maxY - minY);
+ groupBarWidth = barWidth / ((stacked ? 1 : groupBarsLen) * (groupGutter + 1) - groupGutter);
+ zero = (column) ? bbox.y + bbox.height - yPadding : bbox.x + xPadding;
-Ext.KeyMap.prototype = {
-
- stopEvent : false,
+ if (stacked) {
+ total = [[], []];
+ store.each(function(record, i) {
+ total[0][i] = total[0][i] || 0;
+ total[1][i] = total[1][i] || 0;
+ for (j = 0; j < barsLen; j++) {
+ if (me.__excludes && me.__excludes[j]) {
+ continue;
+ }
+ rec = record.get(bars[j]);
+ total[+(rec > 0)][i] += mabs(rec);
+ }
+ });
+ total[+(maxY > 0)].push(mabs(maxY));
+ total[+(minY > 0)].push(mabs(minY));
+ minus = mmax.apply(math, total[0]);
+ plus = mmax.apply(math, total[1]);
+ scale = (column ? bbox.height - yPadding * 2 : bbox.width - xPadding * 2) / (plus + minus);
+ zero = zero + minus * scale * (column ? -1 : 1);
+ }
+ else if (minY / maxY < 0) {
+ zero = zero - minY * scale * (column ? -1 : 1);
+ }
+ return {
+ bars: bars,
+ bbox: bbox,
+ barsLen: barsLen,
+ groupBarsLen: groupBarsLen,
+ barWidth: barWidth,
+ groupBarWidth: groupBarWidth,
+ scale: scale,
+ zero: zero,
+ xPadding: xPadding,
+ yPadding: yPadding,
+ signed: minY / maxY < 0,
+ minY: minY,
+ maxY: maxY
+ };
+ },
- addBinding : function(config){
- if(Ext.isArray(config)){
- Ext.each(config, function(c){
- this.addBinding(c);
- }, this);
- return;
- }
- var keyCode = config.key,
- fn = config.fn || config.handler,
- scope = config.scope;
-
- if (config.stopEvent) {
- this.stopEvent = config.stopEvent;
- }
-
- if(typeof keyCode == "string"){
- var ks = [];
- var keyString = keyCode.toUpperCase();
- for(var j = 0, len = keyString.length; j < len; j++){
- ks.push(keyString.charCodeAt(j));
- }
- keyCode = ks;
- }
- var keyArray = Ext.isArray(keyCode);
-
- var handler = function(e){
- if(this.checkModifiers(config, e)){
- var k = e.getKey();
- if(keyArray){
- for(var i = 0, len = keyCode.length; i < len; i++){
- if(keyCode[i] == k){
- if(this.stopEvent){
- e.stopEvent();
- }
- fn.call(scope || window, k, e);
- return;
- }
+ getPaths: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ bounds = me.bounds = me.getBounds(),
+ items = me.items = [],
+ gutter = me.gutter / 100,
+ groupGutter = me.groupGutter / 100,
+ animate = chart.animate,
+ column = me.column,
+ group = me.group,
+ enableShadows = chart.shadow,
+ shadowGroups = me.shadowGroups,
+ shadowAttributes = me.shadowAttributes,
+ shadowGroupsLn = shadowGroups.length,
+ bbox = bounds.bbox,
+ xPadding = me.xPadding,
+ yPadding = me.yPadding,
+ stacked = me.stacked,
+ barsLen = bounds.barsLen,
+ colors = me.colorArrayStyle,
+ colorLength = colors && colors.length || 0,
+ math = Math,
+ mmax = math.max,
+ mmin = math.min,
+ mabs = math.abs,
+ j, yValue, height, totalDim, totalNegDim, bottom, top, hasShadow, barAttr, attrs, counter,
+ shadowIndex, shadow, sprite, offset, floorY;
+
+ store.each(function(record, i, total) {
+ bottom = bounds.zero;
+ top = bounds.zero;
+ totalDim = 0;
+ totalNegDim = 0;
+ hasShadow = false;
+ for (j = 0, counter = 0; j < barsLen; j++) {
+
+ if (me.__excludes && me.__excludes[j]) {
+ continue;
+ }
+ yValue = record.get(bounds.bars[j]);
+ height = Math.round((yValue - ((bounds.minY < 0) ? 0 : bounds.minY)) * bounds.scale);
+ barAttr = {
+ fill: colors[(barsLen > 1 ? j : 0) % colorLength]
+ };
+ if (column) {
+ Ext.apply(barAttr, {
+ height: height,
+ width: mmax(bounds.groupBarWidth, 0),
+ x: (bbox.x + xPadding + i * bounds.barWidth * (1 + gutter) + counter * bounds.groupBarWidth * (1 + groupGutter) * !stacked),
+ y: bottom - height
+ });
+ }
+ else {
+
+ offset = (total - 1) - i;
+ Ext.apply(barAttr, {
+ height: mmax(bounds.groupBarWidth, 0),
+ width: height + (bottom == bounds.zero),
+ x: bottom + (bottom != bounds.zero),
+ y: (bbox.y + yPadding + offset * bounds.barWidth * (1 + gutter) + counter * bounds.groupBarWidth * (1 + groupGutter) * !stacked + 1)
+ });
+ }
+ if (height < 0) {
+ if (column) {
+ barAttr.y = top;
+ barAttr.height = mabs(height);
+ } else {
+ barAttr.x = top + height;
+ barAttr.width = mabs(height);
}
- }else{
- if(k == keyCode){
- if(this.stopEvent){
- e.stopEvent();
+ }
+ if (stacked) {
+ if (height < 0) {
+ top += height * (column ? -1 : 1);
+ } else {
+ bottom += height * (column ? -1 : 1);
+ }
+ totalDim += mabs(height);
+ if (height < 0) {
+ totalNegDim += mabs(height);
+ }
+ }
+ barAttr.x = Math.floor(barAttr.x) + 1;
+ floorY = Math.floor(barAttr.y);
+ if (!Ext.isIE9 && barAttr.y > floorY) {
+ floorY--;
+ }
+ barAttr.y = floorY;
+ barAttr.width = Math.floor(barAttr.width);
+ barAttr.height = Math.floor(barAttr.height);
+ items.push({
+ series: me,
+ storeItem: record,
+ value: [record.get(me.xField), yValue],
+ attr: barAttr,
+ point: column ? [barAttr.x + barAttr.width / 2, yValue >= 0 ? barAttr.y : barAttr.y + barAttr.height] :
+ [yValue >= 0 ? barAttr.x + barAttr.width : barAttr.x, barAttr.y + barAttr.height / 2]
+ });
+
+ if (animate && chart.resizing) {
+ attrs = column ? {
+ x: barAttr.x,
+ y: bounds.zero,
+ width: barAttr.width,
+ height: 0
+ } : {
+ x: bounds.zero,
+ y: barAttr.y,
+ width: 0,
+ height: barAttr.height
+ };
+ if (enableShadows && (stacked && !hasShadow || !stacked)) {
+ hasShadow = true;
+
+ for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+ shadow = shadowGroups[shadowIndex].getAt(stacked ? i : (i * barsLen + j));
+ if (shadow) {
+ shadow.setAttributes(attrs, true);
+ }
}
- fn.call(scope || window, k, e);
+ }
+
+ sprite = group.getAt(i * barsLen + j);
+ if (sprite) {
+ sprite.setAttributes(attrs, true);
}
}
+ counter++;
}
- };
- this.bindings.push(handler);
- },
-
-
- checkModifiers: function(config, e){
- var val, key, keys = ['shift', 'ctrl', 'alt'];
- for (var i = 0, len = keys.length; i < len; ++i){
- key = keys[i];
- val = config[key];
- if(!(val === undefined || (val === e[key + 'Key']))){
- return false;
+ if (stacked && items.length) {
+ items[i * counter].totalDim = totalDim;
+ items[i * counter].totalNegDim = totalNegDim;
}
- }
- return true;
+ }, me);
},
- on : function(key, fn, scope){
- var keyCode, shift, ctrl, alt;
- if(typeof key == "object" && !Ext.isArray(key)){
- keyCode = key.key;
- shift = key.shift;
- ctrl = key.ctrl;
- alt = key.alt;
- }else{
- keyCode = key;
+ renderShadows: function(i, barAttr, baseAttrs, bounds) {
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ animate = chart.animate,
+ stacked = me.stacked,
+ shadowGroups = me.shadowGroups,
+ shadowAttributes = me.shadowAttributes,
+ shadowGroupsLn = shadowGroups.length,
+ store = chart.substore || chart.store,
+ column = me.column,
+ items = me.items,
+ shadows = [],
+ zero = bounds.zero,
+ shadowIndex, shadowBarAttr, shadow, totalDim, totalNegDim, j, rendererAttributes;
+
+ if ((stacked && (i % bounds.groupBarsLen === 0)) || !stacked) {
+ j = i / bounds.groupBarsLen;
+
+ for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+ shadowBarAttr = Ext.apply({}, shadowAttributes[shadowIndex]);
+ shadow = shadowGroups[shadowIndex].getAt(stacked ? j : i);
+ Ext.copyTo(shadowBarAttr, barAttr, 'x,y,width,height');
+ if (!shadow) {
+ shadow = surface.add(Ext.apply({
+ type: 'rect',
+ group: shadowGroups[shadowIndex]
+ }, Ext.apply({}, baseAttrs, shadowBarAttr)));
+ }
+ if (stacked) {
+ totalDim = items[i].totalDim;
+ totalNegDim = items[i].totalNegDim;
+ if (column) {
+ shadowBarAttr.y = zero - totalNegDim;
+ shadowBarAttr.height = totalDim;
+ }
+ else {
+ shadowBarAttr.x = zero - totalNegDim;
+ shadowBarAttr.width = totalDim;
+ }
+ }
+ if (animate) {
+ if (!stacked) {
+ rendererAttributes = me.renderer(shadow, store.getAt(j), shadowBarAttr, i, store);
+ me.onAnimate(shadow, { to: rendererAttributes });
+ }
+ else {
+ rendererAttributes = me.renderer(shadow, store.getAt(j), Ext.apply(shadowBarAttr, { hidden: true }), i, store);
+ shadow.setAttributes(rendererAttributes, true);
+ }
+ }
+ else {
+ rendererAttributes = me.renderer(shadow, store.getAt(j), Ext.apply(shadowBarAttr, { hidden: false }), i, store);
+ shadow.setAttributes(rendererAttributes, true);
+ }
+ shadows.push(shadow);
+ }
}
- this.addBinding({
- key: keyCode,
- shift: shift,
- ctrl: ctrl,
- alt: alt,
- fn: fn,
- scope: scope
- });
+ return shadows;
},
- handleKeyDown : function(e){
- if(this.enabled){
- var b = this.bindings;
- for(var i = 0, len = b.length; i < len; i++){
- b[i].call(this, e);
- }
- }
- },
-
-
- isEnabled : function(){
- return this.enabled;
- },
+ drawSeries: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ surface = chart.surface,
+ animate = chart.animate,
+ stacked = me.stacked,
+ column = me.column,
+ enableShadows = chart.shadow,
+ shadowGroups = me.shadowGroups,
+ shadowGroupsLn = shadowGroups.length,
+ group = me.group,
+ seriesStyle = me.seriesStyle,
+ items, ln, i, j, baseAttrs, sprite, rendererAttributes, shadowIndex, shadowGroup,
+ bounds, endSeriesStyle, barAttr, attrs, anim;
+
+ if (!store || !store.getCount()) {
+ return;
+ }
+
+
+ delete seriesStyle.fill;
+ endSeriesStyle = Ext.apply(seriesStyle, this.style);
+ me.unHighlightItem();
+ me.cleanHighlights();
-
- enable: function(){
- if(!this.enabled){
- this.el.on(this.eventName, this.handleKeyDown, this);
- this.enabled = true;
- }
- },
+ me.getPaths();
+ bounds = me.bounds;
+ items = me.items;
-
- disable: function(){
- if(this.enabled){
- this.el.removeListener(this.eventName, this.handleKeyDown, this);
- this.enabled = false;
- }
- },
-
-
- setDisabled : function(disabled){
- this[disabled ? "disable" : "enable"]();
- }
-};
-Ext.util.TextMetrics = function(){
- var shared;
- return {
+ baseAttrs = column ? {
+ y: bounds.zero,
+ height: 0
+ } : {
+ x: bounds.zero,
+ width: 0
+ };
+ ln = items.length;
- measure : function(el, text, fixedWidth){
- if(!shared){
- shared = Ext.util.TextMetrics.Instance(el, fixedWidth);
+ for (i = 0; i < ln; i++) {
+ sprite = group.getAt(i);
+ barAttr = items[i].attr;
+
+ if (enableShadows) {
+ items[i].shadows = me.renderShadows(i, barAttr, baseAttrs, bounds);
}
- shared.bind(el);
- shared.setFixedWidth(fixedWidth || 'auto');
- return shared.getSize(text);
- },
-
- createInstance : function(el, fixedWidth){
- return Ext.util.TextMetrics.Instance(el, fixedWidth);
+
+ if (!sprite) {
+ attrs = Ext.apply({}, baseAttrs, barAttr);
+ attrs = Ext.apply(attrs, endSeriesStyle || {});
+ sprite = surface.add(Ext.apply({}, {
+ type: 'rect',
+ group: group
+ }, attrs));
+ }
+ if (animate) {
+ rendererAttributes = me.renderer(sprite, store.getAt(i), barAttr, i, store);
+ sprite._to = rendererAttributes;
+ anim = me.onAnimate(sprite, { to: Ext.apply(rendererAttributes, endSeriesStyle) });
+ if (enableShadows && stacked && (i % bounds.barsLen === 0)) {
+ j = i / bounds.barsLen;
+ for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+ anim.on('afteranimate', function() {
+ this.show(true);
+ }, shadowGroups[shadowIndex].getAt(j));
+ }
+ }
+ }
+ else {
+ rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply(barAttr, { hidden: false }), i, store);
+ sprite.setAttributes(Ext.apply(rendererAttributes, endSeriesStyle), true);
+ }
+ items[i].sprite = sprite;
}
- };
-}();
-Ext.util.TextMetrics.Instance = function(bindTo, fixedWidth){
- var ml = new Ext.Element(document.createElement('div'));
- document.body.appendChild(ml.dom);
- ml.position('absolute');
- ml.setLeftTop(-1000, -1000);
- ml.hide();
-
- if(fixedWidth){
- ml.setWidth(fixedWidth);
- }
-
- var instance = {
- getSize : function(text){
- ml.update(text);
- var s = ml.getSize();
- ml.update('');
- return s;
- },
-
+ ln = group.getCount();
+ for (j = i; j < ln; j++) {
+ group.getAt(j).hide(true);
+ }
- bind : function(el){
- ml.setStyle(
- Ext.fly(el).getStyles('font-size','font-style', 'font-weight', 'font-family','line-height', 'text-transform', 'letter-spacing')
- );
- },
-
+ if (enableShadows) {
+ for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
+ shadowGroup = shadowGroups[shadowIndex];
+ ln = shadowGroup.getCount();
+ for (j = i; j < ln; j++) {
+ shadowGroup.getAt(j).hide(true);
+ }
+ }
+ }
+ me.renderLabels();
+ },
+
+
+ onCreateLabel: function(storeItem, item, i, display) {
+ var me = this,
+ surface = me.chart.surface,
+ group = me.labelsGroup,
+ config = me.label,
+ endLabelStyle = Ext.apply({}, config, me.seriesLabelStyle || {}),
+ sprite;
+ return surface.add(Ext.apply({
+ type: 'text',
+ group: group
+ }, endLabelStyle || {}));
+ },
+
+
+ onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {
- setFixedWidth : function(width){
- ml.setWidth(width);
- },
-
- getWidth : function(text){
- ml.dom.style.width = 'auto';
- return this.getSize(text).width;
- },
+ var me = this,
+ opt = me.bounds,
+ groupBarWidth = opt.groupBarWidth,
+ column = me.column,
+ chart = me.chart,
+ chartBBox = chart.chartBBox,
+ resizing = chart.resizing,
+ xValue = item.value[0],
+ yValue = item.value[1],
+ attr = item.attr,
+ config = me.label,
+ rotate = config.orientation == 'vertical',
+ field = [].concat(config.field),
+ format = config.renderer,
+ text = format(storeItem.get(field[index])),
+ size = me.getLabelSize(text),
+ width = size.width,
+ height = size.height,
+ zero = opt.zero,
+ outside = 'outside',
+ insideStart = 'insideStart',
+ insideEnd = 'insideEnd',
+ offsetX = 10,
+ offsetY = 6,
+ signed = opt.signed,
+ x, y, finalAttr;
+
+ label.setAttributes({
+ text: text
+ });
+ if (column) {
+ if (display == outside) {
+ if (height + offsetY + attr.height > (yValue >= 0 ? zero - chartBBox.y : chartBBox.y + chartBBox.height - zero)) {
+ display = insideEnd;
+ }
+ } else {
+ if (height + offsetY > attr.height) {
+ display = outside;
+ }
+ }
+ x = attr.x + groupBarWidth / 2;
+ y = display == insideStart ?
+ (zero + ((height / 2 + 3) * (yValue >= 0 ? -1 : 1))) :
+ (yValue >= 0 ? (attr.y + ((height / 2 + 3) * (display == outside ? -1 : 1))) :
+ (attr.y + attr.height + ((height / 2 + 3) * (display === outside ? 1 : -1))));
+ }
+ else {
+ if (display == outside) {
+ if (width + offsetX + attr.width > (yValue >= 0 ? chartBBox.x + chartBBox.width - zero : zero - chartBBox.x)) {
+ display = insideEnd;
+ }
+ }
+ else {
+ if (width + offsetX > attr.width) {
+ display = outside;
+ }
+ }
+ x = display == insideStart ?
+ (zero + ((width / 2 + 5) * (yValue >= 0 ? 1 : -1))) :
+ (yValue >= 0 ? (attr.x + attr.width + ((width / 2 + 5) * (display === outside ? 1 : -1))) :
+ (attr.x + ((width / 2 + 5) * (display === outside ? -1 : 1))));
+ y = attr.y + groupBarWidth / 2;
+ }
- getHeight : function(text){
- return this.getSize(text).height;
+ finalAttr = {
+ x: x,
+ y: y
+ };
+
+ if (rotate) {
+ finalAttr.rotate = {
+ x: x,
+ y: y,
+ degrees: 270
+ };
}
- };
+
+ if (animate && resizing) {
+ if (column) {
+ x = attr.x + attr.width / 2;
+ y = zero;
+ } else {
+ x = zero;
+ y = attr.y + attr.height / 2;
+ }
+ label.setAttributes({
+ x: x,
+ y: y
+ }, true);
+ if (rotate) {
+ label.setAttributes({
+ rotate: {
+ x: x,
+ y: y,
+ degrees: 270
+ }
+ }, true);
+ }
+ }
+
+ if (animate) {
+ me.onAnimate(label, { to: finalAttr });
+ }
+ else {
+ label.setAttributes(Ext.apply(finalAttr, {
+ hidden: false
+ }), true);
+ }
+ },
- instance.bind(bindTo);
+
+ getLabelSize: function(value) {
+ var tester = this.testerLabel,
+ config = this.label,
+ endLabelStyle = Ext.apply({}, config, this.seriesLabelStyle || {}),
+ rotated = config.orientation === 'vertical',
+ bbox, w, h,
+ undef;
+ if (!tester) {
+ tester = this.testerLabel = this.chart.surface.add(Ext.apply({
+ type: 'text',
+ opacity: 0
+ }, endLabelStyle));
+ }
+ tester.setAttributes({
+ text: value
+ }, true);
- return instance;
-};
+
+ bbox = tester.getBBox();
+ w = bbox.width;
+ h = bbox.height;
+ return {
+ width: rotated ? h : w,
+ height: rotated ? w : h
+ };
+ },
-Ext.Element.addMethods({
- getTextWidth : function(text, min, max){
- return (Ext.util.TextMetrics.measure(this.dom, Ext.value(text, this.dom.innerHTML, true)).width).constrain(min || 0, max || 1000000);
- }
-});
-
-Ext.util.Cookies = {
+ onAnimate: function(sprite, attr) {
+ sprite.show();
+ return this.callParent(arguments);
+ },
- set : function(name, value){
- var argv = arguments;
- var argc = arguments.length;
- var expires = (argc > 2) ? argv[2] : null;
- var path = (argc > 3) ? argv[3] : '/';
- var domain = (argc > 4) ? argv[4] : null;
- var secure = (argc > 5) ? argv[5] : false;
- document.cookie = name + "=" + escape(value) + ((expires === null) ? "" : ("; expires=" + expires.toGMTString())) + ((path === null) ? "" : ("; path=" + path)) + ((domain === null) ? "" : ("; domain=" + domain)) + ((secure === true) ? "; secure" : "");
+ isItemInPoint: function(x, y, item) {
+ var bbox = item.sprite.getBBox();
+ return bbox.x <= x && bbox.y <= y
+ && (bbox.x + bbox.width) >= x
+ && (bbox.y + bbox.height) >= y;
},
-
- get : function(name){
- var arg = name + "=";
- var alen = arg.length;
- var clen = document.cookie.length;
- var i = 0;
- var j = 0;
- while(i < clen){
- j = i + alen;
- if(document.cookie.substring(i, j) == arg){
- return Ext.util.Cookies.getCookieVal(j);
- }
- i = document.cookie.indexOf(" ", i) + 1;
- if(i === 0){
- break;
+
+ hideAll: function() {
+ var axes = this.chart.axes;
+ if (!isNaN(this._index)) {
+ if (!this.__excludes) {
+ this.__excludes = [];
}
+ this.__excludes[this._index] = true;
+ this.drawSeries();
+ axes.each(function(axis) {
+ axis.drawAxis();
+ });
}
- return null;
},
- clear : function(name){
- if(Ext.util.Cookies.get(name)){
- document.cookie = name + "=" + "; expires=Thu, 01-Jan-70 00:00:01 GMT";
+ showAll: function() {
+ var axes = this.chart.axes;
+ if (!isNaN(this._index)) {
+ if (!this.__excludes) {
+ this.__excludes = [];
+ }
+ this.__excludes[this._index] = false;
+ this.drawSeries();
+ axes.each(function(axis) {
+ axis.drawAxis();
+ });
}
},
- getCookieVal : function(offset){
- var endstr = document.cookie.indexOf(";", offset);
- if(endstr == -1){
- endstr = document.cookie.length;
- }
- return unescape(document.cookie.substring(offset, endstr));
+
+ getLegendColor: function(index) {
+ var me = this;
+ return me.colorArrayStyle[index % me.colorArrayStyle.length];
}
-};
-Ext.handleError = function(e) {
- throw e;
-};
+});
-Ext.Error = function(message) {
-
- this.message = (this.lang[message]) ? this.lang[message] : message;
-};
+Ext.define('Ext.chart.series.Column', {
-Ext.Error.prototype = new Error();
-Ext.apply(Ext.Error.prototype, {
- lang: {},
- name: 'Ext.Error',
+ alternateClassName: ['Ext.chart.ColumnSeries', 'Ext.chart.ColumnChart', 'Ext.chart.StackedColumnChart'],
+
+ extend: 'Ext.chart.series.Bar',
+
- getName : function() {
- return this.name;
- },
+
+ type: 'column',
+ alias: 'series.column',
+
+ column: true,
+
- getMessage : function() {
- return this.message;
- },
+ xPadding: 10,
+
- toJson : function() {
- return Ext.encode(this);
- }
+ yPadding: 0
});
-Ext.ComponentMgr = function(){
- var all = new Ext.util.MixedCollection();
- var types = {};
- var ptypes = {};
-
- return {
-
- register : function(c){
- all.add(c);
- },
+Ext.define('Ext.chart.series.Gauge', {
-
- unregister : function(c){
- all.remove(c);
- },
+
-
- get : function(id){
- return all.get(id);
- },
+ extend: 'Ext.chart.series.Series',
-
- onAvailable : function(id, fn, scope){
- all.on("add", function(index, o){
- if(o.id == id){
- fn.call(scope || o, o);
- all.un("add", fn, scope);
- }
- });
- },
+
-
- all : all,
-
-
- types : types,
-
-
- ptypes: ptypes,
-
-
- isRegistered : function(xtype){
- return types[xtype] !== undefined;
- },
-
-
- isPluginRegistered : function(ptype){
- return ptypes[ptype] !== undefined;
- },
+ type: "gauge",
+ alias: 'series.gauge',
-
- registerType : function(xtype, cls){
- types[xtype] = cls;
- cls.xtype = xtype;
- },
+ rad: Math.PI / 180,
-
- create : function(config, defaultType){
- return config.render ? config : new types[config.xtype || defaultType](config);
- },
+
+ highlightDuration: 150,
-
- registerPlugin : function(ptype, cls){
- ptypes[ptype] = cls;
- cls.ptype = ptype;
- },
+
+ angleField: false,
-
- createPlugin : function(config, defaultType){
- var PluginCls = ptypes[config.ptype || defaultType];
- if (PluginCls.init) {
- return PluginCls;
- } else {
- return new PluginCls(config);
- }
- }
- };
-}();
+
+ needle: false,
+
+
+ donut: false,
+
+ showInLegend: false,
-Ext.reg = Ext.ComponentMgr.registerType;
+
+ style: {},
+
+ constructor: function(config) {
+ this.callParent(arguments);
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ store = chart.store,
+ shadow = chart.shadow, i, l, cfg;
+ Ext.apply(me, config, {
+ shadowAttributes: [{
+ "stroke-width": 6,
+ "stroke-opacity": 1,
+ stroke: 'rgb(200, 200, 200)',
+ translate: {
+ x: 1.2,
+ y: 2
+ }
+ },
+ {
+ "stroke-width": 4,
+ "stroke-opacity": 1,
+ stroke: 'rgb(150, 150, 150)',
+ translate: {
+ x: 0.9,
+ y: 1.5
+ }
+ },
+ {
+ "stroke-width": 2,
+ "stroke-opacity": 1,
+ stroke: 'rgb(100, 100, 100)',
+ translate: {
+ x: 0.6,
+ y: 1
+ }
+ }]
+ });
+ me.group = surface.getGroup(me.seriesId);
+ if (shadow) {
+ for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+ me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+ }
+ }
+ surface.customAttributes.segment = function(opt) {
+ return me.getSegment(opt);
+ };
+ },
+
+ //@private updates some onbefore render parameters.
-Ext.preg = Ext.ComponentMgr.registerPlugin;
+ initialize: function() {
+ var me = this,
+ store = me.chart.substore || me.chart.store;
+
+ me.yField = [];
+ if (me.label.field) {
+ store.each(function(rec) {
+ me.yField.push(rec.get(me.label.field));
+ });
+ }
+ },
-Ext.create = Ext.ComponentMgr.create;
-Ext.Component = function(config){
- config = config || {};
- if(config.initialConfig){
- if(config.isAction){
- this.baseAction = config;
+
+ getSegment: function(opt) {
+ var me = this,
+ rad = me.rad,
+ cos = Math.cos,
+ sin = Math.sin,
+ abs = Math.abs,
+ x = me.centerX,
+ y = me.centerY,
+ x1 = 0, x2 = 0, x3 = 0, x4 = 0,
+ y1 = 0, y2 = 0, y3 = 0, y4 = 0,
+ delta = 1e-2,
+ r = opt.endRho - opt.startRho,
+ startAngle = opt.startAngle,
+ endAngle = opt.endAngle,
+ midAngle = (startAngle + endAngle) / 2 * rad,
+ margin = opt.margin || 0,
+ flag = abs(endAngle - startAngle) > 180,
+ a1 = Math.min(startAngle, endAngle) * rad,
+ a2 = Math.max(startAngle, endAngle) * rad,
+ singleSlice = false;
+
+ x += margin * cos(midAngle);
+ y += margin * sin(midAngle);
+
+ x1 = x + opt.startRho * cos(a1);
+ y1 = y + opt.startRho * sin(a1);
+
+ x2 = x + opt.endRho * cos(a1);
+ y2 = y + opt.endRho * sin(a1);
+
+ x3 = x + opt.startRho * cos(a2);
+ y3 = y + opt.startRho * sin(a2);
+
+ x4 = x + opt.endRho * cos(a2);
+ y4 = y + opt.endRho * sin(a2);
+
+ if (abs(x1 - x3) <= delta && abs(y1 - y3) <= delta) {
+ singleSlice = true;
+ }
+
+ if (singleSlice) {
+ return {
+ path: [
+ ["M", x1, y1],
+ ["L", x2, y2],
+ ["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
+ ["Z"]]
+ };
+ } else {
+ return {
+ path: [
+ ["M", x1, y1],
+ ["L", x2, y2],
+ ["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
+ ["L", x3, y3],
+ ["A", opt.startRho, opt.startRho, 0, +flag, 0, x1, y1],
+ ["Z"]]
+ };
}
- config = config.initialConfig;
- }else if(config.tagName || config.dom || Ext.isString(config)){
- config = {applyTo: config, id: config.id || config};
- }
+ },
- this.initialConfig = config;
+ calcMiddle: function(item) {
+ var me = this,
+ rad = me.rad,
+ slice = item.slice,
+ x = me.centerX,
+ y = me.centerY,
+ startAngle = slice.startAngle,
+ endAngle = slice.endAngle,
+ radius = Math.max(('rho' in slice) ? slice.rho: me.radius, me.label.minMargin),
+ donut = +me.donut,
+ a1 = Math.min(startAngle, endAngle) * rad,
+ a2 = Math.max(startAngle, endAngle) * rad,
+ midAngle = -(a1 + (a2 - a1) / 2),
+ xm = x + (item.endRho + item.startRho) / 2 * Math.cos(midAngle),
+ ym = y - (item.endRho + item.startRho) / 2 * Math.sin(midAngle);
+
+ item.middle = {
+ x: xm,
+ y: ym
+ };
+ },
- Ext.apply(this, config);
- this.addEvents(
-
- 'added',
-
- 'disable',
-
- 'enable',
-
- 'beforeshow',
-
- 'show',
-
- 'beforehide',
-
- 'hide',
-
- 'removed',
-
- 'beforerender',
-
- 'render',
-
- 'afterrender',
-
- 'beforedestroy',
+
+ drawSeries: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ group = me.group,
+ animate = me.chart.animate,
+ axis = me.chart.axes.get(0),
+ minimum = axis && axis.minimum || me.minimum || 0,
+ maximum = axis && axis.maximum || me.maximum || 0,
+ field = me.angleField || me.field || me.xField,
+ surface = chart.surface,
+ chartBBox = chart.chartBBox,
+ rad = me.rad,
+ donut = +me.donut,
+ values = {},
+ items = [],
+ seriesStyle = me.seriesStyle,
+ seriesLabelStyle = me.seriesLabelStyle,
+ colorArrayStyle = me.colorArrayStyle,
+ colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+ gutterX = chart.maxGutter[0],
+ gutterY = chart.maxGutter[1],
+ cos = Math.cos,
+ sin = Math.sin,
+ rendererAttributes, centerX, centerY, slice, slices, sprite, value,
+ item, ln, record, i, j, startAngle, endAngle, middleAngle, sliceLength, path,
+ p, spriteOptions, bbox, splitAngle, sliceA, sliceB;
+
+ Ext.apply(seriesStyle, me.style || {});
+
+ me.setBBox();
+ bbox = me.bbox;
+
+
+ if (me.colorSet) {
+ colorArrayStyle = me.colorSet;
+ colorArrayLength = colorArrayStyle.length;
+ }
+
+
+ if (!store || !store.getCount()) {
+ return;
+ }
- 'destroy',
+ centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
+ centerY = me.centerY = chartBBox.y + chartBBox.height;
+ me.radius = Math.min(centerX - chartBBox.x, centerY - chartBBox.y);
+ me.slices = slices = [];
+ me.items = items = [];
- 'beforestaterestore',
+ if (!me.value) {
+ record = store.getAt(0);
+ me.value = record.get(field);
+ }
- 'staterestore',
+ value = me.value;
+ if (me.needle) {
+ sliceA = {
+ series: me,
+ value: value,
+ startAngle: -180,
+ endAngle: 0,
+ rho: me.radius
+ };
+ splitAngle = -180 * (1 - (value - minimum) / (maximum - minimum));
+ slices.push(sliceA);
+ } else {
+ splitAngle = -180 * (1 - (value - minimum) / (maximum - minimum));
+ sliceA = {
+ series: me,
+ value: value,
+ startAngle: -180,
+ endAngle: splitAngle,
+ rho: me.radius
+ };
+ sliceB = {
+ series: me,
+ value: me.maximum - value,
+ startAngle: splitAngle,
+ endAngle: 0,
+ rho: me.radius
+ };
+ slices.push(sliceA, sliceB);
+ }
- 'beforestatesave',
- 'statesave'
- );
- this.getId();
- Ext.ComponentMgr.register(this);
- Ext.Component.superclass.constructor.call(this);
-
- if(this.baseAction){
- this.baseAction.addComponent(this);
- }
-
- this.initComponent();
+ for (i = 0, ln = slices.length; i < ln; i++) {
+ slice = slices[i];
+ sprite = group.getAt(i);
+
+ rendererAttributes = Ext.apply({
+ segment: {
+ startAngle: slice.startAngle,
+ endAngle: slice.endAngle,
+ margin: 0,
+ rho: slice.rho,
+ startRho: slice.rho * +donut / 100,
+ endRho: slice.rho
+ }
+ }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[i % colorArrayLength] } || {}));
- if(this.plugins){
- if(Ext.isArray(this.plugins)){
- for(var i = 0, len = this.plugins.length; i < len; i++){
- this.plugins[i] = this.initPlugin(this.plugins[i]);
+ item = Ext.apply({},
+ rendererAttributes.segment, {
+ slice: slice,
+ series: me,
+ storeItem: record,
+ index: i
+ });
+ items[i] = item;
+
+ if (!sprite) {
+ spriteOptions = Ext.apply({
+ type: "path",
+ group: group
+ }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[i % colorArrayLength] } || {}));
+ sprite = surface.add(Ext.apply(spriteOptions, rendererAttributes));
+ }
+ slice.sprite = slice.sprite || [];
+ item.sprite = sprite;
+ slice.sprite.push(sprite);
+ if (animate) {
+ rendererAttributes = me.renderer(sprite, record, rendererAttributes, i, store);
+ sprite._to = rendererAttributes;
+ me.onAnimate(sprite, {
+ to: rendererAttributes
+ });
+ } else {
+ rendererAttributes = me.renderer(sprite, record, Ext.apply(rendererAttributes, {
+ hidden: false
+ }), i, store);
+ sprite.setAttributes(rendererAttributes, true);
}
- }else{
- this.plugins = this.initPlugin(this.plugins);
}
- }
-
- if(this.stateful !== false){
- this.initState();
- }
-
- if(this.applyTo){
- this.applyToMarkup(this.applyTo);
- delete this.applyTo;
- }else if(this.renderTo){
- this.render(this.renderTo);
- delete this.renderTo;
- }
-};
-
-
-Ext.Component.AUTO_ID = 1000;
-
-Ext.extend(Ext.Component, Ext.util.Observable, {
-
-
-
-
-
+
+ if (me.needle) {
+ splitAngle = splitAngle * Math.PI / 180;
+
+ if (!me.needleSprite) {
+ me.needleSprite = me.chart.surface.add({
+ type: 'path',
+ path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
+ centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
+ 'L', centerX + me.radius * cos(splitAngle),
+ centerY + -Math.abs(me.radius * sin(splitAngle))],
+ 'stroke-width': 4,
+ 'stroke': '#222'
+ });
+ } else {
+ if (animate) {
+ me.onAnimate(me.needleSprite, {
+ to: {
+ path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
+ centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
+ 'L', centerX + me.radius * cos(splitAngle),
+ centerY + -Math.abs(me.radius * sin(splitAngle))]
+ }
+ });
+ } else {
+ me.needleSprite.setAttributes({
+ type: 'path',
+ path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
+ centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
+ 'L', centerX + me.radius * cos(splitAngle),
+ centerY + -Math.abs(me.radius * sin(splitAngle))]
+ });
+ }
+ }
+ me.needleSprite.setAttributes({
+ hidden: false
+ }, true);
+ }
+
+ delete me.value;
+ },
+ setValue: function (value) {
+ this.value = value;
+ this.drawSeries();
+ },
+ onCreateLabel: function(storeItem, item, i, display) {},
+
+ onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {},
+
+ onPlaceCallout: function() {},
+
+ onAnimate: function(sprite, attr) {
+ sprite.show();
+ return this.callParent(arguments);
+ },
+
+ isItemInPoint: function(x, y, item, i) {
+ return false;
+ },
+ showAll: function() {
+ if (!isNaN(this._index)) {
+ this.__excludes[this._index] = false;
+ this.drawSeries();
+ }
+ },
+ getLegendColor: function(index) {
+ var me = this;
+ return me.colorArrayStyle[index % me.colorArrayStyle.length];
+ }
+});
+
+
+
+
+Ext.define('Ext.chart.series.Line', {
+
- disabled : false,
-
- hidden : false,
-
-
-
-
-
-
-
- autoEl : 'div',
+
+ extend: 'Ext.chart.series.Cartesian',
+
+ alternateClassName: ['Ext.chart.LineSeries', 'Ext.chart.LineChart'],
+
+ requires: ['Ext.chart.axis.Axis', 'Ext.chart.Shape', 'Ext.draw.Draw', 'Ext.fx.Anim'],
- disabledClass : 'x-item-disabled',
+
+ type: 'line',
- allowDomMove : true,
+ alias: 'series.line',
+
- autoShow : false,
+ selectionTolerance: 20,
- hideMode : 'display',
- hideParent : false,
+ showMarkers: true,
+
+ markerConfig: {},
+
+ style: {},
+ smooth: false,
+
- rendered : false,
+ fill: false,
+ constructor: function(config) {
+ this.callParent(arguments);
+ var me = this,
+ surface = me.chart.surface,
+ shadow = me.chart.shadow,
+ i, l;
+ Ext.apply(me, config, {
+ highlightCfg: {
+ 'stroke-width': 3
+ },
+ shadowAttributes: [{
+ "stroke-width": 6,
+ "stroke-opacity": 0.05,
+ stroke: 'rgb(0, 0, 0)',
+ translate: {
+ x: 1,
+ y: 1
+ }
+ }, {
+ "stroke-width": 4,
+ "stroke-opacity": 0.1,
+ stroke: 'rgb(0, 0, 0)',
+ translate: {
+ x: 1,
+ y: 1
+ }
+ }, {
+ "stroke-width": 2,
+ "stroke-opacity": 0.15,
+ stroke: 'rgb(0, 0, 0)',
+ translate: {
+ x: 1,
+ y: 1
+ }
+ }]
+ });
+ me.group = surface.getGroup(me.seriesId);
+ if (me.showMarkers) {
+ me.markerGroup = surface.getGroup(me.seriesId + '-markers');
+ }
+ if (shadow) {
+ for (i = 0, l = this.shadowAttributes.length; i < l; i++) {
+ me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+ }
+ }
+ },
+ shrink: function(xValues, yValues, size) {
+
+ var len = xValues.length,
+ ratio = Math.floor(len / size),
+ i = 1,
+ xSum = 0,
+ ySum = 0,
+ xRes = [xValues[0]],
+ yRes = [yValues[0]];
+
+ for (; i < len; ++i) {
+ xSum += xValues[i] || 0;
+ ySum += yValues[i] || 0;
+ if (i % ratio == 0) {
+ xRes.push(xSum/ratio);
+ yRes.push(ySum/ratio);
+ xSum = 0;
+ ySum = 0;
+ }
+ }
+ return {
+ x: xRes,
+ y: yRes
+ };
+ },
+ drawSeries: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ surface = chart.surface,
+ chartBBox = chart.chartBBox,
+ bbox = {},
+ group = me.group,
+ gutterX = chart.maxGutter[0],
+ gutterY = chart.maxGutter[1],
+ showMarkers = me.showMarkers,
+ markerGroup = me.markerGroup,
+ enableShadows = chart.shadow,
+ shadowGroups = me.shadowGroups,
+ shadowAttributes = this.shadowAttributes,
+ lnsh = shadowGroups.length,
+ dummyPath = ["M"],
+ path = ["M"],
+ markerIndex = chart.markerIndex,
+ axes = [].concat(me.axis),
+ shadowGroup,
+ shadowBarAttr,
+ xValues = [],
+ yValues = [],
+ onbreak = false,
+ markerStyle = me.markerStyle,
+ seriesStyle = me.seriesStyle,
+ seriesLabelStyle = me.seriesLabelStyle,
+ colorArrayStyle = me.colorArrayStyle,
+ colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+ seriesIdx = me.seriesIdx, shadows, shadow, shindex, fromPath, fill, fillPath, rendererAttributes,
+ x, y, prevX, prevY, firstY, markerCount, i, j, ln, axis, ends, marker, markerAux, item, xValue,
+ yValue, coords, xScale, yScale, minX, maxX, minY, maxY, line, animation, endMarkerStyle,
+ endLineStyle, type, props, firstMarker;
+
+
+ if (!store || !store.getCount()) {
+ return;
+ }
+
+
+ endMarkerStyle = Ext.apply(markerStyle, me.markerConfig);
+ type = endMarkerStyle.type;
+ delete endMarkerStyle.type;
+ endLineStyle = Ext.apply(seriesStyle, me.style);
+
+
+ if (!endLineStyle['stroke-width']) {
+ endLineStyle['stroke-width'] = 0.5;
+ }
+
+
+ if (markerIndex && markerGroup && markerGroup.getCount()) {
+ for (i = 0; i < markerIndex; i++) {
+ marker = markerGroup.getAt(i);
+ markerGroup.remove(marker);
+ markerGroup.add(marker);
+ markerAux = markerGroup.getAt(markerGroup.getCount() - 2);
+ marker.setAttributes({
+ x: 0,
+ y: 0,
+ translate: {
+ x: markerAux.attr.translation.x,
+ y: markerAux.attr.translation.y
+ }
+ }, true);
+ }
+ }
+
+ me.unHighlightItem();
+ me.cleanHighlights();
-
- tplWriteMode : 'overwrite',
+ me.setBBox();
+ bbox = me.bbox;
-
-
-
- bubbleEvents: [],
+ me.clipRect = [bbox.x, bbox.y, bbox.width, bbox.height];
+ for (i = 0, ln = axes.length; i < ln; i++) {
+ axis = chart.axes.get(axes[i]);
+ if (axis) {
+ ends = axis.calcEnds();
+ if (axis.position == 'top' || axis.position == 'bottom') {
+ minX = ends.from;
+ maxX = ends.to;
+ }
+ else {
+ minY = ends.from;
+ maxY = ends.to;
+ }
+ }
+ }
+
+
+
+ if (me.xField && !Ext.isNumber(minX)
+ && (me.axis == 'bottom' || me.axis == 'top')) {
+ axis = Ext.create('Ext.chart.axis.Axis', {
+ chart: chart,
+ fields: [].concat(me.xField)
+ }).calcEnds();
+ minX = axis.from;
+ maxX = axis.to;
+ }
+ if (me.yField && !Ext.isNumber(minY)
+ && (me.axis == 'right' || me.axis == 'left')) {
+ axis = Ext.create('Ext.chart.axis.Axis', {
+ chart: chart,
+ fields: [].concat(me.yField)
+ }).calcEnds();
+ minY = axis.from;
+ maxY = axis.to;
+ }
-
- ctype : 'Ext.Component',
+ if (isNaN(minX)) {
+ minX = 0;
+ xScale = bbox.width / (store.getCount() - 1);
+ }
+ else {
+ xScale = bbox.width / (maxX - minX);
+ }
-
- actionMode : 'el',
+ if (isNaN(minY)) {
+ minY = 0;
+ yScale = bbox.height / (store.getCount() - 1);
+ }
+ else {
+ yScale = bbox.height / (maxY - minY);
+ }
-
- getActionEl : function(){
- return this[this.actionMode];
- },
+ store.each(function(record, i) {
+ xValue = record.get(me.xField);
+ yValue = record.get(me.yField);
+
+ if (typeof yValue == 'undefined' || (typeof yValue == 'string' && !yValue)) {
+ if (Ext.isDefined(Ext.global.console)) {
+ Ext.global.console.warn("[Ext.chart.series.Line] Skipping a store element with an undefined value at ", record, xValue, yValue);
+ }
+ return;
+ }
+
+ if (typeof xValue == 'string' || typeof xValue == 'object'
+
+ || (me.axis != 'top' && me.axis != 'bottom')) {
+ xValue = i;
+ }
+ if (typeof yValue == 'string' || typeof yValue == 'object'
+
+ || (me.axis != 'left' && me.axis != 'right')) {
+ yValue = i;
+ }
+ xValues.push(xValue);
+ yValues.push(yValue);
+ }, me);
+
+ ln = xValues.length;
+ if (ln > bbox.width) {
+ coords = me.shrink(xValues, yValues, bbox.width);
+ xValues = coords.x;
+ yValues = coords.y;
+ }
+
+ me.items = [];
+
+ ln = xValues.length;
+ for (i = 0; i < ln; i++) {
+ xValue = xValues[i];
+ yValue = yValues[i];
+ if (yValue === false) {
+ if (path.length == 1) {
+ path = [];
+ }
+ onbreak = true;
+ me.items.push(false);
+ continue;
+ } else {
+ x = (bbox.x + (xValue - minX) * xScale).toFixed(2);
+ y = ((bbox.y + bbox.height) - (yValue - minY) * yScale).toFixed(2);
+ if (onbreak) {
+ onbreak = false;
+ path.push('M');
+ }
+ path = path.concat([x, y]);
+ }
+ if ((typeof firstY == 'undefined') && (typeof y != 'undefined')) {
+ firstY = y;
+ }
+
+ if (!me.line || chart.resizing) {
+ dummyPath = dummyPath.concat([x, bbox.y + bbox.height / 2]);
+ }
- initPlugin : function(p){
- if(p.ptype && !Ext.isFunction(p.init)){
- p = Ext.ComponentMgr.createPlugin(p);
- }else if(Ext.isString(p)){
- p = Ext.ComponentMgr.createPlugin({
- ptype: p
+
+ if (chart.animate && chart.resizing && me.line) {
+ me.line.setAttributes({
+ path: dummyPath
+ }, true);
+ if (me.fillPath) {
+ me.fillPath.setAttributes({
+ path: dummyPath,
+ opacity: 0.2
+ }, true);
+ }
+ if (me.line.shadows) {
+ shadows = me.line.shadows;
+ for (j = 0, lnsh = shadows.length; j < lnsh; j++) {
+ shadow = shadows[j];
+ shadow.setAttributes({
+ path: dummyPath
+ }, true);
+ }
+ }
+ }
+ if (showMarkers) {
+ marker = markerGroup.getAt(i);
+ if (!marker) {
+ marker = Ext.chart.Shape[type](surface, Ext.apply({
+ group: [group, markerGroup],
+ x: 0, y: 0,
+ translate: {
+ x: prevX || x,
+ y: prevY || (bbox.y + bbox.height / 2)
+ },
+ value: '"' + xValue + ', ' + yValue + '"'
+ }, endMarkerStyle));
+ marker._to = {
+ translate: {
+ x: x,
+ y: y
+ }
+ };
+ } else {
+ marker.setAttributes({
+ value: '"' + xValue + ', ' + yValue + '"',
+ x: 0, y: 0,
+ hidden: false
+ }, true);
+ marker._to = {
+ translate: {
+ x: x, y: y
+ }
+ };
+ }
+ }
+ me.items.push({
+ series: me,
+ value: [xValue, yValue],
+ point: [x, y],
+ sprite: marker,
+ storeItem: store.getAt(i)
});
+ prevX = x;
+ prevY = y;
}
- p.init(this);
- return p;
- },
-
-
- initComponent : function(){
- if(this.listeners){
- this.on(this.listeners);
- delete this.listeners;
+ if (path.length <= 1) {
+
+ return;
+ }
+
+ if (me.smooth) {
+ path = Ext.draw.Draw.smooth(path, 6);
+ }
+
+
+ if (chart.markerIndex && me.previousPath) {
+ fromPath = me.previousPath;
+ fromPath.splice(1, 2);
+ } else {
+ fromPath = path;
}
- this.enableBubble(this.bubbleEvents);
- },
-
- render : function(container, position){
- if(!this.rendered && this.fireEvent('beforerender', this) !== false){
- if(!container && this.el){
- this.el = Ext.get(this.el);
- container = this.el.dom.parentNode;
- this.allowDomMove = false;
- }
- this.container = Ext.get(container);
- if(this.ctCls){
- this.container.addClass(this.ctCls);
+
+ if (!me.line) {
+ me.line = surface.add(Ext.apply({
+ type: 'path',
+ group: group,
+ path: dummyPath,
+ stroke: endLineStyle.stroke || endLineStyle.fill
+ }, endLineStyle || {}));
+
+ me.line.setAttributes({
+ fill: 'none'
+ });
+ if (!endLineStyle.stroke && colorArrayLength) {
+ me.line.setAttributes({
+ stroke: colorArrayStyle[seriesIdx % colorArrayLength]
+ }, true);
}
- this.rendered = true;
- if(position !== undefined){
- if(Ext.isNumber(position)){
- position = this.container.dom.childNodes[position];
- }else{
- position = Ext.getDom(position);
+ if (enableShadows) {
+
+ shadows = me.line.shadows = [];
+ for (shindex = 0; shindex < lnsh; shindex++) {
+ shadowBarAttr = shadowAttributes[shindex];
+ shadowBarAttr = Ext.apply({}, shadowBarAttr, { path: dummyPath });
+ shadow = chart.surface.add(Ext.apply({}, {
+ type: 'path',
+ group: shadowGroups[shindex]
+ }, shadowBarAttr));
+ shadows.push(shadow);
}
}
- this.onRender(this.container, position || null);
- if(this.autoShow){
- this.el.removeClass(['x-hidden','x-hide-' + this.hideMode]);
- }
- if(this.cls){
- this.el.addClass(this.cls);
- delete this.cls;
- }
- if(this.style){
- this.el.applyStyles(this.style);
- delete this.style;
- }
- if(this.overCls){
- this.el.addClassOnOver(this.overCls);
+ }
+ if (me.fill) {
+ fillPath = path.concat([
+ ["L", x, bbox.y + bbox.height],
+ ["L", bbox.x, bbox.y + bbox.height],
+ ["L", bbox.x, firstY]
+ ]);
+ if (!me.fillPath) {
+ me.fillPath = surface.add({
+ group: group,
+ type: 'path',
+ opacity: endLineStyle.opacity || 0.3,
+ fill: colorArrayStyle[seriesIdx % colorArrayLength] || endLineStyle.fill,
+ path: dummyPath
+ });
}
- this.fireEvent('render', this);
-
-
+ }
+ markerCount = showMarkers && markerGroup.getCount();
+ if (chart.animate) {
+ fill = me.fill;
+ line = me.line;
+ rendererAttributes = me.renderer(line, false, { path: path }, i, store);
+ Ext.apply(rendererAttributes, endLineStyle || {}, {
+ stroke: endLineStyle.stroke || endLineStyle.fill
+ });
+
+ delete rendererAttributes.fill;
+ if (chart.markerIndex && me.previousPath) {
+ me.animation = animation = me.onAnimate(line, {
+ to: rendererAttributes,
+ from: {
+ path: fromPath
+ }
+ });
+ } else {
+ me.animation = animation = me.onAnimate(line, {
+ to: rendererAttributes
+ });
+ }
- var contentTarget = this.getContentTarget();
- if (this.html){
- contentTarget.update(Ext.DomHelper.markup(this.html));
- delete this.html;
+ if (enableShadows) {
+ shadows = line.shadows;
+ for(j = 0; j < lnsh; j++) {
+ if (chart.markerIndex && me.previousPath) {
+ me.onAnimate(shadows[j], {
+ to: { path: path },
+ from: { path: fromPath }
+ });
+ } else {
+ me.onAnimate(shadows[j], {
+ to: { path: path }
+ });
+ }
+ }
}
- if (this.contentEl){
- var ce = Ext.getDom(this.contentEl);
- Ext.fly(ce).removeClass(['x-hidden', 'x-hide-display']);
- contentTarget.appendChild(ce);
+
+ if (fill) {
+ me.onAnimate(me.fillPath, {
+ to: Ext.apply({}, {
+ path: fillPath,
+ fill: colorArrayStyle[seriesIdx % colorArrayLength] || endLineStyle.fill
+ }, endLineStyle || {})
+ });
}
- if (this.tpl) {
- if (!this.tpl.compile) {
- this.tpl = new Ext.XTemplate(this.tpl);
+
+ if (showMarkers) {
+ for(i = 0; i < ln; i++) {
+ item = markerGroup.getAt(i);
+ if (item) {
+ if (me.items[i]) {
+ rendererAttributes = me.renderer(item, store.getAt(i), item._to, i, store);
+ me.onAnimate(item, {
+ to: Ext.apply(rendererAttributes, endMarkerStyle || {})
+ });
+ } else {
+ item.setAttributes(Ext.apply({
+ hidden: true
+ }, item._to), true);
+ }
+ }
}
- if (this.data) {
- this.tpl[this.tplWriteMode](contentTarget, this.data);
- delete this.data;
+ for(; i < markerCount; i++) {
+ item = markerGroup.getAt(i);
+ item.hide(true);
}
- }
- this.afterRender(this.container);
- if(this.hidden){
-
- this.doHide();
+
+
}
- if(this.disabled){
-
- this.disable(true);
+ } else {
+ rendererAttributes = me.renderer(me.line, false, { path: path, hidden: false }, i, store);
+ Ext.apply(rendererAttributes, endLineStyle || {}, {
+ stroke: endLineStyle.stroke || endLineStyle.fill
+ });
+
+ delete rendererAttributes.fill;
+ me.line.setAttributes(rendererAttributes, true);
+
+ if (enableShadows) {
+ shadows = me.line.shadows;
+ for(j = 0; j < lnsh; j++) {
+ shadows[j].setAttributes({
+ path: path
+ }, true);
+ }
}
-
- if(this.stateful !== false){
- this.initStateEvents();
+ if (me.fill) {
+ me.fillPath.setAttributes({
+ path: fillPath
+ }, true);
+ }
+ if (showMarkers) {
+ for(i = 0; i < ln; i++) {
+ item = markerGroup.getAt(i);
+ if (item) {
+ if (me.items[i]) {
+ rendererAttributes = me.renderer(item, store.getAt(i), item._to, i, store);
+ item.setAttributes(Ext.apply(endMarkerStyle || {}, rendererAttributes || {}), true);
+ } else {
+ item.hide(true);
+ }
+ }
+ }
+ for(; i < markerCount; i++) {
+ item = markerGroup.getAt(i);
+ item.hide(true);
+ }
}
- this.fireEvent('afterrender', this);
}
- return this;
- },
-
-
- update: function(htmlOrData, loadScripts, cb) {
- var contentTarget = this.getContentTarget();
- if (this.tpl && typeof htmlOrData !== "string") {
- this.tpl[this.tplWriteMode](contentTarget, htmlOrData || {});
- } else {
- var html = Ext.isObject(htmlOrData) ? Ext.DomHelper.markup(htmlOrData) : htmlOrData;
- contentTarget.update(html, loadScripts, cb);
+ if (chart.markerIndex) {
+ path.splice(1, 0, path[1], path[2]);
+ me.previousPath = path;
}
+ me.renderLabels();
+ me.renderCallouts();
},
-
-
- onAdded : function(container, pos) {
- this.ownerCt = container;
- this.initRef();
- this.fireEvent('added', this, container, pos);
- },
-
- onRemoved : function() {
- this.removeRef();
- this.fireEvent('removed', this, this.ownerCt);
- delete this.ownerCt;
- },
+ onCreateLabel: function(storeItem, item, i, display) {
+ var me = this,
+ group = me.labelsGroup,
+ config = me.label,
+ bbox = me.bbox,
+ endLabelStyle = Ext.apply(config, me.seriesLabelStyle);
+ return me.chart.surface.add(Ext.apply({
+ 'type': 'text',
+ 'text-anchor': 'middle',
+ 'group': group,
+ 'x': item.point[0],
+ 'y': bbox.y + bbox.height / 2
+ }, endLabelStyle || {}));
+ },
+
- initRef : function() {
+ onPlaceLabel: function(label, storeItem, item, i, display, animate) {
+ var me = this,
+ chart = me.chart,
+ resizing = chart.resizing,
+ config = me.label,
+ format = config.renderer,
+ field = config.field,
+ bbox = me.bbox,
+ x = item.point[0],
+ y = item.point[1],
+ radius = item.sprite.attr.radius,
+ bb, width, height;
+
+ label.setAttributes({
+ text: format(storeItem.get(field)),
+ hidden: true
+ }, true);
- if(this.ref && !this.refOwner){
- var levels = this.ref.split('/'),
- last = levels.length,
- i = 0,
- t = this;
-
- while(t && i < last){
- t = t.ownerCt;
- ++i;
- }
- if(t){
- t[this.refName = levels[--i]] = this;
-
- this.refOwner = t;
+ if (display == 'rotate') {
+ label.setAttributes({
+ 'text-anchor': 'start',
+ 'rotation': {
+ x: x,
+ y: y,
+ degrees: -45
+ }
+ }, true);
+
+ bb = label.getBBox();
+ width = bb.width;
+ height = bb.height;
+ x = x < bbox.x? bbox.x : x;
+ x = (x + width > bbox.x + bbox.width)? (x - (x + width - bbox.x - bbox.width)) : x;
+ y = (y - height < bbox.y)? bbox.y + height : y;
+
+ } else if (display == 'under' || display == 'over') {
+
+ bb = item.sprite.getBBox();
+ bb.width = bb.width || (radius * 2);
+ bb.height = bb.height || (radius * 2);
+ y = y + (display == 'over'? -bb.height : bb.height);
+
+ bb = label.getBBox();
+ width = bb.width/2;
+ height = bb.height/2;
+ x = x - width < bbox.x? bbox.x + width : x;
+ x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
+ y = y - height < bbox.y? bbox.y + height : y;
+ y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
+ }
+
+ if (me.chart.animate && !me.chart.resizing) {
+ label.show(true);
+ me.onAnimate(label, {
+ to: {
+ x: x,
+ y: y
+ }
+ });
+ } else {
+ label.setAttributes({
+ x: x,
+ y: y
+ }, true);
+ if (resizing) {
+ me.animation.on('afteranimate', function() {
+ label.show(true);
+ });
+ } else {
+ label.show(true);
}
}
},
- removeRef : function() {
- if (this.refOwner && this.refName) {
- delete this.refOwner[this.refName];
- delete this.refOwner;
+ //@private Overriding highlights.js highlightItem method.
+
+ highlightItem: function() {
+ var me = this;
+ me.callParent(arguments);
+ if (this.line && !this.highlighted) {
+ if (!('__strokeWidth' in this.line)) {
+ this.line.__strokeWidth = this.line.attr['stroke-width'] || 0;
+ }
+ if (this.line.__anim) {
+ this.line.__anim.paused = true;
+ }
+ this.line.__anim = Ext.create('Ext.fx.Anim', {
+ target: this.line,
+ to: {
+ 'stroke-width': this.line.__strokeWidth + 3
+ }
+ });
+ this.highlighted = true;
}
},
-
- initState : function(){
- if(Ext.state.Manager){
- var id = this.getStateId();
- if(id){
- var state = Ext.state.Manager.get(id);
- if(state){
- if(this.fireEvent('beforestaterestore', this, state) !== false){
- this.applyState(Ext.apply({}, state));
- this.fireEvent('staterestore', this, state);
- }
+ //@private Overriding highlights.js unHighlightItem method.
+
+ unHighlightItem: function() {
+ var me = this;
+ me.callParent(arguments);
+ if (this.line && this.highlighted) {
+ this.line.__anim = Ext.create('Ext.fx.Anim', {
+ target: this.line,
+ to: {
+ 'stroke-width': this.line.__strokeWidth
}
- }
+ });
+ this.highlighted = false;
}
},
-
- getStateId : function(){
- return this.stateId || ((/^(ext-comp-|ext-gen)/).test(String(this.id)) ? null : this.id);
- },
+ //@private called when a callout needs to be placed.
-
- initStateEvents : function(){
- if(this.stateEvents){
- for(var i = 0, e; e = this.stateEvents[i]; i++){
- this.on(e, this.saveState, this, {delay:100});
- }
+ onPlaceCallout : function(callout, storeItem, item, i, display, animate, index) {
+ if (!display) {
+ return;
}
- },
+
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ resizing = chart.resizing,
+ config = me.callouts,
+ items = me.items,
+ prev = i == 0? false : items[i -1].point,
+ next = (i == items.length -1)? false : items[i +1].point,
+ cur = [+item.point[0], +item.point[1]],
+ dir, norm, normal, a, aprev, anext,
+ offsetFromViz = config.offsetFromViz || 30,
+ offsetToSide = config.offsetToSide || 10,
+ offsetBox = config.offsetBox || 3,
+ boxx, boxy, boxw, boxh,
+ p, clipRect = me.clipRect,
+ bbox = {
+ width: config.styles.width || 10,
+ height: config.styles.height || 10
+ },
+ x, y;
-
- applyState : function(state){
- if(state){
- Ext.apply(this, state);
+
+ if (!prev) {
+ prev = cur;
}
- },
+ if (!next) {
+ next = cur;
+ }
+ a = (next[1] - prev[1]) / (next[0] - prev[0]);
+ aprev = (cur[1] - prev[1]) / (cur[0] - prev[0]);
+ anext = (next[1] - cur[1]) / (next[0] - cur[0]);
+
+ norm = Math.sqrt(1 + a * a);
+ dir = [1 / norm, a / norm];
+ normal = [-dir[1], dir[0]];
+
+
+ if (aprev > 0 && anext < 0 && normal[1] < 0
+ || aprev < 0 && anext > 0 && normal[1] > 0) {
+ normal[0] *= -1;
+ normal[1] *= -1;
+ } else if (Math.abs(aprev) < Math.abs(anext) && normal[0] < 0
+ || Math.abs(aprev) > Math.abs(anext) && normal[0] > 0) {
+ normal[0] *= -1;
+ normal[1] *= -1;
+ }
+
+ x = cur[0] + normal[0] * offsetFromViz;
+ y = cur[1] + normal[1] * offsetFromViz;
-
- getState : function(){
- return null;
- },
+
+ boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+ boxy = y - bbox.height /2 - offsetBox;
+ boxw = bbox.width + 2 * offsetBox;
+ boxh = bbox.height + 2 * offsetBox;
+
+
+
+ if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
+ normal[0] *= -1;
+ }
+ if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
+ normal[1] *= -1;
+ }
-
- saveState : function(){
- if(Ext.state.Manager && this.stateful !== false){
- var id = this.getStateId();
- if(id){
- var state = this.getState();
- if(this.fireEvent('beforestatesave', this, state) !== false){
- Ext.state.Manager.set(id, state);
- this.fireEvent('statesave', this, state);
+
+ x = cur[0] + normal[0] * offsetFromViz;
+ y = cur[1] + normal[1] * offsetFromViz;
+
+
+ boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+ boxy = y - bbox.height /2 - offsetBox;
+ boxw = bbox.width + 2 * offsetBox;
+ boxh = bbox.height + 2 * offsetBox;
+
+ if (chart.animate) {
+
+ me.onAnimate(callout.lines, {
+ to: {
+ path: ["M", cur[0], cur[1], "L", x, y, "Z"]
}
+ });
+
+ if (callout.panel) {
+ callout.panel.setPosition(boxx, boxy, true);
}
}
- },
-
-
- applyToMarkup : function(el){
- this.allowDomMove = false;
- this.el = Ext.get(el);
- this.render(this.el.dom.parentNode);
- },
-
-
- addClass : function(cls){
- if(this.el){
- this.el.addClass(cls);
- }else{
- this.cls = this.cls ? this.cls + ' ' + cls : cls;
+ else {
+
+ callout.lines.setAttributes({
+ path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+ }, true);
+
+ if (callout.panel) {
+ callout.panel.setPosition(boxx, boxy);
+ }
+ }
+ for (p in callout) {
+ callout[p].show(true);
}
- return this;
},
-
- removeClass : function(cls){
- if(this.el){
- this.el.removeClass(cls);
- }else if(this.cls){
- this.cls = this.cls.split(' ').remove(cls).join(' ');
+ isItemInPoint: function(x, y, item, i) {
+ var me = this,
+ items = me.items,
+ tolerance = me.selectionTolerance,
+ result = null,
+ prevItem,
+ nextItem,
+ prevPoint,
+ nextPoint,
+ ln,
+ x1,
+ y1,
+ x2,
+ y2,
+ xIntersect,
+ yIntersect,
+ dist1, dist2, dist, midx, midy,
+ sqrt = Math.sqrt, abs = Math.abs;
+
+ nextItem = items[i];
+ prevItem = i && items[i - 1];
+
+ if (i >= ln) {
+ prevItem = items[ln - 1];
+ }
+ prevPoint = prevItem && prevItem.point;
+ nextPoint = nextItem && nextItem.point;
+ x1 = prevItem ? prevPoint[0] : nextPoint[0] - tolerance;
+ y1 = prevItem ? prevPoint[1] : nextPoint[1];
+ x2 = nextItem ? nextPoint[0] : prevPoint[0] + tolerance;
+ y2 = nextItem ? nextPoint[1] : prevPoint[1];
+ dist1 = sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
+ dist2 = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
+ dist = Math.min(dist1, dist2);
+
+ if (dist <= tolerance) {
+ return dist == dist1? prevItem : nextItem;
}
- return this;
+ return false;
},
-
- onRender : function(ct, position){
- if(!this.el && this.autoEl){
- if(Ext.isString(this.autoEl)){
- this.el = document.createElement(this.autoEl);
- }else{
- var div = document.createElement('div');
- Ext.DomHelper.overwrite(div, this.autoEl);
- this.el = div.firstChild;
- }
- if (!this.el.id) {
- this.el.id = this.getId();
- }
+ toggleAll: function(show) {
+ var me = this,
+ i, ln, shadow, shadows;
+ if (!show) {
+ Ext.chart.series.Line.superclass.hideAll.call(me);
}
- if(this.el){
- this.el = Ext.get(this.el);
- if(this.allowDomMove !== false){
- ct.dom.insertBefore(this.el.dom, position);
- if (div) {
- Ext.removeNode(div);
- div = null;
+ else {
+ Ext.chart.series.Line.superclass.showAll.call(me);
+ }
+ if (me.line) {
+ me.line.setAttributes({
+ hidden: !show
+ }, true);
+
+ if (me.line.shadows) {
+ for (i = 0, shadows = me.line.shadows, ln = shadows.length; i < ln; i++) {
+ shadow = shadows[i];
+ shadow.setAttributes({
+ hidden: !show
+ }, true);
}
}
}
- },
-
-
- getAutoCreate : function(){
- var cfg = Ext.isObject(this.autoCreate) ?
- this.autoCreate : Ext.apply({}, this.defaultAutoCreate);
- if(this.id && !cfg.id){
- cfg.id = this.id;
+ if (me.fillPath) {
+ me.fillPath.setAttributes({
+ hidden: !show
+ }, true);
}
- return cfg;
},
-
- afterRender : Ext.emptyFn,
-
- destroy : function(){
- if(!this.isDestroyed){
- if(this.fireEvent('beforedestroy', this) !== false){
- this.destroying = true;
- this.beforeDestroy();
- if(this.ownerCt && this.ownerCt.remove){
- this.ownerCt.remove(this, false);
- }
- if(this.rendered){
- this.el.remove();
- if(this.actionMode == 'container' || this.removeMode == 'container'){
- this.container.remove();
- }
- }
-
- if(this.focusTask && this.focusTask.cancel){
- this.focusTask.cancel();
- }
- this.onDestroy();
- Ext.ComponentMgr.unregister(this);
- this.fireEvent('destroy', this);
- this.purgeListeners();
- this.destroying = false;
- this.isDestroyed = true;
- }
- }
+ hideAll: function() {
+ this.toggleAll(false);
},
+
+
+ showAll: function() {
+ this.toggleAll(true);
+ }
+});
- deleteMembers : function(){
- var args = arguments;
- for(var i = 0, len = args.length; i < len; ++i){
- delete this[args[i]];
- }
- },
+Ext.define('Ext.chart.series.Pie', {
- beforeDestroy : Ext.emptyFn,
-
- onDestroy : Ext.emptyFn,
+ alternateClassName: ['Ext.chart.PieSeries', 'Ext.chart.PieChart'],
-
- getEl : function(){
- return this.el;
- },
+ extend: 'Ext.chart.series.Series',
- getContentTarget : function(){
- return this.el;
- },
+ type: "pie",
- getId : function(){
- return this.id || (this.id = 'ext-comp-' + (++Ext.Component.AUTO_ID));
- },
+ alias: 'series.pie',
-
- getItemId : function(){
- return this.itemId || this.getId();
- },
+ rad: Math.PI / 180,
- focus : function(selectText, delay){
- if(delay){
- this.focusTask = new Ext.util.DelayedTask(this.focus, this, [selectText, false]);
- this.focusTask.delay(Ext.isNumber(delay) ? delay : 10);
- return this;
- }
- if(this.rendered && !this.isDestroyed){
- this.el.focus();
- if(selectText === true){
- this.el.dom.select();
- }
- }
- return this;
- },
+ highlightDuration: 150,
- blur : function(){
- if(this.rendered){
- this.el.blur();
- }
- return this;
- },
+ angleField: false,
- disable : function( silent){
- if(this.rendered){
- this.onDisable();
- }
- this.disabled = true;
- if(silent !== true){
- this.fireEvent('disable', this);
- }
- return this;
- },
+ lengthField: false,
- onDisable : function(){
- this.getActionEl().addClass(this.disabledClass);
- this.el.dom.disabled = true;
- },
+ donut: false,
- enable : function(){
- if(this.rendered){
- this.onEnable();
- }
- this.disabled = false;
- this.fireEvent('enable', this);
- return this;
- },
+ showInLegend: false,
- onEnable : function(){
- this.getActionEl().removeClass(this.disabledClass);
- this.el.dom.disabled = false;
- },
-
- setDisabled : function(disabled){
- return this[disabled ? 'disable' : 'enable']();
- },
-
- show : function(){
- if(this.fireEvent('beforeshow', this) !== false){
- this.hidden = false;
- if(this.autoRender){
- this.render(Ext.isBoolean(this.autoRender) ? Ext.getBody() : this.autoRender);
+ style: {},
+
+ constructor: function(config) {
+ this.callParent(arguments);
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ store = chart.store,
+ shadow = chart.shadow, i, l, cfg;
+ Ext.applyIf(me, {
+ highlightCfg: {
+ segment: {
+ margin: 20
+ }
}
- if(this.rendered){
- this.onShow();
+ });
+ Ext.apply(me, config, {
+ shadowAttributes: [{
+ "stroke-width": 6,
+ "stroke-opacity": 1,
+ stroke: 'rgb(200, 200, 200)',
+ translate: {
+ x: 1.2,
+ y: 2
+ }
+ },
+ {
+ "stroke-width": 4,
+ "stroke-opacity": 1,
+ stroke: 'rgb(150, 150, 150)',
+ translate: {
+ x: 0.9,
+ y: 1.5
+ }
+ },
+ {
+ "stroke-width": 2,
+ "stroke-opacity": 1,
+ stroke: 'rgb(100, 100, 100)',
+ translate: {
+ x: 0.6,
+ y: 1
+ }
+ }]
+ });
+ me.group = surface.getGroup(me.seriesId);
+ if (shadow) {
+ for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+ me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
}
- this.fireEvent('show', this);
}
- return this;
+ surface.customAttributes.segment = function(opt) {
+ return me.getSegment(opt);
+ };
},
-
- onShow : function(){
- this.getVisibilityEl().removeClass('x-hide-' + this.hideMode);
- },
+ //@private updates some onbefore render parameters.
-
- hide : function(){
- if(this.fireEvent('beforehide', this) !== false){
- this.doHide();
- this.fireEvent('hide', this);
+ initialize: function() {
+ var me = this,
+ store = me.chart.substore || me.chart.store;
+
+ me.yField = [];
+ if (me.label.field) {
+ store.each(function(rec) {
+ me.yField.push(rec.get(me.label.field));
+ });
}
- return this;
},
- doHide: function(){
- this.hidden = true;
- if(this.rendered){
- this.onHide();
+ getSegment: function(opt) {
+ var me = this,
+ rad = me.rad,
+ cos = Math.cos,
+ sin = Math.sin,
+ abs = Math.abs,
+ x = me.centerX,
+ y = me.centerY,
+ x1 = 0, x2 = 0, x3 = 0, x4 = 0,
+ y1 = 0, y2 = 0, y3 = 0, y4 = 0,
+ delta = 1e-2,
+ r = opt.endRho - opt.startRho,
+ startAngle = opt.startAngle,
+ endAngle = opt.endAngle,
+ midAngle = (startAngle + endAngle) / 2 * rad,
+ margin = opt.margin || 0,
+ flag = abs(endAngle - startAngle) > 180,
+ a1 = Math.min(startAngle, endAngle) * rad,
+ a2 = Math.max(startAngle, endAngle) * rad,
+ singleSlice = false;
+
+ x += margin * cos(midAngle);
+ y += margin * sin(midAngle);
+
+ x1 = x + opt.startRho * cos(a1);
+ y1 = y + opt.startRho * sin(a1);
+
+ x2 = x + opt.endRho * cos(a1);
+ y2 = y + opt.endRho * sin(a1);
+
+ x3 = x + opt.startRho * cos(a2);
+ y3 = y + opt.startRho * sin(a2);
+
+ x4 = x + opt.endRho * cos(a2);
+ y4 = y + opt.endRho * sin(a2);
+
+ if (abs(x1 - x3) <= delta && abs(y1 - y3) <= delta) {
+ singleSlice = true;
+ }
+
+ if (singleSlice) {
+ return {
+ path: [
+ ["M", x1, y1],
+ ["L", x2, y2],
+ ["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
+ ["Z"]]
+ };
+ } else {
+ return {
+ path: [
+ ["M", x1, y1],
+ ["L", x2, y2],
+ ["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
+ ["L", x3, y3],
+ ["A", opt.startRho, opt.startRho, 0, +flag, 0, x1, y1],
+ ["Z"]]
+ };
}
},
- onHide : function(){
- this.getVisibilityEl().addClass('x-hide-' + this.hideMode);
+ calcMiddle: function(item) {
+ var me = this,
+ rad = me.rad,
+ slice = item.slice,
+ x = me.centerX,
+ y = me.centerY,
+ startAngle = slice.startAngle,
+ endAngle = slice.endAngle,
+ donut = +me.donut,
+ a1 = Math.min(startAngle, endAngle) * rad,
+ a2 = Math.max(startAngle, endAngle) * rad,
+ midAngle = -(a1 + (a2 - a1) / 2),
+ xm = x + (item.endRho + item.startRho) / 2 * Math.cos(midAngle),
+ ym = y - (item.endRho + item.startRho) / 2 * Math.sin(midAngle);
+
+ item.middle = {
+ x: xm,
+ y: ym
+ };
},
- getVisibilityEl : function(){
- return this.hideParent ? this.container : this.getActionEl();
- },
+ drawSeries: function() {
+ var me = this,
+ store = me.chart.substore || me.chart.store,
+ group = me.group,
+ animate = me.chart.animate,
+ field = me.angleField || me.field || me.xField,
+ lenField = [].concat(me.lengthField),
+ totalLenField = 0,
+ colors = me.colorSet,
+ chart = me.chart,
+ surface = chart.surface,
+ chartBBox = chart.chartBBox,
+ enableShadows = chart.shadow,
+ shadowGroups = me.shadowGroups,
+ shadowAttributes = me.shadowAttributes,
+ lnsh = shadowGroups.length,
+ rad = me.rad,
+ layers = lenField.length,
+ rhoAcum = 0,
+ donut = +me.donut,
+ layerTotals = [],
+ values = {},
+ fieldLength,
+ items = [],
+ passed = false,
+ totalField = 0,
+ maxLenField = 0,
+ cut = 9,
+ defcut = true,
+ angle = 0,
+ seriesStyle = me.seriesStyle,
+ seriesLabelStyle = me.seriesLabelStyle,
+ colorArrayStyle = me.colorArrayStyle,
+ colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
+ gutterX = chart.maxGutter[0],
+ gutterY = chart.maxGutter[1],
+ rendererAttributes,
+ shadowGroup,
+ shadowAttr,
+ shadows,
+ shadow,
+ shindex,
+ centerX,
+ centerY,
+ deltaRho,
+ first = 0,
+ slice,
+ slices,
+ sprite,
+ value,
+ item,
+ lenValue,
+ ln,
+ record,
+ i,
+ j,
+ startAngle,
+ endAngle,
+ middleAngle,
+ sliceLength,
+ path,
+ p,
+ spriteOptions, bbox;
+
+ Ext.apply(seriesStyle, me.style || {});
-
- setVisible : function(visible){
- return this[visible ? 'show' : 'hide']();
- },
+ me.setBBox();
+ bbox = me.bbox;
-
- isVisible : function(){
- return this.rendered && this.getVisibilityEl().isVisible();
- },
+
+ if (me.colorSet) {
+ colorArrayStyle = me.colorSet;
+ colorArrayLength = colorArrayStyle.length;
+ }
+
+
+ if (!store || !store.getCount()) {
+ return;
+ }
+
+ me.unHighlightItem();
+ me.cleanHighlights();
-
- cloneConfig : function(overrides){
- overrides = overrides || {};
- var id = overrides.id || Ext.id();
- var cfg = Ext.applyIf(overrides, this.initialConfig);
- cfg.id = id;
- return new this.constructor(cfg);
+ centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
+ centerY = me.centerY = chartBBox.y + (chartBBox.height / 2);
+ me.radius = Math.min(centerX - chartBBox.x, centerY - chartBBox.y);
+ me.slices = slices = [];
+ me.items = items = [];
+
+ store.each(function(record, i) {
+ if (this.__excludes && this.__excludes[i]) {
+
+ return;
+ }
+ totalField += +record.get(field);
+ if (lenField[0]) {
+ for (j = 0, totalLenField = 0; j < layers; j++) {
+ totalLenField += +record.get(lenField[j]);
+ }
+ layerTotals[i] = totalLenField;
+ maxLenField = Math.max(maxLenField, totalLenField);
+ }
+ }, this);
+
+ store.each(function(record, i) {
+ if (this.__excludes && this.__excludes[i]) {
+
+ return;
+ }
+ value = record.get(field);
+ middleAngle = angle - 360 * value / totalField / 2;
+
+ if (isNaN(middleAngle)) {
+ middleAngle = 360;
+ value = 1;
+ totalField = 1;
+ }
+
+ if (!i || first == 0) {
+ angle = 360 - middleAngle;
+ me.firstAngle = angle;
+ middleAngle = angle - 360 * value / totalField / 2;
+ }
+ endAngle = angle - 360 * value / totalField;
+ slice = {
+ series: me,
+ value: value,
+ startAngle: angle,
+ endAngle: endAngle,
+ storeItem: record
+ };
+ if (lenField[0]) {
+ lenValue = layerTotals[i];
+ slice.rho = me.radius * (lenValue / maxLenField);
+ } else {
+ slice.rho = me.radius;
+ }
+ slices[i] = slice;
+ if((slice.startAngle % 360) == (slice.endAngle % 360)) {
+ slice.startAngle -= 0.0001;
+ }
+ angle = endAngle;
+ first++;
+ }, me);
+
+
+ if (enableShadows) {
+ for (i = 0, ln = slices.length; i < ln; i++) {
+ if (this.__excludes && this.__excludes[i]) {
+
+ continue;
+ }
+ slice = slices[i];
+ slice.shadowAttrs = [];
+ for (j = 0, rhoAcum = 0, shadows = []; j < layers; j++) {
+ sprite = group.getAt(i * layers + j);
+ deltaRho = lenField[j] ? store.getAt(i).get(lenField[j]) / layerTotals[i] * slice.rho: slice.rho;
+
+ rendererAttributes = {
+ segment: {
+ startAngle: slice.startAngle,
+ endAngle: slice.endAngle,
+ margin: 0,
+ rho: slice.rho,
+ startRho: rhoAcum + (deltaRho * donut / 100),
+ endRho: rhoAcum + deltaRho
+ }
+ };
+
+ for (shindex = 0, shadows = []; shindex < lnsh; shindex++) {
+ shadowAttr = shadowAttributes[shindex];
+ shadow = shadowGroups[shindex].getAt(i);
+ if (!shadow) {
+ shadow = chart.surface.add(Ext.apply({},
+ {
+ type: 'path',
+ group: shadowGroups[shindex],
+ strokeLinejoin: "round"
+ },
+ rendererAttributes, shadowAttr));
+ }
+ if (animate) {
+ rendererAttributes = me.renderer(shadow, store.getAt(i), Ext.apply({},
+ rendererAttributes, shadowAttr), i, store);
+ me.onAnimate(shadow, {
+ to: rendererAttributes
+ });
+ } else {
+ rendererAttributes = me.renderer(shadow, store.getAt(i), Ext.apply(shadowAttr, {
+ hidden: false
+ }), i, store);
+ shadow.setAttributes(rendererAttributes, true);
+ }
+ shadows.push(shadow);
+ }
+ slice.shadowAttrs[j] = shadows;
+ }
+ }
+ }
+
+ for (i = 0, ln = slices.length; i < ln; i++) {
+ if (this.__excludes && this.__excludes[i]) {
+
+ continue;
+ }
+ slice = slices[i];
+ for (j = 0, rhoAcum = 0; j < layers; j++) {
+ sprite = group.getAt(i * layers + j);
+ deltaRho = lenField[j] ? store.getAt(i).get(lenField[j]) / layerTotals[i] * slice.rho: slice.rho;
+
+ rendererAttributes = Ext.apply({
+ segment: {
+ startAngle: slice.startAngle,
+ endAngle: slice.endAngle,
+ margin: 0,
+ rho: slice.rho,
+ startRho: rhoAcum + (deltaRho * donut / 100),
+ endRho: rhoAcum + deltaRho
+ }
+ }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[(layers > 1? j : i) % colorArrayLength] } || {}));
+ item = Ext.apply({},
+ rendererAttributes.segment, {
+ slice: slice,
+ series: me,
+ storeItem: slice.storeItem,
+ index: i
+ });
+ me.calcMiddle(item);
+ if (enableShadows) {
+ item.shadows = slice.shadowAttrs[j];
+ }
+ items[i] = item;
+
+ if (!sprite) {
+ spriteOptions = Ext.apply({
+ type: "path",
+ group: group,
+ middle: item.middle
+ }, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[(layers > 1? j : i) % colorArrayLength] } || {}));
+ sprite = surface.add(Ext.apply(spriteOptions, rendererAttributes));
+ }
+ slice.sprite = slice.sprite || [];
+ item.sprite = sprite;
+ slice.sprite.push(sprite);
+ slice.point = [item.middle.x, item.middle.y];
+ if (animate) {
+ rendererAttributes = me.renderer(sprite, store.getAt(i), rendererAttributes, i, store);
+ sprite._to = rendererAttributes;
+ sprite._animating = true;
+ me.onAnimate(sprite, {
+ to: rendererAttributes,
+ listeners: {
+ afteranimate: {
+ fn: function() {
+ this._animating = false;
+ },
+ scope: sprite
+ }
+ }
+ });
+ } else {
+ rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply(rendererAttributes, {
+ hidden: false
+ }), i, store);
+ sprite.setAttributes(rendererAttributes, true);
+ }
+ rhoAcum += deltaRho;
+ }
+ }
+
+
+ ln = group.getCount();
+ for (i = 0; i < ln; i++) {
+ if (!slices[(i / layers) >> 0] && group.getAt(i)) {
+ group.getAt(i).hide(true);
+ }
+ }
+ if (enableShadows) {
+ lnsh = shadowGroups.length;
+ for (shindex = 0; shindex < ln; shindex++) {
+ if (!slices[(shindex / layers) >> 0]) {
+ for (j = 0; j < lnsh; j++) {
+ if (shadowGroups[j].getAt(shindex)) {
+ shadowGroups[j].getAt(shindex).hide(true);
+ }
+ }
+ }
+ }
+ }
+ me.renderLabels();
+ me.renderCallouts();
},
- getXType : function(){
- return this.constructor.xtype;
+ onCreateLabel: function(storeItem, item, i, display) {
+ var me = this,
+ group = me.labelsGroup,
+ config = me.label,
+ centerX = me.centerX,
+ centerY = me.centerY,
+ middle = item.middle,
+ endLabelStyle = Ext.apply(me.seriesLabelStyle || {}, config || {});
+
+ return me.chart.surface.add(Ext.apply({
+ 'type': 'text',
+ 'text-anchor': 'middle',
+ 'group': group,
+ 'x': middle.x,
+ 'y': middle.y
+ }, endLabelStyle));
},
- isXType : function(xtype, shallow){
+ onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {
+ var me = this,
+ chart = me.chart,
+ resizing = chart.resizing,
+ config = me.label,
+ format = config.renderer,
+ field = [].concat(config.field),
+ centerX = me.centerX,
+ centerY = me.centerY,
+ middle = item.middle,
+ opt = {
+ x: middle.x,
+ y: middle.y
+ },
+ x = middle.x - centerX,
+ y = middle.y - centerY,
+ from = {},
+ rho = 1,
+ theta = Math.atan2(y, x || 1),
+ dg = theta * 180 / Math.PI,
+ prevDg;
- if (Ext.isFunction(xtype)){
- xtype = xtype.xtype;
- }else if (Ext.isObject(xtype)){
- xtype = xtype.constructor.xtype;
+ function fixAngle(a) {
+ if (a < 0) a += 360;
+ return a % 360;
}
- return !shallow ? ('/' + this.getXTypes() + '/').indexOf('/' + xtype + '/') != -1 : this.constructor.xtype == xtype;
- },
+ label.setAttributes({
+ text: format(storeItem.get(field[index]))
+ }, true);
-
- getXTypes : function(){
- var tc = this.constructor;
- if(!tc.xtypes){
- var c = [], sc = this;
- while(sc && sc.constructor.xtype){
- c.unshift(sc.constructor.xtype);
- sc = sc.constructor.superclass;
+ switch (display) {
+ case 'outside':
+ rho = Math.sqrt(x * x + y * y) * 2;
+
+ opt.x = rho * Math.cos(theta) + centerX;
+ opt.y = rho * Math.sin(theta) + centerY;
+ break;
+
+ case 'rotate':
+ dg = fixAngle(dg);
+ dg = (dg > 90 && dg < 270) ? dg + 180: dg;
+
+ prevDg = label.attr.rotation.degrees;
+ if (prevDg != null && Math.abs(prevDg - dg) > 180) {
+ if (dg > prevDg) {
+ dg -= 360;
+ } else {
+ dg += 360;
+ }
+ dg = dg % 360;
+ } else {
+ dg = fixAngle(dg);
}
- tc.xtypeChain = c;
- tc.xtypes = c.join('/');
+
+ opt.rotate = {
+ degrees: dg,
+ x: opt.x,
+ y: opt.y
+ };
+ break;
+
+ default:
+ break;
}
- return tc.xtypes;
+
+ opt.translate = {
+ x: 0, y: 0
+ };
+ if (animate && !resizing && (display != 'rotate' || prevDg != null)) {
+ me.onAnimate(label, {
+ to: opt
+ });
+ } else {
+ label.setAttributes(opt, true);
+ }
+ label._from = from;
},
- findParentBy : function(fn) {
- for (var p = this.ownerCt; (p != null) && !fn(p, this); p = p.ownerCt);
- return p || null;
- },
+ onPlaceCallout: function(callout, storeItem, item, i, display, animate, index) {
+ var me = this,
+ chart = me.chart,
+ resizing = chart.resizing,
+ config = me.callouts,
+ centerX = me.centerX,
+ centerY = me.centerY,
+ middle = item.middle,
+ opt = {
+ x: middle.x,
+ y: middle.y
+ },
+ x = middle.x - centerX,
+ y = middle.y - centerY,
+ rho = 1,
+ rhoCenter,
+ theta = Math.atan2(y, x || 1),
+ bbox = callout.label.getBBox(),
+ offsetFromViz = 20,
+ offsetToSide = 10,
+ offsetBox = 10,
+ p;
-
- findParentByType : function(xtype, shallow){
- return this.findParentBy(function(c){
- return c.isXType(xtype, shallow);
- });
- },
-
-
- bubble : function(fn, scope, args){
- var p = this;
- while(p){
- if(fn.apply(scope || p, args || [p]) === false){
- break;
- }
- p = p.ownerCt;
+
+ rho = item.endRho + offsetFromViz;
+ rhoCenter = (item.endRho + item.startRho) / 2 + (item.endRho - item.startRho) / 3;
+
+ opt.x = rho * Math.cos(theta) + centerX;
+ opt.y = rho * Math.sin(theta) + centerY;
+
+ x = rhoCenter * Math.cos(theta);
+ y = rhoCenter * Math.sin(theta);
+
+ if (chart.animate) {
+
+ me.onAnimate(callout.lines, {
+ to: {
+ path: ["M", x + centerX, y + centerY, "L", opt.x, opt.y, "Z", "M", opt.x, opt.y, "l", x > 0 ? offsetToSide: -offsetToSide, 0, "z"]
+ }
+ });
+
+ me.onAnimate(callout.box, {
+ to: {
+ x: opt.x + (x > 0 ? offsetToSide: -(offsetToSide + bbox.width + 2 * offsetBox)),
+ y: opt.y + (y > 0 ? ( - bbox.height - offsetBox / 2) : ( - bbox.height - offsetBox / 2)),
+ width: bbox.width + 2 * offsetBox,
+ height: bbox.height + 2 * offsetBox
+ }
+ });
+
+ me.onAnimate(callout.label, {
+ to: {
+ x: opt.x + (x > 0 ? (offsetToSide + offsetBox) : -(offsetToSide + bbox.width + offsetBox)),
+ y: opt.y + (y > 0 ? -bbox.height / 4: -bbox.height / 4)
+ }
+ });
+ } else {
+
+ callout.lines.setAttributes({
+ path: ["M", x + centerX, y + centerY, "L", opt.x, opt.y, "Z", "M", opt.x, opt.y, "l", x > 0 ? offsetToSide: -offsetToSide, 0, "z"]
+ },
+ true);
+
+ callout.box.setAttributes({
+ x: opt.x + (x > 0 ? offsetToSide: -(offsetToSide + bbox.width + 2 * offsetBox)),
+ y: opt.y + (y > 0 ? ( - bbox.height - offsetBox / 2) : ( - bbox.height - offsetBox / 2)),
+ width: bbox.width + 2 * offsetBox,
+ height: bbox.height + 2 * offsetBox
+ },
+ true);
+
+ callout.label.setAttributes({
+ x: opt.x + (x > 0 ? (offsetToSide + offsetBox) : -(offsetToSide + bbox.width + offsetBox)),
+ y: opt.y + (y > 0 ? -bbox.height / 4: -bbox.height / 4)
+ },
+ true);
+ }
+ for (p in callout) {
+ callout[p].show(true);
}
- return this;
},
- getPositionEl : function(){
- return this.positionEl || this.el;
+ onAnimate: function(sprite, attr) {
+ sprite.show();
+ return this.callParent(arguments);
},
-
- purgeListeners : function(){
- Ext.Component.superclass.purgeListeners.call(this);
- if(this.mons){
- this.on('beforedestroy', this.clearMons, this, {single: true});
+ isItemInPoint: function(x, y, item, i) {
+ var me = this,
+ cx = me.centerX,
+ cy = me.centerY,
+ abs = Math.abs,
+ dx = abs(x - cx),
+ dy = abs(y - cy),
+ startAngle = item.startAngle,
+ endAngle = item.endAngle,
+ rho = Math.sqrt(dx * dx + dy * dy),
+ angle = Math.atan2(y - cy, x - cx) / me.rad + 360;
+
+
+ if (angle > me.firstAngle) {
+ angle -= 360;
+ }
+ return (angle <= startAngle && angle > endAngle
+ && rho >= item.startRho && rho <= item.endRho);
+ },
+
+
+ hideAll: function() {
+ var i, l, shadow, shadows, sh, lsh, sprite;
+ if (!isNaN(this._index)) {
+ this.__excludes = this.__excludes || [];
+ this.__excludes[this._index] = true;
+ sprite = this.slices[this._index].sprite;
+ for (sh = 0, lsh = sprite.length; sh < lsh; sh++) {
+ sprite[sh].setAttributes({
+ hidden: true
+ }, true);
+ }
+ if (this.slices[this._index].shadowAttrs) {
+ for (i = 0, shadows = this.slices[this._index].shadowAttrs, l = shadows.length; i < l; i++) {
+ shadow = shadows[i];
+ for (sh = 0, lsh = shadow.length; sh < lsh; sh++) {
+ shadow[sh].setAttributes({
+ hidden: true
+ }, true);
+ }
+ }
+ }
+ this.drawSeries();
}
},
-
- clearMons : function(){
- Ext.each(this.mons, function(m){
- m.item.un(m.ename, m.fn, m.scope);
- }, this);
- this.mons = [];
- },
-
- createMons: function(){
- if(!this.mons){
- this.mons = [];
- this.on('beforedestroy', this.clearMons, this, {single: true});
+ showAll: function() {
+ if (!isNaN(this._index)) {
+ this.__excludes[this._index] = false;
+ this.drawSeries();
}
},
- mon : function(item, ename, fn, scope, opt){
- this.createMons();
- if(Ext.isObject(ename)){
- var propRe = /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/;
+ highlightItem: function(item) {
+ var me = this,
+ rad = me.rad;
+ item = item || this.items[this._index];
+
+
+
+
+
+ this.unHighlightItem();
+
+ if (!item || item.sprite && item.sprite._animating) {
+ return;
+ }
+ me.callParent([item]);
+ if (!me.highlight) {
+ return;
+ }
+ if ('segment' in me.highlightCfg) {
+ var highlightSegment = me.highlightCfg.segment,
+ animate = me.chart.animate,
+ attrs, i, shadows, shadow, ln, to, itemHighlightSegment, prop;
+
+ if (me.labelsGroup) {
+ var group = me.labelsGroup,
+ display = me.label.display,
+ label = group.getAt(item.index),
+ middle = (item.startAngle + item.endAngle) / 2 * rad,
+ r = highlightSegment.margin || 0,
+ x = r * Math.cos(middle),
+ y = r * Math.sin(middle);
- var o = ename;
- for(var e in o){
- if(propRe.test(e)){
- continue;
+
+
+
+
+
+ if (Math.abs(x) < 1e-10) {
+ x = 0;
}
- if(Ext.isFunction(o[e])){
-
- this.mons.push({
- item: item, ename: e, fn: o[e], scope: o.scope
- });
- item.on(e, o[e], o.scope, o);
- }else{
-
- this.mons.push({
- item: item, ename: e, fn: o[e], scope: o.scope
+ if (Math.abs(y) < 1e-10) {
+ y = 0;
+ }
+
+ if (animate) {
+ label.stopAnimation();
+ label.animate({
+ to: {
+ translate: {
+ x: x,
+ y: y
+ }
+ },
+ duration: me.highlightDuration
});
- item.on(e, o[e]);
+ }
+ else {
+ label.setAttributes({
+ translate: {
+ x: x,
+ y: y
+ }
+ }, true);
}
}
- return;
- }
-
- this.mons.push({
- item: item, ename: ename, fn: fn, scope: scope
- });
- item.on(ename, fn, scope, opt);
- },
-
-
- mun : function(item, ename, fn, scope){
- var found, mon;
- this.createMons();
- for(var i = 0, len = this.mons.length; i < len; ++i){
- mon = this.mons[i];
- if(item === mon.item && ename == mon.ename && fn === mon.fn && scope === mon.scope){
- this.mons.splice(i, 1);
- item.un(ename, fn, scope);
- found = true;
- break;
+
+ if (me.chart.shadow && item.shadows) {
+ i = 0;
+ shadows = item.shadows;
+ ln = shadows.length;
+ for (; i < ln; i++) {
+ shadow = shadows[i];
+ to = {};
+ itemHighlightSegment = item.sprite._from.segment;
+ for (prop in itemHighlightSegment) {
+ if (! (prop in highlightSegment)) {
+ to[prop] = itemHighlightSegment[prop];
+ }
+ }
+ attrs = {
+ segment: Ext.applyIf(to, me.highlightCfg.segment)
+ };
+ if (animate) {
+ shadow.stopAnimation();
+ shadow.animate({
+ to: attrs,
+ duration: me.highlightDuration
+ });
+ }
+ else {
+ shadow.setAttributes(attrs, true);
+ }
+ }
}
}
- return found;
},
- nextSibling : function(){
- if(this.ownerCt){
- var index = this.ownerCt.items.indexOf(this);
- if(index != -1 && index+1 < this.ownerCt.items.getCount()){
- return this.ownerCt.items.itemAt(index+1);
- }
+ unHighlightItem: function() {
+ var me = this;
+ if (!me.highlight) {
+ return;
}
- return null;
- },
-
- previousSibling : function(){
- if(this.ownerCt){
- var index = this.ownerCt.items.indexOf(this);
- if(index > 0){
- return this.ownerCt.items.itemAt(index-1);
+ if (('segment' in me.highlightCfg) && me.items) {
+ var items = me.items,
+ animate = me.chart.animate,
+ shadowsEnabled = !!me.chart.shadow,
+ group = me.labelsGroup,
+ len = items.length,
+ i = 0,
+ j = 0,
+ display = me.label.display,
+ shadowLen, p, to, ihs, hs, sprite, shadows, shadow, item, label, attrs;
+
+ for (; i < len; i++) {
+ item = items[i];
+ if (!item) {
+ continue;
+ }
+ sprite = item.sprite;
+ if (sprite && sprite._highlighted) {
+
+ if (group) {
+ label = group.getAt(item.index);
+ attrs = Ext.apply({
+ translate: {
+ x: 0,
+ y: 0
+ }
+ },
+ display == 'rotate' ? {
+ rotate: {
+ x: label.attr.x,
+ y: label.attr.y,
+ degrees: label.attr.rotation.degrees
+ }
+ }: {});
+ if (animate) {
+ label.stopAnimation();
+ label.animate({
+ to: attrs,
+ duration: me.highlightDuration
+ });
+ }
+ else {
+ label.setAttributes(attrs, true);
+ }
+ }
+ if (shadowsEnabled) {
+ shadows = item.shadows;
+ shadowLen = shadows.length;
+ for (; j < shadowLen; j++) {
+ to = {};
+ ihs = item.sprite._to.segment;
+ hs = item.sprite._from.segment;
+ Ext.apply(to, hs);
+ for (p in ihs) {
+ if (! (p in hs)) {
+ to[p] = ihs[p];
+ }
+ }
+ shadow = shadows[j];
+ if (animate) {
+ shadow.stopAnimation();
+ shadow.animate({
+ to: {
+ segment: to
+ },
+ duration: me.highlightDuration
+ });
+ }
+ else {
+ shadow.setAttributes({ segment: to }, true);
+ }
+ }
+ }
+ }
}
}
- return null;
+ me.callParent(arguments);
},
-
- getBubbleTarget : function(){
- return this.ownerCt;
+
+ getLegendColor: function(index) {
+ var me = this;
+ return me.colorArrayStyle[index % me.colorArrayStyle.length];
}
});
-Ext.reg('component', Ext.Component);
-Ext.Action = Ext.extend(Object, {
-
-
-
-
-
-
-
- constructor : function(config){
- this.initialConfig = config;
- this.itemId = config.itemId = (config.itemId || config.id || Ext.id());
- this.items = [];
- },
-
-
- isAction : true,
+Ext.define('Ext.chart.series.Radar', {
- setText : function(text){
- this.initialConfig.text = text;
- this.callEach('setText', [text]);
- },
-
- getText : function(){
- return this.initialConfig.text;
- },
+ extend: 'Ext.chart.series.Series',
-
- setIconClass : function(cls){
- this.initialConfig.iconCls = cls;
- this.callEach('setIconClass', [cls]);
- },
+ requires: ['Ext.chart.Shape', 'Ext.fx.Anim'],
- getIconClass : function(){
- return this.initialConfig.iconCls;
- },
-
- setDisabled : function(v){
- this.initialConfig.disabled = v;
- this.callEach('setDisabled', [v]);
- },
+ type: "radar",
+ alias: 'series.radar',
- enable : function(){
- this.setDisabled(false);
- },
+ rad: Math.PI / 180,
-
- disable : function(){
- this.setDisabled(true);
- },
+ showInLegend: false,
- isDisabled : function(){
- return this.initialConfig.disabled;
- },
-
+ style: {},
- setHidden : function(v){
- this.initialConfig.hidden = v;
- this.callEach('setVisible', [!v]);
+ constructor: function(config) {
+ this.callParent(arguments);
+ var me = this,
+ surface = me.chart.surface, i, l;
+ me.group = surface.getGroup(me.seriesId);
+ if (me.showMarkers) {
+ me.markerGroup = surface.getGroup(me.seriesId + '-markers');
+ }
},
- show : function(){
- this.setHidden(false);
- },
+ drawSeries: function() {
+ var me = this,
+ store = me.chart.substore || me.chart.store,
+ group = me.group,
+ sprite,
+ chart = me.chart,
+ animate = chart.animate,
+ field = me.field || me.yField,
+ surface = chart.surface,
+ chartBBox = chart.chartBBox,
+ rendererAttributes,
+ centerX, centerY,
+ items,
+ radius,
+ maxValue = 0,
+ fields = [],
+ max = Math.max,
+ cos = Math.cos,
+ sin = Math.sin,
+ pi2 = Math.PI * 2,
+ l = store.getCount(),
+ startPath, path, x, y, rho,
+ i, nfields,
+ seriesStyle = me.seriesStyle,
+ seriesLabelStyle = me.seriesLabelStyle,
+ first = chart.resizing || !me.radar,
+ axis = chart.axes && chart.axes.get(0),
+ aggregate = !(axis && axis.maximum);
+
+ me.setBBox();
+
+ maxValue = aggregate? 0 : (axis.maximum || 0);
+
+ Ext.apply(seriesStyle, me.style || {});
+
+
+ if (!store || !store.getCount()) {
+ return;
+ }
+
+ me.unHighlightItem();
+ me.cleanHighlights();
+ centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
+ centerY = me.centerY = chartBBox.y + (chartBBox.height / 2);
+ me.radius = radius = Math.min(chartBBox.width, chartBBox.height) /2;
+ me.items = items = [];
+
+ if (aggregate) {
+
+ chart.series.each(function(series) {
+ fields.push(series.yField);
+ });
+
+ store.each(function(record, i) {
+ for (i = 0, nfields = fields.length; i < nfields; i++) {
+ maxValue = max(+record.get(fields[i]), maxValue);
+ }
+ });
+ }
+
+ maxValue = maxValue || 1;
+
+ startPath = []; path = [];
+ store.each(function(record, i) {
+ rho = radius * record.get(field) / maxValue;
+ x = rho * cos(i / l * pi2);
+ y = rho * sin(i / l * pi2);
+ if (i == 0) {
+ path.push('M', x + centerX, y + centerY);
+ startPath.push('M', 0.01 * x + centerX, 0.01 * y + centerY);
+ } else {
+ path.push('L', x + centerX, y + centerY);
+ startPath.push('L', 0.01 * x + centerX, 0.01 * y + centerY);
+ }
+ items.push({
+ sprite: false,
+ point: [centerX + x, centerY + y],
+ series: me
+ });
+ });
+ path.push('Z');
+
+ if (!me.radar) {
+ me.radar = surface.add(Ext.apply({
+ type: 'path',
+ group: group,
+ path: startPath
+ }, seriesStyle || {}));
+ }
+
+ if (chart.resizing) {
+ me.radar.setAttributes({
+ path: startPath
+ }, true);
+ }
+
+ if (chart.animate) {
+ me.onAnimate(me.radar, {
+ to: Ext.apply({
+ path: path
+ }, seriesStyle || {})
+ });
+ } else {
+ me.radar.setAttributes(Ext.apply({
+ path: path
+ }, seriesStyle || {}), true);
+ }
+
+ if (me.showMarkers) {
+ me.drawMarkers();
+ }
+ me.renderLabels();
+ me.renderCallouts();
+ },
- hide : function(){
- this.setHidden(true);
+
+ drawMarkers: function() {
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ markerStyle = Ext.apply({}, me.markerStyle || {}),
+ endMarkerStyle = Ext.apply(markerStyle, me.markerConfig),
+ items = me.items,
+ type = endMarkerStyle.type,
+ markerGroup = me.markerGroup,
+ centerX = me.centerX,
+ centerY = me.centerY,
+ item, i, l, marker;
+
+ delete endMarkerStyle.type;
+
+ for (i = 0, l = items.length; i < l; i++) {
+ item = items[i];
+ marker = markerGroup.getAt(i);
+ if (!marker) {
+ marker = Ext.chart.Shape[type](surface, Ext.apply({
+ group: markerGroup,
+ x: 0,
+ y: 0,
+ translate: {
+ x: centerX,
+ y: centerY
+ }
+ }, endMarkerStyle));
+ }
+ else {
+ marker.show();
+ }
+ if (chart.resizing) {
+ marker.setAttributes({
+ x: 0,
+ y: 0,
+ translate: {
+ x: centerX,
+ y: centerY
+ }
+ }, true);
+ }
+ marker._to = {
+ translate: {
+ x: item.point[0],
+ y: item.point[1]
+ }
+ };
+
+ if (chart.animate) {
+ me.onAnimate(marker, {
+ to: marker._to
+ });
+ }
+ else {
+ marker.setAttributes(Ext.apply(marker._to, endMarkerStyle || {}), true);
+ }
+ }
},
-
- isHidden : function(){
- return this.initialConfig.hidden;
+ isItemInPoint: function(x, y, item) {
+ var point,
+ tolerance = 10,
+ abs = Math.abs;
+ point = item.point;
+ return (abs(point[0] - x) <= tolerance &&
+ abs(point[1] - y) <= tolerance);
},
- setHandler : function(fn, scope){
- this.initialConfig.handler = fn;
- this.initialConfig.scope = scope;
- this.callEach('setHandler', [fn, scope]);
+ onCreateLabel: function(storeItem, item, i, display) {
+ var me = this,
+ group = me.labelsGroup,
+ config = me.label,
+ centerX = me.centerX,
+ centerY = me.centerY,
+ point = item.point,
+ endLabelStyle = Ext.apply(me.seriesLabelStyle || {}, config);
+
+ return me.chart.surface.add(Ext.apply({
+ 'type': 'text',
+ 'text-anchor': 'middle',
+ 'group': group,
+ 'x': centerX,
+ 'y': centerY
+ }, config || {}));
},
- each : function(fn, scope){
- Ext.each(this.items, fn, scope);
+ onPlaceLabel: function(label, storeItem, item, i, display, animate) {
+ var me = this,
+ chart = me.chart,
+ resizing = chart.resizing,
+ config = me.label,
+ format = config.renderer,
+ field = config.field,
+ centerX = me.centerX,
+ centerY = me.centerY,
+ opt = {
+ x: item.point[0],
+ y: item.point[1]
+ },
+ x = opt.x - centerX,
+ y = opt.y - centerY;
+
+ label.setAttributes({
+ text: format(storeItem.get(field)),
+ hidden: true
+ },
+ true);
+
+ if (resizing) {
+ label.setAttributes({
+ x: centerX,
+ y: centerY
+ }, true);
+ }
+
+ if (animate) {
+ label.show(true);
+ me.onAnimate(label, {
+ to: opt
+ });
+ } else {
+ label.setAttributes(opt, true);
+ label.show(true);
+ }
},
- callEach : function(fnName, args){
- var cs = this.items;
- for(var i = 0, len = cs.length; i < len; i++){
- cs[i][fnName].apply(cs[i], args);
+ toggleAll: function(show) {
+ var me = this,
+ i, ln, shadow, shadows;
+ if (!show) {
+ Ext.chart.series.Radar.superclass.hideAll.call(me);
+ }
+ else {
+ Ext.chart.series.Radar.superclass.showAll.call(me);
+ }
+ if (me.radar) {
+ me.radar.setAttributes({
+ hidden: !show
+ }, true);
+
+ if (me.radar.shadows) {
+ for (i = 0, shadows = me.radar.shadows, ln = shadows.length; i < ln; i++) {
+ shadow = shadows[i];
+ shadow.setAttributes({
+ hidden: !show
+ }, true);
+ }
+ }
}
},
-
- addComponent : function(comp){
- this.items.push(comp);
- comp.on('destroy', this.removeComponent, this);
+
+ hideAll: function() {
+ this.toggleAll(false);
+ this.hideMarkers(0);
},
-
- removeComponent : function(comp){
- this.items.remove(comp);
+
+ showAll: function() {
+ this.toggleAll(true);
},
-
- execute : function(){
- this.initialConfig.handler.apply(this.initialConfig.scope || window, arguments);
+
+ hideMarkers: function(index) {
+ var me = this,
+ count = me.markerGroup && me.markerGroup.getCount() || 0,
+ i = index || 0;
+ for (; i < count; i++) {
+ me.markerGroup.getAt(i).hide(true);
+ }
}
});
-(function(){
-Ext.Layer = function(config, existingEl){
- config = config || {};
- var dh = Ext.DomHelper,
- cp = config.parentEl, pel = cp ? Ext.getDom(cp) : document.body;
-
- if (existingEl) {
- this.dom = Ext.getDom(existingEl);
- }
- if(!this.dom){
- var o = config.dh || {tag: 'div', cls: 'x-layer'};
- this.dom = dh.append(pel, o);
- }
- if(config.cls){
- this.addClass(config.cls);
- }
- this.constrain = config.constrain !== false;
- this.setVisibilityMode(Ext.Element.VISIBILITY);
- if(config.id){
- this.id = this.dom.id = config.id;
- }else{
- this.id = Ext.id(this.dom);
- }
- this.zindex = config.zindex || this.getZIndex();
- this.position('absolute', this.zindex);
- if(config.shadow){
- this.shadowOffset = config.shadowOffset || 4;
- this.shadow = new Ext.Shadow({
- offset : this.shadowOffset,
- mode : config.shadow
- });
- }else{
- this.shadowOffset = 0;
- }
- this.useShim = config.shim !== false && Ext.useShims;
- this.useDisplay = config.useDisplay;
- this.hide();
-};
-var supr = Ext.Element.prototype;
+Ext.define('Ext.chart.series.Scatter', {
-var shims = [];
+
-Ext.extend(Ext.Layer, Ext.Element, {
+ extend: 'Ext.chart.series.Cartesian',
- getZIndex : function(){
- return this.zindex || parseInt((this.getShim() || this).getStyle('z-index'), 10) || 11000;
- },
+ requires: ['Ext.chart.axis.Axis', 'Ext.chart.Shape', 'Ext.fx.Anim'],
- getShim : function(){
- if(!this.useShim){
- return null;
+
+
+ type: 'scatter',
+ alias: 'series.scatter',
+
+
+
+
+
+ constructor: function(config) {
+ this.callParent(arguments);
+ var me = this,
+ shadow = me.chart.shadow,
+ surface = me.chart.surface, i, l;
+ Ext.apply(me, config, {
+ style: {},
+ markerConfig: {},
+ shadowAttributes: [{
+ "stroke-width": 6,
+ "stroke-opacity": 0.05,
+ stroke: 'rgb(0, 0, 0)'
+ }, {
+ "stroke-width": 4,
+ "stroke-opacity": 0.1,
+ stroke: 'rgb(0, 0, 0)'
+ }, {
+ "stroke-width": 2,
+ "stroke-opacity": 0.15,
+ stroke: 'rgb(0, 0, 0)'
+ }]
+ });
+ me.group = surface.getGroup(me.seriesId);
+ if (shadow) {
+ for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
+ me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
+ }
}
- if(this.shim){
- return this.shim;
+ },
+
+
+ getBounds: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ axes = [].concat(me.axis),
+ bbox, xScale, yScale, ln, minX, minY, maxX, maxY, i, axis, ends;
+
+ me.setBBox();
+ bbox = me.bbox;
+
+ for (i = 0, ln = axes.length; i < ln; i++) {
+ axis = chart.axes.get(axes[i]);
+ if (axis) {
+ ends = axis.calcEnds();
+ if (axis.position == 'top' || axis.position == 'bottom') {
+ minX = ends.from;
+ maxX = ends.to;
+ }
+ else {
+ minY = ends.from;
+ maxY = ends.to;
+ }
+ }
}
- var shim = shims.shift();
- if(!shim){
- shim = this.createShim();
- shim.enableDisplayMode('block');
- shim.dom.style.display = 'none';
- shim.dom.style.visibility = 'visible';
+
+ if (me.xField && !Ext.isNumber(minX)) {
+ axis = Ext.create('Ext.chart.axis.Axis', {
+ chart: chart,
+ fields: [].concat(me.xField)
+ }).calcEnds();
+ minX = axis.from;
+ maxX = axis.to;
}
- var pn = this.dom.parentNode;
- if(shim.dom.parentNode != pn){
- pn.insertBefore(shim.dom, this.dom);
+ if (me.yField && !Ext.isNumber(minY)) {
+ axis = Ext.create('Ext.chart.axis.Axis', {
+ chart: chart,
+ fields: [].concat(me.yField)
+ }).calcEnds();
+ minY = axis.from;
+ maxY = axis.to;
}
- shim.setStyle('z-index', this.getZIndex()-2);
- this.shim = shim;
- return shim;
- },
- hideShim : function(){
- if(this.shim){
- this.shim.setDisplayed(false);
- shims.push(this.shim);
- delete this.shim;
+ if (isNaN(minX)) {
+ minX = 0;
+ maxX = store.getCount() - 1;
+ xScale = bbox.width / (store.getCount() - 1);
}
- },
-
- disableShadow : function(){
- if(this.shadow){
- this.shadowDisabled = true;
- this.shadow.hide();
- this.lastShadowOffset = this.shadowOffset;
- this.shadowOffset = 0;
+ else {
+ xScale = bbox.width / (maxX - minX);
}
- },
- enableShadow : function(show){
- if(this.shadow){
- this.shadowDisabled = false;
- this.shadowOffset = this.lastShadowOffset;
- delete this.lastShadowOffset;
- if(show){
- this.sync(true);
- }
+ if (isNaN(minY)) {
+ minY = 0;
+ maxY = store.getCount() - 1;
+ yScale = bbox.height / (store.getCount() - 1);
+ }
+ else {
+ yScale = bbox.height / (maxY - minY);
}
+
+ return {
+ bbox: bbox,
+ minX: minX,
+ minY: minY,
+ xScale: xScale,
+ yScale: yScale
+ };
},
-
-
- sync : function(doShow){
- var shadow = this.shadow;
- if(!this.updating && this.isVisible() && (shadow || this.useShim)){
- var shim = this.getShim(),
- w = this.getWidth(),
- h = this.getHeight(),
- l = this.getLeft(true),
- t = this.getTop(true);
-
- if(shadow && !this.shadowDisabled){
- if(doShow && !shadow.isVisible()){
- shadow.show(this);
- }else{
- shadow.realign(l, t, w, h);
+ getPaths: function() {
+ var me = this,
+ chart = me.chart,
+ enableShadows = chart.shadow,
+ store = chart.substore || chart.store,
+ group = me.group,
+ bounds = me.bounds = me.getBounds(),
+ bbox = me.bbox,
+ xScale = bounds.xScale,
+ yScale = bounds.yScale,
+ minX = bounds.minX,
+ minY = bounds.minY,
+ boxX = bbox.x,
+ boxY = bbox.y,
+ boxHeight = bbox.height,
+ items = me.items = [],
+ attrs = [],
+ x, y, xValue, yValue, sprite;
+
+ store.each(function(record, i) {
+ xValue = record.get(me.xField);
+ yValue = record.get(me.yField);
+
+ if (typeof yValue == 'undefined' || (typeof yValue == 'string' && !yValue)) {
+ if (Ext.isDefined(Ext.global.console)) {
+ Ext.global.console.warn("[Ext.chart.series.Scatter] Skipping a store element with an undefined value at ", record, xValue, yValue);
}
- if(shim){
- if(doShow){
- shim.show();
+ return;
+ }
+
+ if (typeof xValue == 'string' || typeof xValue == 'object') {
+ xValue = i;
+ }
+ if (typeof yValue == 'string' || typeof yValue == 'object') {
+ yValue = i;
+ }
+ x = boxX + (xValue - minX) * xScale;
+ y = boxY + boxHeight - (yValue - minY) * yScale;
+ attrs.push({
+ x: x,
+ y: y
+ });
+
+ me.items.push({
+ series: me,
+ value: [xValue, yValue],
+ point: [x, y],
+ storeItem: record
+ });
+
+
+ if (chart.animate && chart.resizing) {
+ sprite = group.getAt(i);
+ if (sprite) {
+ me.resetPoint(sprite);
+ if (enableShadows) {
+ me.resetShadow(sprite);
}
-
- var shadowAdj = shadow.el.getXY(), shimStyle = shim.dom.style,
- shadowSize = shadow.el.getSize();
- shimStyle.left = (shadowAdj[0])+'px';
- shimStyle.top = (shadowAdj[1])+'px';
- shimStyle.width = (shadowSize.width)+'px';
- shimStyle.height = (shadowSize.height)+'px';
- }
- }else if(shim){
- if(doShow){
- shim.show();
}
- shim.setSize(w, h);
- shim.setLeftTop(l, t);
}
- }
+ });
+ return attrs;
},
- destroy : function(){
- this.hideShim();
- if(this.shadow){
- this.shadow.hide();
- }
- this.removeAllListeners();
- Ext.removeNode(this.dom);
- delete this.dom;
- },
-
- remove : function(){
- this.destroy();
+ resetPoint: function(sprite) {
+ var bbox = this.bbox;
+ sprite.setAttributes({
+ translate: {
+ x: (bbox.x + bbox.width) / 2,
+ y: (bbox.y + bbox.height) / 2
+ }
+ }, true);
},
- beginUpdate : function(){
- this.updating = true;
+ resetShadow: function(sprite) {
+ var me = this,
+ shadows = sprite.shadows,
+ shadowAttributes = me.shadowAttributes,
+ ln = me.shadowGroups.length,
+ bbox = me.bbox,
+ i, attr;
+ for (i = 0; i < ln; i++) {
+ attr = Ext.apply({}, shadowAttributes[i]);
+ if (attr.translate) {
+ attr.translate.x += (bbox.x + bbox.width) / 2;
+ attr.translate.y += (bbox.y + bbox.height) / 2;
+ }
+ else {
+ attr.translate = {
+ x: (bbox.x + bbox.width) / 2,
+ y: (bbox.y + bbox.height) / 2
+ };
+ }
+ shadows[i].setAttributes(attr, true);
+ }
},
- endUpdate : function(){
- this.updating = false;
- this.sync(true);
+ createPoint: function(attr, type) {
+ var me = this,
+ chart = me.chart,
+ group = me.group,
+ bbox = me.bbox;
+
+ return Ext.chart.Shape[type](chart.surface, Ext.apply({}, {
+ x: 0,
+ y: 0,
+ group: group,
+ translate: {
+ x: (bbox.x + bbox.width) / 2,
+ y: (bbox.y + bbox.height) / 2
+ }
+ }, attr));
},
- hideUnders : function(negOffset){
- if(this.shadow){
- this.shadow.hide();
+ createShadow: function(sprite, endMarkerStyle, type) {
+ var me = this,
+ chart = me.chart,
+ shadowGroups = me.shadowGroups,
+ shadowAttributes = me.shadowAttributes,
+ lnsh = shadowGroups.length,
+ bbox = me.bbox,
+ i, shadow, shadows, attr;
+
+ sprite.shadows = shadows = [];
+
+ for (i = 0; i < lnsh; i++) {
+ attr = Ext.apply({}, shadowAttributes[i]);
+ if (attr.translate) {
+ attr.translate.x += (bbox.x + bbox.width) / 2;
+ attr.translate.y += (bbox.y + bbox.height) / 2;
+ }
+ else {
+ Ext.apply(attr, {
+ translate: {
+ x: (bbox.x + bbox.width) / 2,
+ y: (bbox.y + bbox.height) / 2
+ }
+ });
+ }
+ Ext.apply(attr, endMarkerStyle);
+ shadow = Ext.chart.Shape[type](chart.surface, Ext.apply({}, {
+ x: 0,
+ y: 0,
+ group: shadowGroups[i]
+ }, attr));
+ shadows.push(shadow);
}
- this.hideShim();
},
- constrainXY : function(){
- if(this.constrain){
- var vw = Ext.lib.Dom.getViewWidth(),
- vh = Ext.lib.Dom.getViewHeight();
- var s = Ext.getDoc().getScroll();
+ drawSeries: function() {
+ var me = this,
+ chart = me.chart,
+ store = chart.substore || chart.store,
+ group = me.group,
+ enableShadows = chart.shadow,
+ shadowGroups = me.shadowGroups,
+ shadowAttributes = me.shadowAttributes,
+ lnsh = shadowGroups.length,
+ sprite, attrs, attr, ln, i, endMarkerStyle, shindex, type, shadows,
+ rendererAttributes, shadowAttribute;
+
+ endMarkerStyle = Ext.apply(me.markerStyle, me.markerConfig);
+ type = endMarkerStyle.type;
+ delete endMarkerStyle.type;
+
+
+ if (!store || !store.getCount()) {
+ return;
+ }
+
+ me.unHighlightItem();
+ me.cleanHighlights();
+
+ attrs = me.getPaths();
+ ln = attrs.length;
+ for (i = 0; i < ln; i++) {
+ attr = attrs[i];
+ sprite = group.getAt(i);
+ Ext.apply(attr, endMarkerStyle);
- var xy = this.getXY();
- var x = xy[0], y = xy[1];
- var so = this.shadowOffset;
- var w = this.dom.offsetWidth+so, h = this.dom.offsetHeight+so;
-
- var moved = false;
-
- if((x + w) > vw+s.left){
- x = vw - w - so;
- moved = true;
- }
- if((y + h) > vh+s.top){
- y = vh - h - so;
- moved = true;
- }
- if(x < s.left){
- x = s.left;
- moved = true;
+ if (!sprite) {
+ sprite = me.createPoint(attr, type);
+ if (enableShadows) {
+ me.createShadow(sprite, endMarkerStyle, type);
+ }
}
- if(y < s.top){
- y = s.top;
- moved = true;
+
+ shadows = sprite.shadows;
+ if (chart.animate) {
+ rendererAttributes = me.renderer(sprite, store.getAt(i), { translate: attr }, i, store);
+ sprite._to = rendererAttributes;
+ me.onAnimate(sprite, {
+ to: rendererAttributes
+ });
+
+ for (shindex = 0; shindex < lnsh; shindex++) {
+ shadowAttribute = Ext.apply({}, shadowAttributes[shindex]);
+ rendererAttributes = me.renderer(shadows[shindex], store.getAt(i), Ext.apply({}, {
+ translate: {
+ x: attr.x + (shadowAttribute.translate? shadowAttribute.translate.x : 0),
+ y: attr.y + (shadowAttribute.translate? shadowAttribute.translate.y : 0)
+ }
+ }, shadowAttribute), i, store);
+ me.onAnimate(shadows[shindex], { to: rendererAttributes });
+ }
}
- if(moved){
- if(this.avoidY){
- var ay = this.avoidY;
- if(y <= ay && (y+h) >= ay){
- y = ay-h-5;
- }
+ else {
+ rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply({ translate: attr }, { hidden: false }), i, store);
+ sprite.setAttributes(rendererAttributes, true);
+
+ for (shindex = 0; shindex < lnsh; shindex++) {
+ shadowAttribute = shadowAttributes[shindex];
+ rendererAttributes = me.renderer(shadows[shindex], store.getAt(i), Ext.apply({
+ x: attr.x,
+ y: attr.y
+ }, shadowAttribute), i, store);
+ shadows[shindex].setAttributes(rendererAttributes, true);
}
- xy = [x, y];
- this.storeXY(xy);
- supr.setXY.call(this, xy);
- this.sync();
}
+ me.items[i].sprite = sprite;
}
- return this;
- },
-
- getConstrainOffset : function(){
- return this.shadowOffset;
- },
-
- isVisible : function(){
- return this.visible;
- },
-
- showAction : function(){
- this.visible = true;
- if(this.useDisplay === true){
- this.setDisplayed('');
- }else if(this.lastXY){
- supr.setXY.call(this, this.lastXY);
- }else if(this.lastLT){
- supr.setLeftTop.call(this, this.lastLT[0], this.lastLT[1]);
+
+ ln = group.getCount();
+ for (i = attrs.length; i < ln; i++) {
+ group.getAt(i).hide(true);
}
+ me.renderLabels();
+ me.renderCallouts();
},
-
- hideAction : function(){
- this.visible = false;
- if(this.useDisplay === true){
- this.setDisplayed(false);
- }else{
- this.setLeftTop(-10000,-10000);
- }
+
+ onCreateLabel: function(storeItem, item, i, display) {
+ var me = this,
+ group = me.labelsGroup,
+ config = me.label,
+ endLabelStyle = Ext.apply({}, config, me.seriesLabelStyle),
+ bbox = me.bbox;
+
+ return me.chart.surface.add(Ext.apply({
+ type: 'text',
+ group: group,
+ x: item.point[0],
+ y: bbox.y + bbox.height / 2
+ }, endLabelStyle));
},
-
- setVisible : function(v, a, d, c, e){
- if(v){
- this.showAction();
+
+ onPlaceLabel: function(label, storeItem, item, i, display, animate) {
+ var me = this,
+ chart = me.chart,
+ resizing = chart.resizing,
+ config = me.label,
+ format = config.renderer,
+ field = config.field,
+ bbox = me.bbox,
+ x = item.point[0],
+ y = item.point[1],
+ radius = item.sprite.attr.radius,
+ bb, width, height, anim;
+
+ label.setAttributes({
+ text: format(storeItem.get(field)),
+ hidden: true
+ }, true);
+
+ if (display == 'rotate') {
+ label.setAttributes({
+ 'text-anchor': 'start',
+ 'rotation': {
+ x: x,
+ y: y,
+ degrees: -45
+ }
+ }, true);
+
+ bb = label.getBBox();
+ width = bb.width;
+ height = bb.height;
+ x = x < bbox.x? bbox.x : x;
+ x = (x + width > bbox.x + bbox.width)? (x - (x + width - bbox.x - bbox.width)) : x;
+ y = (y - height < bbox.y)? bbox.y + height : y;
+
+ } else if (display == 'under' || display == 'over') {
+
+ bb = item.sprite.getBBox();
+ bb.width = bb.width || (radius * 2);
+ bb.height = bb.height || (radius * 2);
+ y = y + (display == 'over'? -bb.height : bb.height);
+
+ bb = label.getBBox();
+ width = bb.width/2;
+ height = bb.height/2;
+ x = x - width < bbox.x ? bbox.x + width : x;
+ x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
+ y = y - height < bbox.y? bbox.y + height : y;
+ y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
+ }
+
+ if (!chart.animate) {
+ label.setAttributes({
+ x: x,
+ y: y
+ }, true);
+ label.show(true);
}
- if(a && v){
- var cb = function(){
- this.sync(true);
- if(c){
- c();
+ else {
+ if (resizing) {
+ anim = item.sprite.getActiveAnimation();
+ if (anim) {
+ anim.on('afteranimate', function() {
+ label.setAttributes({
+ x: x,
+ y: y
+ }, true);
+ label.show(true);
+ });
+ }
+ else {
+ label.show(true);
}
- }.createDelegate(this);
- supr.setVisible.call(this, true, true, d, cb, e);
- }else{
- if(!v){
- this.hideUnders(true);
}
- var cb = c;
- if(a){
- cb = function(){
- this.hideAction();
- if(c){
- c();
+ else {
+ me.onAnimate(label, {
+ to: {
+ x: x,
+ y: y
}
- }.createDelegate(this);
- }
- supr.setVisible.call(this, v, a, d, cb, e);
- if(v){
- this.sync(true);
- }else if(!a){
- this.hideAction();
+ });
}
}
- return this;
- },
-
- storeXY : function(xy){
- delete this.lastLT;
- this.lastXY = xy;
},
-
- storeLeftTop : function(left, top){
- delete this.lastXY;
- this.lastLT = [left, top];
- },
-
- beforeFx : function(){
- this.beforeAction();
- return Ext.Layer.superclass.beforeFx.apply(this, arguments);
- },
-
- afterFx : function(){
- Ext.Layer.superclass.afterFx.apply(this, arguments);
- this.sync(this.isVisible());
- },
-
+ onPlaceCallout: function(callout, storeItem, item, i, display, animate, index) {
+ var me = this,
+ chart = me.chart,
+ surface = chart.surface,
+ resizing = chart.resizing,
+ config = me.callouts,
+ items = me.items,
+ cur = item.point,
+ normal,
+ bbox = callout.label.getBBox(),
+ offsetFromViz = 30,
+ offsetToSide = 10,
+ offsetBox = 3,
+ boxx, boxy, boxw, boxh,
+ p, clipRect = me.bbox,
+ x, y;
- beforeAction : function(){
- if(!this.updating && this.shadow){
- this.shadow.hide();
+
+ normal = [Math.cos(Math.PI /4), -Math.sin(Math.PI /4)];
+ x = cur[0] + normal[0] * offsetFromViz;
+ y = cur[1] + normal[1] * offsetFromViz;
+
+
+ boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+ boxy = y - bbox.height /2 - offsetBox;
+ boxw = bbox.width + 2 * offsetBox;
+ boxh = bbox.height + 2 * offsetBox;
+
+
+
+ if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
+ normal[0] *= -1;
+ }
+ if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
+ normal[1] *= -1;
}
- },
-
- setLeft : function(left){
- this.storeLeftTop(left, this.getTop(true));
- supr.setLeft.apply(this, arguments);
- this.sync();
- return this;
+
+ x = cur[0] + normal[0] * offsetFromViz;
+ y = cur[1] + normal[1] * offsetFromViz;
+
+
+ boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
+ boxy = y - bbox.height /2 - offsetBox;
+ boxw = bbox.width + 2 * offsetBox;
+ boxh = bbox.height + 2 * offsetBox;
+
+ if (chart.animate) {
+
+ me.onAnimate(callout.lines, {
+ to: {
+ path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+ }
+ }, true);
+
+ me.onAnimate(callout.box, {
+ to: {
+ x: boxx,
+ y: boxy,
+ width: boxw,
+ height: boxh
+ }
+ }, true);
+
+ me.onAnimate(callout.label, {
+ to: {
+ x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
+ y: y
+ }
+ }, true);
+ } else {
+
+ callout.lines.setAttributes({
+ path: ["M", cur[0], cur[1], "L", x, y, "Z"]
+ }, true);
+
+ callout.box.setAttributes({
+ x: boxx,
+ y: boxy,
+ width: boxw,
+ height: boxh
+ }, true);
+
+ callout.label.setAttributes({
+ x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
+ y: y
+ }, true);
+ }
+ for (p in callout) {
+ callout[p].show(true);
+ }
},
- setTop : function(top){
- this.storeLeftTop(this.getLeft(true), top);
- supr.setTop.apply(this, arguments);
- this.sync();
- return this;
+
+ onAnimate: function(sprite, attr) {
+ sprite.show();
+ return this.callParent(arguments);
},
- setLeftTop : function(left, top){
- this.storeLeftTop(left, top);
- supr.setLeftTop.apply(this, arguments);
- this.sync();
- return this;
- },
+ isItemInPoint: function(x, y, item) {
+ var point,
+ tolerance = 10,
+ abs = Math.abs;
- setXY : function(xy, a, d, c, e){
- this.fixDisplay();
- this.beforeAction();
- this.storeXY(xy);
- var cb = this.createCB(c);
- supr.setXY.call(this, xy, a, d, cb, e);
- if(!a){
- cb();
+ function dist(point) {
+ var dx = abs(point[0] - x),
+ dy = abs(point[1] - y);
+ return Math.sqrt(dx * dx + dy * dy);
}
- return this;
- },
+ point = item.point;
+ return (point[0] - tolerance <= x && point[0] + tolerance >= x &&
+ point[1] - tolerance <= y && point[1] + tolerance >= y);
+ }
+});
-
- createCB : function(c){
- var el = this;
- return function(){
- el.constrainXY();
- el.sync(true);
- if(c){
- c();
- }
- };
- },
-
- setX : function(x, a, d, c, e){
- this.setXY([x, this.getY()], a, d, c, e);
- return this;
- },
-
- setY : function(y, a, d, c, e){
- this.setXY([this.getX(), y], a, d, c, e);
- return this;
- },
+Ext.define('Ext.chart.theme.Base', {
- setSize : function(w, h, a, d, c, e){
- this.beforeAction();
- var cb = this.createCB(c);
- supr.setSize.call(this, w, h, a, d, cb, e);
- if(!a){
- cb();
- }
- return this;
- },
-
- setWidth : function(w, a, d, c, e){
- this.beforeAction();
- var cb = this.createCB(c);
- supr.setWidth.call(this, w, a, d, cb, e);
- if(!a){
- cb();
- }
- return this;
- },
+ requires: ['Ext.chart.theme.Theme'],
- setHeight : function(h, a, d, c, e){
- this.beforeAction();
- var cb = this.createCB(c);
- supr.setHeight.call(this, h, a, d, cb, e);
- if(!a){
- cb();
- }
- return this;
- },
+ constructor: function(config) {
+ Ext.chart.theme.call(this, config, {
+ background: false,
+ axis: {
+ stroke: '#444',
+ 'stroke-width': 1
+ },
+ axisLabelTop: {
+ fill: '#444',
+ font: '12px Arial, Helvetica, sans-serif',
+ spacing: 2,
+ padding: 5,
+ renderer: function(v) { return v; }
+ },
+ axisLabelRight: {
+ fill: '#444',
+ font: '12px Arial, Helvetica, sans-serif',
+ spacing: 2,
+ padding: 5,
+ renderer: function(v) { return v; }
+ },
+ axisLabelBottom: {
+ fill: '#444',
+ font: '12px Arial, Helvetica, sans-serif',
+ spacing: 2,
+ padding: 5,
+ renderer: function(v) { return v; }
+ },
+ axisLabelLeft: {
+ fill: '#444',
+ font: '12px Arial, Helvetica, sans-serif',
+ spacing: 2,
+ padding: 5,
+ renderer: function(v) { return v; }
+ },
+ axisTitleTop: {
+ font: 'bold 18px Arial',
+ fill: '#444'
+ },
+ axisTitleRight: {
+ font: 'bold 18px Arial',
+ fill: '#444',
+ rotate: {
+ x:0, y:0,
+ degrees: 270
+ }
+ },
+ axisTitleBottom: {
+ font: 'bold 18px Arial',
+ fill: '#444'
+ },
+ axisTitleLeft: {
+ font: 'bold 18px Arial',
+ fill: '#444',
+ rotate: {
+ x:0, y:0,
+ degrees: 270
+ }
+ },
+ series: {
+ 'stroke-width': 0
+ },
+ seriesLabel: {
+ font: '12px Arial',
+ fill: '#333'
+ },
+ marker: {
+ stroke: '#555',
+ fill: '#000',
+ radius: 3,
+ size: 3
+ },
+ colors: [ "#94ae0a", "#115fa6","#a61120", "#ff8809", "#ffd13e", "#a61187", "#24ad9a", "#7c7474", "#a66111"],
+ seriesThemes: [{
+ fill: "#115fa6"
+ }, {
+ fill: "#94ae0a"
+ }, {
+ fill: "#a61120"
+ }, {
+ fill: "#ff8809"
+ }, {
+ fill: "#ffd13e"
+ }, {
+ fill: "#a61187"
+ }, {
+ fill: "#24ad9a"
+ }, {
+ fill: "#7c7474"
+ }, {
+ fill: "#a66111"
+ }],
+ markerThemes: [{
+ fill: "#115fa6",
+ type: 'circle'
+ }, {
+ fill: "#94ae0a",
+ type: 'cross'
+ }, {
+ fill: "#a61120",
+ type: 'plus'
+ }]
+ });
+ }
+}, function() {
+ var palette = ['#b1da5a', '#4ce0e7', '#e84b67', '#da5abd', '#4d7fe6', '#fec935'],
+ names = ['Green', 'Sky', 'Red', 'Purple', 'Blue', 'Yellow'],
+ i = 0, j = 0, l = palette.length, themes = Ext.chart.theme,
+ categories = [['#f0a50a', '#c20024', '#2044ba', '#810065', '#7eae29'],
+ ['#6d9824', '#87146e', '#2a9196', '#d39006', '#1e40ac'],
+ ['#fbbc29', '#ce2e4e', '#7e0062', '#158b90', '#57880e'],
+ ['#ef5773', '#fcbd2a', '#4f770d', '#1d3eaa', '#9b001f'],
+ ['#7eae29', '#fdbe2a', '#910019', '#27b4bc', '#d74dbc'],
+ ['#44dce1', '#0b2592', '#996e05', '#7fb325', '#b821a1']],
+ cats = categories.length;
+
+
+ for (; i < l; i++) {
+ themes[names[i]] = (function(color) {
+ return Ext.extend(themes.Base, {
+ constructor: function(config) {
+ themes.Base.prototype.constructor.call(this, Ext.apply({
+ baseColor: color
+ }, config));
+ }
+ });
+ })(palette[i]);
+ }
- setBounds : function(x, y, w, h, a, d, c, e){
- this.beforeAction();
- var cb = this.createCB(c);
- if(!a){
- this.storeXY([x, y]);
- supr.setXY.call(this, [x, y]);
- supr.setSize.call(this, w, h, a, d, cb, e);
- cb();
- }else{
- supr.setBounds.call(this, x, y, w, h, a, d, cb, e);
- }
- return this;
- },
-
- setZIndex : function(zindex){
- this.zindex = zindex;
- this.setStyle('z-index', zindex + 2);
- if(this.shadow){
- this.shadow.setZIndex(zindex + 1);
- }
- if(this.shim){
- this.shim.setStyle('z-index', zindex);
- }
- return this;
+ for (i = 0; i < cats; i++) {
+ themes['Category' + (i + 1)] = (function(category) {
+ return Ext.extend(themes.Base, {
+ constructor: function(config) {
+ themes.Base.prototype.constructor.call(this, Ext.apply({
+ colors: category
+ }, config));
+ }
+ });
+ })(categories[i]);
}
});
-})();
-
-Ext.Shadow = function(config) {
- Ext.apply(this, config);
- if (typeof this.mode != "string") {
- this.mode = this.defaultMode;
- }
- var o = this.offset,
- a = {
- h: 0
- },
- rad = Math.floor(this.offset / 2);
- switch (this.mode.toLowerCase()) {
-
- case "drop":
- a.w = 0;
- a.l = a.t = o;
- a.t -= 1;
- if (Ext.isIE) {
- a.l -= this.offset + rad;
- a.t -= this.offset + rad;
- a.w -= rad;
- a.h -= rad;
- a.t += 1;
- }
- break;
- case "sides":
- a.w = (o * 2);
- a.l = -o;
- a.t = o - 1;
- if (Ext.isIE) {
- a.l -= (this.offset - rad);
- a.t -= this.offset + rad;
- a.l += 1;
- a.w -= (this.offset - rad) * 2;
- a.w -= rad + 1;
- a.h -= 1;
- }
- break;
- case "frame":
- a.w = a.h = (o * 2);
- a.l = a.t = -o;
- a.t += 1;
- a.h -= 2;
- if (Ext.isIE) {
- a.l -= (this.offset - rad);
- a.t -= (this.offset - rad);
- a.l += 1;
- a.w -= (this.offset + rad + 1);
- a.h -= (this.offset + rad);
- a.h += 1;
- }
- break;
- };
- this.adjusts = a;
-};
-Ext.Shadow.prototype = {
-
-
- offset: 4,
+Ext.define('Ext.data.ArrayStore', {
+ extend: 'Ext.data.Store',
+ alias: 'store.array',
+ uses: ['Ext.data.reader.Array'],
- defaultMode: "drop",
+ constructor: function(config) {
+ config = config || {};
-
- show: function(target) {
- target = Ext.get(target);
- if (!this.el) {
- this.el = Ext.Shadow.Pool.pull();
- if (this.el.dom.nextSibling != target.dom) {
- this.el.insertBefore(target);
+ Ext.applyIf(config, {
+ proxy: {
+ type: 'memory',
+ reader: 'array'
}
- }
- this.el.setStyle("z-index", this.zIndex || parseInt(target.getStyle("z-index"), 10) - 1);
- if (Ext.isIE) {
- this.el.dom.style.filter = "progid:DXImageTransform.Microsoft.alpha(opacity=50) progid:DXImageTransform.Microsoft.Blur(pixelradius=" + (this.offset) + ")";
- }
- this.realign(
- target.getLeft(true),
- target.getTop(true),
- target.getWidth(),
- target.getHeight()
- );
- this.el.dom.style.display = "block";
- },
+ });
-
- isVisible: function() {
- return this.el ? true: false;
+ this.callParent([config]);
},
-
- realign: function(l, t, w, h) {
- if (!this.el) {
- return;
- }
- var a = this.adjusts,
- d = this.el.dom,
- s = d.style,
- iea = 0,
- sw = (w + a.w),
- sh = (h + a.h),
- sws = sw + "px",
- shs = sh + "px",
- cn,
- sww;
- s.left = (l + a.l) + "px";
- s.top = (t + a.t) + "px";
- if (s.width != sws || s.height != shs) {
- s.width = sws;
- s.height = shs;
- if (!Ext.isIE) {
- cn = d.childNodes;
- sww = Math.max(0, (sw - 12)) + "px";
- cn[0].childNodes[1].style.width = sww;
- cn[1].childNodes[1].style.width = sww;
- cn[2].childNodes[1].style.width = sww;
- cn[1].style.height = Math.max(0, (sh - 12)) + "px";
+ loadData: function(data, append) {
+ if (this.expandData === true) {
+ var r = [],
+ i = 0,
+ ln = data.length;
+
+ for (; i < ln; i++) {
+ r[r.length] = [data[i]];
}
- }
- },
-
- hide: function() {
- if (this.el) {
- this.el.dom.style.display = "none";
- Ext.Shadow.Pool.push(this.el);
- delete this.el;
+ data = r;
}
- },
-
- setZIndex: function(z) {
- this.zIndex = z;
- if (this.el) {
- this.el.setStyle("z-index", z);
- }
+ this.callParent([data, append]);
}
-};
-
-
-Ext.Shadow.Pool = function() {
- var p = [],
- markup = Ext.isIE ?
- '':
- '';
- return {
- pull: function() {
- var sh = p.shift();
- if (!sh) {
- sh = Ext.get(Ext.DomHelper.insertHtml("beforeBegin", document.body.firstChild, markup));
- sh.autoBoxAdjust = false;
- }
- return sh;
- },
+}, function() {
+
+ Ext.data.SimpleStore = Ext.data.ArrayStore;
+
+});
- push: function(sh) {
- p.push(sh);
- }
- };
-}();
-Ext.BoxComponent = Ext.extend(Ext.Component, {
+Ext.define('Ext.data.Batch', {
+ mixins: {
+ observable: 'Ext.util.Observable'
+ },
+
+
+ autoStart: false,
+
+
+ current: -1,
+ total: 0,
+ isRunning: false,
+ isComplete: false,
+ hasException: false,
+
+
+ pauseOnException: true,
+
+ constructor: function(config) {
+ var me = this;
+
+ me.addEvents(
+
+ 'complete',
+
+
+ 'exception',
+
+
+ 'operationcomplete'
+ );
+
+ me.mixins.observable.constructor.call(me, config);
+
+
+ me.operations = [];
+ },
+ add: function(operation) {
+ this.total++;
+
+ operation.setBatch(this);
+
+ this.operations.push(operation);
+ },
+ start: function() {
+ this.hasException = false;
+ this.isRunning = true;
+
+ this.runNextOperation();
+ },
+ runNextOperation: function() {
+ this.runOperation(this.current + 1);
+ },
+ pause: function() {
+ this.isRunning = false;
+ },
+ runOperation: function(index) {
+ var me = this,
+ operations = me.operations,
+ operation = operations[index],
+ onProxyReturn;
+
+ if (operation === undefined) {
+ me.isRunning = false;
+ me.isComplete = true;
+ me.fireEvent('complete', me, operations[operations.length - 1]);
+ } else {
+ me.current = index;
+
+ onProxyReturn = function(operation) {
+ var hasException = operation.hasException();
+
+ if (hasException) {
+ me.hasException = true;
+ me.fireEvent('exception', me, operation);
+ } else {
+ me.fireEvent('operationcomplete', me, operation);
+ }
+
+ if (hasException && me.pauseOnException) {
+ me.pause();
+ } else {
+ operation.setCompleted();
+ me.runNextOperation();
+ }
+ };
+
+ operation.setStarted();
+
+ me.proxy[operation.action](operation, onProxyReturn, me);
+ }
+ }
+});
+
+Ext.define('Ext.data.BelongsToAssociation', {
+ extend: 'Ext.data.Association',
+
+ alias: 'association.belongsto',
+
+
+
-
+ constructor: function(config) {
+ this.callParent(arguments);
+
+ var me = this,
+ ownerProto = me.ownerModel.prototype,
+ associatedName = me.associatedName,
+ getterName = me.getterName || 'get' + associatedName,
+ setterName = me.setterName || 'set' + associatedName;
+
+ Ext.applyIf(me, {
+ name : associatedName,
+ foreignKey : associatedName.toLowerCase() + "_id",
+ instanceName: associatedName + 'BelongsToInstance',
+ associationKey: associatedName.toLowerCase()
+ });
-
- initComponent : function(){
- Ext.BoxComponent.superclass.initComponent.call(this);
- this.addEvents(
-
- 'resize',
-
- 'move'
- );
+ ownerProto[getterName] = me.createGetter();
+ ownerProto[setterName] = me.createSetter();
},
- boxReady : false,
-
- deferHeight: false,
-
-
- setSize : function(w, h){
+ createSetter: function() {
+ var me = this,
+ ownerModel = me.ownerModel,
+ associatedModel = me.associatedModel,
+ foreignKey = me.foreignKey,
+ primaryKey = me.primaryKey;
- if(typeof w == 'object'){
- h = w.height;
- w = w.width;
- }
- if (Ext.isDefined(w) && Ext.isDefined(this.boxMinWidth) && (w < this.boxMinWidth)) {
- w = this.boxMinWidth;
- }
- if (Ext.isDefined(h) && Ext.isDefined(this.boxMinHeight) && (h < this.boxMinHeight)) {
- h = this.boxMinHeight;
- }
- if (Ext.isDefined(w) && Ext.isDefined(this.boxMaxWidth) && (w > this.boxMaxWidth)) {
- w = this.boxMaxWidth;
- }
- if (Ext.isDefined(h) && Ext.isDefined(this.boxMaxHeight) && (h > this.boxMaxHeight)) {
- h = this.boxMaxHeight;
- }
-
- if(!this.boxReady){
- this.width = w;
- this.height = h;
- return this;
- }
+ return function(value, options, scope) {
+ this.set(foreignKey, value);
-
- if(this.cacheSizes !== false && this.lastSize && this.lastSize.width == w && this.lastSize.height == h){
- return this;
- }
- this.lastSize = {width: w, height: h};
- var adj = this.adjustSize(w, h),
- aw = adj.width,
- ah = adj.height,
- rz;
- if(aw !== undefined || ah !== undefined){
- rz = this.getResizeEl();
- if(!this.deferHeight && aw !== undefined && ah !== undefined){
- rz.setSize(aw, ah);
- }else if(!this.deferHeight && ah !== undefined){
- rz.setHeight(ah);
- }else if(aw !== undefined){
- rz.setWidth(aw);
- }
- this.onResize(aw, ah, w, h);
- this.fireEvent('resize', this, aw, ah, w, h);
- }
- return this;
- },
+ if (typeof options == 'function') {
+ options = {
+ callback: options,
+ scope: scope || this
+ };
+ }
-
- setWidth : function(width){
- return this.setSize(width);
+ if (Ext.isObject(options)) {
+ return this.save(options);
+ }
+ };
},
- setHeight : function(height){
- return this.setSize(undefined, height);
- },
+ createGetter: function() {
+ var me = this,
+ ownerModel = me.ownerModel,
+ associatedName = me.associatedName,
+ associatedModel = me.associatedModel,
+ foreignKey = me.foreignKey,
+ primaryKey = me.primaryKey,
+ instanceName = me.instanceName;
-
- getSize : function(){
- return this.getResizeEl().getSize();
+
+ return function(options, scope) {
+ options = options || {};
+
+ var foreignKeyId = this.get(foreignKey),
+ instance, callbackFn;
+
+ if (this[instanceName] === undefined) {
+ instance = Ext.ModelManager.create({}, associatedName);
+ instance.set(primaryKey, foreignKeyId);
+
+ if (typeof options == 'function') {
+ options = {
+ callback: options,
+ scope: scope || this
+ };
+ }
+
+ associatedModel.load(foreignKeyId, options);
+ } else {
+ instance = this[instanceName];
+
+
+
+
+ if (typeof options == 'function') {
+ options.call(scope || this, instance);
+ }
+
+ if (options.success) {
+ options.success.call(scope || this, instance);
+ }
+
+ if (options.callback) {
+ options.callback.call(scope || this, instance);
+ }
+
+ return instance;
+ }
+ };
},
- getWidth : function(){
- return this.getResizeEl().getWidth();
- },
+ read: function(record, reader, associationData){
+ record[this.instanceName] = reader.read([associationData]).records[0];
+ }
+});
+
+Ext.define('Ext.data.BufferStore', {
+ extend: 'Ext.data.Store',
+ alias: 'store.buffer',
+ sortOnLoad: false,
+ filterOnLoad: false,
- getHeight : function(){
- return this.getResizeEl().getHeight();
- },
+ constructor: function() {
+ Ext.Error.raise('The BufferStore class has been deprecated. Instead, specify the buffered config option on Ext.data.Store');
+ }
+});
+
+Ext.define('Ext.direct.Manager', {
- getOuterSize : function(){
- var el = this.getResizeEl();
- return {width: el.getWidth() + el.getMargins('lr'),
- height: el.getHeight() + el.getMargins('tb')};
+
+ singleton: true,
+
+ mixins: {
+ observable: 'Ext.util.Observable'
},
-
- getPosition : function(local){
- var el = this.getPositionEl();
- if(local === true){
- return [el.getLeft(true), el.getTop(true)];
+ requires: ['Ext.util.MixedCollection'],
+
+ statics: {
+ exceptions: {
+ TRANSPORT: 'xhr',
+ PARSE: 'parse',
+ LOGIN: 'login',
+ SERVER: 'exception'
}
- return this.xy || el.getXY();
},
-
- getBox : function(local){
- var pos = this.getPosition(local);
- var s = this.getSize();
- s.x = pos[0];
- s.y = pos[1];
- return s;
- },
-
- updateBox : function(box){
- this.setSize(box.width, box.height);
- this.setPagePosition(box.x, box.y);
- return this;
+
+ constructor: function(){
+ var me = this;
+
+ me.addEvents(
+
+ 'event',
+
+ 'exception'
+ );
+ me.transactions = Ext.create('Ext.util.MixedCollection');
+ me.providers = Ext.create('Ext.util.MixedCollection');
+
+ me.mixins.observable.constructor.call(me);
},
-
- getResizeEl : function(){
- return this.resizeEl || this.el;
- },
-
- setAutoScroll : function(scroll){
- if(this.rendered){
- this.getContentTarget().setOverflow(scroll ? 'auto' : '');
+ addProvider : function(provider){
+ var me = this,
+ args = arguments,
+ i = 0,
+ len;
+
+ if (args.length > 1) {
+ for (len = args.length; i < len; ++i) {
+ me.addProvider(args[i]);
+ }
+ return;
}
- this.autoScroll = scroll;
- return this;
- },
-
- setPosition : function(x, y){
- if(x && typeof x[1] == 'number'){
- y = x[1];
- x = x[0];
- }
- this.x = x;
- this.y = y;
- if(!this.boxReady){
- return this;
+
+ if (!provider.isProvider) {
+ provider = Ext.create('direct.' + provider.type + 'provider', provider);
}
- var adj = this.adjustPosition(x, y);
- var ax = adj.x, ay = adj.y;
+ me.providers.add(provider);
+ provider.on('data', me.onProviderData, me);
- var el = this.getPositionEl();
- if(ax !== undefined || ay !== undefined){
- if(ax !== undefined && ay !== undefined){
- el.setLeftTop(ax, ay);
- }else if(ax !== undefined){
- el.setLeft(ax);
- }else if(ay !== undefined){
- el.setTop(ay);
- }
- this.onPosition(ax, ay);
- this.fireEvent('move', this, ax, ay);
+
+ if (!provider.isConnected()) {
+ provider.connect();
}
- return this;
- },
+ return provider;
+ },
- setPagePosition : function(x, y){
- if(x && typeof x[1] == 'number'){
- y = x[1];
- x = x[0];
- }
- this.pageX = x;
- this.pageY = y;
- if(!this.boxReady){
- return;
- }
- if(x === undefined || y === undefined){
- return;
- }
- var p = this.getPositionEl().translatePoints(x, y);
- this.setPosition(p.left, p.top);
- return this;
+
+ getProvider : function(id){
+ return id.isProvider ? id : this.providers.get(id);
},
-
- afterRender : function(){
- Ext.BoxComponent.superclass.afterRender.call(this);
- if(this.resizeEl){
- this.resizeEl = Ext.get(this.resizeEl);
- }
- if(this.positionEl){
- this.positionEl = Ext.get(this.positionEl);
- }
- this.boxReady = true;
- Ext.isDefined(this.autoScroll) && this.setAutoScroll(this.autoScroll);
- this.setSize(this.width, this.height);
- if(this.x || this.y){
- this.setPosition(this.x, this.y);
- }else if(this.pageX || this.pageY){
- this.setPagePosition(this.pageX, this.pageY);
+
+ removeProvider : function(provider){
+ var me = this,
+ providers = me.providers,
+ provider = provider.isProvider ? provider : providers.get(provider);
+
+ if (provider) {
+ provider.un('data', me.onProviderData, me);
+ providers.remove(provider);
+ return provider;
}
+ return null;
},
-
- syncSize : function(){
- delete this.lastSize;
- this.setSize(this.autoWidth ? undefined : this.getResizeEl().getWidth(), this.autoHeight ? undefined : this.getResizeEl().getHeight());
- return this;
+
+ addTransaction: function(transaction){
+ this.transactions.add(transaction);
+ return transaction;
},
- onResize : function(adjWidth, adjHeight, rawWidth, rawHeight){
+ removeTransaction: function(transaction){
+ transaction = this.getTransaction(transaction);
+ this.transactions.remove(transaction);
+ return transaction;
},
- onPosition : function(x, y){
-
+ getTransaction: function(transaction){
+ return transaction.isTransaction ? transaction : this.transactions.get(transaction);
},
-
- adjustSize : function(w, h){
- if(this.autoWidth){
- w = 'auto';
+ onProviderData : function(provider, event){
+ var me = this,
+ i = 0,
+ len;
+
+ if (Ext.isArray(event)) {
+ for (len = event.length; i < len; ++i) {
+ me.onProviderData(provider, event[i]);
+ }
+ return;
}
- if(this.autoHeight){
- h = 'auto';
+ if (event.name && event.name != 'event' && event.name != 'exception') {
+ me.fireEvent(event.name, event);
+ } else if (event.type == 'exception') {
+ me.fireEvent('exception', event);
}
- return {width : w, height: h};
- },
-
-
- adjustPosition : function(x, y){
- return {x : x, y: y};
+ me.fireEvent('event', event, provider);
}
+}, function(){
+
+ Ext.Direct = Ext.direct.Manager;
});
-Ext.reg('box', Ext.BoxComponent);
-
-Ext.Spacer = Ext.extend(Ext.BoxComponent, {
- autoEl:'div'
-});
-Ext.reg('spacer', Ext.Spacer);
-Ext.SplitBar = function(dragElement, resizingElement, orientation, placement, existingProxy){
-
+Ext.define('Ext.data.proxy.Direct', {
- this.el = Ext.get(dragElement, true);
- this.el.dom.unselectable = "on";
- this.resizingEl = Ext.get(resizingElement, true);
-
+ extend: 'Ext.data.proxy.Server',
+ alternateClassName: 'Ext.data.DirectProxy',
- this.orientation = orientation || Ext.SplitBar.HORIZONTAL;
-
+ alias: 'proxy.direct',
+ requires: ['Ext.direct.Manager'],
- this.minSize = 0;
-
- this.maxSize = 2000;
+
+
+ paramOrder: undefined,
- this.animate = false;
+ paramsAsHash: true,
- this.useShim = false;
-
+ directFn : undefined,
- this.shim = null;
-
- if(!existingProxy){
-
- this.proxy = Ext.SplitBar.createProxy(this.orientation);
- }else{
- this.proxy = Ext.get(existingProxy).dom;
- }
- this.dd = new Ext.dd.DDProxy(this.el.dom.id, "XSplitBars", {dragElId : this.proxy.id});
-
- this.dd.b4StartDrag = this.onStartProxyDrag.createDelegate(this);
-
- this.dd.endDrag = this.onEndProxyDrag.createDelegate(this);
-
- this.dragSpecs = {};
-
- this.adapter = new Ext.SplitBar.BasicLayoutAdapter();
- this.adapter.init(this);
-
- if(this.orientation == Ext.SplitBar.HORIZONTAL){
-
- this.placement = placement || (this.el.getX() > this.resizingEl.getX() ? Ext.SplitBar.LEFT : Ext.SplitBar.RIGHT);
- this.el.addClass("x-splitbar-h");
- }else{
-
- this.placement = placement || (this.el.getY() > this.resizingEl.getY() ? Ext.SplitBar.TOP : Ext.SplitBar.BOTTOM);
- this.el.addClass("x-splitbar-v");
- }
-
- this.addEvents(
-
- "resize",
-
- "moved",
+ paramOrderRe: /[\s,|]/,
+
+ constructor: function(config){
+ var me = this;
- "beforeresize",
-
- "beforeapply"
- );
-
- Ext.SplitBar.superclass.constructor.call(this);
-};
-
-Ext.extend(Ext.SplitBar, Ext.util.Observable, {
- onStartProxyDrag : function(x, y){
- this.fireEvent("beforeresize", this);
- this.overlay = Ext.DomHelper.append(document.body, {cls: "x-drag-overlay", html: " "}, true);
- this.overlay.unselectable();
- this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
- this.overlay.show();
- Ext.get(this.proxy).setDisplayed("block");
- var size = this.adapter.getElementSize(this);
- this.activeMinSize = this.getMinimumSize();
- this.activeMaxSize = this.getMaximumSize();
- var c1 = size - this.activeMinSize;
- var c2 = Math.max(this.activeMaxSize - size, 0);
- if(this.orientation == Ext.SplitBar.HORIZONTAL){
- this.dd.resetConstraints();
- this.dd.setXConstraint(
- this.placement == Ext.SplitBar.LEFT ? c1 : c2,
- this.placement == Ext.SplitBar.LEFT ? c2 : c1,
- this.tickSize
- );
- this.dd.setYConstraint(0, 0);
- }else{
- this.dd.resetConstraints();
- this.dd.setXConstraint(0, 0);
- this.dd.setYConstraint(
- this.placement == Ext.SplitBar.TOP ? c1 : c2,
- this.placement == Ext.SplitBar.TOP ? c2 : c1,
- this.tickSize
- );
- }
- this.dragSpecs.startSize = size;
- this.dragSpecs.startPoint = [x, y];
- Ext.dd.DDProxy.prototype.b4StartDrag.call(this.dd, x, y);
+ Ext.apply(me, config);
+ if (Ext.isString(me.paramOrder)) {
+ me.paramOrder = me.paramOrder.split(me.paramOrderRe);
+ }
+ me.callParent(arguments);
},
-
- onEndProxyDrag : function(e){
- Ext.get(this.proxy).setDisplayed(false);
- var endPoint = Ext.lib.Event.getXY(e);
- if(this.overlay){
- Ext.destroy(this.overlay);
- delete this.overlay;
+ doRequest: function(operation, callback, scope) {
+ var me = this,
+ writer = me.getWriter(),
+ request = me.buildRequest(operation, callback, scope),
+ fn = me.api[request.action] || me.directFn,
+ args = [],
+ params = request.params,
+ paramOrder = me.paramOrder,
+ method,
+ i = 0,
+ len;
+
+ if (!fn) {
+ Ext.Error.raise('No direct function specified for this proxy');
}
- var newSize;
- if(this.orientation == Ext.SplitBar.HORIZONTAL){
- newSize = this.dragSpecs.startSize +
- (this.placement == Ext.SplitBar.LEFT ?
- endPoint[0] - this.dragSpecs.startPoint[0] :
- this.dragSpecs.startPoint[0] - endPoint[0]
- );
- }else{
- newSize = this.dragSpecs.startSize +
- (this.placement == Ext.SplitBar.TOP ?
- endPoint[1] - this.dragSpecs.startPoint[1] :
- this.dragSpecs.startPoint[1] - endPoint[1]
- );
+
+ if (operation.allowWrite()) {
+ request = writer.write(request);
}
- newSize = Math.min(Math.max(newSize, this.activeMinSize), this.activeMaxSize);
- if(newSize != this.dragSpecs.startSize){
- if(this.fireEvent('beforeapply', this, newSize) !== false){
- this.adapter.setElementSize(this, newSize);
- this.fireEvent("moved", this, newSize);
- this.fireEvent("resize", this, newSize);
+
+ if (operation.action == 'read') {
+
+ method = fn.directCfg.method;
+
+ if (method.ordered) {
+ if (method.len > 0) {
+ if (paramOrder) {
+ for (len = paramOrder.length; i < len; ++i) {
+ args.push(params[paramOrder[i]]);
+ }
+ } else if (me.paramsAsHash) {
+ args.push(params);
+ }
+ }
+ } else {
+ args.push(params);
}
+ } else {
+ args.push(request.jsonData);
}
+
+ Ext.apply(request, {
+ args: args,
+ directFn: fn
+ });
+ args.push(me.createRequestCallback(request, operation, callback, scope), me);
+ fn.apply(window, args);
},
-
- getAdapter : function(){
- return this.adapter;
- },
-
- setAdapter : function(adapter){
- this.adapter = adapter;
- this.adapter.init(this);
+ applyEncoding: function(value){
+ return value;
},
-
- getMinimumSize : function(){
- return this.minSize;
+ createRequestCallback: function(request, operation, callback, scope){
+ var me = this;
+
+ return function(data, event){
+ me.processResponse(event.status, operation, request, event, callback, scope);
+ };
},
-
- setMinimumSize : function(minSize){
- this.minSize = minSize;
- },
-
- getMaximumSize : function(){
- return this.maxSize;
+ extractResponseData: function(response){
+ return Ext.isDefined(response.result) ? response.result : response.data;
},
-
- setMaximumSize : function(maxSize){
- this.maxSize = maxSize;
- },
-
- setCurrentSize : function(size){
- var oldAnimate = this.animate;
- this.animate = false;
- this.adapter.setElementSize(this, size);
- this.animate = oldAnimate;
+ setException: function(operation, response) {
+ operation.setException(response.message);
},
-
- destroy : function(removeEl){
- Ext.destroy(this.shim, Ext.get(this.proxy));
- this.dd.unreg();
- if(removeEl){
- this.el.remove();
- }
- this.purgeListeners();
+
+ buildUrl: function(){
+ return '';
}
});
-Ext.SplitBar.createProxy = function(dir){
- var proxy = new Ext.Element(document.createElement("div"));
- document.body.appendChild(proxy.dom);
- proxy.unselectable();
- var cls = 'x-splitbar-proxy';
- proxy.addClass(cls + ' ' + (dir == Ext.SplitBar.HORIZONTAL ? cls +'-h' : cls + '-v'));
- return proxy.dom;
-};
-
-
-Ext.SplitBar.BasicLayoutAdapter = function(){
-};
-Ext.SplitBar.BasicLayoutAdapter.prototype = {
+Ext.define('Ext.data.DirectStore', {
- init : function(s){
-
- },
- getElementSize : function(s){
- if(s.orientation == Ext.SplitBar.HORIZONTAL){
- return s.resizingEl.getWidth();
- }else{
- return s.resizingEl.getHeight();
- }
- },
-
+ extend: 'Ext.data.Store',
- setElementSize : function(s, newSize, onComplete){
- if(s.orientation == Ext.SplitBar.HORIZONTAL){
- if(!s.animate){
- s.resizingEl.setWidth(newSize);
- if(onComplete){
- onComplete(s, newSize);
- }
- }else{
- s.resizingEl.setWidth(newSize, true, .1, onComplete, 'easeOut');
- }
- }else{
-
- if(!s.animate){
- s.resizingEl.setHeight(newSize);
- if(onComplete){
- onComplete(s, newSize);
+ alias: 'store.direct',
+
+ requires: ['Ext.data.proxy.Direct'],
+
+
+
+ constructor : function(config){
+ config = Ext.apply({}, config);
+ if (!config.proxy) {
+ var proxy = {
+ type: 'direct',
+ reader: {
+ type: 'json'
}
- }else{
- s.resizingEl.setHeight(newSize, true, .1, onComplete, 'easeOut');
- }
- }
- }
-};
-
-
-Ext.SplitBar.AbsoluteLayoutAdapter = function(container){
- this.basic = new Ext.SplitBar.BasicLayoutAdapter();
- this.container = Ext.get(container);
-};
-
-Ext.SplitBar.AbsoluteLayoutAdapter.prototype = {
- init : function(s){
- this.basic.init(s);
- },
-
- getElementSize : function(s){
- return this.basic.getElementSize(s);
- },
-
- setElementSize : function(s, newSize, onComplete){
- this.basic.setElementSize(s, newSize, this.moveSplitter.createDelegate(this, [s]));
- },
-
- moveSplitter : function(s){
- var yes = Ext.SplitBar;
- switch(s.placement){
- case yes.LEFT:
- s.el.setX(s.resizingEl.getRight());
- break;
- case yes.RIGHT:
- s.el.setStyle("right", (this.container.getWidth() - s.resizingEl.getLeft()) + "px");
- break;
- case yes.TOP:
- s.el.setY(s.resizingEl.getBottom());
- break;
- case yes.BOTTOM:
- s.el.setY(s.resizingEl.getTop() - s.el.getHeight());
- break;
+ };
+ Ext.copyTo(proxy, config, 'paramOrder,paramsAsHash,directFn,api,simpleSortMode');
+ Ext.copyTo(proxy.reader, config, 'totalProperty,root,idProperty');
+ config.proxy = proxy;
}
- }
-};
-
-
-Ext.SplitBar.VERTICAL = 1;
-
-
-Ext.SplitBar.HORIZONTAL = 2;
-
-
-Ext.SplitBar.LEFT = 1;
-
+ this.callParent([config]);
+ }
+});
-Ext.SplitBar.RIGHT = 2;
-Ext.SplitBar.TOP = 3;
+Ext.define('Ext.util.Inflector', {
+
-Ext.SplitBar.BOTTOM = 4;
+ singleton: true,
-Ext.Container = Ext.extend(Ext.BoxComponent, {
+
+ plurals: [
+ [(/(quiz)$/i), "$1zes" ],
+ [(/^(ox)$/i), "$1en" ],
+ [(/([m|l])ouse$/i), "$1ice" ],
+ [(/(matr|vert|ind)ix|ex$/i), "$1ices" ],
+ [(/(x|ch|ss|sh)$/i), "$1es" ],
+ [(/([^aeiouy]|qu)y$/i), "$1ies" ],
+ [(/(hive)$/i), "$1s" ],
+ [(/(?:([^f])fe|([lr])f)$/i), "$1$2ves"],
+ [(/sis$/i), "ses" ],
+ [(/([ti])um$/i), "$1a" ],
+ [(/(buffal|tomat|potat)o$/i), "$1oes" ],
+ [(/(bu)s$/i), "$1ses" ],
+ [(/(alias|status|sex)$/i), "$1es" ],
+ [(/(octop|vir)us$/i), "$1i" ],
+ [(/(ax|test)is$/i), "$1es" ],
+ [(/^person$/), "people" ],
+ [(/^man$/), "men" ],
+ [(/^(child)$/), "$1ren" ],
+ [(/s$/i), "s" ],
+ [(/$/), "s" ]
+ ],
- bufferResize: 50,
-
+ singulars: [
+ [(/(quiz)zes$/i), "$1" ],
+ [(/(matr)ices$/i), "$1ix" ],
+ [(/(vert|ind)ices$/i), "$1ex" ],
+ [(/^(ox)en/i), "$1" ],
+ [(/(alias|status)es$/i), "$1" ],
+ [(/(octop|vir)i$/i), "$1us" ],
+ [(/(cris|ax|test)es$/i), "$1is" ],
+ [(/(shoe)s$/i), "$1" ],
+ [(/(o)es$/i), "$1" ],
+ [(/(bus)es$/i), "$1" ],
+ [(/([m|l])ice$/i), "$1ouse" ],
+ [(/(x|ch|ss|sh)es$/i), "$1" ],
+ [(/(m)ovies$/i), "$1ovie" ],
+ [(/(s)eries$/i), "$1eries"],
+ [(/([^aeiouy]|qu)ies$/i), "$1y" ],
+ [(/([lr])ves$/i), "$1f" ],
+ [(/(tive)s$/i), "$1" ],
+ [(/(hive)s$/i), "$1" ],
+ [(/([^f])ves$/i), "$1fe" ],
+ [(/(^analy)ses$/i), "$1sis" ],
+ [(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i), "$1$2sis"],
+ [(/([ti])a$/i), "$1um" ],
+ [(/(n)ews$/i), "$1ews" ],
+ [(/people$/i), "person" ],
+ [(/s$/i), "" ]
+ ],
+ uncountable: [
+ "sheep",
+ "fish",
+ "series",
+ "species",
+ "money",
+ "rice",
+ "information",
+ "equipment",
+ "grass",
+ "mud",
+ "offspring",
+ "deer",
+ "means"
+ ],
-
-
- autoDestroy : true,
-
+ singular: function(matcher, replacer) {
+ this.singulars.unshift([matcher, replacer]);
+ },
- forceLayout: false,
-
+ plural: function(matcher, replacer) {
+ this.plurals.unshift([matcher, replacer]);
+ },
- defaultType : 'panel',
-
- resizeEvent: 'resize',
-
+ clearSingulars: function() {
+ this.singulars = [];
+ },
- bubbleEvents: ['add', 'remove'],
-
- initComponent : function(){
- Ext.Container.superclass.initComponent.call(this);
-
- this.addEvents(
-
- 'afterlayout',
-
- 'beforeadd',
-
- 'beforeremove',
-
- 'add',
-
- 'remove'
- );
-
-
- var items = this.items;
- if(items){
- delete this.items;
- this.add(items);
- }
+ clearPlurals: function() {
+ this.plurals = [];
},
-
- initItems : function(){
- if(!this.items){
- this.items = new Ext.util.MixedCollection(false, this.getComponentId);
- this.getLayout();
- }
+
+ isTransnumeral: function(word) {
+ return Ext.Array.indexOf(this.uncountable, word) != -1;
},
- setLayout : function(layout){
- if(this.layout && this.layout != layout){
- this.layout.setContainer(null);
+ pluralize: function(word) {
+ if (this.isTransnumeral(word)) {
+ return word;
}
- this.layout = layout;
- this.initItems();
- layout.setContainer(this);
- },
- afterRender: function(){
-
+ var plurals = this.plurals,
+ length = plurals.length,
+ tuple, regex, i;
- Ext.Container.superclass.afterRender.call(this);
- if(!this.layout){
- this.layout = 'auto';
- }
- if(Ext.isObject(this.layout) && !this.layout.layout){
- this.layoutConfig = this.layout;
- this.layout = this.layoutConfig.type;
- }
- if(Ext.isString(this.layout)){
- this.layout = new Ext.Container.LAYOUTS[this.layout.toLowerCase()](this.layoutConfig);
+ for (i = 0; i < length; i++) {
+ tuple = plurals[i];
+ regex = tuple[0];
+
+ if (regex == word || (regex.test && regex.test(word))) {
+ return word.replace(regex, tuple[1]);
+ }
}
- this.setLayout(this.layout);
-
- if(this.activeItem !== undefined && this.layout.setActiveItem){
- var item = this.activeItem;
- delete this.activeItem;
- this.layout.setActiveItem(item);
+ return word;
+ },
+
+
+ singularize: function(word) {
+ if (this.isTransnumeral(word)) {
+ return word;
}
+ var singulars = this.singulars,
+ length = singulars.length,
+ tuple, regex, i;
- if(!this.ownerCt){
- this.doLayout(false, true);
+ for (i = 0; i < length; i++) {
+ tuple = singulars[i];
+ regex = tuple[0];
+
+ if (regex == word || (regex.test && regex.test(word))) {
+ return word.replace(regex, tuple[1]);
+ }
}
-
-
- if(this.monitorResize === true){
- Ext.EventManager.onWindowResize(this.doLayout, this, [false]);
- }
+ return word;
},
-
- getLayoutTarget : function(){
- return this.el;
- },
-
- getComponentId : function(comp){
- return comp.getItemId();
+ classify: function(word) {
+ return Ext.String.capitalize(this.singularize(word));
},
-
- add : function(comp){
- this.initItems();
- var args = arguments.length > 1;
- if(args || Ext.isArray(comp)){
- var result = [];
- Ext.each(args ? arguments : comp, function(c){
- result.push(this.add(c));
- }, this);
- return result;
- }
- var c = this.lookupComponent(this.applyDefaults(comp));
- var index = this.items.length;
- if(this.fireEvent('beforeadd', this, c, index) !== false && this.onBeforeAdd(c) !== false){
- this.items.add(c);
-
- c.onAdded(this, index);
- this.onAdd(c);
- this.fireEvent('add', this, c, index);
- }
- return c;
- },
-
- onAdd : function(c){
-
- },
-
- onAdded : function(container, pos) {
+ ordinalize: function(number) {
+ var parsed = parseInt(number, 10),
+ mod10 = parsed % 10,
+ mod100 = parsed % 100;
- this.ownerCt = container;
- this.initRef();
- this.cascade(function(c){
- c.initRef();
- });
- this.fireEvent('added', this, container, pos);
- },
+ if (11 <= mod100 && mod100 <= 13) {
+ return number + "th";
+ } else {
+ switch(mod10) {
+ case 1 : return number + "st";
+ case 2 : return number + "nd";
+ case 3 : return number + "rd";
+ default: return number + "th";
+ }
+ }
+ }
+}, function() {
+
+ var irregulars = {
+ alumnus: 'alumni',
+ cactus : 'cacti',
+ focus : 'foci',
+ nucleus: 'nuclei',
+ radius: 'radii',
+ stimulus: 'stimuli',
+ ellipsis: 'ellipses',
+ paralysis: 'paralyses',
+ oasis: 'oases',
+ appendix: 'appendices',
+ index: 'indexes',
+ beau: 'beaux',
+ bureau: 'bureaux',
+ tableau: 'tableaux',
+ woman: 'women',
+ child: 'children',
+ man: 'men',
+ corpus: 'corpora',
+ criterion: 'criteria',
+ curriculum: 'curricula',
+ genus: 'genera',
+ memorandum: 'memoranda',
+ phenomenon: 'phenomena',
+ foot: 'feet',
+ goose: 'geese',
+ tooth: 'teeth',
+ antenna: 'antennae',
+ formula: 'formulae',
+ nebula: 'nebulae',
+ vertebra: 'vertebrae',
+ vita: 'vitae'
+ },
+ singular;
+
+ for (singular in irregulars) {
+ this.plural(singular, irregulars[singular]);
+ this.singular(irregulars[singular], singular);
+ }
+});
+
+Ext.define('Ext.data.HasManyAssociation', {
+ extend: 'Ext.data.Association',
+ requires: ['Ext.util.Inflector'],
+
+ alias: 'association.hasmany',
- insert : function(index, comp) {
- var args = arguments,
- length = args.length,
- result = [],
- i, c;
-
- this.initItems();
+
+
+
+
+
+
+
+
+
+
+
+ constructor: function(config) {
+ var me = this,
+ ownerProto,
+ name;
+
+ me.callParent(arguments);
- if (length > 2) {
- for (i = length - 1; i >= 1; --i) {
- result.push(this.insert(index, args[i]));
- }
- return result;
- }
+ me.name = me.name || Ext.util.Inflector.pluralize(me.associatedName.toLowerCase());
- c = this.lookupComponent(this.applyDefaults(comp));
- index = Math.min(index, this.items.length);
+ ownerProto = me.ownerModel.prototype;
+ name = me.name;
- if (this.fireEvent('beforeadd', this, c, index) !== false && this.onBeforeAdd(c) !== false) {
- if (c.ownerCt == this) {
- this.items.remove(c);
- }
- this.items.insert(index, c);
- c.onAdded(this, index);
- this.onAdd(c);
- this.fireEvent('add', this, c, index);
- }
+ Ext.applyIf(me, {
+ storeName : name + "Store",
+ foreignKey: me.ownerName.toLowerCase() + "_id"
+ });
- return c;
+ ownerProto[name] = me.createStore();
},
-
- applyDefaults : function(c){
- var d = this.defaults;
- if(d){
- if(Ext.isFunction(d)){
- d = d.call(this, c);
- }
- if(Ext.isString(c)){
- c = Ext.ComponentMgr.get(c);
- Ext.apply(c, d);
- }else if(!c.events){
- Ext.applyIf(c.isAction ? c.initialConfig : c, d);
- }else{
- Ext.apply(c, d);
+
+ createStore: function() {
+ var that = this,
+ associatedModel = that.associatedModel,
+ storeName = that.storeName,
+ foreignKey = that.foreignKey,
+ primaryKey = that.primaryKey,
+ filterProperty = that.filterProperty,
+ autoLoad = that.autoLoad,
+ storeConfig = that.storeConfig || {};
+
+ return function() {
+ var me = this,
+ config, filter,
+ modelDefaults = {};
+
+ if (me[storeName] === undefined) {
+ if (filterProperty) {
+ filter = {
+ property : filterProperty,
+ value : me.get(filterProperty),
+ exactMatch: true
+ };
+ } else {
+ filter = {
+ property : foreignKey,
+ value : me.get(primaryKey),
+ exactMatch: true
+ };
+ }
+
+ modelDefaults[foreignKey] = me.get(primaryKey);
+
+ config = Ext.apply({}, storeConfig, {
+ model : associatedModel,
+ filters : [filter],
+ remoteFilter : false,
+ modelDefaults: modelDefaults
+ });
+
+ me[storeName] = Ext.create('Ext.data.Store', config);
+ if (autoLoad) {
+ me[storeName].load();
+ }
}
- }
- return c;
+
+ return me[storeName];
+ };
},
-
- onBeforeAdd : function(item){
- if(item.ownerCt){
- item.ownerCt.remove(item, false);
- }
- if(this.hideBorders === true){
- item.border = (item.border === true);
- }
- },
-
- remove : function(comp, autoDestroy){
- this.initItems();
- var c = this.getComponent(comp);
- if(c && this.fireEvent('beforeremove', this, c) !== false){
- this.doRemove(c, autoDestroy);
- this.fireEvent('remove', this, c);
- }
- return c;
- },
-
- onRemove: function(c){
-
- },
-
+ read: function(record, reader, associationData){
+ var store = record[this.name](),
+ inverse;
- doRemove: function(c, autoDestroy){
- var l = this.layout,
- hasLayout = l && this.rendered;
-
- if(hasLayout){
- l.onRemove(c);
- }
- this.items.remove(c);
- c.onRemoved();
- this.onRemove(c);
- if(autoDestroy === true || (autoDestroy !== false && this.autoDestroy)){
- c.destroy();
- }
- if(hasLayout){
- l.afterRemove(c);
- }
- },
-
+ store.add(reader.read(associationData).records);
- removeAll: function(autoDestroy){
- this.initItems();
- var item, rem = [], items = [];
- this.items.each(function(i){
- rem.push(i);
+
+
+ inverse = this.associatedModel.prototype.associations.findBy(function(assoc){
+ return assoc.type === 'belongsTo' && assoc.associatedName === record.$className;
});
- for (var i = 0, len = rem.length; i < len; ++i){
- item = rem[i];
- this.remove(item, autoDestroy);
- if(item.ownerCt !== this){
- items.push(item);
- }
- }
- return items;
- },
-
- getComponent : function(comp){
- if(Ext.isObject(comp)){
- comp = comp.getItemId();
+
+ if (inverse) {
+ store.data.each(function(associatedRecord){
+ associatedRecord[inverse.instanceName] = record;
+ });
}
- return this.items.get(comp);
- },
+ }
+});
+Ext.define('Ext.data.JsonP', {
- lookupComponent : function(comp){
- if(Ext.isString(comp)){
- return Ext.ComponentMgr.get(comp);
- }else if(!comp.events){
- return this.createComponent(comp);
- }
- return comp;
+
+
+ singleton: true,
+
+ statics: {
+ requestCount: 0,
+ requests: {}
},
-
- createComponent : function(config, defaultType){
- if (config.render) {
- return config;
+
+
+
+ timeout: 30000,
+
+
+ disableCaching: true,
+
+
+ disableCachingParam: '_dc',
+
+
+ callbackKey: 'callback',
+
+
+ request: function(options){
+ options = Ext.apply({}, options);
+
+ if (!options.url) {
+ Ext.Error.raise('A url must be specified for a JSONP request.');
+ }
+
+ var me = this,
+ disableCaching = Ext.isDefined(options.disableCaching) ? options.disableCaching : me.disableCaching,
+ cacheParam = options.disableCachingParam || me.disableCachingParam,
+ id = ++me.statics().requestCount,
+ callbackName = 'callback' + id,
+ callbackKey = options.callbackKey || me.callbackKey,
+ timeout = Ext.isDefined(options.timeout) ? options.timeout : me.timeout,
+ params = Ext.apply({}, options.params),
+ url = options.url,
+ request,
+ script;
+
+ params[callbackKey] = 'Ext.data.JsonP.' + callbackName;
+ if (disableCaching) {
+ params[cacheParam] = new Date().getTime();
}
+ script = me.createScript(url, params);
+
+ me.statics().requests[id] = request = {
+ url: url,
+ params: params,
+ script: script,
+ id: id,
+ scope: options.scope,
+ success: options.success,
+ failure: options.failure,
+ callback: options.callback,
+ callbackName: callbackName
+ };
+
+ if (timeout > 0) {
+ request.timeout = setTimeout(Ext.bind(me.handleTimeout, me, [request]), timeout);
+ }
- var c = Ext.create(Ext.apply({
- ownerCt: this
- }, config), defaultType || this.defaultType);
- delete c.initialConfig.ownerCt;
- delete c.ownerCt;
- return c;
+ me.setupErrorHandling(request);
+ me[callbackName] = Ext.bind(me.handleResponse, me, [request], true);
+ Ext.getHead().appendChild(script);
+ return request;
},
-
- canLayout : function() {
- var el = this.getVisibilityEl();
- return el && el.dom && !el.isStyle("display", "none");
- },
-
-
- doLayout : function(shallow, force){
- var rendered = this.rendered,
- forceLayout = force || this.forceLayout;
-
- if(this.collapsed || !this.canLayout()){
- this.deferLayout = this.deferLayout || !shallow;
- if(!forceLayout){
- return;
+ abort: function(request){
+ var requests = this.statics().requests,
+ key;
+
+ if (request) {
+ if (!request.id) {
+ request = requests[request];
}
- shallow = shallow && !this.deferLayout;
+ this.abort(request);
} else {
- delete this.deferLayout;
- }
- if(rendered && this.layout){
- this.layout.layout();
- }
- if(shallow !== true && this.items){
- var cs = this.items.items;
- for(var i = 0, len = cs.length; i < len; i++){
- var c = cs[i];
- if(c.doLayout){
- c.doLayout(false, forceLayout);
+ for (key in requests) {
+ if (requests.hasOwnProperty(key)) {
+ this.abort(requests[key]);
}
}
}
- if(rendered){
- this.onLayout(shallow, forceLayout);
- }
-
- this.hasLayout = true;
- delete this.forceLayout;
},
-
- onLayout : Ext.emptyFn,
-
- shouldBufferLayout: function(){
-
- var hl = this.hasLayout;
- if(this.ownerCt){
-
- return hl ? !this.hasLayoutPending() : false;
- }
-
- return hl;
+
+ setupErrorHandling: function(request){
+ request.script.onerror = Ext.bind(this.handleError, this, [request]);
},
-
- hasLayoutPending: function(){
-
- var pending = false;
- this.ownerCt.bubble(function(c){
- if(c.layoutPending){
- pending = true;
- return false;
- }
- });
- return pending;
+
+ handleAbort: function(request){
+ request.errorType = 'abort';
+ this.handleResponse(null, request);
},
-
- onShow : function(){
-
- Ext.Container.superclass.onShow.call(this);
-
- if(Ext.isDefined(this.deferLayout)){
- delete this.deferLayout;
- this.doLayout(true);
- }
+
+
+ handleError: function(request){
+ request.errorType = 'error';
+ this.handleResponse(null, request);
},
-
+
- getLayout : function(){
- if(!this.layout){
- var layout = new Ext.layout.AutoLayout(this.layoutConfig);
- this.setLayout(layout);
- }
- return this.layout;
+ cleanupErrorHandling: function(request){
+ request.script.onerror = null;
},
-
+
- beforeDestroy : function(){
- var c;
- if(this.items){
- while(c = this.items.first()){
- this.doRemove(c, true);
- }
- }
- if(this.monitorResize){
- Ext.EventManager.removeResizeListener(this.doLayout, this);
- }
- Ext.destroy(this.layout);
- Ext.Container.superclass.beforeDestroy.call(this);
+ handleTimeout: function(request){
+ request.errorType = 'timeout';
+ this.handleResponse(null, request);
},
-
+
- cascade : function(fn, scope, args){
- if(fn.apply(scope || this, args || [this]) !== false){
- if(this.items){
- var cs = this.items.items;
- for(var i = 0, len = cs.length; i < len; i++){
- if(cs[i].cascade){
- cs[i].cascade(fn, scope, args);
- }else{
- fn.apply(scope || cs[i], args || [cs[i]]);
- }
- }
- }
+ handleResponse: function(result, request){
+
+ var success = true;
+
+ if (request.timeout) {
+ clearTimeout(request.timeout);
}
- return this;
+ delete this[request.callbackName];
+ delete this.statics()[request.id];
+ this.cleanupErrorHandling(request);
+ Ext.fly(request.script).remove();
+
+ if (request.errorType) {
+ success = false;
+ Ext.callback(request.failure, request.scope, [request.errorType]);
+ } else {
+ Ext.callback(request.success, request.scope, [result]);
+ }
+ Ext.callback(request.callback, request.scope, [success, result, request.errorType]);
},
-
- findById : function(id){
- var m = null,
- ct = this;
- this.cascade(function(c){
- if(ct != c && c.id === id){
- m = c;
- return false;
- }
- });
- return m;
- },
-
- findByType : function(xtype, shallow){
- return this.findBy(function(c){
- return c.isXType(xtype, shallow);
- });
- },
+ createScript: function(url, params) {
+ var script = document.createElement('script');
+ script.setAttribute("src", Ext.urlAppend(url, Ext.Object.toQueryString(params)));
+ script.setAttribute("async", true);
+ script.setAttribute("type", "text/javascript");
+ return script;
+ }
+});
-
- find : function(prop, value){
- return this.findBy(function(c){
- return c[prop] === value;
- });
- },
-
- findBy : function(fn, scope){
- var m = [], ct = this;
- this.cascade(function(c){
- if(ct != c && fn.call(scope || c, c, ct) === true){
- m.push(c);
- }
- });
- return m;
- },
+Ext.define('Ext.data.JsonPStore', {
+ extend: 'Ext.data.Store',
+ alias : 'store.jsonp',
- get : function(key){
- return this.getComponent(key);
+ constructor: function(config) {
+ this.callParent(Ext.apply(config, {
+ reader: Ext.create('Ext.data.reader.Json', config),
+ proxy : Ext.create('Ext.data.proxy.JsonP', config)
+ }));
}
});
-Ext.Container.LAYOUTS = {};
-Ext.reg('container', Ext.Container);
-Ext.layout.ContainerLayout = Ext.extend(Object, {
-
+Ext.define('Ext.data.NodeInterface', {
+ requires: ['Ext.data.Field'],
+ statics: {
+
+ decorate: function(record) {
+ if (!record.isNode) {
+
+
+ var mgr = Ext.ModelManager,
+ modelName = record.modelName,
+ modelClass = mgr.getModel(modelName),
+ idName = modelClass.prototype.idProperty,
+ instances = Ext.Array.filter(mgr.all.getArray(), function(item) {
+ return item.modelName == modelName;
+ }),
+ iln = instances.length,
+ newFields = [],
+ i, instance, jln, j, newField;
-
+
+ modelClass.override(this.getPrototypeBody());
+ newFields = this.applyFields(modelClass, [
+ {name: idName, type: 'string', defaultValue: null},
+ {name: 'parentId', type: 'string', defaultValue: null},
+ {name: 'index', type: 'int', defaultValue: null},
+ {name: 'depth', type: 'int', defaultValue: 0},
+ {name: 'expanded', type: 'bool', defaultValue: false, persist: false},
+ {name: 'checked', type: 'auto', defaultValue: null},
+ {name: 'leaf', type: 'bool', defaultValue: false, persist: false},
+ {name: 'cls', type: 'string', defaultValue: null, persist: false},
+ {name: 'iconCls', type: 'string', defaultValue: null, persist: false},
+ {name: 'root', type: 'boolean', defaultValue: false, persist: false},
+ {name: 'isLast', type: 'boolean', defaultValue: false, persist: false},
+ {name: 'isFirst', type: 'boolean', defaultValue: false, persist: false},
+ {name: 'allowDrop', type: 'boolean', defaultValue: true, persist: false},
+ {name: 'allowDrag', type: 'boolean', defaultValue: true, persist: false},
+ {name: 'loaded', type: 'boolean', defaultValue: false, persist: false},
+ {name: 'loading', type: 'boolean', defaultValue: false, persist: false},
+ {name: 'href', type: 'string', defaultValue: null, persist: false},
+ {name: 'hrefTarget',type: 'string', defaultValue: null, persist: false},
+ {name: 'qtip', type: 'string', defaultValue: null, persist: false},
+ {name: 'qtitle', type: 'string', defaultValue: null, persist: false}
+ ]);
+
+ jln = newFields.length;
+
+ for (i = 0; i < iln; i++) {
+ instance = instances[i];
+ for (j = 0; j < jln; j++) {
+ newField = newFields[j];
+ if (instance.get(newField.name) === undefined) {
+ instance.data[newField.name] = newField.defaultValue;
+ }
+ }
+ }
+ }
+
+ Ext.applyIf(record, {
+ firstChild: null,
+ lastChild: null,
+ parentNode: null,
+ previousSibling: null,
+ nextSibling: null,
+ childNodes: []
+ });
+
+ record.commit(true);
+
+ record.enableBubble([
+
+ "append",
-
- monitorResize:false,
-
- activeItem : null,
+
+ "remove",
- constructor : function(config){
- this.id = Ext.id(null, 'ext-layout-');
- Ext.apply(this, config);
- },
+
+ "move",
- type: 'container',
+
+ "insert",
-
- IEMeasureHack : function(target, viewFlag) {
- var tChildren = target.dom.childNodes, tLen = tChildren.length, c, d = [], e, i, ret;
- for (i = 0 ; i < tLen ; i++) {
- c = tChildren[i];
- e = Ext.get(c);
- if (e) {
- d[i] = e.getStyle('display');
- e.setStyle({display: 'none'});
- }
- }
- ret = target ? target.getViewSize(viewFlag) : {};
- for (i = 0 ; i < tLen ; i++) {
- c = tChildren[i];
- e = Ext.get(c);
- if (e) {
- e.setStyle({display: d[i]});
+
+ "beforeappend",
+
+
+ "beforeremove",
+
+
+ "beforemove",
+
+
+ "beforeinsert",
+
+
+ "expand",
+
+
+ "collapse",
+
+
+ "beforeexpand",
+
+
+ "beforecollapse",
+
+
+ "sort"
+ ]);
+
+ return record;
+ },
+
+ applyFields: function(modelClass, addFields) {
+ var modelPrototype = modelClass.prototype,
+ fields = modelPrototype.fields,
+ keys = fields.keys,
+ ln = addFields.length,
+ addField, i, name,
+ newFields = [];
+
+ for (i = 0; i < ln; i++) {
+ addField = addFields[i];
+ if (!Ext.Array.contains(keys, addField.name)) {
+ addField = Ext.create('data.field', addField);
+
+ newFields.push(addField);
+ fields.add(addField);
+ }
}
- }
- return ret;
- },
+
+ return newFields;
+ },
+
+ getPrototypeBody: function() {
+ return {
+ isNode: true,
-
- getLayoutTargetSize : Ext.EmptyFn,
+
+ createNode: function(node) {
+ if (Ext.isObject(node) && !node.isModel) {
+ node = Ext.ModelManager.create(node, this.modelName);
+ }
+
+ return Ext.data.NodeInterface.decorate(node);
+ },
+
+
+ isLeaf : function() {
+ return this.get('leaf') === true;
+ },
-
- layout : function(){
- var ct = this.container, target = ct.getLayoutTarget();
- if(!(this.hasLayout || Ext.isEmpty(this.targetCls))){
- target.addClass(this.targetCls);
- }
- this.onLayout(ct, target);
- ct.fireEvent('afterlayout', ct, this);
- },
+
+ setFirstChild : function(node) {
+ this.firstChild = node;
+ },
-
- onLayout : function(ct, target){
- this.renderAll(ct, target);
- },
+
+ setLastChild : function(node) {
+ this.lastChild = node;
+ },
-
- isValidParent : function(c, target){
- return target && c.getPositionEl().dom.parentNode == (target.dom || target);
- },
+
+ updateInfo: function(silent) {
+ var me = this,
+ isRoot = me.isRoot(),
+ parentNode = me.parentNode,
+ isFirst = (!parentNode ? true : parentNode.firstChild == me),
+ isLast = (!parentNode ? true : parentNode.lastChild == me),
+ depth = 0,
+ parent = me,
+ children = me.childNodes,
+ len = children.length,
+ i = 0;
+
+ while (parent.parentNode) {
+ ++depth;
+ parent = parent.parentNode;
+ }
+
+ me.beginEdit();
+ me.set({
+ isFirst: isFirst,
+ isLast: isLast,
+ depth: depth,
+ index: parentNode ? parentNode.indexOf(me) : 0,
+ parentId: parentNode ? parentNode.getId() : null
+ });
+ me.endEdit(silent);
+ if (silent) {
+ me.commit();
+ }
+
+ for (i = 0; i < len; i++) {
+ children[i].updateInfo(silent);
+ }
+ },
-
- renderAll : function(ct, target){
- var items = ct.items.items, i, c, len = items.length;
- for(i = 0; i < len; i++) {
- c = items[i];
- if(c && (!c.rendered || !this.isValidParent(c, target))){
- this.renderItem(c, i, target);
- }
- }
- },
+
+ isLast : function() {
+ return this.get('isLast');
+ },
-
- renderItem : function(c, position, target){
- if (c) {
- if (!c.rendered) {
- c.render(target, position);
- this.configureItem(c);
- } else if (!this.isValidParent(c, target)) {
- if (Ext.isNumber(position)) {
- position = target.dom.childNodes[position];
- }
- target.dom.insertBefore(c.getPositionEl().dom, position || null);
- c.container = target;
- this.configureItem(c);
- }
- }
- },
+ isFirst : function() {
+ return this.get('isFirst');
+ },
-
-
- getRenderedItems: function(ct){
- var t = ct.getLayoutTarget(), cti = ct.items.items, len = cti.length, i, c, items = [];
- for (i = 0; i < len; i++) {
- if((c = cti[i]).rendered && this.isValidParent(c, t) && c.shouldLayout !== false){
- items.push(c);
- }
- };
- return items;
- },
+
+ hasChildNodes : function() {
+ return !this.isLeaf() && this.childNodes.length > 0;
+ },
-
- configureItem: function(c){
- if (this.extraCls) {
- var t = c.getPositionEl ? c.getPositionEl() : c;
- t.addClass(this.extraCls);
- }
-
-
- if (c.doLayout && this.forceLayout) {
- c.doLayout();
- }
- if (this.renderHidden && c != this.activeItem) {
- c.hide();
- }
- },
+
+ isExpandable : function() {
+ return this.get('expandable') || this.hasChildNodes();
+ },
- onRemove: function(c){
- if(this.activeItem == c){
- delete this.activeItem;
- }
- if(c.rendered && this.extraCls){
- var t = c.getPositionEl ? c.getPositionEl() : c;
- t.removeClass(this.extraCls);
- }
- },
+
+ appendChild : function(node, suppressEvents, suppressNodeUpdate) {
+ var me = this,
+ i, ln,
+ index,
+ oldParent,
+ ps;
- afterRemove: function(c){
- if(c.removeRestore){
- c.removeMode = 'container';
- delete c.removeRestore;
- }
- },
+
+ if (Ext.isArray(node)) {
+ for (i = 0, ln = node.length; i < ln; i++) {
+ me.appendChild(node[i]);
+ }
+ } else {
+
+ node = me.createNode(node);
+
+ if (suppressEvents !== true && me.fireEvent("beforeappend", me, node) === false) {
+ return false;
+ }
-
- onResize: function(){
- var ct = this.container,
- b;
- if(ct.collapsed){
- return;
- }
- if(b = ct.bufferResize && ct.shouldBufferLayout()){
- if(!this.resizeTask){
- this.resizeTask = new Ext.util.DelayedTask(this.runLayout, this);
- this.resizeBuffer = Ext.isNumber(b) ? b : 50;
- }
- ct.layoutPending = true;
- this.resizeTask.delay(this.resizeBuffer);
- }else{
- this.runLayout();
- }
- },
+ index = me.childNodes.length;
+ oldParent = node.parentNode;
- runLayout: function(){
- var ct = this.container;
- this.layout();
- ct.onLayout();
- delete ct.layoutPending;
- },
+
+ if (oldParent) {
+ if (suppressEvents !== true && node.fireEvent("beforemove", node, oldParent, me, index) === false) {
+ return false;
+ }
+ oldParent.removeChild(node, null, false, true);
+ }
-
- setContainer : function(ct){
-
- if(this.monitorResize && ct != this.container){
- var old = this.container;
- if(old){
- old.un(old.resizeEvent, this.onResize, this);
- }
- if(ct){
- ct.on(ct.resizeEvent, this.onResize, this);
- }
- }
- this.container = ct;
- },
+ index = me.childNodes.length;
+ if (index === 0) {
+ me.setFirstChild(node);
+ }
-
- parseMargins : function(v){
- if (Ext.isNumber(v)) {
- v = v.toString();
- }
- var ms = v.split(' '),
- len = ms.length;
-
- if (len == 1) {
- ms[1] = ms[2] = ms[3] = ms[0];
- } else if(len == 2) {
- ms[2] = ms[0];
- ms[3] = ms[1];
- } else if(len == 3) {
- ms[3] = ms[1];
- }
-
- return {
- top :parseInt(ms[0], 10) || 0,
- right :parseInt(ms[1], 10) || 0,
- bottom:parseInt(ms[2], 10) || 0,
- left :parseInt(ms[3], 10) || 0
- };
- },
+ me.childNodes.push(node);
+ node.parentNode = me;
+ node.nextSibling = null;
+
+ me.setLastChild(node);
+
+ ps = me.childNodes[index - 1];
+ if (ps) {
+ node.previousSibling = ps;
+ ps.nextSibling = node;
+ ps.updateInfo(suppressNodeUpdate);
+ } else {
+ node.previousSibling = null;
+ }
-
- fieldTpl: (function() {
- var t = new Ext.Template(
- ' '
- );
- tt.disableFormats = true;
- tt.compile();
- Ext.layout.BorderLayout.Region.prototype.toolTemplate = tt;
- }
- this.collapsedEl = this.targetEl.createChild({
- cls: "x-layout-collapsed x-layout-collapsed-"+this.position,
- id: this.panel.id + '-xcollapsed'
- });
- this.collapsedEl.enableDisplayMode('block');
+ root: null,
+
+ constructor: function(root) {
+ var me = this;
+
+ me.nodeHash = {};
- if(this.collapseMode == 'mini'){
- this.collapsedEl.addClass('x-layout-cmini-'+this.position);
- this.miniCollapsedEl = this.collapsedEl.createChild({
- cls: "x-layout-mini x-layout-mini-"+this.position, html: " "
- });
- this.miniCollapsedEl.addClassOnOver('x-layout-mini-over');
- this.collapsedEl.addClassOnOver("x-layout-collapsed-over");
- this.collapsedEl.on('click', this.onExpandClick, this, {stopEvent:true});
- }else {
- if(this.collapsible !== false && !this.hideCollapseTool) {
- var t = this.expandToolEl = this.toolTemplate.append(
- this.collapsedEl.dom,
- {id:'expand-'+this.position}, true);
- t.addClassOnOver('x-tool-expand-'+this.position+'-over');
- t.on('click', this.onExpandClick, this, {stopEvent:true});
- }
- if(this.floatable !== false || this.titleCollapse){
- this.collapsedEl.addClassOnOver("x-layout-collapsed-over");
- this.collapsedEl.on("click", this[this.floatable ? 'collapseClick' : 'onExpandClick'], this);
- }
- }
+ me.mixins.observable.constructor.call(me);
+
+ if (root) {
+ me.setRootNode(root);
}
- return this.collapsedEl;
},
- onExpandClick : function(e){
- if(this.isSlid){
- this.panel.expand(false);
- }else{
- this.panel.expand();
- }
+ getRootNode : function() {
+ return this.root;
},
- onCollapseClick : function(e){
- this.panel.collapse();
- },
+ setRootNode : function(node) {
+ var me = this;
+
+ me.root = node;
+ Ext.data.NodeInterface.decorate(node);
+
+ if (me.fireEvent('beforeappend', null, node) !== false) {
+ node.set('root', true);
+ node.updateInfo();
+
+ me.relayEvents(node, [
+
+ "append",
-
- beforeCollapse : function(p, animate){
- this.lastAnim = animate;
- if(this.splitEl){
- this.splitEl.hide();
- }
- this.getCollapsedEl().show();
- var el = this.panel.getEl();
- this.originalZIndex = el.getStyle('z-index');
- el.setStyle('z-index', 100);
- this.isCollapsed = true;
- this.layout.layout();
- },
+
+ "remove",
-
- onCollapse : function(animate){
- this.panel.el.setStyle('z-index', 1);
- if(this.lastAnim === false || this.panel.animCollapse === false){
- this.getCollapsedEl().dom.style.visibility = 'visible';
- }else{
- this.getCollapsedEl().slideIn(this.panel.slideAnchor, {duration:.2});
- }
- this.state.collapsed = true;
- this.panel.saveState();
- },
+
+ "move",
-
- beforeExpand : function(animate){
- if(this.isSlid){
- this.afterSlideIn();
- }
- var c = this.getCollapsedEl();
- this.el.show();
- if(this.position == 'east' || this.position == 'west'){
- this.panel.setSize(undefined, c.getHeight());
- }else{
- this.panel.setSize(c.getWidth(), undefined);
- }
- c.hide();
- c.dom.style.visibility = 'hidden';
- this.panel.el.setStyle('z-index', this.floatingZIndex);
- },
+
+ "insert",
-
- onExpand : function(){
- this.isCollapsed = false;
- if(this.splitEl){
- this.splitEl.show();
- }
- this.layout.layout();
- this.panel.el.setStyle('z-index', this.originalZIndex);
- this.state.collapsed = false;
- this.panel.saveState();
- },
+
+ "beforeappend",
-
- collapseClick : function(e){
- if(this.isSlid){
- e.stopPropagation();
- this.slideIn();
- }else{
- e.stopPropagation();
- this.slideOut();
- }
- },
+
+ "beforeremove",
-
- onHide : function(){
- if(this.isCollapsed){
- this.getCollapsedEl().hide();
- }else if(this.splitEl){
- this.splitEl.hide();
+
+ "beforemove",
+
+
+ "beforeinsert",
+
+
+ "expand",
+
+
+ "collapse",
+
+
+ "beforeexpand",
+
+
+ "beforecollapse" ,
+
+
+ "rootchange"
+ ]);
+
+ node.on({
+ scope: me,
+ insert: me.onNodeInsert,
+ append: me.onNodeAppend,
+ remove: me.onNodeRemove
+ });
+
+ me.registerNode(node);
+ me.fireEvent('append', null, node);
+ me.fireEvent('rootchange', node);
}
+
+ return node;
},
-
- onShow : function(){
- if(this.isCollapsed){
- this.getCollapsedEl().show();
- }else if(this.splitEl){
- this.splitEl.show();
+
+ flatten: function(){
+ var nodes = [],
+ hash = this.nodeHash,
+ key;
+
+ for (key in hash) {
+ if (hash.hasOwnProperty(key)) {
+ nodes.push(hash[key]);
+ }
}
+ return nodes;
},
-
- isVisible : function(){
- return !this.panel.hidden;
- },
-
- getMargins : function(){
- return this.isCollapsed && this.cmargins ? this.cmargins : this.margins;
+ onNodeInsert: function(parent, node) {
+ this.registerNode(node);
},
-
- getSize : function(){
- return this.isCollapsed ? this.getCollapsedEl().getSize() : this.panel.getSize();
- },
-
- setPanel : function(panel){
- this.panel = panel;
+ onNodeAppend: function(parent, node) {
+ this.registerNode(node);
},
-
- getMinWidth: function(){
- return this.minWidth;
- },
-
- getMinHeight: function(){
- return this.minHeight;
+ onNodeRemove: function(parent, node) {
+ this.unregisterNode(node);
},
- applyLayoutCollapsed : function(box){
- var ce = this.getCollapsedEl();
- ce.setLeftTop(box.x, box.y);
- ce.setSize(box.width, box.height);
+ getNodeById : function(id) {
+ return this.nodeHash[id];
},
- applyLayout : function(box){
- if(this.isCollapsed){
- this.applyLayoutCollapsed(box);
- }else{
- this.panel.setPosition(box.x, box.y);
- this.panel.setSize(box.width, box.height);
- }
+ registerNode : function(node) {
+ this.nodeHash[node.getId() || node.internalId] = node;
},
- beforeSlide: function(){
- this.panel.beforeEffect();
+ unregisterNode : function(node) {
+ delete this.nodeHash[node.getId() || node.internalId];
},
-
- afterSlide : function(){
- this.panel.afterEffect();
+
+ sort: function(sorterFn, recursive) {
+ this.getRootNode().sort(sorterFn, recursive);
},
+
+
+ filter: function(filters, recursive) {
+ this.getRootNode().filter(filters, recursive);
+ }
+});
+
+Ext.define('Ext.data.TreeStore', {
+ extend: 'Ext.data.AbstractStore',
+ alias: 'store.tree',
+ requires: ['Ext.data.Tree', 'Ext.data.NodeInterface', 'Ext.data.NodeStore'],
- initAutoHide : function(){
- if(this.autoHide !== false){
- if(!this.autoHideHd){
- this.autoHideSlideTask = new Ext.util.DelayedTask(this.slideIn, this);
- this.autoHideHd = {
- "mouseout": function(e){
- if(!e.within(this.el, true)){
- this.autoHideSlideTask.delay(500);
- }
- },
- "mouseover" : function(e){
- this.autoHideSlideTask.cancel();
- },
- scope : this
- };
- }
- this.el.on(this.autoHideHd);
- this.collapsedEl.on(this.autoHideHd);
- }
- },
+ clearOnLoad : true,
- clearAutoHide : function(){
- if(this.autoHide !== false){
- this.el.un("mouseout", this.autoHideHd.mouseout);
- this.el.un("mouseover", this.autoHideHd.mouseover);
- this.collapsedEl.un("mouseout", this.autoHideHd.mouseout);
- this.collapsedEl.un("mouseover", this.autoHideHd.mouseover);
- }
- },
+ nodeParam: 'node',
- clearMonitor : function(){
- Ext.getDoc().un("click", this.slideInIf, this);
- },
+ defaultRootId: 'root',
+
+
+ defaultRootProperty: 'children',
- slideOut : function(){
- if(this.isSlid || this.el.hasActiveFx()){
- return;
- }
- this.isSlid = true;
- var ts = this.panel.tools, dh, pc;
- if(ts && ts.toggle){
- ts.toggle.hide();
+ folderSort: false,
+
+ constructor: function(config) {
+ var me = this,
+ root,
+ fields;
+
+
+ config = Ext.apply({}, config);
+
+
+ fields = config.fields || me.fields;
+ if (!fields) {
+ config.fields = [{name: 'text', type: 'string'}];
}
- this.el.show();
+ me.callParent([config]);
- pc = this.panel.collapsed;
- this.panel.collapsed = false;
-
- if(this.position == 'east' || this.position == 'west'){
-
- dh = this.panel.deferHeight;
- this.panel.deferHeight = false;
+
+ me.tree = Ext.create('Ext.data.Tree');
+
+ me.tree.on({
+ scope: me,
+ remove: me.onNodeRemove,
+ beforeexpand: me.onBeforeNodeExpand,
+ beforecollapse: me.onBeforeNodeCollapse,
+ append: me.onNodeAdded,
+ insert: me.onNodeAdded
+ });
- this.panel.setSize(undefined, this.collapsedEl.getHeight());
+ me.onBeforeSort();
+
+ root = me.root;
+ if (root) {
+ delete me.root;
+ me.setRootNode(root);
+ }
+ me.relayEvents(me.tree, [
- this.panel.deferHeight = dh;
- }else{
- this.panel.setSize(this.collapsedEl.getWidth(), undefined);
- }
+ "append",
+
+
+ "remove",
+
+
+ "move",
+
+
+ "insert",
+
+
+ "beforeappend",
+
+
+ "beforeremove",
+
+
+ "beforemove",
+
+
+ "beforeinsert",
+
+
+ "expand",
+
+
+ "collapse",
+
+
+ "beforeexpand",
+
+
+ "beforecollapse",
+
+ "sort",
+
+
+ "rootchange"
+ ]);
- this.panel.collapsed = pc;
-
- this.restoreLT = [this.el.dom.style.left, this.el.dom.style.top];
- this.el.alignTo(this.collapsedEl, this.getCollapseAnchor());
- this.el.setStyle("z-index", this.floatingZIndex+2);
- this.panel.el.replaceClass('x-panel-collapsed', 'x-panel-floating');
- if(this.animFloat !== false){
- this.beforeSlide();
- this.el.slideIn(this.getSlideAnchor(), {
- callback: function(){
- this.afterSlide();
- this.initAutoHide();
- Ext.getDoc().on("click", this.slideInIf, this);
- },
- scope: this,
- block: true
- });
- }else{
- this.initAutoHide();
- Ext.getDoc().on("click", this.slideInIf, this);
+ me.addEvents(
+
+ 'rootchange'
+ );
+
+ if (Ext.isDefined(me.nodeParameter)) {
+ if (Ext.isDefined(Ext.global.console)) {
+ Ext.global.console.warn('Ext.data.TreeStore: nodeParameter has been deprecated. Please use nodeParam instead.');
+ }
+ me.nodeParam = me.nodeParameter;
+ delete me.nodeParameter;
}
},
-
- afterSlideIn : function(){
- this.clearAutoHide();
- this.isSlid = false;
- this.clearMonitor();
- this.el.setStyle("z-index", "");
- this.panel.el.replaceClass('x-panel-floating', 'x-panel-collapsed');
- this.el.dom.style.left = this.restoreLT[0];
- this.el.dom.style.top = this.restoreLT[1];
-
- var ts = this.panel.tools;
- if(ts && ts.toggle){
- ts.toggle.show();
- }
- },
-
- slideIn : function(cb){
- if(!this.isSlid || this.el.hasActiveFx()){
- Ext.callback(cb);
- return;
+ setProxy: function(proxy) {
+ var reader,
+ needsRoot;
+
+ if (proxy instanceof Ext.data.proxy.Proxy) {
+
+ needsRoot = Ext.isEmpty(proxy.getReader().root);
+ } else if (Ext.isString(proxy)) {
+
+ needsRoot = true;
+ } else {
+
+ reader = proxy.reader;
+ needsRoot = !(reader && !Ext.isEmpty(reader.root));
}
- this.isSlid = false;
- if(this.animFloat !== false){
- this.beforeSlide();
- this.el.slideOut(this.getSlideAnchor(), {
- callback: function(){
- this.el.hide();
- this.afterSlide();
- this.afterSlideIn();
- Ext.callback(cb);
- },
- scope: this,
- block: true
- });
- }else{
- this.el.hide();
- this.afterSlideIn();
+ proxy = this.callParent(arguments);
+ if (needsRoot) {
+ reader = proxy.getReader();
+ reader.root = this.defaultRootProperty;
+
+ reader.buildExtractors(true);
}
},
-
- slideInIf : function(e){
- if(!e.within(this.el)){
- this.slideIn();
+
+ onBeforeSort: function() {
+ if (this.folderSort) {
+ this.sort({
+ property: 'leaf',
+ direction: 'ASC'
+ }, 'prepend', false);
}
},
-
- anchors : {
- "west" : "left",
- "east" : "right",
- "north" : "top",
- "south" : "bottom"
- },
-
- sanchors : {
- "west" : "l",
- "east" : "r",
- "north" : "t",
- "south" : "b"
+ onBeforeNodeExpand: function(node, callback, scope) {
+ if (node.isLoaded()) {
+ Ext.callback(callback, scope || node, [node.childNodes]);
+ }
+ else if (node.isLoading()) {
+ this.on('load', function() {
+ Ext.callback(callback, scope || node, [node.childNodes]);
+ }, this, {single: true});
+ }
+ else {
+ this.read({
+ node: node,
+ callback: function() {
+ Ext.callback(callback, scope || node, [node.childNodes]);
+ }
+ });
+ }
},
-
- canchors : {
- "west" : "tl-tr",
- "east" : "tr-tl",
- "north" : "tl-bl",
- "south" : "bl-tl"
- },
-
- getAnchor : function(){
- return this.anchors[this.position];
+ getNewRecords: function() {
+ return Ext.Array.filter(this.tree.flatten(), this.filterNew);
},
- getCollapseAnchor : function(){
- return this.canchors[this.position];
+ getUpdatedRecords: function() {
+ return Ext.Array.filter(this.tree.flatten(), this.filterUpdated);
},
-
- getSlideAnchor : function(){
- return this.sanchors[this.position];
+
+ onBeforeNodeCollapse: function(node, callback, scope) {
+ callback.call(scope || node, node.childNodes);
},
-
- getAlignAdj : function(){
- var cm = this.cmargins;
- switch(this.position){
- case "west":
- return [0, 0];
- break;
- case "east":
- return [0, 0];
- break;
- case "north":
- return [0, 0];
- break;
- case "south":
- return [0, 0];
- break;
+ onNodeRemove: function(parent, node) {
+ var removed = this.removed;
+
+ if (!node.isReplace && Ext.Array.indexOf(removed, node) == -1) {
+ removed.push(node);
}
},
-
- getExpandAdj : function(){
- var c = this.collapsedEl, cm = this.cmargins;
- switch(this.position){
- case "west":
- return [-(cm.right+c.getWidth()+cm.left), 0];
- break;
- case "east":
- return [cm.right+c.getWidth()+cm.left, 0];
- break;
- case "north":
- return [0, -(cm.top+cm.bottom+c.getHeight())];
- break;
- case "south":
- return [0, cm.top+cm.bottom+c.getHeight()];
- break;
+ onNodeAdded: function(parent, node) {
+ var proxy = this.getProxy(),
+ reader = proxy.getReader(),
+ data = node.raw || node.data,
+ dataRoot, children;
+
+ Ext.Array.remove(this.removed, node);
+
+ if (!node.isLeaf() && !node.isLoaded()) {
+ dataRoot = reader.getRoot(data);
+ if (dataRoot) {
+ this.fillNode(node, reader.extractData(dataRoot));
+ delete data[reader.root];
+ }
}
},
+
+
+ setRootNode: function(root) {
+ var me = this;
- destroy : function(){
- if (this.autoHideSlideTask && this.autoHideSlideTask.cancel){
- this.autoHideSlideTask.cancel();
+ root = root || {};
+ if (!root.isNode) {
+
+ Ext.applyIf(root, {
+ id: me.defaultRootId,
+ text: 'Root',
+ allowDrag: false
+ });
+ root = Ext.ModelManager.create(root, me.model);
}
- Ext.destroyMembers(this, 'miniCollapsedEl', 'collapsedEl', 'expandToolEl');
- }
-};
-
-
-Ext.layout.BorderLayout.SplitRegion = function(layout, config, pos){
- Ext.layout.BorderLayout.SplitRegion.superclass.constructor.call(this, layout, config, pos);
-
- this.applyLayout = this.applyFns[pos];
-};
+ Ext.data.NodeInterface.decorate(root);
-Ext.extend(Ext.layout.BorderLayout.SplitRegion, Ext.layout.BorderLayout.Region, {
-
-
- splitTip : "Drag to resize.",
-
- collapsibleSplitTip : "Drag to resize. Double click to hide.",
+
+
+ me.getProxy().getReader().buildExtractors(true);
+
+
+ me.tree.setRootNode(root);
+
+
+ if (!root.isLoaded() && root.isExpanded()) {
+ me.load({
+ node: root
+ });
+ }
+
+ return root;
+ },
+
- useSplitTips : false,
+ getRootNode: function() {
+ return this.tree.getRootNode();
+ },
- splitSettings : {
- north : {
- orientation: Ext.SplitBar.VERTICAL,
- placement: Ext.SplitBar.TOP,
- maxFn : 'getVMaxSize',
- minProp: 'minHeight',
- maxProp: 'maxHeight'
- },
- south : {
- orientation: Ext.SplitBar.VERTICAL,
- placement: Ext.SplitBar.BOTTOM,
- maxFn : 'getVMaxSize',
- minProp: 'minHeight',
- maxProp: 'maxHeight'
- },
- east : {
- orientation: Ext.SplitBar.HORIZONTAL,
- placement: Ext.SplitBar.RIGHT,
- maxFn : 'getHMaxSize',
- minProp: 'minWidth',
- maxProp: 'maxWidth'
- },
- west : {
- orientation: Ext.SplitBar.HORIZONTAL,
- placement: Ext.SplitBar.LEFT,
- maxFn : 'getHMaxSize',
- minProp: 'minWidth',
- maxProp: 'maxWidth'
- }
+ getNodeById: function(id) {
+ return this.tree.getNodeById(id);
},
- applyFns : {
- west : function(box){
- if(this.isCollapsed){
- return this.applyLayoutCollapsed(box);
- }
- var sd = this.splitEl.dom, s = sd.style;
- this.panel.setPosition(box.x, box.y);
- var sw = sd.offsetWidth;
- s.left = (box.x+box.width-sw)+'px';
- s.top = (box.y)+'px';
- s.height = Math.max(0, box.height)+'px';
- this.panel.setSize(box.width-sw, box.height);
- },
- east : function(box){
- if(this.isCollapsed){
- return this.applyLayoutCollapsed(box);
- }
- var sd = this.splitEl.dom, s = sd.style;
- var sw = sd.offsetWidth;
- this.panel.setPosition(box.x+sw, box.y);
- s.left = (box.x)+'px';
- s.top = (box.y)+'px';
- s.height = Math.max(0, box.height)+'px';
- this.panel.setSize(box.width-sw, box.height);
- },
- north : function(box){
- if(this.isCollapsed){
- return this.applyLayoutCollapsed(box);
- }
- var sd = this.splitEl.dom, s = sd.style;
- var sh = sd.offsetHeight;
- this.panel.setPosition(box.x, box.y);
- s.left = (box.x)+'px';
- s.top = (box.y+box.height-sh)+'px';
- s.width = Math.max(0, box.width)+'px';
- this.panel.setSize(box.width, box.height-sh);
- },
- south : function(box){
- if(this.isCollapsed){
- return this.applyLayoutCollapsed(box);
- }
- var sd = this.splitEl.dom, s = sd.style;
- var sh = sd.offsetHeight;
- this.panel.setPosition(box.x, box.y+sh);
- s.left = (box.x)+'px';
- s.top = (box.y)+'px';
- s.width = Math.max(0, box.width)+'px';
- this.panel.setSize(box.width, box.height-sh);
+ load: function(options) {
+ options = options || {};
+ options.params = options.params || {};
+
+ var me = this,
+ node = options.node || me.tree.getRootNode(),
+ root;
+
+
+
+ if (!node) {
+ node = me.setRootNode({
+ expanded: true
+ });
+ }
+
+ if (me.clearOnLoad) {
+ node.removeAll();
+ }
+
+ Ext.applyIf(options, {
+ node: node
+ });
+ options.params[me.nodeParam] = node ? node.getId() : 'root';
+
+ if (node) {
+ node.set('loading', true);
}
+
+ return me.callParent([options]);
},
+
- render : function(ct, p){
- Ext.layout.BorderLayout.SplitRegion.superclass.render.call(this, ct, p);
-
- var ps = this.position;
-
- this.splitEl = ct.createChild({
- cls: "x-layout-split x-layout-split-"+ps, html: " ",
- id: this.panel.id + '-xsplit'
- });
+ fillNode: function(node, records) {
+ var me = this,
+ ln = records ? records.length : 0,
+ i = 0, sortCollection;
- if(this.collapseMode == 'mini'){
- this.miniSplitEl = this.splitEl.createChild({
- cls: "x-layout-mini x-layout-mini-"+ps, html: " "
- });
- this.miniSplitEl.addClassOnOver('x-layout-mini-over');
- this.miniSplitEl.on('click', this.onCollapseClick, this, {stopEvent:true});
+ if (ln && me.sortOnLoad && !me.remoteSort && me.sorters && me.sorters.items) {
+ sortCollection = Ext.create('Ext.util.MixedCollection');
+ sortCollection.addAll(records);
+ sortCollection.sort(me.sorters.items);
+ records = sortCollection.items;
}
+
+ node.set('loaded', true);
+ for (; i < ln; i++) {
+ node.appendChild(records[i], undefined, true);
+ }
+
+ return records;
+ },
- var s = this.splitSettings[ps];
-
- this.split = new Ext.SplitBar(this.splitEl.dom, p.el, s.orientation);
- this.split.tickSize = this.tickSize;
- this.split.placement = s.placement;
- this.split.getMaximumSize = this[s.maxFn].createDelegate(this);
- this.split.minSize = this.minSize || this[s.minProp];
- this.split.on("beforeapply", this.onSplitMove, this);
- this.split.useShim = this.useShim === true;
- this.maxSize = this.maxSize || this[s.maxProp];
+
+ onProxyLoad: function(operation) {
+ var me = this,
+ successful = operation.wasSuccessful(),
+ records = operation.getRecords(),
+ node = operation.node;
- if(p.hidden){
- this.splitEl.hide();
+ node.set('loading', false);
+ if (successful) {
+ records = me.fillNode(node, records);
}
+
+ me.fireEvent('read', me, operation.node, records, successful);
+ me.fireEvent('load', me, operation.node, records, successful);
+
+ Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
+ },
+
+
+ onCreateRecords: function(records, operation, success) {
+ if (success) {
+ var i = 0,
+ length = records.length,
+ originalRecords = operation.records,
+ parentNode,
+ record,
+ original,
+ index;
- if(this.useSplitTips){
- this.splitEl.dom.title = this.collapsible ? this.collapsibleSplitTip : this.splitTip;
- }
- if(this.collapsible){
- this.splitEl.on("dblclick", this.onCollapseClick, this);
+
+ for (; i < length; ++i) {
+ record = records[i];
+ original = originalRecords[i];
+ if (original) {
+ parentNode = original.parentNode;
+ if (parentNode) {
+
+ original.isReplace = true;
+ parentNode.replaceChild(record, original);
+ delete original.isReplace;
+ }
+ record.phantom = false;
+ }
+ }
}
},
- getSize : function(){
- if(this.isCollapsed){
- return this.collapsedEl.getSize();
- }
- var s = this.panel.getSize();
- if(this.position == 'north' || this.position == 'south'){
- s.height += this.splitEl.dom.offsetHeight;
- }else{
- s.width += this.splitEl.dom.offsetWidth;
+ onUpdateRecords: function(records, operation, success){
+ if (success) {
+ var me = this,
+ i = 0,
+ length = records.length,
+ data = me.data,
+ original,
+ parentNode,
+ record;
+
+ for (; i < length; ++i) {
+ record = records[i];
+ original = me.tree.getNodeById(record.getId());
+ parentNode = original.parentNode;
+ if (parentNode) {
+
+ original.isReplace = true;
+ parentNode.replaceChild(record, original);
+ original.isReplace = false;
+ }
+ }
}
- return s;
},
- getHMaxSize : function(){
- var cmax = this.maxSize || 10000;
- var center = this.layout.center;
- return Math.min(cmax, (this.el.getWidth()+center.el.getWidth())-center.getMinWidth());
+ onDestroyRecords: function(records, operation, success){
+ if (success) {
+ this.removed = [];
+ }
},
- getVMaxSize : function(){
- var cmax = this.maxSize || 10000;
- var center = this.layout.center;
- return Math.min(cmax, (this.el.getHeight()+center.el.getHeight())-center.getMinHeight());
+ removeAll: function() {
+ this.getRootNode().destroy();
+ this.fireEvent('clear', this);
},
- onSplitMove : function(split, newSize){
- var s = this.panel.getSize();
- this.lastSplitSize = newSize;
- if(this.position == 'north' || this.position == 'south'){
- this.panel.setSize(s.width, newSize);
- this.state.height = newSize;
- }else{
- this.panel.setSize(newSize, s.height);
- this.state.width = newSize;
- }
- this.layout.layout();
- this.panel.saveState();
- return false;
- },
+ doSort: function(sorterFn) {
+ var me = this;
+ if (me.remoteSort) {
+
+ me.load();
+ } else {
+ me.tree.sort(sorterFn, true);
+ me.fireEvent('datachanged', me);
+ }
+ me.fireEvent('sort', me);
+ }
+});
+
+Ext.define('Ext.data.XmlStore', {
+ extend: 'Ext.data.Store',
+ alternateClassName: 'Ext.data.XmlStore',
+ alias: 'store.xml',
- getSplitBar : function(){
- return this.split;
- },
+ constructor: function(config){
+ config = config || {};
+ config = config || {};
+
+ Ext.applyIf(config, {
+ proxy: {
+ type: 'ajax',
+ reader: 'xml',
+ writer: 'xml'
+ }
+ });
+
+ this.callParent([config]);
+ }
+});
+
+Ext.define('Ext.data.proxy.Client', {
+ extend: 'Ext.data.proxy.Proxy',
+ alternateClassName: 'Ext.data.ClientProxy',
- destroy : function() {
- Ext.destroy(this.miniSplitEl, this.split, this.splitEl);
- Ext.layout.BorderLayout.SplitRegion.superclass.destroy.call(this);
+
+ clear: function() {
+ Ext.Error.raise("The Ext.data.proxy.Client subclass that you are using has not defined a 'clear' function. See src/data/ClientProxy.js for details.");
}
});
-Ext.Container.LAYOUTS['border'] = Ext.layout.BorderLayout;
+Ext.define('Ext.data.proxy.JsonP', {
+ extend: 'Ext.data.proxy.Server',
+ alternateClassName: 'Ext.data.ScriptTagProxy',
+ alias: ['proxy.jsonp', 'proxy.scripttag'],
+ requires: ['Ext.data.JsonP'],
-Ext.layout.FormLayout = Ext.extend(Ext.layout.AnchorLayout, {
+ defaultWriterType: 'base',
- labelSeparator : ':',
+ callbackKey : 'callback',
+ recordParam: 'records',
- trackLabels: true,
+ autoAppendParams: true,
+
+ constructor: function(){
+ this.addEvents(
+
+ 'exception'
+ );
+ this.callParent(arguments);
+ },
- type: 'form',
+
+ doRequest: function(operation, callback, scope) {
+
+ var me = this,
+ writer = me.getWriter(),
+ request = me.buildRequest(operation),
+ params = request.params;
- onRemove: function(c){
- Ext.layout.FormLayout.superclass.onRemove.call(this, c);
- if(this.trackLabels){
- c.un('show', this.onFieldShow, this);
- c.un('hide', this.onFieldHide, this);
+ if (operation.allowWrite()) {
+ request = writer.write(request);
}
+
- var el = c.getPositionEl(),
- ct = c.getItemCt && c.getItemCt();
- if (c.rendered && ct) {
- if (el && el.dom) {
- el.insertAfter(ct);
- }
- Ext.destroy(ct);
- Ext.destroyMembers(c, 'label', 'itemCt');
- if (c.customItemCt) {
- Ext.destroyMembers(c, 'getItemCt', 'customItemCt');
- }
+ Ext.apply(request, {
+ callbackKey: me.callbackKey,
+ timeout: me.timeout,
+ scope: me,
+ disableCaching: false,
+ callback: me.createRequestCallback(request, operation, callback, scope)
+ });
+
+
+ if (me.autoAppendParams) {
+ request.params = {};
}
+
+ request.jsonp = Ext.data.JsonP.request(request);
+
+ request.params = params;
+ operation.setStarted();
+ me.lastRequest = request;
+
+ return request;
},
- setContainer : function(ct){
- Ext.layout.FormLayout.superclass.setContainer.call(this, ct);
- if(ct.labelAlign){
- ct.addClass('x-form-label-'+ct.labelAlign);
- }
+ createRequestCallback: function(request, operation, callback, scope) {
+ var me = this;
- if(ct.hideLabels){
- Ext.apply(this, {
- labelStyle: 'display:none',
- elementStyle: 'padding-left:0;',
- labelAdjust: 0
- });
- }else{
- this.labelSeparator = Ext.isDefined(ct.labelSeparator) ? ct.labelSeparator : this.labelSeparator;
- ct.labelWidth = ct.labelWidth || 100;
- if(Ext.isNumber(ct.labelWidth)){
- var pad = Ext.isNumber(ct.labelPad) ? ct.labelPad : 5;
- Ext.apply(this, {
- labelAdjust: ct.labelWidth + pad,
- labelStyle: 'width:' + ct.labelWidth + 'px;',
- elementStyle: 'padding-left:' + (ct.labelWidth + pad) + 'px'
- });
- }
- if(ct.labelAlign == 'top'){
- Ext.apply(this, {
- labelStyle: 'width:auto;',
- labelAdjust: 0,
- elementStyle: 'padding-left:0;'
- });
- }
- }
+ return function(success, response, errorType) {
+ delete me.lastRequest;
+ me.processResponse(success, operation, request, response, callback, scope);
+ };
},
-
- isHide: function(c){
- return c.hideLabel || this.container.hideLabels;
+
+ setException: function(operation, response) {
+ operation.setException(operation.request.jsonp.errorType);
},
- onFieldShow: function(c){
- c.getItemCt().removeClass('x-hide-' + c.hideMode);
-
- if (c.isComposite) {
- c.doLayout();
+
+ buildUrl: function(request) {
+ var me = this,
+ url = me.callParent(arguments),
+ params = Ext.apply({}, request.params),
+ filters = params.filters,
+ records,
+ filter, i;
+
+ delete params.filters;
+
+ if (me.autoAppendParams) {
+ url = Ext.urlAppend(url, Ext.Object.toQueryString(params));
}
- },
- onFieldHide: function(c){
- c.getItemCt().addClass('x-hide-' + c.hideMode);
- },
+ if (filters && filters.length) {
+ for (i = 0; i < filters.length; i++) {
+ filter = filters[i];
-
- getLabelStyle: function(s){
- var ls = '', items = [this.labelStyle, s];
- for (var i = 0, len = items.length; i < len; ++i){
- if (items[i]){
- ls += items[i];
- if (ls.substr(-1, 1) != ';'){
- ls += ';';
+ if (filter.value) {
+ url = Ext.urlAppend(url, filter.property + "=" + filter.value);
}
}
}
- return ls;
- },
-
+
+ records = request.records;
-
- renderItem : function(c, position, target){
- if(c && (c.isFormField || c.fieldLabel) && c.inputType != 'hidden'){
- var args = this.getTemplateArgs(c);
- if(Ext.isNumber(position)){
- position = target.dom.childNodes[position] || null;
- }
- if(position){
- c.itemCt = this.fieldTpl.insertBefore(position, args, true);
- }else{
- c.itemCt = this.fieldTpl.append(target, args, true);
- }
- if(!c.getItemCt){
-
-
- Ext.apply(c, {
- getItemCt: function(){
- return c.itemCt;
- },
- customItemCt: true
- });
- }
- c.label = c.getItemCt().child('label.x-form-item-label');
- if(!c.rendered){
- c.render('x-form-el-' + c.id);
- }else if(!this.isValidParent(c, target)){
- Ext.fly('x-form-el-' + c.id).appendChild(c.getPositionEl());
- }
- if(this.trackLabels){
- if(c.hidden){
- this.onFieldHide(c);
- }
- c.on({
- scope: this,
- show: this.onFieldShow,
- hide: this.onFieldHide
- });
- }
- this.configureItem(c);
- }else {
- Ext.layout.FormLayout.superclass.renderItem.apply(this, arguments);
+ if (Ext.isArray(records) && records.length > 0) {
+ url = Ext.urlAppend(url, Ext.String.format("{0}={1}", me.recordParam, me.encodeRecords(records)));
}
+
+ return url;
},
- getTemplateArgs: function(field) {
- var noLabelSep = !field.fieldLabel || field.hideLabel;
-
- return {
- id : field.id,
- label : field.fieldLabel,
- itemCls : (field.itemCls || this.container.itemCls || '') + (field.hideLabel ? ' x-hide-label' : ''),
- clearCls : field.clearCls || 'x-form-clear-left',
- labelStyle : this.getLabelStyle(field.labelStyle),
- elementStyle : this.elementStyle || '',
- labelSeparator: noLabelSep ? '' : (Ext.isDefined(field.labelSeparator) ? field.labelSeparator : this.labelSeparator)
- };
+ destroy: function() {
+ this.abort();
+ this.callParent();
},
- adjustWidthAnchor: function(value, c){
- if(c.label && !this.isHide(c) && (this.container.labelAlign != 'top')){
- var adjust = Ext.isIE6 || (Ext.isIE && !Ext.isStrict);
- return value - this.labelAdjust + (adjust ? -3 : 0);
+ abort: function() {
+ var lastRequest = this.lastRequest;
+ if (lastRequest) {
+ Ext.data.JsonP.abort(lastRequest.jsonp);
}
- return value;
},
- adjustHeightAnchor : function(value, c){
- if(c.label && !this.isHide(c) && (this.container.labelAlign == 'top')){
- return value - c.label.getHeight();
+
+ encodeRecords: function(records) {
+ var encoded = "",
+ i = 0,
+ len = records.length;
+
+ for (; i < len; i++) {
+ encoded += Ext.Object.toQueryString(records[i].data);
}
- return value;
- },
-
- isValidParent : function(c, target){
- return target && this.container.getEl().contains(c.getPositionEl());
+ return encoded;
}
-
-
});
-Ext.Container.LAYOUTS['form'] = Ext.layout.FormLayout;
-Ext.layout.AccordionLayout = Ext.extend(Ext.layout.FitLayout, {
-
- fill : true,
-
- autoWidth : true,
-
- titleCollapse : true,
-
- hideCollapseTool : false,
-
- collapseFirst : false,
-
- animate : false,
+Ext.define('Ext.data.proxy.WebStorage', {
+ extend: 'Ext.data.proxy.Client',
+ alternateClassName: 'Ext.data.WebStorageProxy',
- sequence : false,
- activeOnTop : false,
-
- type: 'accordion',
-
- renderItem : function(c){
- if(this.animate === false){
- c.animCollapse = false;
- }
- c.collapsible = true;
- if(this.autoWidth){
- c.autoWidth = true;
- }
- if(this.titleCollapse){
- c.titleCollapse = true;
- }
- if(this.hideCollapseTool){
- c.hideCollapseTool = true;
- }
- if(this.collapseFirst !== undefined){
- c.collapseFirst = this.collapseFirst;
- }
- if(!this.activeItem && !c.collapsed){
- this.setActiveItem(c, true);
- }else if(this.activeItem && this.activeItem != c){
- c.collapsed = true;
- }
- Ext.layout.AccordionLayout.superclass.renderItem.apply(this, arguments);
- c.header.addClass('x-accordion-hd');
- c.on('beforeexpand', this.beforeExpand, this);
- },
-
- onRemove: function(c){
- Ext.layout.AccordionLayout.superclass.onRemove.call(this, c);
- if(c.rendered){
- c.header.removeClass('x-accordion-hd');
- }
- c.un('beforeexpand', this.beforeExpand, this);
- },
+ id: undefined,
- beforeExpand : function(p, anim){
- var ai = this.activeItem;
- if(ai){
- if(this.sequence){
- delete this.activeItem;
- if (!ai.collapsed){
- ai.collapse({callback:function(){
- p.expand(anim || true);
- }, scope: this});
- return false;
- }
- }else{
- ai.collapse(this.animate);
- }
- }
- this.setActive(p);
- if(this.activeOnTop){
- p.el.dom.parentNode.insertBefore(p.el.dom, p.el.dom.parentNode.firstChild);
- }
+ constructor: function(config) {
+ this.callParent(arguments);
- this.layout();
- },
+
+ this.cache = {};
-
- setItemSize : function(item, size){
- if(this.fill && item){
- var hh = 0, i, ct = this.getRenderedItems(this.container), len = ct.length, p;
-
- for (i = 0; i < len; i++) {
- if((p = ct[i]) != item && !p.hidden){
- hh += p.header.getHeight();
- }
- };
-
- size.height -= hh;
-
-
- item.setSize(size);
+ if (this.getStorageObject() === undefined) {
+ Ext.Error.raise("Local Storage is not supported in this browser, please use another type of data proxy");
}
- },
-
- setActiveItem : function(item){
- this.setActive(item, true);
- },
+
+ this.id = this.id || (this.store ? this.store.storeId : undefined);
-
- setActive : function(item, expand){
- var ai = this.activeItem;
- item = this.container.getComponent(item);
- if(ai != item){
- if(item.rendered && item.collapsed && expand){
- item.expand();
- }else{
- if(ai){
- ai.fireEvent('deactivate', ai);
- }
- this.activeItem = item;
- item.fireEvent('activate', item);
- }
+ if (this.id === undefined) {
+ Ext.Error.raise("No unique id was provided to the local storage proxy. See Ext.data.proxy.LocalStorage documentation for details");
}
- }
-});
-Ext.Container.LAYOUTS.accordion = Ext.layout.AccordionLayout;
-
-Ext.layout.Accordion = Ext.layout.AccordionLayout;
-Ext.layout.TableLayout = Ext.extend(Ext.layout.ContainerLayout, {
-
+ this.initialize();
+ },
- monitorResize:false,
-
- type: 'table',
+ create: function(operation, callback, scope) {
+ var records = operation.records,
+ length = records.length,
+ ids = this.getIds(),
+ id, record, i;
+
+ operation.setStarted();
- targetCls: 'x-table-layout-ct',
+ for (i = 0; i < length; i++) {
+ record = records[i];
-
- tableAttrs:null,
+ if (record.phantom) {
+ record.phantom = false;
+ id = this.getNextId();
+ } else {
+ id = record.getId();
+ }
-
- setContainer : function(ct){
- Ext.layout.TableLayout.superclass.setContainer.call(this, ct);
+ this.setRecord(record, id);
+ ids.push(id);
+ }
- this.currentRow = 0;
- this.currentColumn = 0;
- this.cells = [];
- },
-
-
- onLayout : function(ct, target){
- var cs = ct.items.items, len = cs.length, c, i;
+ this.setIds(ids);
- if(!this.table){
- target.addClass('x-table-layout-ct');
+ operation.setCompleted();
+ operation.setSuccessful();
- this.table = target.createChild(
- Ext.apply({tag:'table', cls:'x-table-layout', cellspacing: 0, cn: {tag: 'tbody'}}, this.tableAttrs), null, true);
+ if (typeof callback == 'function') {
+ callback.call(scope || this, operation);
}
- this.renderAll(ct, target);
},
- getRow : function(index){
- var row = this.table.tBodies[0].childNodes[index];
- if(!row){
- row = document.createElement('tr');
- this.table.tBodies[0].appendChild(row);
- }
- return row;
- },
+ read: function(operation, callback, scope) {
+
-
- getNextCell : function(c){
- var cell = this.getNextNonSpan(this.currentColumn, this.currentRow);
- var curCol = this.currentColumn = cell[0], curRow = this.currentRow = cell[1];
- for(var rowIndex = curRow; rowIndex < curRow + (c.rowspan || 1); rowIndex++){
- if(!this.cells[rowIndex]){
- this.cells[rowIndex] = [];
+ var records = [],
+ ids = this.getIds(),
+ length = ids.length,
+ i, recordData, record;
+
+
+ if (operation.id) {
+ record = this.getRecord(operation.id);
+
+ if (record) {
+ records.push(record);
+ operation.setSuccessful();
}
- for(var colIndex = curCol; colIndex < curCol + (c.colspan || 1); colIndex++){
- this.cells[rowIndex][colIndex] = true;
+ } else {
+ for (i = 0; i < length; i++) {
+ records.push(this.getRecord(ids[i]));
}
+ operation.setSuccessful();
}
- var td = document.createElement('td');
- if(c.cellId){
- td.id = c.cellId;
- }
- var cls = 'x-table-layout-cell';
- if(c.cellCls){
- cls += ' ' + c.cellCls;
- }
- td.className = cls;
- if(c.colspan){
- td.colSpan = c.colspan;
- }
- if(c.rowspan){
- td.rowSpan = c.rowspan;
+
+ operation.setCompleted();
+
+ operation.resultSet = Ext.create('Ext.data.ResultSet', {
+ records: records,
+ total : records.length,
+ loaded : true
+ });
+
+ if (typeof callback == 'function') {
+ callback.call(scope || this, operation);
}
- this.getRow(curRow).appendChild(td);
- return td;
},
- getNextNonSpan: function(colIndex, rowIndex){
- var cols = this.columns;
- while((cols && colIndex >= cols) || (this.cells[rowIndex] && this.cells[rowIndex][colIndex])) {
- if(cols && colIndex >= cols){
- rowIndex++;
- colIndex = 0;
- }else{
- colIndex++;
+ update: function(operation, callback, scope) {
+ var records = operation.records,
+ length = records.length,
+ ids = this.getIds(),
+ record, id, i;
+
+ operation.setStarted();
+
+ for (i = 0; i < length; i++) {
+ record = records[i];
+ this.setRecord(record);
+
+
+
+ id = record.getId();
+ if (id !== undefined && Ext.Array.indexOf(ids, id) == -1) {
+ ids.push(id);
}
}
- return [colIndex, rowIndex];
- },
+ this.setIds(ids);
-
- renderItem : function(c, position, target){
-
- if(!this.table){
- this.table = target.createChild(
- Ext.apply({tag:'table', cls:'x-table-layout', cellspacing: 0, cn: {tag: 'tbody'}}, this.tableAttrs), null, true);
- }
- if(c && !c.rendered){
- c.render(this.getNextCell(c));
- this.configureItem(c);
- }else if(c && !this.isValidParent(c, target)){
- var container = this.getNextCell(c);
- container.insertBefore(c.getPositionEl().dom, null);
- c.container = Ext.get(container);
- this.configureItem(c);
- }
- },
+ operation.setCompleted();
+ operation.setSuccessful();
-
- isValidParent : function(c, target){
- return c.getPositionEl().up('table', 5).dom.parentNode === (target.dom || target);
+ if (typeof callback == 'function') {
+ callback.call(scope || this, operation);
+ }
},
-
- destroy: function(){
- delete this.table;
- Ext.layout.TableLayout.superclass.destroy.call(this);
- }
-});
-
-Ext.Container.LAYOUTS['table'] = Ext.layout.TableLayout;
-Ext.layout.AbsoluteLayout = Ext.extend(Ext.layout.AnchorLayout, {
+ destroy: function(operation, callback, scope) {
+ var records = operation.records,
+ length = records.length,
+ ids = this.getIds(),
- extraCls: 'x-abs-layout-item',
+
+ newIds = [].concat(ids),
+ i;
- type: 'absolute',
+ for (i = 0; i < length; i++) {
+ Ext.Array.remove(newIds, records[i].getId());
+ this.removeRecord(records[i], false);
+ }
- onLayout : function(ct, target){
- target.position();
- this.paddingLeft = target.getPadding('l');
- this.paddingTop = target.getPadding('t');
- Ext.layout.AbsoluteLayout.superclass.onLayout.call(this, ct, target);
- },
+ this.setIds(newIds);
+
+ operation.setCompleted();
+ operation.setSuccessful();
-
- adjustWidthAnchor : function(value, comp){
- return value ? value - comp.getPosition(true)[0] + this.paddingLeft : value;
+ if (typeof callback == 'function') {
+ callback.call(scope || this, operation);
+ }
},
- adjustHeightAnchor : function(value, comp){
- return value ? value - comp.getPosition(true)[1] + this.paddingTop : value;
- }
-
-});
-Ext.Container.LAYOUTS['absolute'] = Ext.layout.AbsoluteLayout;
+ getRecord: function(id) {
+ if (this.cache[id] === undefined) {
+ var rawData = Ext.decode(this.getStorageObject().getItem(this.getRecordKey(id))),
+ data = {},
+ Model = this.model,
+ fields = Model.prototype.fields.items,
+ length = fields.length,
+ i, field, name, record;
-Ext.layout.BoxLayout = Ext.extend(Ext.layout.ContainerLayout, {
-
- defaultMargins : {left:0,top:0,right:0,bottom:0},
-
- padding : '0',
-
- pack : 'start',
+ for (i = 0; i < length; i++) {
+ field = fields[i];
+ name = field.name;
-
- monitorResize : true,
- type: 'box',
- scrollOffset : 0,
- extraCls : 'x-box-item',
- targetCls : 'x-box-layout-ct',
- innerCls : 'x-box-inner',
+ if (typeof field.decode == 'function') {
+ data[name] = field.decode(rawData[name]);
+ } else {
+ data[name] = rawData[name];
+ }
+ }
- constructor : function(config){
- Ext.layout.BoxLayout.superclass.constructor.call(this, config);
+ record = new Model(data, id);
+ record.phantom = false;
- if (Ext.isString(this.defaultMargins)) {
- this.defaultMargins = this.parseMargins(this.defaultMargins);
- }
-
- var handler = this.overflowHandler;
-
- if (typeof handler == 'string') {
- handler = {
- type: handler
- };
- }
-
- var handlerType = 'none';
- if (handler && handler.type != undefined) {
- handlerType = handler.type;
- }
-
- var constructor = Ext.layout.boxOverflow[handlerType];
- if (constructor[this.type]) {
- constructor = constructor[this.type];
+ this.cache[id] = record;
}
- this.overflowHandler = new constructor(this, handler);
+ return this.cache[id];
},
- onLayout: function(container, target) {
- Ext.layout.BoxLayout.superclass.onLayout.call(this, container, target);
+ setRecord: function(record, id) {
+ if (id) {
+ record.setId(id);
+ } else {
+ id = record.getId();
+ }
- var tSize = this.getLayoutTargetSize(),
- items = this.getVisibleItems(container),
- calcs = this.calculateChildBoxes(items, tSize),
- boxes = calcs.boxes,
- meta = calcs.meta;
-
-
- if (tSize.width > 0) {
- var handler = this.overflowHandler,
- method = meta.tooNarrow ? 'handleOverflow' : 'clearOverflow';
-
- var results = handler[method](calcs, tSize);
-
- if (results) {
- if (results.targetSize) {
- tSize = results.targetSize;
- }
-
- if (results.recalculate) {
- items = this.getVisibleItems(container);
- calcs = this.calculateChildBoxes(items, tSize);
- boxes = calcs.boxes;
- }
+ var me = this,
+ rawData = record.data,
+ data = {},
+ model = me.model,
+ fields = model.prototype.fields.items,
+ length = fields.length,
+ i = 0,
+ field, name, obj, key;
+
+ for (; i < length; i++) {
+ field = fields[i];
+ name = field.name;
+
+ if (typeof field.encode == 'function') {
+ data[name] = field.encode(rawData[name], record);
+ } else {
+ data[name] = rawData[name];
}
}
+
+ obj = me.getStorageObject();
+ key = me.getRecordKey(id);
- this.layoutTargetLastSize = tSize;
-
-
- this.childBoxCache = calcs;
+ me.cache[id] = record;
- this.updateInnerCtSize(tSize, calcs);
- this.updateChildBoxes(boxes);
-
- this.handleTargetOverflow(tSize, container, target);
+ obj.removeItem(key);
+ obj.setItem(key, Ext.encode(data));
},
- updateChildBoxes: function(boxes) {
- for (var i = 0, length = boxes.length; i < length; i++) {
- var box = boxes[i],
- comp = box.component;
-
- if (box.dirtySize) {
- comp.setSize(box.width, box.height);
- }
-
- if (isNaN(box.left) || isNaN(box.top)) {
- continue;
- }
+ removeRecord: function(id, updateIds) {
+ var me = this,
+ ids;
- comp.setPosition(box.left, box.top);
+ if (id.isModel) {
+ id = id.getId();
}
- },
-
- updateInnerCtSize: function(tSize, calcs) {
- var align = this.align,
- padding = this.padding,
- width = tSize.width,
- height = tSize.height;
-
- if (this.type == 'hbox') {
- var innerCtWidth = width,
- innerCtHeight = calcs.meta.maxHeight + padding.top + padding.bottom;
-
- if (align == 'stretch') {
- innerCtHeight = height;
- } else if (align == 'middle') {
- innerCtHeight = Math.max(height, innerCtHeight);
- }
- } else {
- var innerCtHeight = height,
- innerCtWidth = calcs.meta.maxWidth + padding.left + padding.right;
-
- if (align == 'stretch') {
- innerCtWidth = width;
- } else if (align == 'center') {
- innerCtWidth = Math.max(width, innerCtWidth);
- }
+ if (updateIds !== false) {
+ ids = me.getIds();
+ Ext.Array.remove(ids, id);
+ me.setIds(ids);
}
- this.innerCt.setSize(innerCtWidth || undefined, innerCtHeight || undefined);
+ me.getStorageObject().removeItem(me.getRecordKey(id));
},
- handleTargetOverflow: function(previousTargetSize, container, target) {
- var overflow = target.getStyle('overflow');
-
- if (overflow && overflow != 'hidden' &&!this.adjustmentPass) {
- var newTargetSize = this.getLayoutTargetSize();
- if (newTargetSize.width != previousTargetSize.width || newTargetSize.height != previousTargetSize.height){
- this.adjustmentPass = true;
- this.onLayout(container, target);
- }
+ getRecordKey: function(id) {
+ if (id.isModel) {
+ id = id.getId();
}
- delete this.adjustmentPass;
+ return Ext.String.format("{0}-{1}", this.id, id);
},
- isValidParent : function(c, target) {
- return this.innerCt && c.getPositionEl().dom.parentNode == this.innerCt.dom;
+ getRecordCounterKey: function() {
+ return Ext.String.format("{0}-counter", this.id);
},
- getVisibleItems: function(ct) {
- var ct = ct || this.container,
- t = ct.getLayoutTarget(),
- cti = ct.items.items,
- len = cti.length,
-
- i, c, items = [];
+ getIds: function() {
+ var ids = (this.getStorageObject().getItem(this.id) || "").split(","),
+ length = ids.length,
+ i;
- for (i = 0; i < len; i++) {
- if((c = cti[i]).rendered && this.isValidParent(c, t) && c.hidden !== true && c.collapsed !== true && c.shouldLayout !== false){
- items.push(c);
+ if (length == 1 && ids[0] === "") {
+ ids = [];
+ } else {
+ for (i = 0; i < length; i++) {
+ ids[i] = parseInt(ids[i], 10);
}
}
- return items;
+ return ids;
},
- renderAll : function(ct, target) {
- if (!this.innerCt) {
-
- this.innerCt = target.createChild({cls:this.innerCls});
- this.padding = this.parseMargins(this.padding);
+ setIds: function(ids) {
+ var obj = this.getStorageObject(),
+ str = ids.join(",");
+
+ obj.removeItem(this.id);
+
+ if (!Ext.isEmpty(str)) {
+ obj.setItem(this.id, str);
}
- Ext.layout.BoxLayout.superclass.renderAll.call(this, ct, this.innerCt);
},
- getLayoutTargetSize : function() {
- var target = this.container.getLayoutTarget(), ret;
+
+ getNextId: function() {
+ var obj = this.getStorageObject(),
+ key = this.getRecordCounterKey(),
+ last = obj.getItem(key),
+ ids, id;
- 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');
+ if (last === null) {
+ ids = this.getIds();
+ last = ids[ids.length - 1] || 0;
}
- return ret;
+ id = parseInt(last, 10) + 1;
+ obj.setItem(key, id);
+
+ return id;
},
- 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);
+ initialize: function() {
+ var storageObject = this.getStorageObject();
+ storageObject.setItem(this.id, storageObject.getItem(this.id) || "");
},
+
-
- destroy: function() {
- Ext.destroy(this.overflowHandler);
+ clear: function() {
+ var obj = this.getStorageObject(),
+ ids = this.getIds(),
+ len = ids.length,
+ i;
+
+
+ for (i = 0; i < len; i++) {
+ this.removeRecord(ids[i]);
+ }
+
- Ext.layout.BoxLayout.superclass.destroy.apply(this, arguments);
+ obj.removeItem(this.getRecordCounterKey());
+ obj.removeItem(this.id);
+ },
+
+
+ getStorageObject: function() {
+ Ext.Error.raise("The getStorageObject function has not been defined in your Ext.data.proxy.WebStorage subclass");
}
});
+Ext.define('Ext.data.proxy.LocalStorage', {
+ extend: 'Ext.data.proxy.WebStorage',
+ alias: 'proxy.localstorage',
+ alternateClassName: 'Ext.data.LocalStorageProxy',
+
+
+ getStorageObject: function() {
+ return window.localStorage;
+ }
+});
+Ext.define('Ext.data.proxy.Memory', {
+ extend: 'Ext.data.proxy.Client',
+ alias: 'proxy.memory',
+ alternateClassName: 'Ext.data.MemoryProxy',
-Ext.ns('Ext.layout.boxOverflow');
-
+
+ constructor: function(config) {
+ this.callParent([config]);
-Ext.layout.boxOverflow.None = Ext.extend(Object, {
- constructor: function(layout, config) {
- this.layout = layout;
- Ext.apply(this, config || {});
+ this.setReader(this.reader);
},
+
- handleOverflow: Ext.emptyFn,
-
- clearOverflow: Ext.emptyFn
-});
+ read: function(operation, callback, scope) {
+ var me = this,
+ reader = me.getReader(),
+ result = reader.read(me.data);
+
+ Ext.apply(operation, {
+ resultSet: result
+ });
+
+ operation.setCompleted();
+ operation.setSuccessful();
+ Ext.callback(callback, scope || me, [operation]);
+ },
+ clear: Ext.emptyFn
+});
-Ext.layout.boxOverflow.none = Ext.layout.boxOverflow.None;
-Ext.layout.boxOverflow.Menu = Ext.extend(Ext.layout.boxOverflow.None, {
+Ext.define('Ext.data.proxy.Rest', {
+ extend: 'Ext.data.proxy.Ajax',
+ alternateClassName: 'Ext.data.RestProxy',
+ alias : 'proxy.rest',
- afterCls: 'x-strip-right',
+ appendId: true,
- noItemsMenuText : '',
- 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');
- }
- },
+ batchActions: false,
- clearOverflow: function(calculations, targetSize) {
- var newWidth = targetSize.width + (this.afterCt ? this.afterCt.getWidth() : 0),
- items = this.menuItems;
+ buildUrl: function(request) {
+ var me = this,
+ operation = request.operation,
+ records = operation.records || [],
+ record = records[0],
+ format = me.format,
+ url = me.getUrl(request),
+ id = record ? record.getId() : operation.id;
- this.hideTrigger();
-
- for (var index = 0, length = items.length; index < length; index++) {
- items.pop().component.show();
+ if (me.appendId && id) {
+ if (!url.match(/\/$/)) {
+ url += '/';
+ }
+
+ url += id;
}
- return {
- targetSize: {
- height: targetSize.height,
- width : newWidth
+ if (format) {
+ if (!url.match(/\.$/)) {
+ url += '.';
}
- };
- },
-
+
+ url += format;
+ }
+
+ request.url = url;
+
+ return me.callParent(arguments);
+ }
+}, function() {
+ Ext.apply(this.prototype, {
+
+ actionMethods: {
+ create : 'POST',
+ read : 'GET',
+ update : 'PUT',
+ destroy: 'DELETE'
+ }
+ });
+});
+
+
+Ext.define('Ext.data.proxy.SessionStorage', {
+ extend: 'Ext.data.proxy.WebStorage',
+ alias: 'proxy.sessionstorage',
+ alternateClassName: 'Ext.data.SessionStorageProxy',
- showTrigger: function() {
- this.createMenu();
- this.menuTrigger.show();
- },
+ getStorageObject: function() {
+ return window.sessionStorage;
+ }
+});
+
+
+Ext.define('Ext.data.reader.Array', {
+ extend: 'Ext.data.reader.Json',
+ alternateClassName: 'Ext.data.ArrayReader',
+ alias : 'reader.array',
+
- hideTrigger: function() {
- if (this.menuTrigger != undefined) {
- this.menuTrigger.hide();
+ buildExtractors: function() {
+ this.callParent(arguments);
+
+ var fields = this.model.prototype.fields.items,
+ length = fields.length,
+ extractorFunctions = [],
+ i;
+
+ for (i = 0; i < length; i++) {
+ extractorFunctions.push(function(index) {
+ return function(data) {
+ return data[index];
+ };
+ }(fields[i].mapping || i));
}
- },
+
+ this.extractorFunctions = extractorFunctions;
+ }
+});
+
+
+Ext.define('Ext.data.reader.Xml', {
+ extend: 'Ext.data.reader.Reader',
+ alternateClassName: 'Ext.data.XmlReader',
+ alias : 'reader.xml',
- 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);
+
+
+ createAccessor: function() {
+ var selectValue = function(expr, root){
+ var node = Ext.DomQuery.selectNode(expr, root),
+ val;
+
+
+
};
-
- this.clearMenu();
- menu.removeAll();
-
- for (var i = 0; i < len; i++) {
- item = items[i].component;
+
+ return function(expr) {
+ var me = this;
- if (prev && (needsSep(item, prev) || needsSep(prev, item))) {
- menu.add('-');
+ if (Ext.isEmpty(expr)) {
+ return Ext.emptyFn;
}
- this.addComponentToMenu(menu, item);
- prev = item;
- }
-
-
- if (menu.items.length < 1) {
- menu.add(this.noItemsMenuText);
+ if (Ext.isFunction(expr)) {
+ return expr;
+ }
+
+ return function(root) {
+ var node = Ext.DomQuery.selectNode(expr, root),
+ val = me.getNodeValue(node);
+
+ return Ext.isEmpty(val) ? null : val;
+ };
+ };
+ }(),
+
+ getNodeValue: function(node) {
+ var val;
+ if (node && node.firstChild) {
+ val = node.firstChild.nodeValue;
}
+ return val || null;
},
-
-
- 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
- });
+
+ getResponseData: function(response) {
+ var xml = response.responseXML;
- if (group || component.enableToggle) {
- Ext.apply(config, {
- group : group,
- checked: component.pressed,
- listeners: {
- checkchange: function(item, checked){
- component.toggle(checked);
- }
- }
+ if (!xml) {
+ Ext.Error.raise({
+ response: response,
+ msg: 'XML data not found in the response'
});
}
- delete config.ownerCt;
- delete config.xtype;
- delete config.id;
-
- return config;
+ return xml;
},
- 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));
+ getData: function(data) {
+ return data.documentElement || data;
+ },
- } else if (component.isXType('button')) {
- menu.add(this.createMenuConfig(component, !component.menu));
+
+ getRoot: function(data) {
+ var nodeName = data.nodeName,
+ root = this.root;
+
+ if (!root || (nodeName && nodeName == root)) {
+ return data;
+ } else if (Ext.DomQuery.isXml(data)) {
+
+
+
+ return Ext.DomQuery.selectNode(root, data);
+ }
+ },
- } else if (component.isXType('buttongroup')) {
- component.items.each(function(item){
- this.addComponentToMenu(menu, item);
- }, this);
- }
+
+ extractData: function(root) {
+ var recordName = this.record;
+
+ if (!recordName) {
+ Ext.Error.raise('Record is a required parameter');
+ }
+
+ if (recordName != root.nodeName) {
+ root = Ext.DomQuery.select(recordName, root);
+ } else {
+ root = [root];
}
+ return this.callParent([root]);
+ },
+
+
+ getAssociatedDataRoot: function(data, associationName) {
+ return Ext.DomQuery.select(associationName, data)[0];
},
+
+
+ readRecords: function(doc) {
+
+ if (Ext.isArray(doc)) {
+ doc = doc[0];
+ }
+
+
+ this.xmlData = doc;
+ return this.callParent([doc]);
+ }
+});
+
+
+Ext.define('Ext.data.writer.Xml', {
+
+
+
+ extend: 'Ext.data.writer.Writer',
+ alternateClassName: 'Ext.data.XmlWriter',
+
+ alias: 'writer.xml',
- 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
- });
- }
- },
+ documentRoot: 'xmlData',
- destroy: function() {
- Ext.destroy(this.menu, this.menuTrigger);
- }
-});
-
-Ext.layout.boxOverflow.menu = Ext.layout.boxOverflow.Menu;
+ defaultDocumentRoot: 'xmlData',
+
+ header: '',
+
+ record: 'record',
-Ext.layout.boxOverflow.HorizontalMenu = Ext.extend(Ext.layout.boxOverflow.Menu, {
- constructor: function() {
- Ext.layout.boxOverflow.HorizontalMenu.superclass.constructor.apply(this, arguments);
-
+ writeRecords: function(request, data) {
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;
+ xml = [],
+ i = 0,
+ len = data.length,
+ root = me.documentRoot,
+ record = me.record,
+ needsRoot = data.length !== 1,
+ item,
+ key;
- return calcs;
- };
- },
-
- handleOverflow: function(calculations, targetSize) {
- this.showTrigger();
- var newWidth = targetSize.width - this.afterCt.getWidth(),
- boxes = calculations.boxes,
- usedWidth = 0,
- recalculate = false;
+ xml.push(me.header || '');
-
- for (var index = 0, length = boxes.length; index < length; index++) {
- usedWidth += boxes[index].width;
+ if (!root && needsRoot) {
+ root = me.defaultDocumentRoot;
}
- 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 (root) {
+ xml.push('<', root, '>');
}
-
- 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;
+
+ for (; i < len; ++i) {
+ item = data[i];
+ xml.push('<', record, '>');
+ for (key in item) {
+ if (item.hasOwnProperty(key)) {
+ xml.push('<', key, '>', item[key], '');
}
}
+ xml.push('');
}
- if (this.menuItems.length == 0) {
- this.hideTrigger();
+ if (root) {
+ xml.push('');
}
-
- return {
- targetSize: {
- height: targetSize.height,
- width : newWidth
- },
- recalculate: recalculate
- };
+
+ request.xmlData = xml.join('');
+ return request;
}
});
-Ext.layout.boxOverflow.menu.hbox = Ext.layout.boxOverflow.HorizontalMenu;
-Ext.layout.boxOverflow.Scroller = Ext.extend(Ext.layout.boxOverflow.None, {
-
- animateScroll: true,
+
+Ext.define('Ext.direct.Event', {
- scrollIncrement: 100,
+
+ alias: 'direct.event',
+ requires: ['Ext.direct.Manager'],
- wheelIncrement: 3,
+
+ status: true,
- scrollRepeatInterval: 400,
+ constructor: function(config) {
+ Ext.apply(this, config);
+ },
- scrollDuration: 0.4,
+ getData: function(){
+ return this.data;
+ }
+});
+
+
+Ext.define('Ext.direct.RemotingEvent', {
- beforeCls: 'x-strip-left',
+
+ extend: 'Ext.direct.Event',
+ alias: 'direct.rpc',
- afterCls: 'x-strip-right',
- scrollerCls: 'x-strip-scroller',
+ getTransaction: function(){
+ return this.transaction || Ext.direct.Manager.getTransaction(this.tid);
+ }
+});
+
+
+Ext.define('Ext.direct.ExceptionEvent', {
- beforeScrollerCls: 'x-strip-scroller-left',
+
+ extend: 'Ext.direct.RemotingEvent',
- afterScrollerCls: 'x-strip-scroller-right',
+ alias: 'direct.exception',
- createWheelListener: function() {
- this.layout.innerCt.on({
- scope : this,
- mousewheel: function(e) {
- e.stopEvent();
+
+ status: false
+});
- this.scrollBy(e.getWheelDelta() * this.wheelIncrement * -1, false);
- }
- });
- },
+
+Ext.define('Ext.direct.Provider', {
- handleOverflow: function(calculations, targetSize) {
- this.createInnerElements();
- this.showScrollers();
+
+ alias: 'direct.provider',
+
+ mixins: {
+ observable: 'Ext.util.Observable'
},
+
+
+
- clearOverflow: function() {
- this.hideScrollers();
+ constructor : function(config){
+ var me = this;
+
+ Ext.apply(me, config);
+ me.addEvents(
+
+ 'connect',
+
+ 'disconnect',
+
+ 'data',
+
+ 'exception'
+ );
+ me.mixins.observable.constructor.call(me, config);
},
- showScrollers: function() {
- this.createScrollers();
-
- this.beforeScroller.show();
- this.afterScroller.show();
-
- this.updateScrollButtons();
+ isConnected: function(){
+ return false;
},
+
+
+ connect: Ext.emptyFn,
- hideScrollers: function() {
- if (this.beforeScroller != undefined) {
- this.beforeScroller.hide();
- this.afterScroller.hide();
+ disconnect: Ext.emptyFn
+});
+
+
+
+Ext.define('Ext.direct.JsonProvider', {
+
+
+
+ extend: 'Ext.direct.Provider',
+
+ alias: 'direct.jsonprovider',
+
+ uses: ['Ext.direct.ExceptionEvent'],
+
+
+
+
+ parseResponse: function(response){
+ if (!Ext.isEmpty(response.responseText)) {
+ if (Ext.isObject(response.responseText)) {
+ return response.responseText;
+ }
+ return Ext.decode(response.responseText);
}
+ return null;
},
+
-
- createScrollers: function() {
- if (!this.beforeScroller && !this.afterScroller) {
- var before = this.beforeCt.createChild({
- cls: String.format("{0} {1} ", this.scrollerCls, this.beforeScrollerCls)
- });
-
- var after = this.afterCt.createChild({
- cls: String.format("{0} {1}", this.scrollerCls, this.afterScrollerCls)
- });
-
- before.addClassOnOver(this.beforeScrollerCls + '-hover');
- after.addClassOnOver(this.afterScrollerCls + '-hover');
-
- before.setVisibilityMode(Ext.Element.DISPLAY);
- after.setVisibilityMode(Ext.Element.DISPLAY);
-
- this.beforeRepeater = new Ext.util.ClickRepeater(before, {
- interval: this.scrollRepeatInterval,
- handler : this.scrollLeft,
- scope : this
- });
+ createEvents: function(response){
+ var data = null,
+ events = [],
+ event,
+ i = 0,
+ len;
- this.afterRepeater = new Ext.util.ClickRepeater(after, {
- interval: this.scrollRepeatInterval,
- handler : this.scrollRight,
- scope : this
+ try{
+ data = this.parseResponse(response);
+ } catch(e) {
+ event = Ext.create('Ext.direct.ExceptionEvent', {
+ data: e,
+ xhr: response,
+ code: Ext.direct.Manager.self.exceptions.PARSE,
+ message: 'Error parsing json response: \n\n ' + data
});
-
-
- this.beforeScroller = before;
-
-
- this.afterScroller = after;
+ return [event];
+ }
+
+ if (Ext.isArray(data)) {
+ for (len = data.length; i < len; ++i) {
+ events.push(this.createEvent(data[i]));
+ }
+ } else {
+ events.push(this.createEvent(data));
}
+ return events;
},
- destroy: function() {
- Ext.destroy(this.beforeScroller, this.afterScroller, this.beforeRepeater, this.afterRepeater, this.beforeCt, this.afterCt);
- },
+ createEvent: function(response){
+ return Ext.create('direct.' + response.type, response);
+ }
+});
+
+Ext.define('Ext.direct.PollingProvider', {
- scrollBy: function(delta, animate) {
- this.scrollTo(this.getScrollPosition() + delta, animate);
- },
+ extend: 'Ext.direct.JsonProvider',
- getItem: function(item) {
- if (Ext.isString(item)) {
- item = Ext.getCmp(item);
- } else if (Ext.isNumber(item)) {
- item = this.items[item];
- }
-
- return item;
- },
+ alias: 'direct.pollingprovider',
+ uses: ['Ext.direct.ExceptionEvent'],
- getScrollAnim: function() {
- return {
- duration: this.scrollDuration,
- callback: this.updateScrollButtons,
- scope : this
- };
- },
+ requires: ['Ext.Ajax', 'Ext.util.DelayedTask'],
- updateScrollButtons: function() {
- if (this.beforeScroller == undefined || this.afterScroller == undefined) {
- return;
- }
-
- var beforeMeth = this.atExtremeBefore() ? 'addClass' : 'removeClass',
- afterMeth = this.atExtremeAfter() ? 'addClass' : 'removeClass',
- beforeCls = this.beforeScrollerCls + '-disabled',
- afterCls = this.afterScrollerCls + '-disabled';
-
- this.beforeScroller[beforeMeth](beforeCls);
- this.afterScroller[afterMeth](afterCls);
- this.scrolling = false;
- },
- atExtremeBefore: function() {
- return this.getScrollPosition() === 0;
- },
+ interval: 3000,
+
- scrollLeft: function(animate) {
- this.scrollBy(-this.scrollIncrement, animate);
- },
+
- scrollRight: function(animate) {
- this.scrollBy(this.scrollIncrement, animate);
+ constructor : function(config){
+ this.callParent(arguments);
+ this.addEvents(
+
+ 'beforepoll',
+
+ 'poll'
+ );
},
+
+ isConnected: function(){
+ return !!this.pollTask;
+ },
+
- scrollToItem: function(item, animate) {
- item = this.getItem(item);
+ connect: function(){
+ var me = this, url = me.url;
- if (item != undefined) {
- var visibility = this.getItemVisibility(item);
-
- if (!visibility.fullyVisible) {
- var box = item.getBox(true, true),
- newX = box.x;
-
- if (visibility.hiddenRight) {
- newX -= (this.layout.innerCt.getWidth() - box.width);
- }
-
- this.scrollTo(newX, animate);
- }
+ if (url && !me.pollTask) {
+ me.pollTask = Ext.TaskManager.start({
+ run: function(){
+ if (me.fireEvent('beforepoll', me) !== false) {
+ if (Ext.isFunction(url)) {
+ url(me.baseParams);
+ } else {
+ Ext.Ajax.request({
+ url: url,
+ callback: me.onData,
+ scope: me,
+ params: me.baseParams
+ });
+ }
+ }
+ },
+ interval: me.interval,
+ scope: me
+ });
+ me.fireEvent('connect', me);
+ } else if (!url) {
+ Ext.Error.raise('Error initializing PollingProvider, no url configured.');
}
},
-
-
- getItemVisibility: function(item) {
- var box = this.getItem(item).getBox(true, true),
- itemLeft = box.x,
- itemRight = box.x + box.width,
- scrollLeft = this.getScrollPosition(),
- scrollRight = this.layout.innerCt.getWidth() + scrollLeft;
-
- return {
- hiddenLeft : itemLeft < scrollLeft,
- hiddenRight : itemRight > scrollRight,
- fullyVisible: itemLeft > scrollLeft && itemRight < scrollRight
- };
- }
-});
-Ext.layout.boxOverflow.scroller = Ext.layout.boxOverflow.Scroller;
-
-
-
-Ext.layout.boxOverflow.VerticalScroller = Ext.extend(Ext.layout.boxOverflow.Scroller, {
- scrollIncrement: 75,
- wheelIncrement : 2,
- handleOverflow: function(calculations, targetSize) {
- Ext.layout.boxOverflow.VerticalScroller.superclass.handleOverflow.apply(this, arguments);
+ disconnect: function(){
+ var me = this;
- return {
- targetSize: {
- height: targetSize.height - (this.beforeCt.getHeight() + this.afterCt.getHeight()),
- width : targetSize.width
- }
- };
+ if (me.pollTask) {
+ Ext.TaskManager.stop(me.pollTask);
+ delete me.pollTask;
+ me.fireEvent('disconnect', me);
+ }
},
+
-
- createInnerElements: function() {
- var target = this.layout.innerCt;
-
-
+ onData: function(opt, success, response){
+ var me = this,
+ i = 0,
+ len,
+ events;
- if (!this.beforeCt) {
- this.beforeCt = target.insertSibling({cls: this.beforeCls}, 'before');
- this.afterCt = target.insertSibling({cls: this.afterCls}, 'after');
+ if (success) {
+ events = me.createEvents(response);
+ for (len = events.length; i < len; ++i) {
+ me.fireEvent('data', me, events[i]);
+ }
+ } else {
+ me.fireEvent('data', me, Ext.create('Ext.direct.ExceptionEvent', {
+ data: null,
+ code: Ext.direct.Manager.self.exceptions.TRANSPORT,
+ message: 'Unable to connect to the server.',
+ xhr: response
+ }));
+ }
+ }
+});
- this.createWheelListener();
+Ext.define('Ext.direct.RemotingMethod', {
+
+ constructor: function(config){
+ var me = this,
+ params = Ext.isDefined(config.params) ? config.params : config.len,
+ name;
+
+ me.name = config.name;
+ me.formHandler = config.formHandler;
+ if (Ext.isNumber(params)) {
+
+ me.len = params;
+ me.ordered = true;
+ } else {
+
+ me.params = [];
+ Ext.each(params, function(param){
+ name = Ext.isObject(param) ? param.name : param;
+ me.params.push(name);
+ });
}
},
- scrollTo: function(position, animate) {
- var oldPosition = this.getScrollPosition(),
- newPosition = position.constrain(0, this.getMaxScrollBottom());
-
- if (newPosition != oldPosition && !this.scrolling) {
- if (animate == undefined) {
- animate = this.animateScroll;
+ getCallData: function(args){
+ var me = this,
+ data = null,
+ len = me.len,
+ params = me.params,
+ callback,
+ scope,
+ name;
+
+ if (me.ordered) {
+ callback = args[len];
+ scope = args[len + 1];
+ if (len !== 0) {
+ data = args.slice(0, len);
}
+ } else {
+ data = Ext.apply({}, args[0]);
+ callback = args[1];
+ scope = args[2];
- this.layout.innerCt.scrollTo('top', newPosition, animate ? this.getScrollAnim() : false);
- if (animate) {
- this.scrolling = true;
- } else {
- this.scrolling = false;
- this.updateScrollButtons();
+ for (name in data) {
+ if (data.hasOwnProperty(name)) {
+ if (!Ext.Array.contains(params, name)) {
+ delete data[name];
+ }
+ }
}
}
- },
+
+ return {
+ data: data,
+ callback: callback,
+ scope: scope
+ };
+ }
+});
+
+
+Ext.define('Ext.direct.Transaction', {
- getScrollPosition: function(){
- return parseInt(this.layout.innerCt.dom.scrollTop, 10) || 0;
+
+ alias: 'direct.transaction',
+ alternateClassName: 'Ext.Direct.Transaction',
+
+ statics: {
+ TRANSACTION_ID: 0
},
+
-
- getMaxScrollBottom: function() {
- return this.layout.innerCt.dom.scrollHeight - this.layout.innerCt.getHeight();
+
+ constructor: function(config){
+ var me = this;
+
+ Ext.apply(me, config);
+ me.id = ++me.self.TRANSACTION_ID;
+ me.retryCount = 0;
+ },
+
+ send: function(){
+ this.provider.queueTransaction(this);
},
-
-
- atExtremeAfter: function() {
- return this.getScrollPosition() >= this.getMaxScrollBottom();
- }
-});
-Ext.layout.boxOverflow.scroller.vbox = Ext.layout.boxOverflow.VerticalScroller;
+ retry: function(){
+ this.retryCount++;
+ this.send();
+ },
+ getProvider: function(){
+ return this.provider;
+ }
+});
-Ext.layout.boxOverflow.HorizontalScroller = Ext.extend(Ext.layout.boxOverflow.Scroller, {
- handleOverflow: function(calculations, targetSize) {
- Ext.layout.boxOverflow.HorizontalScroller.superclass.handleOverflow.apply(this, arguments);
-
- return {
- targetSize: {
- height: targetSize.height,
- width : targetSize.width - (this.beforeCt.getWidth() + this.afterCt.getWidth())
- }
- };
- },
+Ext.define('Ext.direct.RemotingProvider', {
- createInnerElements: function() {
- var target = this.layout.innerCt;
-
-
-
- if (!this.beforeCt) {
- this.afterCt = target.insertSibling({cls: this.afterCls}, 'before');
- this.beforeCt = target.insertSibling({cls: this.beforeCls}, 'before');
-
- this.createWheelListener();
- }
+
+ alias: 'direct.remotingprovider',
+
+ extend: 'Ext.direct.JsonProvider',
+
+ requires: [
+ 'Ext.util.MixedCollection',
+ 'Ext.util.DelayedTask',
+ 'Ext.direct.Transaction',
+ 'Ext.direct.RemotingMethod'
+ ],
+
+
+
+
+
+
+
+
+
+
+
+
+ enableBuffer: 10,
+
+
+ maxRetries: 1,
+
+
+ timeout: undefined,
+
+ constructor : function(config){
+ var me = this;
+ me.callParent(arguments);
+ me.addEvents(
+
+ 'beforecall',
+
+ 'call'
+ );
+ me.namespace = (Ext.isString(me.namespace)) ? Ext.ns(me.namespace) : me.namespace || window;
+ me.transactions = Ext.create('Ext.util.MixedCollection');
+ me.callBuffer = [];
},
- scrollTo: function(position, animate) {
- var oldPosition = this.getScrollPosition(),
- newPosition = position.constrain(0, this.getMaxScrollRight());
-
- if (newPosition != oldPosition && !this.scrolling) {
- if (animate == undefined) {
- animate = this.animateScroll;
- }
+ initAPI : function(){
+ var actions = this.actions,
+ namespace = this.namespace,
+ action,
+ cls,
+ methods,
+ i,
+ len,
+ method;
- this.layout.innerCt.scrollTo('left', newPosition, animate ? this.getScrollAnim() : false);
+ for (action in actions) {
+ cls = namespace[action];
+ if (!cls) {
+ cls = namespace[action] = {};
+ }
+ methods = actions[action];
- if (animate) {
- this.scrolling = true;
- } else {
- this.scrolling = false;
- this.updateScrollButtons();
+ for (i = 0, len = methods.length; i < len; ++i) {
+ method = Ext.create('Ext.direct.RemotingMethod', methods[i]);
+ cls[method.name] = this.createHandler(action, method);
}
}
},
- getScrollPosition: function(){
- return parseInt(this.layout.innerCt.dom.scrollLeft, 10) || 0;
+ createHandler : function(action, method){
+ var me = this,
+ handler;
+
+ if (!method.formHandler) {
+ handler = function(){
+ me.configureRequest(action, method, Array.prototype.slice.call(arguments, 0));
+ };
+ } else {
+ handler = function(form, callback, scope){
+ me.configureFormRequest(action, method, form, callback, scope);
+ };
+ }
+ handler.directCfg = {
+ action: action,
+ method: method
+ };
+ return handler;
},
- getMaxScrollRight: function() {
- return this.layout.innerCt.dom.scrollWidth - this.layout.innerCt.getWidth();
+ isConnected: function(){
+ return !!this.connected;
},
-
-
- atExtremeAfter: function() {
- return this.getScrollPosition() >= this.getMaxScrollRight();
- }
-});
-Ext.layout.boxOverflow.scroller.hbox = Ext.layout.boxOverflow.HorizontalScroller;
-Ext.layout.HBoxLayout = Ext.extend(Ext.layout.BoxLayout, {
- align: 'top',
-
- type : 'hbox',
+ connect: function(){
+ var me = this;
+
+ if (me.url) {
+ me.initAPI();
+ me.connected = true;
+ me.fireEvent('connect', me);
+ } else if(!me.url) {
+ Ext.Error.raise('Error initializing RemotingProvider, no url configured.');
+ }
+ },
+ disconnect: function(){
+ var me = this;
+
+ if (me.connected) {
+ me.connected = false;
+ me.fireEvent('disconnect', me);
+ }
+ },
-
- calculateChildBoxes: function(visibleItems, targetSize) {
- var visibleCount = visibleItems.length,
-
- padding = this.padding,
- topOffset = padding.top,
- leftOffset = padding.left,
- paddingVert = topOffset + padding.bottom,
- paddingHoriz = leftOffset + padding.right,
-
- width = targetSize.width - this.scrollOffset,
- height = targetSize.height,
- availHeight = Math.max(0, height - paddingVert),
-
- isStart = this.pack == 'start',
- isCenter = this.pack == 'center',
- isEnd = this.pack == 'end',
-
- nonFlexWidth = 0,
- maxHeight = 0,
- totalFlex = 0,
- desiredWidth = 0,
- minimumWidth = 0,
-
-
- boxes = [],
-
-
- child, childWidth, childHeight, childSize, childMargins, canLayout, i, calcs, flexedWidth,
- horizMargins, vertMargins, stretchHeight;
-
+ runCallback: function(transaction, event){
+ var funcName = event.status ? 'success' : 'failure',
+ callback,
+ result;
- for (i = 0; i < visibleCount; i++) {
- child = visibleItems[i];
- childHeight = child.height;
- childWidth = child.width;
- canLayout = !child.hasLayout && typeof child.doLayout == 'function';
-
-
- if (typeof childWidth != 'number') {
-
-
- if (child.flex && !childWidth) {
- totalFlex += child.flex;
-
-
- } else {
-
-
- if (!childWidth && canLayout) {
- child.doLayout();
- }
-
- childSize = child.getSize();
- childWidth = childSize.width;
- childHeight = childSize.height;
- }
- }
-
- childMargins = child.margins;
- horizMargins = childMargins.left + childMargins.right;
-
- nonFlexWidth += horizMargins + (childWidth || 0);
- desiredWidth += horizMargins + (child.flex ? child.minWidth || 0 : childWidth);
- minimumWidth += horizMargins + (child.minWidth || childWidth || 0);
-
-
- if (typeof childHeight != 'number') {
- if (canLayout) {
- child.doLayout();
- }
- childHeight = child.getHeight();
+ if (transaction && transaction.callback) {
+ callback = transaction.callback;
+ result = Ext.isDefined(event.result) ? event.result : event.data;
+
+ if (Ext.isFunction(callback)) {
+ callback(result, event);
+ } else {
+ Ext.callback(callback[funcName], callback.scope, [result, event]);
+ Ext.callback(callback.callback, callback.scope, [result, event]);
}
-
- maxHeight = Math.max(maxHeight, childHeight + childMargins.top + childMargins.bottom);
-
-
- boxes.push({
- component: child,
- height : childHeight || undefined,
- width : childWidth || undefined
- });
}
-
- var shortfall = desiredWidth - width,
- tooNarrow = minimumWidth > width;
-
-
- var availableWidth = Math.max(0, width - nonFlexWidth - paddingHoriz);
-
- if (tooNarrow) {
- for (i = 0; i < visibleCount; i++) {
- boxes[i].width = visibleItems[i].minWidth || visibleItems[i].width || boxes[i].width;
+ },
+
+
+ onData: function(options, success, response){
+ var me = this,
+ i = 0,
+ len,
+ events,
+ event,
+ transaction,
+ transactions;
+
+ if (success) {
+ events = me.createEvents(response);
+ for (len = events.length; i < len; ++i) {
+ event = events[i];
+ transaction = me.getTransaction(event);
+ me.fireEvent('data', me, event);
+ if (transaction) {
+ me.runCallback(transaction, event, true);
+ Ext.direct.Manager.removeTransaction(transaction);
+ }
}
} else {
-
-
- if (shortfall > 0) {
- var minWidths = [];
-
-
- for (var index = 0, length = visibleCount; index < length; index++) {
- var item = visibleItems[index],
- minWidth = item.minWidth || 0;
-
-
-
- if (item.flex) {
- boxes[index].width = minWidth;
- } else {
- minWidths.push({
- minWidth : minWidth,
- available: boxes[index].width - minWidth,
- index : index
- });
- }
- }
-
-
- minWidths.sort(function(a, b) {
- return a.available > b.available ? 1 : -1;
- });
-
-
- for (var i = 0, length = minWidths.length; i < length; i++) {
- var itemIndex = minWidths[i].index;
-
- if (itemIndex == undefined) {
- continue;
+ transactions = [].concat(options.transaction);
+ for (len = transactions.length; i < len; ++i) {
+ transaction = me.getTransaction(transactions[i]);
+ if (transaction && transaction.retryCount < me.maxRetries) {
+ transaction.retry();
+ } else {
+ event = Ext.create('Ext.direct.ExceptionEvent', {
+ data: null,
+ transaction: transaction,
+ code: Ext.direct.Manager.self.exceptions.TRANSPORT,
+ message: 'Unable to connect to the server.',
+ xhr: response
+ });
+ me.fireEvent('data', me, event);
+ if (transaction) {
+ me.runCallback(transaction, event, false);
+ Ext.direct.Manager.removeTransaction(transaction);
}
-
- var item = visibleItems[itemIndex],
- box = boxes[itemIndex],
- oldWidth = box.width,
- minWidth = item.minWidth,
- newWidth = Math.max(minWidth, oldWidth - Math.ceil(shortfall / (length - i))),
- reduction = oldWidth - newWidth;
-
- boxes[itemIndex].width = newWidth;
- shortfall -= reduction;
}
- } else {
-
- var remainingWidth = availableWidth,
- remainingFlex = totalFlex;
-
-
- for (i = 0; i < visibleCount; i++) {
- child = visibleItems[i];
- calcs = boxes[i];
-
- childMargins = child.margins;
- vertMargins = childMargins.top + childMargins.bottom;
+ }
+ }
+ },
+
+
+ getTransaction: function(options){
+ return options && options.tid ? Ext.direct.Manager.getTransaction(options.tid) : null;
+ },
+
+
+ configureRequest: function(action, method, args){
+ var me = this,
+ callData = method.getCallData(args),
+ data = callData.data,
+ callback = callData.callback,
+ scope = callData.scope,
+ transaction;
+
+ transaction = Ext.create('Ext.direct.Transaction', {
+ provider: me,
+ args: args,
+ action: action,
+ method: method.name,
+ data: data,
+ callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback
+ });
- if (isStart && child.flex && !child.width) {
- flexedWidth = Math.ceil((child.flex / remainingFlex) * remainingWidth);
- remainingWidth -= flexedWidth;
- remainingFlex -= child.flex;
+ if (me.fireEvent('beforecall', me, transaction, method) !== false) {
+ Ext.direct.Manager.addTransaction(transaction);
+ me.queueTransaction(transaction);
+ me.fireEvent('call', me, transaction, method);
+ }
+ },
+
+
+ getCallData: function(transaction){
+ return {
+ action: transaction.action,
+ method: transaction.method,
+ data: transaction.data,
+ type: 'rpc',
+ tid: transaction.id
+ };
+ },
+
+
+ sendRequest : function(data){
+ var me = this,
+ request = {
+ url: me.url,
+ callback: me.onData,
+ scope: me,
+ transaction: data,
+ timeout: me.timeout
+ }, callData,
+ enableUrlEncode = me.enableUrlEncode,
+ i = 0,
+ len,
+ params;
+
- calcs.width = flexedWidth;
- calcs.dirtySize = true;
- }
- }
+ if (Ext.isArray(data)) {
+ callData = [];
+ for (len = data.length; i < len; ++i) {
+ callData.push(me.getCallData(data[i]));
}
+ } else {
+ callData = me.getCallData(data);
}
-
- if (isCenter) {
- leftOffset += availableWidth / 2;
- } else if (isEnd) {
- leftOffset += availableWidth;
+
+ if (enableUrlEncode) {
+ params = {};
+ params[Ext.isString(enableUrlEncode) ? enableUrlEncode : 'data'] = Ext.encode(callData);
+ request.params = params;
+ } else {
+ request.jsonData = callData;
}
+ Ext.Ajax.request(request);
+ },
+
+
+ queueTransaction: function(transaction){
+ var me = this,
+ enableBuffer = me.enableBuffer;
+ if (transaction.form) {
+ me.sendFormRequest(transaction);
+ return;
+ }
- for (i = 0; i < visibleCount; i++) {
- child = visibleItems[i];
- calcs = boxes[i];
-
- childMargins = child.margins;
- leftOffset += childMargins.left;
- vertMargins = childMargins.top + childMargins.bottom;
-
- calcs.left = leftOffset;
- calcs.top = topOffset + childMargins.top;
-
- switch (this.align) {
- case 'stretch':
- stretchHeight = availHeight - vertMargins;
- calcs.height = stretchHeight.constrain(child.minHeight || 0, child.maxHeight || 1000000);
- calcs.dirtySize = true;
- break;
- case 'stretchmax':
- stretchHeight = maxHeight - vertMargins;
- calcs.height = stretchHeight.constrain(child.minHeight || 0, child.maxHeight || 1000000);
- calcs.dirtySize = true;
- break;
- case 'middle':
- var diff = availHeight - calcs.height - vertMargins;
- if (diff > 0) {
- calcs.top = topOffset + vertMargins + (diff / 2);
- }
+ me.callBuffer.push(transaction);
+ if (enableBuffer) {
+ if (!me.callTask) {
+ me.callTask = Ext.create('Ext.util.DelayedTask', me.combineAndSend, me);
}
+ me.callTask.delay(Ext.isNumber(enableBuffer) ? enableBuffer : 10);
+ } else {
+ me.combineAndSend();
+ }
+ },
+
+
+ combineAndSend : function(){
+ var buffer = this.callBuffer,
+ len = buffer.length;
- leftOffset += calcs.width + childMargins.right;
+ if (len > 0) {
+ this.sendRequest(len == 1 ? buffer[0] : buffer);
+ this.callBuffer = [];
}
-
- return {
- boxes: boxes,
- meta : {
- maxHeight : maxHeight,
- nonFlexWidth: nonFlexWidth,
- desiredWidth: desiredWidth,
- minimumWidth: minimumWidth,
- shortfall : desiredWidth - width,
- tooNarrow : tooNarrow
- }
- };
- }
-});
-
-Ext.Container.LAYOUTS.hbox = Ext.layout.HBoxLayout;
-Ext.layout.VBoxLayout = Ext.extend(Ext.layout.BoxLayout, {
+ },
- align : 'left',
- type: 'vbox',
-
-
+ configureFormRequest : function(action, method, form, callback, scope){
+ var me = this,
+ transaction = Ext.create('Ext.direct.Transaction', {
+ provider: me,
+ action: action,
+ method: method.name,
+ args: [form, callback, scope],
+ callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback,
+ isForm: true
+ }),
+ isUpload,
+ params;
+
+ if (me.fireEvent('beforecall', me, transaction, method) !== false) {
+ Ext.direct.Manager.addTransaction(transaction);
+ isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data';
+
+ params = {
+ extTID: transaction.id,
+ extAction: action,
+ extMethod: method.name,
+ extType: 'rpc',
+ extUpload: String(isUpload)
+ };
+
+
+
+ Ext.apply(transaction, {
+ form: Ext.getDom(form),
+ isUpload: isUpload,
+ params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
+ });
+ me.fireEvent('call', me, transaction, method);
+ me.sendFormRequest(transaction);
+ }
+ },
-
- calculateChildBoxes: function(visibleItems, targetSize) {
- var visibleCount = visibleItems.length,
-
- padding = this.padding,
- topOffset = padding.top,
- leftOffset = padding.left,
- paddingVert = topOffset + padding.bottom,
- paddingHoriz = leftOffset + padding.right,
-
- width = targetSize.width - this.scrollOffset,
- height = targetSize.height,
- availWidth = Math.max(0, width - paddingHoriz),
+ sendFormRequest: function(transaction){
+ Ext.Ajax.request({
+ url: this.url,
+ params: transaction.params,
+ callback: this.onData,
+ scope: this,
+ form: transaction.form,
+ isUpload: transaction.isUpload,
+ transaction: transaction
+ });
+ }
+
+});
- isStart = this.pack == 'start',
- isCenter = this.pack == 'center',
- isEnd = this.pack == 'end',
- nonFlexHeight= 0,
- maxWidth = 0,
- totalFlex = 0,
- desiredHeight= 0,
- minimumHeight= 0,
+Ext.define('Ext.draw.Matrix', {
-
- boxes = [],
-
-
- child, childWidth, childHeight, childSize, childMargins, canLayout, i, calcs, flexedWidth,
- horizMargins, vertMargins, stretchWidth;
+
-
- for (i = 0; i < visibleCount; i++) {
- child = visibleItems[i];
- childHeight = child.height;
- childWidth = child.width;
- canLayout = !child.hasLayout && typeof child.doLayout == 'function';
+ requires: ['Ext.draw.Draw'],
-
- if (typeof childHeight != 'number') {
+
-
- if (child.flex && !childHeight) {
- totalFlex += child.flex;
+ constructor: function(a, b, c, d, e, f) {
+ if (a != null) {
+ this.matrix = [[a, c, e], [b, d, f], [0, 0, 1]];
+ }
+ else {
+ this.matrix = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+ }
+ },
-
- } else {
-
-
- if (!childHeight && canLayout) {
- child.doLayout();
- }
+ add: function(a, b, c, d, e, f) {
+ var me = this,
+ out = [[], [], []],
+ matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
+ x,
+ y,
+ z,
+ res;
- childSize = child.getSize();
- childWidth = childSize.width;
- childHeight = childSize.height;
+ for (x = 0; x < 3; x++) {
+ for (y = 0; y < 3; y++) {
+ res = 0;
+ for (z = 0; z < 3; z++) {
+ res += me.matrix[x][z] * matrix[z][y];
}
+ out[x][y] = res;
}
-
- childMargins = child.margins;
- vertMargins = childMargins.top + childMargins.bottom;
+ }
+ me.matrix = out;
+ },
- nonFlexHeight += vertMargins + (childHeight || 0);
- desiredHeight += vertMargins + (child.flex ? child.minHeight || 0 : childHeight);
- minimumHeight += vertMargins + (child.minHeight || childHeight || 0);
+ prepend: function(a, b, c, d, e, f) {
+ var me = this,
+ out = [[], [], []],
+ matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
+ x,
+ y,
+ z,
+ res;
-
- if (typeof childWidth != 'number') {
- if (canLayout) {
- child.doLayout();
+ for (x = 0; x < 3; x++) {
+ for (y = 0; y < 3; y++) {
+ res = 0;
+ for (z = 0; z < 3; z++) {
+ res += matrix[x][z] * me.matrix[z][y];
}
- childWidth = child.getWidth();
+ out[x][y] = res;
}
+ }
+ me.matrix = out;
+ },
- maxWidth = Math.max(maxWidth, childWidth + childMargins.left + childMargins.right);
+ invert: function() {
+ var matrix = this.matrix,
+ a = matrix[0][0],
+ b = matrix[1][0],
+ c = matrix[0][1],
+ d = matrix[1][1],
+ e = matrix[0][2],
+ f = matrix[1][2],
+ x = a * d - b * c;
+ return new Ext.draw.Matrix(d / x, -b / x, -c / x, a / x, (c * f - d * e) / x, (b * e - a * f) / x);
+ },
-
- boxes.push({
- component: child,
- height : childHeight || undefined,
- width : childWidth || undefined
- });
- }
-
- var shortfall = desiredHeight - height,
- tooNarrow = minimumHeight > height;
+ clone: function() {
+ var matrix = this.matrix,
+ a = matrix[0][0],
+ b = matrix[1][0],
+ c = matrix[0][1],
+ d = matrix[1][1],
+ e = matrix[0][2],
+ f = matrix[1][2];
+ return new Ext.draw.Matrix(a, b, c, d, e, f);
+ },
-
- var availableHeight = Math.max(0, (height - nonFlexHeight - paddingVert));
-
- if (tooNarrow) {
- for (i = 0, length = visibleCount; i < length; i++) {
- boxes[i].height = visibleItems[i].minHeight || visibleItems[i].height || boxes[i].height;
- }
- } else {
-
-
- if (shortfall > 0) {
- var minHeights = [];
+ translate: function(x, y) {
+ this.prepend(1, 0, 0, 1, x, y);
+ },
-
- for (var index = 0, length = visibleCount; index < length; index++) {
- var item = visibleItems[index],
- minHeight = item.minHeight || 0;
+ scale: function(x, y, cx, cy) {
+ var me = this;
+ if (y == null) {
+ y = x;
+ }
+ me.add(1, 0, 0, 1, cx, cy);
+ me.add(x, 0, 0, y, 0, 0);
+ me.add(1, 0, 0, 1, -cx, -cy);
+ },
-
-
- if (item.flex) {
- boxes[index].height = minHeight;
- } else {
- minHeights.push({
- minHeight: minHeight,
- available: boxes[index].height - minHeight,
- index : index
- });
- }
- }
+ rotate: function(a, x, y) {
+ a = Ext.draw.Draw.rad(a);
+ var me = this,
+ cos = +Math.cos(a).toFixed(9),
+ sin = +Math.sin(a).toFixed(9);
+ me.add(cos, sin, -sin, cos, x, y);
+ me.add(1, 0, 0, 1, -x, -y);
+ },
-
- minHeights.sort(function(a, b) {
- return a.available > b.available ? 1 : -1;
- });
+ x: function(x, y) {
+ var matrix = this.matrix;
+ return x * matrix[0][0] + y * matrix[0][1] + matrix[0][2];
+ },
-
- for (var i = 0, length = minHeights.length; i < length; i++) {
- var itemIndex = minHeights[i].index;
+ y: function(x, y) {
+ var matrix = this.matrix;
+ return x * matrix[1][0] + y * matrix[1][1] + matrix[1][2];
+ },
- if (itemIndex == undefined) {
- continue;
- }
+ get: function(i, j) {
+ return + this.matrix[i][j].toFixed(4);
+ },
- var item = visibleItems[itemIndex],
- box = boxes[itemIndex],
- oldHeight = box.height,
- minHeight = item.minHeight,
- newHeight = Math.max(minHeight, oldHeight - Math.ceil(shortfall / (length - i))),
- reduction = oldHeight - newHeight;
+ toString: function() {
+ var me = this;
+ return [me.get(0, 0), me.get(0, 1), me.get(1, 0), me.get(1, 1), 0, 0].join();
+ },
- boxes[itemIndex].height = newHeight;
- shortfall -= reduction;
- }
- } else {
-
- var remainingHeight = availableHeight,
- remainingFlex = totalFlex;
-
-
- for (i = 0; i < visibleCount; i++) {
- child = visibleItems[i];
- calcs = boxes[i];
+ toSvg: function() {
+ var me = this;
+ return "matrix(" + [me.get(0, 0), me.get(1, 0), me.get(0, 1), me.get(1, 1), me.get(0, 2), me.get(1, 2)].join() + ")";
+ },
- childMargins = child.margins;
- horizMargins = childMargins.left + childMargins.right;
+ toFilter: function() {
+ var me = this;
+ return "progid:DXImageTransform.Microsoft.Matrix(M11=" + me.get(0, 0) +
+ ", M12=" + me.get(0, 1) + ", M21=" + me.get(1, 0) + ", M22=" + me.get(1, 1) +
+ ", Dx=" + me.get(0, 2) + ", Dy=" + me.get(1, 2) + ")";
+ },
- if (isStart && child.flex && !child.height) {
- flexedHeight = Math.ceil((child.flex / remainingFlex) * remainingHeight);
- remainingHeight -= flexedHeight;
- remainingFlex -= child.flex;
+ offset: function() {
+ var matrix = this.matrix;
+ return [matrix[0][2].toFixed(4), matrix[1][2].toFixed(4)];
+ },
- calcs.height = flexedHeight;
- calcs.dirtySize = true;
- }
- }
- }
+
+ split: function () {
+ function norm(a) {
+ return a[0] * a[0] + a[1] * a[1];
}
-
- if (isCenter) {
- topOffset += availableHeight / 2;
- } else if (isEnd) {
- topOffset += availableHeight;
+ function normalize(a) {
+ var mag = Math.sqrt(norm(a));
+ a[0] /= mag;
+ a[1] /= mag;
}
+ var matrix = this.matrix,
+ out = {
+ translateX: matrix[0][2],
+ translateY: matrix[1][2]
+ },
+ row;
- for (i = 0; i < visibleCount; i++) {
- child = visibleItems[i];
- calcs = boxes[i];
+ row = [[matrix[0][0], matrix[0][1]], [matrix[1][1], matrix[1][1]]];
+ out.scaleX = Math.sqrt(norm(row[0]));
+ normalize(row[0]);
- childMargins = child.margins;
- topOffset += childMargins.top;
- horizMargins = childMargins.left + childMargins.right;
-
+ out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1];
+ row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear];
- 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);
- }
- }
+ out.scaleY = Math.sqrt(norm(row[1]));
+ normalize(row[1]);
+ out.shear /= out.scaleY;
- 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;
+ out.rotate = Math.asin(-row[0][1]);
-Ext.layout.ToolbarLayout = Ext.extend(Ext.layout.ContainerLayout, {
- monitorResize : true,
+ out.isSimple = !+out.shear.toFixed(9) && (out.scaleX.toFixed(9) == out.scaleY.toFixed(9) || !out.rotate);
- type: 'toolbar',
-
-
- triggerWidth: 18,
+ return out;
+ }
+});
-
- noItemsMenuText : '',
+Ext.define('Ext.draw.SpriteDD', {
+ extend: 'Ext.dd.DragSource',
-
- lastOverflow: false,
+ constructor : function(sprite, cfg){
+ var me = this,
+ el = sprite.el;
+ me.sprite = sprite;
+ me.el = el;
+ me.dragData = {el: el, sprite: sprite};
+ me.callParent([el, cfg]);
+ me.sprite.setStyle('cursor', 'move');
+ },
-
- tableHTML: [
- '',
- '',
- '
'
- ].join(""),
+ showFrame: Ext.emptyFn,
+ createFrame : Ext.emptyFn,
+ getDragEl : function(e){
+ return this.el;
+ },
- onLayout : function(ct, target) {
+ getRegion: function() {
+ var me = this,
+ el = me.el,
+ pos, x1, x2, y1, y2, t, r, b, l, bbox, sprite;
- 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 = [];
- }
- }
-
- var side = ct.buttonAlign == 'right' ? this.rightTr : this.leftTr,
- items = ct.items.items,
- position = 0;
-
+ sprite = me.sprite;
+ bbox = sprite.getBBox();
- for (var i = 0, len = items.length, c; i < len; i++, position++) {
- c = items[i];
+ try {
+ pos = Ext.core.Element.getXY(el);
+ } catch (e) { }
- if (c.isFill) {
- side = this.rightTr;
- position = -1;
- } else if (!c.rendered) {
- c.render(this.insertCell(c, side, position));
- this.configureItem(c);
- } else {
- if (!c.xtbHidden && !this.isValidParent(c, side.childNodes[position])) {
- var td = this.insertCell(c, side, position);
- td.appendChild(c.getPositionEl().dom);
- c.container = Ext.get(td);
- }
- }
+ if (!pos) {
+ return null;
}
+ x1 = pos[0];
+ x2 = x1 + bbox.width;
+ y1 = pos[1];
+ y2 = y1 + bbox.height;
- this.cleanup(this.leftTr);
- this.cleanup(this.rightTr);
- this.cleanup(this.extrasTr);
- this.fitToSize(target);
+ return Ext.create('Ext.util.Region', y1, x2, y2, x1);
},
- cleanup : function(el) {
- var cn = el.childNodes, i, c;
+
+ startDrag: function(x, y) {
+ var me = this,
+ attr = me.sprite.attr,
+ trans = attr.translation;
+ if (me.sprite.vml) {
+ me.prevX = x + attr.x;
+ me.prevY = y + attr.y;
+ } else {
+ me.prevX = x - trans.x;
+ me.prevY = y - trans.y;
+ }
+ },
- for (i = cn.length-1; i >= 0 && (c = cn[i]); i--) {
- if (!c.firstChild) {
- el.removeChild(c);
+ onDrag: function(e) {
+ var xy = e.getXY(),
+ me = this,
+ sprite = me.sprite,
+ attr = sprite.attr;
+ me.translateX = xy[0] - me.prevX;
+ me.translateY = xy[1] - me.prevY;
+ sprite.setAttributes({
+ translate: {
+ x: me.translateX,
+ y: me.translateY
}
+ }, true);
+ if (sprite.vml) {
+ me.prevX = xy[0] + attr.x || 0;
+ me.prevY = xy[1] + attr.y || 0;
}
- },
+ }
+});
+Ext.define('Ext.draw.Sprite', {
- insertCell : function(c, target, position) {
- var td = document.createElement('td');
- td.className = 'x-toolbar-cell';
- target.insertBefore(td, target.childNodes[position] || null);
-
- return td;
+ mixins: {
+ observable: 'Ext.util.Observable',
+ animate: 'Ext.util.Animate'
},
+ requires: ['Ext.draw.SpriteDD'],
+
- hideItem : function(item) {
- this.hiddenItems.push(item);
- item.xtbHidden = true;
- item.xtbWidth = item.getPositionEl().dom.parentNode.offsetWidth;
- item.hide();
+ dirty: false,
+ dirtyHidden: false,
+ dirtyTransform: false,
+ dirtyPath: true,
+ dirtyFont: true,
+ zIndexDirty: true,
+ isSprite: true,
+ zIndex: 0,
+ fontProperties: [
+ 'font',
+ 'font-size',
+ 'font-weight',
+ 'font-style',
+ 'font-family',
+ 'text-anchor',
+ 'text'
+ ],
+ pathProperties: [
+ 'x',
+ 'y',
+ 'd',
+ 'path',
+ 'height',
+ 'width',
+ 'radius',
+ 'r',
+ 'rx',
+ 'ry',
+ 'cx',
+ 'cy'
+ ],
+ constructor: function(config) {
+ var me = this;
+ config = config || {};
+ me.id = Ext.id(null, 'ext-sprite-');
+ me.transformations = [];
+ Ext.copyTo(this, config, 'surface,group,type,draggable');
+
+ me.bbox = {};
+ me.attr = {
+ zIndex: 0,
+ translation: {
+ x: null,
+ y: null
+ },
+ rotation: {
+ degrees: null,
+ x: null,
+ y: null
+ },
+ scaling: {
+ x: null,
+ y: null,
+ cx: null,
+ cy: null
+ }
+ };
+
+ delete config.surface;
+ delete config.group;
+ delete config.type;
+ delete config.draggable;
+ me.setAttributes(config);
+ me.addEvents(
+ 'beforedestroy',
+ 'destroy',
+ 'render',
+ 'mousedown',
+ 'mouseup',
+ 'mouseover',
+ 'mouseout',
+ 'mousemove',
+ 'click'
+ );
+ me.mixins.observable.constructor.apply(this, arguments);
},
- unhideItem : function(item) {
- item.show();
- item.xtbHidden = false;
- this.hiddenItems.remove(item);
+ initDraggable: function() {
+ var me = this;
+ me.draggable = true;
+
+ if (!me.el) {
+ me.surface.createSprite(me);
+ }
+ me.dd = Ext.create('Ext.draw.SpriteDD', me, Ext.isBoolean(me.draggable) ? null : me.draggable);
+ me.on('beforedestroy', me.dd.destroy, me.dd);
},
- getItemWidth : function(c) {
- return c.hidden ? (c.xtbWidth || 0) : c.getPositionEl().dom.parentNode.offsetWidth;
- },
+ setAttributes: function(attrs, redraw) {
+ var me = this,
+ fontProps = me.fontProperties,
+ fontPropsLength = fontProps.length,
+ pathProps = me.pathProperties,
+ pathPropsLength = pathProps.length,
+ hasSurface = !!me.surface,
+ custom = hasSurface && me.surface.customAttributes || {},
+ spriteAttrs = me.attr,
+ attr, i, translate, translation, rotate, rotation, scale, scaling;
-
- fitToSize : function(target) {
- if (this.container.enableOverflow === false) {
- return;
+ for (attr in custom) {
+ if (attrs.hasOwnProperty(attr) && typeof custom[attr] == "function") {
+ Ext.apply(attrs, custom[attr].apply(me, [].concat(attrs[attr])));
+ }
}
- 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 (!!attrs.hidden !== !!spriteAttrs.hidden) {
+ me.dirtyHidden = true;
+ }
- 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);
- }
- }
+
+ for (i = 0; i < pathPropsLength; i++) {
+ attr = pathProps[i];
+ if (attr in attrs && attrs[attr] !== spriteAttrs[attr]) {
+ me.dirtyPath = true;
+ break;
}
}
- hasHiddens = hiddenItems.length != 0;
-
- if (hasHiddens) {
- this.initMore();
+ if ('zIndex' in attrs) {
+ me.zIndexDirty = true;
+ }
- if (!this.lastOverflow) {
- this.container.fireEvent('overflowchange', this.container, true);
- this.lastOverflow = true;
+
+ for (i = 0; i < fontPropsLength; i++) {
+ attr = fontProps[i];
+ if (attr in attrs && attrs[attr] !== spriteAttrs[attr]) {
+ me.dirtyFont = true;
+ break;
}
- } 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;
+ translate = attrs.translate;
+ translation = spriteAttrs.translation;
+ if (translate) {
+ if ((translate.x && translate.x !== translation.x) ||
+ (translate.y && translate.y !== translation.y)) {
+ Ext.apply(translation, translate);
+ me.dirtyTransform = true;
}
+ delete attrs.translate;
}
- },
-
-
- 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
- });
+ rotate = attrs.rotate;
+ rotation = spriteAttrs.rotation;
+ if (rotate) {
+ if ((rotate.x && rotate.x !== rotation.x) ||
+ (rotate.y && rotate.y !== rotation.y) ||
+ (rotate.degrees && rotate.degrees !== rotation.degrees)) {
+ Ext.apply(rotation, rotate);
+ me.dirtyTransform = true;
+ }
+ delete attrs.rotate;
+ }
- if (group || component.enableToggle) {
- Ext.apply(config, {
- group : group,
- checked: component.pressed,
- listeners: {
- checkchange: function(item, checked){
- component.toggle(checked);
- }
- }
- });
+ scale = attrs.scale;
+ scaling = spriteAttrs.scaling;
+ if (scale) {
+ if ((scale.x && scale.x !== scaling.x) ||
+ (scale.y && scale.y !== scaling.y) ||
+ (scale.cx && scale.cx !== scaling.cx) ||
+ (scale.cy && scale.cy !== scaling.cy)) {
+ Ext.apply(scaling, scale);
+ me.dirtyTransform = true;
+ }
+ delete attrs.scale;
}
- delete config.ownerCt;
- delete config.xtype;
- delete config.id;
+ Ext.apply(spriteAttrs, attrs);
+ me.dirty = true;
- return config;
+ if (redraw === true && hasSurface) {
+ me.redraw();
+ }
+ return this;
},
- 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);
- }
- }
+ getBBox: function() {
+ return this.surface.getBBox(this);
},
-
- clearMenu : function(){
- var menu = this.moreMenu;
- if (menu && menu.items) {
- menu.items.each(function(item){
- delete item.menu;
- });
- }
+ setText: function(text) {
+ return this.surface.setText(this, text);
},
- beforeMoreShow : function(menu) {
- var items = this.container.items.items,
- len = items.length,
- item,
- prev;
+ hide: function(redraw) {
+ this.setAttributes({
+ hidden: true
+ }, redraw);
+ return this;
+ },
- var needsSep = function(group, item){
- return group.isXType('buttongroup') && !(item instanceof Ext.Toolbar.Separator);
- };
+
+ show: function(redraw) {
+ this.setAttributes({
+ hidden: false
+ }, redraw);
+ return this;
+ },
- 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;
- }
+
+ remove: function() {
+ if (this.surface) {
+ this.surface.remove(this);
+ return true;
}
+ return false;
+ },
-
- if (menu.items.length < 1) {
- menu.add(this.noItemsMenuText);
+ onRemove: function() {
+ this.surface.onRemove(this);
+ },
+
+
+ destroy: function() {
+ var me = this;
+ if (me.fireEvent('beforedestroy', me) !== false) {
+ me.remove();
+ me.surface.onDestroy(me);
+ me.clearListeners();
+ me.fireEvent('destroy');
}
},
- initMore : function(){
- if (!this.more) {
-
- this.moreMenu = new Ext.menu.Menu({
- ownerCt : this.container,
- listeners: {
- beforeshow: this.beforeMoreShow,
- scope: this
- }
- });
+ redraw: function() {
+ this.surface.renderItem(this);
+ return this;
+ },
-
- this.more = new Ext.Button({
- iconCls: 'x-toolbar-more-icon',
- cls : 'x-toolbar-more',
- menu : this.moreMenu,
- ownerCt: this.container
- });
+
+ setStyle: function() {
+ this.el.setStyle.apply(this.el, arguments);
+ return this;
+ },
- var td = this.insertCell(this.more, this.extrasTr, 100);
- this.more.render(td);
- }
+
+ addCls: function(obj) {
+ this.surface.addCls(this, obj);
+ return this;
},
- destroy : function(){
- Ext.destroy(this.more, this.moreMenu);
- delete this.leftTr;
- delete this.rightTr;
- delete this.extrasTr;
- Ext.layout.ToolbarLayout.superclass.destroy.call(this);
+
+ removeCls: function(obj) {
+ this.surface.removeCls(this, obj);
+ return this;
}
});
-Ext.Container.LAYOUTS.toolbar = Ext.layout.ToolbarLayout;
- Ext.layout.MenuLayout = Ext.extend(Ext.layout.ContainerLayout, {
- monitorResize : true,
+Ext.define('Ext.draw.engine.Svg', {
- type: 'menu',
+
- setContainer : function(ct){
- this.monitorResize = !ct.floating;
-
-
- ct.on('autosize', this.doAutoSize, this);
- Ext.layout.MenuLayout.superclass.setContainer.call(this, ct);
- },
+ extend: 'Ext.draw.Surface',
- renderItem : function(c, position, target){
- if (!this.itemTpl) {
- this.itemTpl = Ext.layout.MenuLayout.prototype.itemTpl = new Ext.XTemplate(
- '',
- '',
- '
',
- ' ',
- ' '
- );
- }
+ requires: ['Ext.draw.Draw', 'Ext.draw.Sprite', 'Ext.draw.Matrix', 'Ext.core.Element'],
- if(c && !c.rendered){
- if(Ext.isNumber(position)){
- position = target.dom.childNodes[position];
- }
- var a = this.getItemArgs(c);
+
+ engine: 'Svg',
- c.render(c.positionEl = position ?
- this.itemTpl.insertBefore(position, a, true) :
- this.itemTpl.append(target, a, true));
+ trimRe: /^\s+|\s+$/g,
+ spacesRe: /\s+/,
+ xlink: "http:/" + "/www.w3.org/1999/xlink",
+ translateAttrs: {
+ radius: "r",
+ radiusX: "rx",
+ radiusY: "ry",
+ path: "d",
+ lineWidth: "stroke-width",
+ fillOpacity: "fill-opacity",
+ strokeOpacity: "stroke-opacity",
+ strokeLinejoin: "stroke-linejoin"
+ },
+
+ minDefaults: {
+ circle: {
+ cx: 0,
+ cy: 0,
+ r: 0,
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ ellipse: {
+ cx: 0,
+ cy: 0,
+ rx: 0,
+ ry: 0,
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ rect: {
+ x: 0,
+ y: 0,
+ width: 0,
+ height: 0,
+ rx: 0,
+ ry: 0,
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ text: {
+ x: 0,
+ y: 0,
+ "text-anchor": "start",
+ "font-family": null,
+ "font-size": null,
+ "font-weight": null,
+ "font-style": null,
+ fill: "#000",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ path: {
+ d: "M0,0",
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ image: {
+ x: 0,
+ y: 0,
+ width: 0,
+ height: 0,
+ preserveAspectRatio: "none",
+ opacity: null
+ }
+ },
- c.positionEl.menuItemId = c.getItemId();
+ createSvgElement: function(type, attrs) {
+ var el = this.domRef.createElementNS("http:/" + "/www.w3.org/2000/svg", type),
+ key;
+ if (attrs) {
+ for (key in attrs) {
+ el.setAttribute(key, String(attrs[key]));
+ }
+ }
+ return el;
+ },
+ createSpriteElement: function(sprite) {
+
+ var el = this.createSvgElement(sprite.type);
+ el.id = sprite.id;
+ if (el.style) {
+ el.style.webkitTapHighlightColor = "rgba(0,0,0,0)";
+ }
+ sprite.el = Ext.get(el);
+ this.applyZIndex(sprite);
+ sprite.matrix = Ext.create('Ext.draw.Matrix');
+ sprite.bbox = {
+ plain: 0,
+ transform: 0
+ };
+ sprite.fireEvent("render", sprite);
+ return el;
+ },
+ getBBox: function (sprite, isWithoutTransform) {
+ var realPath = this["getPath" + sprite.type](sprite);
+ if (isWithoutTransform) {
+ sprite.bbox.plain = sprite.bbox.plain || Ext.draw.Draw.pathDimensions(realPath);
+ return sprite.bbox.plain;
+ }
+ sprite.bbox.transform = sprite.bbox.transform || Ext.draw.Draw.pathDimensions(Ext.draw.Draw.mapPath(realPath, sprite.matrix));
+ return sprite.bbox.transform;
+ },
+
+ getBBoxText: function (sprite) {
+ var bbox = {},
+ bb, height, width, i, ln, el;
- if (!a.isMenuItem && a.needsIcon) {
- c.positionEl.addClass('x-menu-list-item-indent');
+ if (sprite && sprite.el) {
+ el = sprite.el.dom;
+ try {
+ bbox = el.getBBox();
+ return bbox;
+ } catch(e) {
+
}
- this.configureItem(c);
- }else if(c && !this.isValidParent(c, target)){
- if(Ext.isNumber(position)){
- position = target.dom.childNodes[position];
+ bbox = {x: bbox.x, y: Infinity, width: 0, height: 0};
+ ln = el.getNumberOfChars();
+ for (i = 0; i < ln; i++) {
+ bb = el.getExtentOfChar(i);
+ bbox.y = Math.min(bb.y, bbox.y);
+ height = bb.y + bb.height - bbox.y;
+ bbox.height = Math.max(bbox.height, height);
+ width = bb.x + bb.width - bbox.x;
+ bbox.width = Math.max(bbox.width, width);
}
- target.dom.insertBefore(c.getActionEl().dom, position || null);
+ return bbox;
}
},
- getItemArgs : function(c) {
- var isMenuItem = c instanceof Ext.menu.Item,
- canHaveIcon = !(isMenuItem || c instanceof Ext.menu.Separator);
+ hide: function() {
+ Ext.get(this.el).hide();
+ },
- 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 || ''
- };
+ show: function() {
+ Ext.get(this.el).show();
},
-
- isValidParent : function(c, target) {
- return c.el.up('li.x-menu-list-item', 5).dom.parentNode === (target.dom || target);
+ hidePrim: function(sprite) {
+ this.addCls(sprite, Ext.baseCSSPrefix + 'hide-visibility');
+ },
+
+ showPrim: function(sprite) {
+ this.removeCls(sprite, Ext.baseCSSPrefix + 'hide-visibility');
},
- onLayout : function(ct, target){
- Ext.layout.MenuLayout.superclass.onLayout.call(this, ct, target);
- this.doAutoSize();
+ getDefs: function() {
+ return this._defs || (this._defs = this.createSvgElement("defs"));
},
- 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'));
+ transform: function(sprite) {
+ var me = this,
+ matrix = Ext.create('Ext.draw.Matrix'),
+ transforms = sprite.transformations,
+ transformsLength = transforms.length,
+ i = 0,
+ transform, type;
+
+ for (; i < transformsLength; i++) {
+ transform = transforms[i];
+ type = transform.type;
+ if (type == "translate") {
+ matrix.translate(transform.x, transform.y);
+ }
+ else if (type == "rotate") {
+ matrix.rotate(transform.degrees, transform.x, transform.y);
+ }
+ else if (type == "scale") {
+ matrix.scale(transform.x, transform.y, transform.centerX, transform.centerY);
}
}
- }
-});
-Ext.Container.LAYOUTS['menu'] = Ext.layout.MenuLayout;
+ sprite.matrix = matrix;
+ sprite.el.set({transform: matrix.toSvg()});
+ },
-Ext.Viewport = Ext.extend(Ext.Container, {
-
-
-
-
-
-
-
-
-
-
-
-
+ setSize: function(w, h) {
+ var me = this,
+ el = me.el;
+
+ w = +w || me.width;
+ h = +h || me.height;
+ me.width = w;
+ me.height = h;
- 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;
+ el.setSize(w, h);
+ el.set({
+ width: w,
+ height: h
+ });
+ me.callParent([w, h]);
},
- fireResize : function(w, h){
- this.fireEvent('resize', this, w, h, w, h);
- }
-});
-Ext.reg('viewport', Ext.Viewport);
-
-Ext.Panel = Ext.extend(Ext.Container, {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+ getRegion: function() {
+
+
+ var svgXY = this.el.getXY(),
+ rectXY = this.bgRect.getXY(),
+ max = Math.max,
+ x = max(svgXY[0], rectXY[0]),
+ y = max(svgXY[1], rectXY[1]);
+ return {
+ left: x,
+ top: y,
+ right: x + this.width,
+ bottom: y + this.height
+ };
+ },
+ onRemove: function(sprite) {
+ if (sprite.el) {
+ sprite.el.remove();
+ delete sprite.el;
+ }
+ this.callParent(arguments);
+ },
-
-
-
-
-
-
-
-
+ setViewBox: function(x, y, width, height) {
+ if (isFinite(x) && isFinite(y) && isFinite(width) && isFinite(height)) {
+ this.callParent(arguments);
+ this.el.dom.setAttribute("viewBox", [x, y, width, height].join(" "));
+ }
+ },
-
- baseCls : 'x-panel',
-
- collapsedCls : 'x-panel-collapsed',
-
- maskDisabled : true,
-
- animCollapse : Ext.enableFx,
-
- headerAsText : true,
-
- buttonAlign : 'right',
-
- collapsed : false,
-
- collapseFirst : true,
-
- minButtonWidth : 75,
-
-
- elements : 'body',
-
- preventBodyReset : false,
+ render: function (container) {
+ var me = this;
+ if (!me.el) {
+ var width = me.width || 10,
+ height = me.height || 10,
+ el = me.createSvgElement('svg', {
+ xmlns: "http:/" + "/www.w3.org/2000/svg",
+ version: 1.1,
+ width: width,
+ height: height
+ }),
+ defs = me.getDefs(),
-
- padding: undefined,
+
+
+
+
+ bgRect = me.createSvgElement("rect", {
+ width: "100%",
+ height: "100%",
+ fill: "#000",
+ stroke: "none",
+ opacity: 0
+ }),
+ webkitRect;
+
+ if (Ext.isSafari3) {
+
+ webkitRect = me.createSvgElement("rect", {
+ x: -10,
+ y: -10,
+ width: "110%",
+ height: "110%",
+ fill: "none",
+ stroke: "#000"
+ });
+ }
+ el.appendChild(defs);
+ if (Ext.isSafari3) {
+ el.appendChild(webkitRect);
+ }
+ el.appendChild(bgRect);
+ container.appendChild(el);
+ me.el = Ext.get(el);
+ me.bgRect = Ext.get(bgRect);
+ if (Ext.isSafari3) {
+ me.webkitRect = Ext.get(webkitRect);
+ me.webkitRect.hide();
+ }
+ me.el.on({
+ scope: me,
+ mouseup: me.onMouseUp,
+ mousedown: me.onMouseDown,
+ mouseover: me.onMouseOver,
+ mouseout: me.onMouseOut,
+ mousemove: me.onMouseMove,
+ mouseenter: me.onMouseEnter,
+ mouseleave: me.onMouseLeave,
+ click: me.onClick
+ });
+ }
+ me.renderAll();
+ },
- resizeEvent: 'bodyresize',
+ onMouseEnter: function(e) {
+ if (this.el.parent().getRegion().contains(e.getPoint())) {
+ this.fireEvent('mouseenter', e);
+ }
+ },
+ onMouseLeave: function(e) {
+ if (!this.el.parent().getRegion().contains(e.getPoint())) {
+ this.fireEvent('mouseleave', e);
+ }
+ },
-
- toolTarget : 'header',
- collapseEl : 'bwrap',
- slideAnchor : 't',
- disabledClass : '',
+ processEvent: function(name, e) {
+ var target = e.getTarget(),
+ surface = this.surface,
+ sprite;
-
- deferHeight : true,
-
- expandDefaults: {
- duration : 0.25
+ this.fireEvent(name, e);
+
+ if (target.nodeName == "tspan" && target.parentNode) {
+ target = target.parentNode;
+ }
+ sprite = this.items.get(target.id);
+ if (sprite) {
+ sprite.fireEvent(name, sprite, e);
+ }
},
+
- collapseDefaults : {
- duration : 0.25
+ tuneText: function (sprite, attrs) {
+ var el = sprite.el.dom,
+ tspans = [],
+ height, tspan, text, i, ln, texts, factor;
+
+ if (attrs.hasOwnProperty("text")) {
+ tspans = this.setText(sprite, attrs.text);
+ }
+
+ if (tspans.length) {
+ height = this.getBBoxText(sprite).height;
+ for (i = 0, ln = tspans.length; i < ln; i++) {
+
+
+ factor = (Ext.isFF3_0 || Ext.isFF3_5) ? 2 : 4;
+ tspans[i].setAttribute("dy", i ? height * 1.2 : height / factor);
+ }
+ sprite.dirty = true;
+ }
},
-
- initComponent : function(){
- Ext.Panel.superclass.initComponent.call(this);
+ setText: function(sprite, textString) {
+ var me = this,
+ el = sprite.el.dom,
+ x = el.getAttribute("x"),
+ tspans = [],
+ height, tspan, text, i, ln, texts;
+
+ while (el.firstChild) {
+ el.removeChild(el.firstChild);
+ }
+
+ texts = String(textString).split("\n");
+ for (i = 0, ln = texts.length; i < ln; i++) {
+ text = texts[i];
+ if (text) {
+ tspan = me.createSvgElement("tspan");
+ tspan.appendChild(document.createTextNode(Ext.htmlDecode(text)));
+ tspan.setAttribute("x", x);
+ el.appendChild(tspan);
+ tspans[i] = tspan;
+ }
+ }
+ return tspans;
+ },
- this.addEvents(
-
- 'bodyresize',
-
- 'titlechange',
-
- 'iconchange',
-
- 'collapse',
-
- 'expand',
-
- 'beforecollapse',
-
- 'beforeexpand',
-
- 'beforeclose',
-
- 'close',
-
- 'activate',
-
- 'deactivate'
- );
+ renderAll: function() {
+ this.items.each(this.renderItem, this);
+ },
- if(this.unstyled){
- this.baseCls = 'x-plain';
+ renderItem: function (sprite) {
+ if (!this.el) {
+ return;
+ }
+ if (!sprite.el) {
+ this.createSpriteElement(sprite);
+ }
+ if (sprite.zIndexDirty) {
+ this.applyZIndex(sprite);
+ }
+ if (sprite.dirty) {
+ this.applyAttrs(sprite);
+ this.applyTransformations(sprite);
}
+ },
+
+ redraw: function(sprite) {
+ sprite.dirty = sprite.zIndexDirty = true;
+ this.renderItem(sprite);
+ },
+
+ applyAttrs: function (sprite) {
+ var me = this,
+ el = sprite.el,
+ group = sprite.group,
+ sattr = sprite.attr,
+ groups, i, ln, attrs, font, key, style, name, rect;
+ if (group) {
+ groups = [].concat(group);
+ ln = groups.length;
+ for (i = 0; i < ln; i++) {
+ group = groups[i];
+ me.getGroup(group).add(sprite);
+ }
+ delete sprite.group;
+ }
+ attrs = me.scrubAttrs(sprite) || {};
- this.toolbars = [];
- if(this.tbar){
- this.elements += ',tbar';
- this.topToolbar = this.createToolbar(this.tbar);
- this.tbar = null;
+ sprite.bbox.plain = 0;
+ sprite.bbox.transform = 0;
+ if (sprite.type == "circle" || sprite.type == "ellipse") {
+ attrs.cx = attrs.cx || attrs.x;
+ attrs.cy = attrs.cy || attrs.y;
+ }
+ else if (sprite.type == "rect") {
+ attrs.rx = attrs.ry = attrs.r;
+ }
+ else if (sprite.type == "path" && attrs.d) {
+ attrs.d = Ext.draw.Draw.pathToAbsolute(attrs.d);
+ }
+ sprite.dirtyPath = false;
+
+ if (attrs['clip-rect']) {
+ me.setClip(sprite, attrs);
+ delete attrs['clip-rect'];
}
- if(this.bbar){
- this.elements += ',bbar';
- this.bottomToolbar = this.createToolbar(this.bbar);
- this.bbar = null;
+ if (sprite.type == 'text' && attrs.font && sprite.dirtyFont) {
+ el.set({ style: "font: " + attrs.font});
+ sprite.dirtyFont = false;
}
-
- if(this.header === true){
- this.elements += ',header';
- this.header = null;
- }else if(this.headerCfg || (this.title && this.header !== false)){
- this.elements += ',header';
+ if (sprite.type == "image") {
+ el.dom.setAttributeNS(me.xlink, "href", attrs.src);
}
+ Ext.applyIf(attrs, me.minDefaults[sprite.type]);
- if(this.footerCfg || this.footer === true){
- this.elements += ',footer';
- this.footer = null;
+ if (sprite.dirtyHidden) {
+ (sattr.hidden) ? me.hidePrim(sprite) : me.showPrim(sprite);
+ sprite.dirtyHidden = false;
}
-
- if(this.buttons){
- this.fbar = this.buttons;
- this.buttons = null;
+ for (key in attrs) {
+ if (attrs.hasOwnProperty(key) && attrs[key] != null) {
+ el.dom.setAttribute(key, String(attrs[key]));
+ }
}
- if(this.fbar){
- this.createFbar(this.fbar);
+ if (sprite.type == 'text') {
+ me.tuneText(sprite, attrs);
+ }
+
+
+ style = sattr.style;
+ if (style) {
+ el.setStyle(style);
}
- if(this.autoLoad){
- this.on('render', this.doAutoLoad, this, {delay:10});
+
+ sprite.dirty = false;
+
+ if (Ext.isSafari3) {
+
+ me.webkitRect.show();
+ setTimeout(function () {
+ me.webkitRect.hide();
+ });
}
},
-
- createFbar : function(fbar){
- var min = this.minButtonWidth;
- this.elements += ',footer';
- this.fbar = this.createToolbar(fbar, {
- buttonAlign: this.buttonAlign,
- toolbarCls: 'x-panel-fbar',
- enableOverflow: false,
- defaults: function(c){
- return {
- minWidth: c.minWidth || min
- };
+ setClip: function(sprite, params) {
+ var me = this,
+ rect = params["clip-rect"],
+ clipEl, clipPath;
+ if (rect) {
+ if (sprite.clip) {
+ sprite.clip.parentNode.parentNode.removeChild(sprite.clip.parentNode);
}
- });
+ clipEl = me.createSvgElement('clipPath');
+ clipPath = me.createSvgElement('rect');
+ clipEl.id = Ext.id(null, 'ext-clip-');
+ clipPath.setAttribute("x", rect.x);
+ clipPath.setAttribute("y", rect.y);
+ clipPath.setAttribute("width", rect.width);
+ clipPath.setAttribute("height", rect.height);
+ clipEl.appendChild(clipPath);
+ me.getDefs().appendChild(clipEl);
+ sprite.el.dom.setAttribute("clip-path", "url(#" + clipEl.id + ")");
+ sprite.clip = clipPath;
+ }
+
+
+
- this.fbar.items.each(function(c){
- c.minWidth = c.minWidth || this.minButtonWidth;
- }, this);
- this.buttons = this.fbar.items.items;
},
- createToolbar: function(tb, options){
- var result;
-
- if(Ext.isArray(tb)){
- tb = {
- items: tb
- };
+ applyZIndex: function(sprite) {
+ var idx = this.normalizeSpriteCollection(sprite),
+ el = sprite.el,
+ prevEl;
+ if (this.el.dom.childNodes[idx + 2] !== el.dom) {
+ if (idx > 0) {
+
+ do {
+ prevEl = this.items.getAt(--idx).el;
+ } while (!prevEl && idx > 0);
+ }
+ el.insertAfter(prevEl || this.bgRect);
}
- result = tb.events ? Ext.apply(tb, options) : this.createComponent(Ext.apply({}, tb, options), 'toolbar');
- this.toolbars.push(result);
- return result;
+ sprite.zIndexDirty = false;
},
-
- createElement : function(name, pnode){
- if(this[name]){
- pnode.appendChild(this[name].dom);
- return;
+ createItem: function (config) {
+ var sprite = Ext.create('Ext.draw.Sprite', config);
+ sprite.surface = this;
+ return sprite;
+ },
+
+ addGradient: function(gradient) {
+ gradient = Ext.draw.Draw.parseGradient(gradient);
+ var ln = gradient.stops.length,
+ vector = gradient.vector,
+ gradientEl,
+ stop,
+ stopEl,
+ i;
+ if (gradient.type == "linear") {
+ gradientEl = this.createSvgElement("linearGradient");
+ gradientEl.setAttribute("x1", vector[0]);
+ gradientEl.setAttribute("y1", vector[1]);
+ gradientEl.setAttribute("x2", vector[2]);
+ gradientEl.setAttribute("y2", vector[3]);
+ }
+ else {
+ gradientEl = this.createSvgElement("radialGradient");
+ gradientEl.setAttribute("cx", gradient.centerX);
+ gradientEl.setAttribute("cy", gradient.centerY);
+ gradientEl.setAttribute("r", gradient.radius);
+ if (Ext.isNumber(gradient.focalX) && Ext.isNumber(gradient.focalY)) {
+ gradientEl.setAttribute("fx", gradient.focalX);
+ gradientEl.setAttribute("fy", gradient.focalY);
+ }
+ }
+ gradientEl.id = gradient.id;
+ this.getDefs().appendChild(gradientEl);
+
+ for (i = 0; i < ln; i++) {
+ stop = gradient.stops[i];
+ stopEl = this.createSvgElement("stop");
+ stopEl.setAttribute("offset", stop.offset + "%");
+ stopEl.setAttribute("stop-color", stop.color);
+ stopEl.setAttribute("stop-opacity",stop.opacity);
+ gradientEl.appendChild(stopEl);
}
+ },
- if(name === 'bwrap' || this.elements.indexOf(name) != -1){
- if(this[name+'Cfg']){
- this[name] = Ext.fly(pnode).createChild(this[name+'Cfg']);
- }else{
- var el = document.createElement('div');
- el.className = this[name+'Cls'];
- this[name] = Ext.get(pnode.appendChild(el));
+
+ hasCls: function(sprite, className) {
+ return className && (' ' + (sprite.el.dom.getAttribute('class') || '') + ' ').indexOf(' ' + className + ' ') != -1;
+ },
+
+ addCls: function(sprite, className) {
+ var el = sprite.el,
+ i,
+ len,
+ v,
+ cls = [],
+ curCls = el.getAttribute('class') || '';
+
+ if (!Ext.isArray(className)) {
+ if (typeof className == 'string' && !this.hasCls(sprite, className)) {
+ el.set({ 'class': curCls + ' ' + className });
+ }
+ }
+ else {
+ for (i = 0, len = className.length; i < len; i++) {
+ v = className[i];
+ if (typeof v == 'string' && (' ' + curCls + ' ').indexOf(' ' + v + ' ') == -1) {
+ cls.push(v);
+ }
}
- if(this[name+'CssClass']){
- this[name].addClass(this[name+'CssClass']);
+ if (cls.length) {
+ el.set({ 'class': ' ' + cls.join(' ') });
}
- if(this[name+'Style']){
- this[name].applyStyles(this[name+'Style']);
+ }
+ },
+
+ removeCls: function(sprite, className) {
+ var me = this,
+ el = sprite.el,
+ curCls = el.getAttribute('class') || '',
+ i, idx, len, cls, elClasses;
+ if (!Ext.isArray(className)){
+ className = [className];
+ }
+ if (curCls) {
+ elClasses = curCls.replace(me.trimRe, ' ').split(me.spacesRe);
+ for (i = 0, len = className.length; i < len; i++) {
+ cls = className[i];
+ if (typeof cls == 'string') {
+ cls = cls.replace(me.trimRe, '');
+ idx = Ext.Array.indexOf(elClasses, cls);
+ if (idx != -1) {
+ elClasses.splice(idx, 1);
+ }
+ }
}
+ el.set({ 'class': elClasses.join(' ') });
}
},
+ destroy: function() {
+ var me = this;
+
+ me.callParent();
+ if (me.el) {
+ me.el.remove();
+ }
+ delete me.el;
+ }
+});
+
+
+Ext.define('Ext.draw.engine.Vml', {
+
- onRender : function(ct, position){
- Ext.Panel.superclass.onRender.call(this, ct, position);
- this.createClasses();
- var el = this.el,
- d = el.dom,
- bw,
- ts;
+ extend: 'Ext.draw.Surface',
+ requires: ['Ext.draw.Draw', 'Ext.draw.Color', 'Ext.draw.Sprite', 'Ext.draw.Matrix', 'Ext.core.Element'],
- if(this.collapsible && !this.hideCollapseTool){
- this.tools = this.tools ? this.tools.slice(0) : [];
- this.tools[this.collapseFirst?'unshift':'push']({
- id: 'toggle',
- handler : this.toggleCollapse,
- scope: this
+
+
+ engine: 'Vml',
+
+ map: {M: "m", L: "l", C: "c", Z: "x", m: "t", l: "r", c: "v", z: "x"},
+ bitesRe: /([clmz]),?([^clmz]*)/gi,
+ valRe: /-?[^,\s-]+/g,
+ fillUrlRe: /^url\(\s*['"]?([^\)]+?)['"]?\s*\)$/i,
+ pathlike: /^(path|rect)$/,
+ NonVmlPathRe: /[ahqstv]/ig, // Non-VML Pathing ops
+ partialPathRe: /[clmz]/g,
+ fontFamilyRe: /^['"]+|['"]+$/g,
+ baseVmlCls: Ext.baseCSSPrefix + 'vml-base',
+ vmlGroupCls: Ext.baseCSSPrefix + 'vml-group',
+ spriteCls: Ext.baseCSSPrefix + 'vml-sprite',
+ measureSpanCls: Ext.baseCSSPrefix + 'vml-measure-span',
+ zoom: 21600,
+ coordsize: 1000,
+ coordorigin: '0 0',
+
+ // @private
+ // Convert an SVG standard path into a VML path
+ path2vml: function (path) {
+ var me = this,
+ nonVML = me.NonVmlPathRe,
+ map = me.map,
+ val = me.valRe,
+ zoom = me.zoom,
+ bites = me.bitesRe,
+ command = Ext.Function.bind(Ext.draw.Draw.pathToAbsolute, Ext.draw.Draw),
+ res, pa, p, r, i, ii, j, jj;
+ if (String(path).match(nonVML)) {
+ command = Ext.Function.bind(Ext.draw.Draw.path2curve, Ext.draw.Draw);
+ } else if (!String(path).match(me.partialPathRe)) {
+ res = String(path).replace(bites, function (all, command, args) {
+ var vals = [],
+ isMove = command.toLowerCase() == "m",
+ res = map[command];
+ args.replace(val, function (value) {
+ if (isMove && vals[length] == 2) {
+ res += vals + map[command == "m" ? "l" : "L"];
+ vals = [];
+ }
+ vals.push(Math.round(value * zoom));
+ });
+ return res + vals;
});
+ return res;
+ }
+ pa = command(path);
+ res = [];
+ for (i = 0, ii = pa.length; i < ii; i++) {
+ p = pa[i];
+ r = pa[i][0].toLowerCase();
+ if (r == "z") {
+ r = "x";
+ }
+ for (j = 1, jj = p.length; j < jj; j++) {
+ r += Math.round(p[j] * me.zoom) + (j != jj - 1 ? "," : "");
+ }
+ res.push(r);
+ }
+ return res.join(" ");
+ },
+
+ // @private - set of attributes which need to be translated from the sprite API to the native browser API
+ translateAttrs: {
+ radius: "r",
+ radiusX: "rx",
+ radiusY: "ry",
+ lineWidth: "stroke-width",
+ fillOpacity: "fill-opacity",
+ strokeOpacity: "stroke-opacity",
+ strokeLinejoin: "stroke-linejoin"
+ },
+
+ // @private - Minimun set of defaults for different types of sprites.
+ minDefaults: {
+ circle: {
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ ellipse: {
+ cx: 0,
+ cy: 0,
+ rx: 0,
+ ry: 0,
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ rect: {
+ x: 0,
+ y: 0,
+ width: 0,
+ height: 0,
+ rx: 0,
+ ry: 0,
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ text: {
+ x: 0,
+ y: 0,
+ "text-anchor": "start",
+ font: '10px "Arial"',
+ fill: "#000",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ path: {
+ d: "M0,0",
+ fill: "none",
+ stroke: null,
+ "stroke-width": null,
+ opacity: null,
+ "fill-opacity": null,
+ "stroke-opacity": null
+ },
+ image: {
+ x: 0,
+ y: 0,
+ width: 0,
+ height: 0,
+ preserveAspectRatio: "none",
+ opacity: null
}
+ },
- if(this.tools){
- ts = this.tools;
- this.elements += (this.header !== false) ? ',header' : '';
- }
- this.tools = {};
+ // private
+ onMouseEnter: function(e) {
+ this.fireEvent("mouseenter", e);
+ },
- el.addClass(this.baseCls);
- if(d.firstChild){
- this.header = el.down('.'+this.headerCls);
- this.bwrap = el.down('.'+this.bwrapCls);
- var cp = this.bwrap ? this.bwrap : el;
- this.tbar = cp.down('.'+this.tbarCls);
- this.body = cp.down('.'+this.bodyCls);
- this.bbar = cp.down('.'+this.bbarCls);
- this.footer = cp.down('.'+this.footerCls);
- this.fromMarkup = true;
- }
- if (this.preventBodyReset === true) {
- el.addClass('x-panel-reset');
- }
- if(this.cls){
- el.addClass(this.cls);
- }
+ // private
+ onMouseLeave: function(e) {
+ this.fireEvent("mouseleave", e);
+ },
- if(this.buttons){
- this.elements += ',footer';
+ // @private - Normalize a delegated single event from the main container to each sprite and sprite group
+ processEvent: function(name, e) {
+ var target = e.getTarget(),
+ surface = this.surface,
+ sprite;
+ this.fireEvent(name, e);
+ sprite = this.items.get(target.id);
+ if (sprite) {
+ sprite.fireEvent(name, sprite, e);
}
+ },
-
-
-
- if(this.frame){
- el.insertHtml('afterBegin', String.format(Ext.Element.boxMarkup, this.baseCls));
+ // Create the VML element/elements and append them to the DOM
+ createSpriteElement: function(sprite) {
+ var me = this,
+ attr = sprite.attr,
+ type = sprite.type,
+ zoom = me.zoom,
+ vml = sprite.vml || (sprite.vml = {}),
+ round = Math.round,
+ el = (type === 'image') ? me.createNode('image') : me.createNode('shape'),
+ path, skew, textPath;
+
+ el.coordsize = zoom + ' ' + zoom;
+ el.coordorigin = attr.coordorigin || "0 0";
+ Ext.get(el).addCls(me.spriteCls);
+ if (type == "text") {
+ vml.path = path = me.createNode("path");
+ path.textpathok = true;
+ vml.textpath = textPath = me.createNode("textpath");
+ textPath.on = true;
+ el.appendChild(textPath);
+ el.appendChild(path);
+ }
+ el.id = sprite.id;
+ sprite.el = Ext.get(el);
+ me.el.appendChild(el);
+ if (type !== 'image') {
+ skew = me.createNode("skew");
+ skew.on = true;
+ el.appendChild(skew);
+ sprite.skew = skew;
+ }
+ sprite.matrix = Ext.create('Ext.draw.Matrix');
+ sprite.bbox = {
+ plain: null,
+ transform: null
+ };
+ sprite.fireEvent("render", sprite);
+ return sprite.el;
+ },
- this.createElement('header', d.firstChild.firstChild.firstChild);
- this.createElement('bwrap', d);
+ // @private - Get bounding box for the sprite. The Sprite itself has the public method.
+ getBBox: function (sprite, isWithoutTransform) {
+ var realPath = this["getPath" + sprite.type](sprite);
+ if (isWithoutTransform) {
+ sprite.bbox.plain = sprite.bbox.plain || Ext.draw.Draw.pathDimensions(realPath);
+ return sprite.bbox.plain;
+ }
+ sprite.bbox.transform = sprite.bbox.transform || Ext.draw.Draw.pathDimensions(Ext.draw.Draw.mapPath(realPath, sprite.matrix));
+ return sprite.bbox.transform;
+ },
-
- bw = this.bwrap.dom;
- var ml = d.childNodes[1], bl = d.childNodes[2];
- bw.appendChild(ml);
- bw.appendChild(bl);
+ getBBoxText: function (sprite) {
+ var vml = sprite.vml;
+ return {
+ x: vml.X + (vml.bbx || 0) - vml.W / 2,
+ y: vml.Y - vml.H / 2,
+ width: vml.W,
+ height: vml.H
+ };
+ },
- var mc = bw.firstChild.firstChild.firstChild;
- this.createElement('tbar', mc);
- this.createElement('body', mc);
- this.createElement('bbar', mc);
- this.createElement('footer', bw.lastChild.firstChild.firstChild);
+ applyAttrs: function (sprite) {
+ var me = this,
+ vml = sprite.vml,
+ group = sprite.group,
+ spriteAttr = sprite.attr,
+ el = sprite.el,
+ dom = el.dom,
+ style, name, groups, i, ln, scrubbedAttrs, font, key, bbox;
- if(!this.footer){
- this.bwrap.dom.lastChild.className += ' x-panel-nofooter';
+ if (group) {
+ groups = [].concat(group);
+ ln = groups.length;
+ for (i = 0; i < ln; i++) {
+ group = groups[i];
+ me.getGroup(group).add(sprite);
}
-
- this.ft = Ext.get(this.bwrap.dom.lastChild);
- this.mc = Ext.get(mc);
- }else{
- this.createElement('header', d);
- this.createElement('bwrap', d);
+ delete sprite.group;
+ }
+ scrubbedAttrs = me.scrubAttrs(sprite) || {};
-
- bw = this.bwrap.dom;
- this.createElement('tbar', bw);
- this.createElement('body', bw);
- this.createElement('bbar', bw);
- this.createElement('footer', bw);
+ if (sprite.zIndexDirty) {
+ me.setZIndex(sprite);
+ }
- if(!this.header){
- this.body.addClass(this.bodyCls + '-noheader');
- if(this.tbar){
- this.tbar.addClass(this.tbarCls + '-noheader');
- }
- }
+ // Apply minimum default attributes
+ Ext.applyIf(scrubbedAttrs, me.minDefaults[sprite.type]);
+
+ if (sprite.type == 'image') {
+ Ext.apply(sprite.attr, {
+ x: scrubbedAttrs.x,
+ y: scrubbedAttrs.y,
+ width: scrubbedAttrs.width,
+ height: scrubbedAttrs.height
+ });
+ bbox = sprite.getBBox();
+ el.setStyle({
+ width: bbox.width + 'px',
+ height: bbox.height + 'px'
+ });
+ dom.src = scrubbedAttrs.src;
}
- if(Ext.isDefined(this.padding)){
- this.body.setStyle('padding', this.body.addUnits(this.padding));
+ if (dom.href) {
+ dom.href = scrubbedAttrs.href;
+ }
+ if (dom.title) {
+ dom.title = scrubbedAttrs.title;
+ }
+ if (dom.target) {
+ dom.target = scrubbedAttrs.target;
+ }
+ if (dom.cursor) {
+ dom.cursor = scrubbedAttrs.cursor;
}
- if(this.border === false){
- this.el.addClass(this.baseCls + '-noborder');
- this.body.addClass(this.bodyCls + '-noborder');
- if(this.header){
- this.header.addClass(this.headerCls + '-noborder');
- }
- if(this.footer){
- this.footer.addClass(this.footerCls + '-noborder');
- }
- if(this.tbar){
- this.tbar.addClass(this.tbarCls + '-noborder');
+ // Change visibility
+ if (sprite.dirtyHidden) {
+ (scrubbedAttrs.hidden) ? me.hidePrim(sprite) : me.showPrim(sprite);
+ sprite.dirtyHidden = false;
+ }
+
+ // Update path
+ if (sprite.dirtyPath) {
+ if (sprite.type == "circle" || sprite.type == "ellipse") {
+ var cx = scrubbedAttrs.x,
+ cy = scrubbedAttrs.y,
+ rx = scrubbedAttrs.rx || scrubbedAttrs.r || 0,
+ ry = scrubbedAttrs.ry || scrubbedAttrs.r || 0;
+ dom.path = Ext.String.format("ar{0},{1},{2},{3},{4},{1},{4},{1}",
+ Math.round((cx - rx) * me.zoom),
+ Math.round((cy - ry) * me.zoom),
+ Math.round((cx + rx) * me.zoom),
+ Math.round((cy + ry) * me.zoom),
+ Math.round(cx * me.zoom));
+ sprite.dirtyPath = false;
}
- if(this.bbar){
- this.bbar.addClass(this.bbarCls + '-noborder');
+ else if (sprite.type !== "text" && sprite.type !== 'image') {
+ sprite.attr.path = scrubbedAttrs.path = me.setPaths(sprite, scrubbedAttrs) || scrubbedAttrs.path;
+ dom.path = me.path2vml(scrubbedAttrs.path);
+ sprite.dirtyPath = false;
}
}
- if(this.bodyBorder === false){
- this.body.addClass(this.bodyCls + '-noborder');
+ // Apply clipping
+ if ("clip-rect" in scrubbedAttrs) {
+ me.setClip(sprite, scrubbedAttrs);
}
- this.bwrap.enableDisplayMode('block');
+ // Handle text (special handling required)
+ if (sprite.type == "text") {
+ me.setTextAttributes(sprite, scrubbedAttrs);
+ }
- if(this.header){
- this.header.unselectable();
+ // Handle fill and opacity
+ if (scrubbedAttrs.opacity || scrubbedAttrs['stroke-opacity'] || scrubbedAttrs.fill) {
+ me.setFill(sprite, scrubbedAttrs);
+ }
-
- if(this.headerAsText){
- this.header.dom.innerHTML =
- ''+this.header.dom.innerHTML+'';
+ // Handle stroke (all fills require a stroke element)
+ if (scrubbedAttrs.stroke || scrubbedAttrs['stroke-opacity'] || scrubbedAttrs.fill) {
+ me.setStroke(sprite, scrubbedAttrs);
+ }
+
+ //set styles
+ style = spriteAttr.style;
+ if (style) {
+ el.setStyle(style);
+ }
- if(this.iconCls){
- this.setIconClass(this.iconCls);
- }
+ sprite.dirty = false;
+ },
+
+ setZIndex: function(sprite) {
+ if (sprite.el) {
+ if (sprite.attr.zIndex != undefined) {
+ sprite.el.setStyle('zIndex', sprite.attr.zIndex);
}
+ sprite.zIndexDirty = false;
}
+ },
- if(this.floating){
- this.makeFloating(this.floating);
+ // Normalize all virtualized types into paths.
+ setPaths: function(sprite, params) {
+ var spriteAttr = sprite.attr;
+ // Clear bbox cache
+ sprite.bbox.plain = null;
+ sprite.bbox.transform = null;
+ if (sprite.type == 'circle') {
+ spriteAttr.rx = spriteAttr.ry = params.r;
+ return Ext.draw.Draw.ellipsePath(sprite);
}
-
- if(this.collapsible && this.titleCollapse && this.header){
- this.mon(this.header, 'click', this.toggleCollapse, this);
- this.header.setStyle('cursor', 'pointer');
+ else if (sprite.type == 'ellipse') {
+ spriteAttr.rx = params.rx;
+ spriteAttr.ry = params.ry;
+ return Ext.draw.Draw.ellipsePath(sprite);
}
- if(ts){
- this.addTool.apply(this, ts);
+ else if (sprite.type == 'rect') {
+ spriteAttr.rx = spriteAttr.ry = params.r;
+ return Ext.draw.Draw.rectPath(sprite);
}
+ else if (sprite.type == 'path' && spriteAttr.path) {
+ return Ext.draw.Draw.pathToAbsolute(spriteAttr.path);
+ }
+ return false;
+ },
-
- if(this.fbar){
- this.footer.addClass('x-panel-btns');
- this.fbar.ownerCt = this;
- this.fbar.render(this.footer);
- this.footer.createChild({cls:'x-clear'});
+ setFill: function(sprite, params) {
+ var me = this,
+ el = sprite.el.dom,
+ fillEl = el.fill,
+ newfill = false,
+ opacity, gradient, fillUrl, rotation, angle;
+
+ if (!fillEl) {
+ // NOT an expando (but it sure looks like one)...
+ fillEl = el.fill = me.createNode("fill");
+ newfill = true;
+ }
+ if (Ext.isArray(params.fill)) {
+ params.fill = params.fill[0];
+ }
+ if (params.fill == "none") {
+ fillEl.on = false;
}
- if(this.tbar && this.topToolbar){
- this.topToolbar.ownerCt = this;
- this.topToolbar.render(this.tbar);
+ else {
+ if (typeof params.opacity == "number") {
+ fillEl.opacity = params.opacity;
+ }
+ if (typeof params["fill-opacity"] == "number") {
+ fillEl.opacity = params["fill-opacity"];
+ }
+ fillEl.on = true;
+ if (typeof params.fill == "string") {
+ fillUrl = params.fill.match(me.fillUrlRe);
+ if (fillUrl) {
+ fillUrl = fillUrl[1];
+ // If the URL matches one of the registered gradients, render that gradient
+ if (fillUrl.charAt(0) == "#") {
+ gradient = me.gradientsColl.getByKey(fillUrl.substring(1));
+ }
+ if (gradient) {
+ // VML angle is offset and inverted from standard, and must be adjusted to match rotation transform
+ rotation = params.rotation;
+ angle = -(gradient.angle + 270 + (rotation ? rotation.degrees : 0)) % 360;
+ // IE will flip the angle at 0 degrees...
+ if (angle === 0) {
+ angle = 180;
+ }
+ fillEl.angle = angle;
+ fillEl.type = "gradient";
+ fillEl.method = "sigma";
+ fillEl.colors.value = gradient.colors;
+ }
+ // Otherwise treat it as an image
+ else {
+ fillEl.src = fillUrl;
+ fillEl.type = "tile";
+ }
+ }
+ else {
+ fillEl.color = Ext.draw.Color.toHex(params.fill);
+ fillEl.src = "";
+ fillEl.type = "solid";
+ }
+ }
}
- if(this.bbar && this.bottomToolbar){
- this.bottomToolbar.ownerCt = this;
- this.bottomToolbar.render(this.bbar);
+ if (newfill) {
+ el.appendChild(fillEl);
}
},
-
- setIconClass : function(cls){
- var old = this.iconCls;
- this.iconCls = cls;
- if(this.rendered && this.header){
- if(this.frame){
- this.header.addClass('x-panel-icon');
- this.header.replaceClass(old, this.iconCls);
- }else{
- var hd = this.header,
- img = hd.child('img.x-panel-inline-icon');
- if(img){
- Ext.fly(img).replaceClass(old, this.iconCls);
- }else{
- var hdspan = hd.child('span.' + this.headerTextCls);
- if (hdspan) {
- Ext.DomHelper.insertBefore(hdspan.dom, {
- tag:'img', alt: '', src: Ext.BLANK_IMAGE_URL, cls:'x-panel-inline-icon '+this.iconCls
- });
- }
- }
+ setStroke: function(sprite, params) {
+ var me = this,
+ el = sprite.el.dom,
+ strokeEl = sprite.strokeEl,
+ newStroke = false,
+ width, opacity;
+
+ if (!strokeEl) {
+ strokeEl = sprite.strokeEl = me.createNode("stroke");
+ newStroke = true;
+ }
+ if (Ext.isArray(params.stroke)) {
+ params.stroke = params.stroke[0];
+ }
+ if (!params.stroke || params.stroke == "none" || params.stroke == 0 || params["stroke-width"] == 0) {
+ strokeEl.on = false;
+ }
+ else {
+ strokeEl.on = true;
+ if (params.stroke && !params.stroke.match(me.fillUrlRe)) {
+ // VML does NOT support a gradient stroke :(
+ strokeEl.color = Ext.draw.Color.toHex(params.stroke);
+ }
+ strokeEl.joinstyle = params["stroke-linejoin"];
+ strokeEl.endcap = params["stroke-linecap"] || "round";
+ strokeEl.miterlimit = params["stroke-miterlimit"] || 8;
+ width = parseFloat(params["stroke-width"] || 1) * 0.75;
+ opacity = params["stroke-opacity"] || 1;
+ // VML Does not support stroke widths under 1, so we're going to fiddle with stroke-opacity instead.
+ if (Ext.isNumber(width) && width < 1) {
+ strokeEl.weight = 1;
+ strokeEl.opacity = opacity * width;
+ }
+ else {
+ strokeEl.weight = width;
+ strokeEl.opacity = opacity;
}
}
- this.fireEvent('iconchange', this, cls, old);
+ if (newStroke) {
+ el.appendChild(strokeEl);
+ }
},
-
- makeFloating : function(cfg){
- this.floating = true;
- this.el = new Ext.Layer(Ext.apply({}, cfg, {
- shadow: Ext.isDefined(this.shadow) ? this.shadow : 'sides',
- shadowOffset: this.shadowOffset,
- constrain:false,
- shim: this.shim === false ? false : undefined
- }), this.el);
+ setClip: function(sprite, params) {
+ var me = this,
+ el = sprite.el,
+ clipEl = sprite.clipEl,
+ rect = String(params["clip-rect"]).split(me.separatorRe);
+ if (!clipEl) {
+ clipEl = sprite.clipEl = me.el.insertFirst(Ext.getDoc().dom.createElement("div"));
+ clipEl.addCls(Ext.baseCSSPrefix + 'vml-sprite');
+ }
+ if (rect.length == 4) {
+ rect[2] = +rect[2] + (+rect[0]);
+ rect[3] = +rect[3] + (+rect[1]);
+ clipEl.setStyle("clip", Ext.String.format("rect({1}px {2}px {3}px {0}px)", rect[0], rect[1], rect[2], rect[3]));
+ clipEl.setSize(me.el.width, me.el.height);
+ }
+ else {
+ clipEl.setStyle("clip", "");
+ }
},
+ setTextAttributes: function(sprite, params) {
+ var me = this,
+ vml = sprite.vml,
+ textStyle = vml.textpath.style,
+ spanCacheStyle = me.span.style,
+ zoom = me.zoom,
+ round = Math.round,
+ fontObj = {
+ fontSize: "font-size",
+ fontWeight: "font-weight",
+ fontStyle: "font-style"
+ },
+ fontProp,
+ paramProp;
+ if (sprite.dirtyFont) {
+ if (params.font) {
+ textStyle.font = spanCacheStyle.font = params.font;
+ }
+ if (params["font-family"]) {
+ textStyle.fontFamily = '"' + params["font-family"].split(",")[0].replace(me.fontFamilyRe, "") + '"';
+ spanCacheStyle.fontFamily = params["font-family"];
+ }
+
+ for (fontProp in fontObj) {
+ paramProp = params[fontObj[fontProp]];
+ if (paramProp) {
+ textStyle[fontProp] = spanCacheStyle[fontProp] = paramProp;
+ }
+ }
+
+ me.setText(sprite, params.text);
+
+ if (vml.textpath.string) {
+ me.span.innerHTML = String(vml.textpath.string).replace(/");
+ }
+ vml.W = me.span.offsetWidth;
+ vml.H = me.span.offsetHeight + 2;
+
+
+ if (params["text-anchor"] == "middle") {
+ textStyle["v-text-align"] = "center";
+ }
+ else if (params["text-anchor"] == "end") {
+ textStyle["v-text-align"] = "right";
+ vml.bbx = -Math.round(vml.W / 2);
+ }
+ else {
+ textStyle["v-text-align"] = "left";
+ vml.bbx = Math.round(vml.W / 2);
+ }
+ }
+ vml.X = params.x;
+ vml.Y = params.y;
+ vml.path.v = Ext.String.format("m{0},{1}l{2},{1}", Math.round(vml.X * zoom), Math.round(vml.Y * zoom), Math.round(vml.X * zoom) + 1);
+
+ sprite.bbox.plain = null;
+ sprite.bbox.transform = null;
+ sprite.dirtyFont = false;
+ },
- getTopToolbar : function(){
- return this.topToolbar;
+ setText: function(sprite, text) {
+ sprite.vml.textpath.string = Ext.htmlDecode(text);
},
-
- getBottomToolbar : function(){
- return this.bottomToolbar;
+ hide: function() {
+ this.el.hide();
},
-
- getFooterToolbar : function() {
- return this.fbar;
+ show: function() {
+ this.el.show();
},
-
- addButton : function(config, handler, scope){
- if(!this.fbar){
- this.createFbar([]);
- }
- if(handler){
- if(Ext.isString(config)){
- config = {text: config};
- }
- config = Ext.apply({
- handler: handler,
- scope: scope
- }, config);
- }
- return this.fbar.add(config);
+ hidePrim: function(sprite) {
+ sprite.el.addCls(Ext.baseCSSPrefix + 'hide-visibility');
},
-
- addTool : function(){
- if(!this.rendered){
- if(!this.tools){
- this.tools = [];
- }
- Ext.each(arguments, function(arg){
- this.tools.push(arg);
- }, this);
+ showPrim: function(sprite) {
+ sprite.el.removeCls(Ext.baseCSSPrefix + 'hide-visibility');
+ },
+
+ setSize: function(width, height) {
+ var me = this,
+ viewBox = me.viewBox,
+ scaleX, scaleY, items, i, len;
+ width = width || me.width;
+ height = height || me.height;
+ me.width = width;
+ me.height = height;
+
+ if (!me.el) {
return;
}
-
- if(!this[this.toolTarget]){
- return;
+
+
+ if (width != undefined) {
+ me.el.setWidth(width);
+ }
+ if (height != undefined) {
+ me.el.setHeight(height);
}
- if(!this.toolTemplate){
+
+
+ if (viewBox && (width || height)) {
+ var viewBoxX = viewBox.x,
+ viewBoxY = viewBox.y,
+ viewBoxWidth = viewBox.width,
+ viewBoxHeight = viewBox.height,
+ relativeHeight = height / viewBoxHeight,
+ relativeWidth = width / viewBoxWidth,
+ size;
+ if (viewBoxWidth * relativeHeight < width) {
+ viewBoxX -= (width - viewBoxWidth * relativeHeight) / 2 / relativeHeight;
+ }
+ if (viewBoxHeight * relativeWidth < height) {
+ viewBoxY -= (height - viewBoxHeight * relativeWidth) / 2 / relativeWidth;
+ }
+ size = 1 / Math.max(viewBoxWidth / width, viewBoxHeight / height);
- var tt = new Ext.Template(
- ' '
- );
- tt.disableFormats = true;
- tt.compile();
- Ext.Panel.prototype.toolTemplate = tt;
- }
- for(var i = 0, a = arguments, len = a.length; i < len; i++) {
- var tc = a[i];
- if(!this.tools[tc.id]){
- var overCls = 'x-tool-'+tc.id+'-over';
- var t = this.toolTemplate.insertFirst(this[this.toolTarget], tc, true);
- this.tools[tc.id] = t;
- t.enableDisplayMode('block');
- this.mon(t, 'click', this.createToolHandler(t, tc, overCls, this));
- if(tc.on){
- this.mon(t, tc.on);
- }
- if(tc.hidden){
- t.hide();
- }
- if(tc.qtip){
- if(Ext.isObject(tc.qtip)){
- Ext.QuickTips.register(Ext.apply({
- target: t.id
- }, tc.qtip));
- } else {
- t.dom.qtip = tc.qtip;
- }
- }
- t.addClassOnOver(overCls);
+ me.viewBoxShift = {
+ dx: -viewBoxX,
+ dy: -viewBoxY,
+ scale: size
+ };
+ items = me.items.items;
+ for (i = 0, len = items.length; i < len; i++) {
+ me.transform(items[i]);
}
}
+ this.callParent(arguments);
},
- onLayout : function(shallow, force){
- Ext.Panel.superclass.onLayout.apply(this, arguments);
- if(this.hasLayout && this.toolbars.length > 0){
- Ext.each(this.toolbars, function(tb){
- tb.doLayout(undefined, force);
- });
- this.syncHeight();
- }
+ setViewBox: function(x, y, width, height) {
+ this.callParent(arguments);
+ this.viewBox = {
+ x: x,
+ y: y,
+ width: width,
+ height: height
+ };
},
- syncHeight : function(){
- var h = this.toolbarHeight,
- bd = this.body,
- lsh = this.lastSize.height,
- sz;
-
- if(this.autoHeight || !Ext.isDefined(lsh) || lsh == 'auto'){
- return;
+ onAdd: function(item) {
+ this.callParent(arguments);
+ if (this.el) {
+ this.renderItem(item);
}
+ },
-
- if(h != this.getToolbarHeight()){
- h = Math.max(0, lsh - this.getFrameHeight());
- bd.setHeight(h);
- sz = bd.getSize();
- this.toolbarHeight = this.getToolbarHeight();
- this.onBodyResize(sz.width, sz.height);
+ onRemove: function(sprite) {
+ if (sprite.el) {
+ sprite.el.remove();
+ delete sprite.el;
}
+ this.callParent(arguments);
},
-
- onShow : function(){
- if(this.floating){
- return this.el.show();
+ render: function (container) {
+ var me = this,
+ doc = Ext.getDoc().dom;
+
+ if (!me.createNode) {
+ try {
+ if (!doc.namespaces.rvml) {
+ doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml");
+ }
+ me.createNode = function (tagName) {
+ return doc.createElement("');
+ };
+ } catch (e) {
+ me.createNode = function (tagName) {
+ return doc.createElement("<" + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
+ };
+ }
}
- Ext.Panel.superclass.onShow.call(this);
- },
-
- onHide : function(){
- if(this.floating){
- return this.el.hide();
+ if (!me.el) {
+ var el = doc.createElement("div");
+ me.el = Ext.get(el);
+ me.el.addCls(me.baseVmlCls);
+
+
+ me.span = doc.createElement("span");
+ Ext.get(me.span).addCls(me.measureSpanCls);
+ el.appendChild(me.span);
+ me.el.setSize(me.width || 10, me.height || 10);
+ container.appendChild(el);
+ me.el.on({
+ scope: me,
+ mouseup: me.onMouseUp,
+ mousedown: me.onMouseDown,
+ mouseover: me.onMouseOver,
+ mouseout: me.onMouseOut,
+ mousemove: me.onMouseMove,
+ mouseenter: me.onMouseEnter,
+ mouseleave: me.onMouseLeave,
+ click: me.onClick
+ });
}
- Ext.Panel.superclass.onHide.call(this);
+ me.renderAll();
},
-
- createToolHandler : function(t, tc, overCls, panel){
- return function(e){
- t.removeClass(overCls);
- if(tc.stopEvent !== false){
- e.stopEvent();
- }
- if(tc.handler){
- tc.handler.call(tc.scope || t, e, t, panel, tc);
- }
- };
+ renderAll: function() {
+ this.items.each(this.renderItem, this);
},
-
- afterRender : function(){
- if(this.floating && !this.hidden){
- this.el.show();
+ redraw: function(sprite) {
+ sprite.dirty = true;
+ this.renderItem(sprite);
+ },
+
+ renderItem: function (sprite) {
+
+ if (!this.el) {
+ return;
}
- if(this.title){
- this.setTitle(this.title);
+
+
+ if (!sprite.el) {
+ this.createSpriteElement(sprite);
}
- Ext.Panel.superclass.afterRender.call(this);
- if (this.collapsed) {
- this.collapsed = false;
- this.collapse(false);
+
+ if (sprite.dirty) {
+ this.applyAttrs(sprite);
+ if (sprite.dirtyTransform) {
+ this.applyTransformations(sprite);
+ }
}
- this.initEvents();
},
-
- getKeyMap : function(){
- if(!this.keyMap){
- this.keyMap = new Ext.KeyMap(this.el, this.keys);
- }
- return this.keyMap;
+ rotationCompensation: function (deg, dx, dy) {
+ var matrix = Ext.create('Ext.draw.Matrix');
+ matrix.rotate(-deg, 0.5, 0.5);
+ return {
+ x: matrix.x(dx, dy),
+ y: matrix.y(dx, dy)
+ };
},
-
- initEvents : function(){
- if(this.keys){
- this.getKeyMap();
- }
- if(this.draggable){
- this.initDraggable();
- }
- if(this.toolbars.length > 0){
- Ext.each(this.toolbars, function(tb){
- tb.doLayout();
- tb.on({
- scope: this,
- afterlayout: this.syncHeight,
- remove: this.syncHeight
- });
- }, this);
- this.syncHeight();
+ transform: function(sprite) {
+ var me = this,
+ matrix = Ext.create('Ext.draw.Matrix'),
+ transforms = sprite.transformations,
+ transformsLength = transforms.length,
+ i = 0,
+ deltaDegrees = 0,
+ deltaScaleX = 1,
+ deltaScaleY = 1,
+ flip = "",
+ el = sprite.el,
+ dom = el.dom,
+ domStyle = dom.style,
+ zoom = me.zoom,
+ skew = sprite.skew,
+ deltaX, deltaY, transform, type, compensate, y, fill, newAngle,zoomScaleX, zoomScaleY, newOrigin;
+
+ for (; i < transformsLength; i++) {
+ transform = transforms[i];
+ type = transform.type;
+ if (type == "translate") {
+ matrix.translate(transform.x, transform.y);
+ }
+ else if (type == "rotate") {
+ matrix.rotate(transform.degrees, transform.x, transform.y);
+ deltaDegrees += transform.degrees;
+ }
+ else if (type == "scale") {
+ matrix.scale(transform.x, transform.y, transform.centerX, transform.centerY);
+ deltaScaleX *= transform.x;
+ deltaScaleY *= transform.y;
+ }
}
- },
+ if (me.viewBoxShift) {
+ matrix.scale(me.viewBoxShift.scale, me.viewBoxShift.scale, -1, -1);
+ matrix.add(1, 0, 0, 1, me.viewBoxShift.dx, me.viewBoxShift.dy);
+ }
+
+ sprite.matrix = matrix;
+
-
- initDraggable : function(){
- this.dd = new Ext.Panel.DD(this, Ext.isBoolean(this.draggable) ? null : this.draggable);
- },
-
- beforeEffect : function(anim){
- if(this.floating){
- this.el.beforeAction();
+ if (sprite.type != "image" && skew) {
+
+ skew.matrix = matrix.toString();
+ skew.offset = matrix.offset();
}
- if(anim !== false){
- this.el.addClass('x-panel-animated');
+ else {
+ deltaX = matrix.matrix[0][2];
+ deltaY = matrix.matrix[1][2];
+
+ zoomScaleX = zoom / deltaScaleX;
+ zoomScaleY = zoom / deltaScaleY;
+
+ dom.coordsize = Math.abs(zoomScaleX) + " " + Math.abs(zoomScaleY);
+
+
+ newAngle = deltaDegrees * (deltaScaleX * ((deltaScaleY < 0) ? -1 : 1));
+ if (newAngle != domStyle.rotation && !(newAngle === 0 && !domStyle.rotation)) {
+ domStyle.rotation = newAngle;
+ }
+ if (deltaDegrees) {
+
+ compensate = me.rotationCompensation(deltaDegrees, deltaX, deltaY);
+ deltaX = compensate.x;
+ deltaY = compensate.y;
+ }
+
+
+ if (deltaScaleX < 0) {
+ flip += "x";
+ }
+ if (deltaScaleY < 0) {
+ flip += " y";
+ y = -1;
+ }
+ if (flip != "" && !dom.style.flip) {
+ domStyle.flip = flip;
+ }
+
+
+ newOrigin = (deltaX * -zoomScaleX) + " " + (deltaY * -zoomScaleY);
+ if (newOrigin != dom.coordorigin) {
+ dom.coordorigin = (deltaX * -zoomScaleX) + " " + (deltaY * -zoomScaleY);
+ }
}
},
-
- afterEffect : function(anim){
- this.syncShadow();
- this.el.removeClass('x-panel-animated');
+ createItem: function (config) {
+ return Ext.create('Ext.draw.Sprite', config);
},
-
- createEffect : function(a, cb, scope){
- var o = {
- scope:scope,
- block:true
- };
- if(a === true){
- o.callback = cb;
- return o;
- }else if(!a.callback){
- o.callback = cb;
- }else {
- o.callback = function(){
- cb.call(scope);
- Ext.callback(a.callback, a.scope);
- };
- }
- return Ext.applyIf(o, a);
+ getRegion: function() {
+ return this.el.getRegion();
},
-
- collapse : function(animate){
- if(this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforecollapse', this, animate) === false){
- return;
+ addCls: function(sprite, className) {
+ if (sprite && sprite.el) {
+ sprite.el.addCls(className);
}
- var doAnim = animate === true || (animate !== false && this.animCollapse);
- this.beforeEffect(doAnim);
- this.onCollapse(doAnim, animate);
- return this;
},
-
- onCollapse : function(doAnim, animArg){
- if(doAnim){
- this[this.collapseEl].slideOut(this.slideAnchor,
- Ext.apply(this.createEffect(animArg||true, this.afterCollapse, this),
- this.collapseDefaults));
- }else{
- this[this.collapseEl].hide(this.hideMode);
- this.afterCollapse(false);
+ removeCls: function(sprite, className) {
+ if (sprite && sprite.el) {
+ sprite.el.removeCls(className);
}
},
- afterCollapse : function(anim){
- this.collapsed = true;
- this.el.addClass(this.collapsedCls);
- if(anim !== false){
- this[this.collapseEl].hide(this.hideMode);
- }
- this.afterEffect(anim);
+ addGradient: function(gradient) {
+ var gradients = this.gradientsColl || (this.gradientsColl = Ext.create('Ext.util.MixedCollection')),
+ colors = [],
+ stops = Ext.create('Ext.util.MixedCollection');
- this.cascade(function(c) {
- if (c.lastSize) {
- c.lastSize = { width: undefined, height: undefined };
- }
+ stops.addAll(gradient.stops);
+ stops.sortByKey("ASC", function(a, b) {
+ a = parseInt(a, 10);
+ b = parseInt(b, 10);
+ return a > b ? 1 : (a < b ? -1 : 0);
+ });
+ stops.eachKey(function(k, v) {
+ colors.push(k + "% " + v.color);
});
- this.fireEvent('collapse', this);
- },
-
- expand : function(animate){
- if(!this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforeexpand', this, animate) === false){
- return;
- }
- var doAnim = animate === true || (animate !== false && this.animCollapse);
- this.el.removeClass(this.collapsedCls);
- this.beforeEffect(doAnim);
- this.onExpand(doAnim, animate);
- return this;
+ gradients.add(gradient.id, {
+ colors: colors.join(","),
+ angle: gradient.angle
+ });
},
-
- onExpand : function(doAnim, animArg){
- if(doAnim){
- this[this.collapseEl].slideIn(this.slideAnchor,
- Ext.apply(this.createEffect(animArg||true, this.afterExpand, this),
- this.expandDefaults));
- }else{
- this[this.collapseEl].show(this.hideMode);
- this.afterExpand(false);
+ destroy: function() {
+ var me = this;
+
+ me.callParent(arguments);
+ if (me.el) {
+ me.el.remove();
}
- },
+ delete me.el;
+ }
+});
-
- afterExpand : function(anim){
- this.collapsed = false;
- if(anim !== false){
- this[this.collapseEl].show(this.hideMode);
- }
- this.afterEffect(anim);
- if (this.deferLayout) {
- delete this.deferLayout;
- this.doLayout(true);
- }
- this.fireEvent('expand', this);
- },
-
- toggleCollapse : function(animate){
- this[this.collapsed ? 'expand' : 'collapse'](animate);
- return this;
- },
+Ext.define('Ext.fx.target.ElementCSS', {
- onDisable : function(){
- if(this.rendered && this.maskDisabled){
- this.el.mask();
- }
- Ext.Panel.superclass.onDisable.call(this);
- },
-
- onEnable : function(){
- if(this.rendered && this.maskDisabled){
- this.el.unmask();
- }
- Ext.Panel.superclass.onEnable.call(this);
- },
+ extend: 'Ext.fx.target.Element',
- onResize : function(adjWidth, adjHeight, rawWidth, rawHeight){
- var w = adjWidth,
- h = adjHeight;
-
- if(Ext.isDefined(w) || Ext.isDefined(h)){
- if(!this.collapsed){
-
-
-
- if(Ext.isNumber(w)){
- this.body.setWidth(w = this.adjustBodyWidth(w - this.getFrameWidth()));
- } else if (w == 'auto') {
- w = this.body.setWidth('auto').dom.offsetWidth;
- } else {
- w = this.body.dom.offsetWidth;
+ setAttr: function(targetData, isFirstFrame) {
+ var cssArr = {
+ attrs: [],
+ duration: [],
+ easing: []
+ },
+ ln = targetData.length,
+ attributes,
+ attrs,
+ attr,
+ easing,
+ duration,
+ o,
+ i,
+ j,
+ ln2;
+ for (i = 0; i < ln; i++) {
+ attrs = targetData[i];
+ duration = attrs.duration;
+ easing = attrs.easing;
+ attrs = attrs.attrs;
+ for (attr in attrs) {
+ if (Ext.Array.indexOf(cssArr.attrs, attr) == -1) {
+ cssArr.attrs.push(attr.replace(/[A-Z]/g, function(v) {
+ return '-' + v.toLowerCase();
+ }));
+ cssArr.duration.push(duration + 'ms');
+ cssArr.easing.push(easing);
}
+ }
+ }
+ attributes = cssArr.attrs.join(',');
+ duration = cssArr.duration.join(',');
+ easing = cssArr.easing.join(', ');
+ for (i = 0; i < ln; i++) {
+ attrs = targetData[i].attrs;
+ for (attr in attrs) {
+ ln2 = attrs[attr].length;
+ for (j = 0; j < ln2; j++) {
+ o = attrs[attr][j];
+ o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionProperty', isFirstFrame ? '' : attributes);
+ o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionDuration', isFirstFrame ? '' : duration);
+ o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionTimingFunction', isFirstFrame ? '' : easing);
+ o[0].setStyle(attr, o[1]);
- if(this.tbar){
- this.tbar.setWidth(w);
- if(this.topToolbar){
- this.topToolbar.setSize(w);
+
+ if (isFirstFrame) {
+ o = o[0].dom.offsetWidth;
}
- }
- if(this.bbar){
- this.bbar.setWidth(w);
- if(this.bottomToolbar){
- this.bottomToolbar.setSize(w);
+ else {
- if (Ext.isIE) {
- this.bbar.setStyle('position', 'static');
- this.bbar.setStyle('position', '');
- }
+ o[0].on(Ext.supports.CSS3TransitionEnd, function() {
+ this.setStyle(Ext.supports.CSS3Prefix + 'TransitionProperty', null);
+ this.setStyle(Ext.supports.CSS3Prefix + 'TransitionDuration', null);
+ this.setStyle(Ext.supports.CSS3Prefix + 'TransitionTimingFunction', null);
+ }, o[0], { single: true });
}
}
- if(this.footer){
- this.footer.setWidth(w);
- if(this.fbar){
- this.fbar.setSize(Ext.isIE ? (w - this.footer.getFrameWidth('lr')) : 'auto');
- }
- }
-
-
- if(Ext.isNumber(h)){
- h = Math.max(0, h - this.getFrameHeight());
-
- this.body.setHeight(h);
- }else if(h == 'auto'){
- this.body.setHeight(h);
- }
-
- if(this.disabled && this.el._mask){
- this.el._mask.setSize(this.el.dom.clientWidth, this.el.getHeight());
- }
- }else{
-
- this.queuedBodySize = {width: w, height: h};
- if(!this.queuedExpand && this.allowQueuedExpand !== false){
- this.queuedExpand = true;
- this.on('expand', function(){
- delete this.queuedExpand;
- this.onResize(this.queuedBodySize.width, this.queuedBodySize.height);
- }, this, {single:true});
- }
}
- this.onBodyResize(w, h);
}
- this.syncShadow();
- Ext.Panel.superclass.onResize.call(this, adjWidth, adjHeight, rawWidth, rawHeight);
+ }
+});
- },
+Ext.define('Ext.fx.target.CompositeElementCSS', {
- onBodyResize: function(w, h){
- this.fireEvent('bodyresize', this, w, h);
- },
+
+ extend: 'Ext.fx.target.CompositeElement',
+
+ requires: ['Ext.fx.target.ElementCSS'],
- getToolbarHeight: function(){
- var h = 0;
- if(this.rendered){
- Ext.each(this.toolbars, function(tb){
- h += tb.getHeight();
- }, this);
- }
- return h;
- },
+ setAttr: function() {
+ return Ext.fx.target.ElementCSS.prototype.setAttr.apply(this, arguments);
+ }
+});
+
+Ext.define('Ext.layout.container.AbstractFit', {
- adjustBodyHeight : function(h){
- return h;
- },
+
+ extend: 'Ext.layout.container.Container',
- adjustBodyWidth : function(w){
- return w;
- },
+
+ itemCls: Ext.baseCSSPrefix + 'fit-item',
+ targetCls: Ext.baseCSSPrefix + 'layout-fit',
+ type: 'fit'
+});
+
+Ext.define('Ext.layout.container.Fit', {
- onPosition : function(){
- this.syncShadow();
- },
+ extend: 'Ext.layout.container.AbstractFit',
+ alias: 'layout.fit',
+ alternateClassName: 'Ext.layout.FitLayout',
+
+
+
- getFrameWidth : function(){
- var w = this.el.getFrameWidth('lr') + this.bwrap.getFrameWidth('lr');
+ onLayout : function() {
+ var me = this;
+ me.callParent();
- if(this.frame){
- var l = this.bwrap.dom.firstChild;
- w += (Ext.fly(l).getFrameWidth('l') + Ext.fly(l.firstChild).getFrameWidth('r'));
- w += this.mc.getFrameWidth('lr');
+ if (me.owner.items.length) {
+ me.setItemBox(me.owner.items.get(0), me.getLayoutTargetSize());
}
- return w;
},
-
- getFrameHeight : function() {
- var h = this.el.getFrameWidth('tb') + this.bwrap.getFrameWidth('tb');
- h += (this.tbar ? this.tbar.getHeight() : 0) +
- (this.bbar ? this.bbar.getHeight() : 0);
+ getTargetBox : function() {
+ return this.getLayoutTargetSize();
+ },
- if(this.frame){
- h += this.el.dom.firstChild.offsetHeight + this.ft.dom.offsetHeight + this.mc.getFrameWidth('tb');
- }else{
- h += (this.header ? this.header.getHeight() : 0) +
- (this.footer ? this.footer.getHeight() : 0);
+ setItemBox : function(item, box) {
+ var me = this;
+ if (item && box.height > 0) {
+ if (me.isManaged('width') === true) {
+ box.width = undefined;
+ }
+ if (me.isManaged('height') === true) {
+ box.height = undefined;
+ }
+ me.setItemSize(item, box.width, box.height);
}
- return h;
- },
+ }
+});
+
+
+Ext.define('Ext.layout.container.AbstractCard', {
- getInnerWidth : function(){
- return this.getSize().width - this.getFrameWidth();
- },
+
+ extend: 'Ext.layout.container.Fit',
- getInnerHeight : function(){
- return this.body.getHeight();
-
- },
+
+ type: 'card',
+
+ sizeAllCards: false,
+
+ hideInactive: true,
- syncShadow : function(){
- if(this.floating){
- this.el.sync(true);
+ deferredRender : false,
+
+ beforeLayout: function() {
+ var me = this;
+ me.activeItem = me.getActiveItem();
+ if (me.activeItem && me.deferredRender) {
+ me.renderItems([me.activeItem], me.getRenderTarget());
+ return true;
+ }
+ else {
+ return this.callParent(arguments);
}
},
-
- getLayoutTarget : function(){
- return this.body;
+ onLayout: function() {
+ var me = this,
+ activeItem = me.activeItem,
+ items = me.getVisibleItems(),
+ ln = items.length,
+ targetBox = me.getTargetBox(),
+ i, item;
+
+ for (i = 0; i < ln; i++) {
+ item = items[i];
+ me.setItemBox(item, targetBox);
+ }
+
+ if (!me.firstActivated && activeItem) {
+ if (activeItem.fireEvent('beforeactivate', activeItem) !== false) {
+ activeItem.fireEvent('activate', activeItem);
+ }
+ me.firstActivated = true;
+ }
},
-
- getContentTarget : function(){
- return this.body;
+ isValidParent : function(item, target, position) {
+
+
+ var itemEl = item.el ? item.el.dom : Ext.getDom(item);
+ return (itemEl && itemEl.parentNode === (target.dom || target)) || false;
},
- setTitle : function(title, iconCls){
- this.title = title;
- if(this.header && this.headerAsText){
- this.header.child('span').update(title);
+ getActiveItem: function() {
+ var me = this;
+ if (!me.activeItem && me.owner) {
+ me.activeItem = me.parseActiveItem(me.owner.activeItem);
}
- if(iconCls){
- this.setIconClass(iconCls);
+
+ if (me.activeItem && me.owner.items.indexOf(me.activeItem) != -1) {
+ return me.activeItem;
}
- this.fireEvent('titlechange', this, title);
- return this;
- },
-
- getUpdater : function(){
- return this.body.getUpdater();
+ return null;
},
-
- load : function(){
- var um = this.body.getUpdater();
- um.update.apply(um, arguments);
- return this;
+
+ parseActiveItem: function(item) {
+ if (item && item.isComponent) {
+ return item;
+ }
+ else if (typeof item == 'number' || item === undefined) {
+ return this.getLayoutItems()[item || 0];
+ }
+ else {
+ return this.owner.getComponent(item);
+ }
},
- beforeDestroy : function(){
- Ext.Panel.superclass.beforeDestroy.call(this);
- if(this.header){
- this.header.removeAllListeners();
- }
- if(this.tools){
- for(var k in this.tools){
- Ext.destroy(this.tools[k]);
- }
+ configureItem: function(item, position) {
+ this.callParent([item, position]);
+ if (this.hideInactive && this.activeItem !== item) {
+ item.hide();
}
- if(this.toolbars.length > 0){
- Ext.each(this.toolbars, function(tb){
- tb.un('afterlayout', this.syncHeight, this);
- tb.un('remove', this.syncHeight, this);
- }, this);
+ else {
+ item.show();
}
- if(Ext.isArray(this.buttons)){
- while(this.buttons.length) {
- Ext.destroy(this.buttons[0]);
+ },
+
+ onRemove: function(component) {
+ if (component === this.activeItem) {
+ this.activeItem = null;
+ if (this.owner.items.getCount() === 0) {
+ this.firstActivated = false;
}
}
- if(this.rendered){
- Ext.destroy(
- this.ft,
- this.header,
- this.footer,
- this.tbar,
- this.bbar,
- this.body,
- this.mc,
- this.bwrap,
- this.dd
- );
- if (this.fbar) {
- Ext.destroy(
- this.fbar,
- this.fbar.el
- );
- }
+ },
+
+
+ getAnimation: function(newCard, owner) {
+ var newAnim = (newCard || {}).cardSwitchAnimation;
+ if (newAnim === false) {
+ return false;
}
- Ext.destroy(this.toolbars);
+ return newAnim || owner.cardSwitchAnimation;
},
- createClasses : function(){
- this.headerCls = this.baseCls + '-header';
- this.headerTextCls = this.baseCls + '-header-text';
- this.bwrapCls = this.baseCls + '-bwrap';
- this.tbarCls = this.baseCls + '-tbar';
- this.bodyCls = this.baseCls + '-body';
- this.bbarCls = this.baseCls + '-bbar';
- this.footerCls = this.baseCls + '-footer';
+ getNext: function(wrap) {
+
+
+
+ var items = this.getLayoutItems(),
+ index = Ext.Array.indexOf(items, this.activeItem);
+ return items[index + 1] || (wrap ? items[0] : false);
},
- createGhost : function(cls, useShim, appendTo){
- var el = document.createElement('div');
- el.className = 'x-panel-ghost ' + (cls ? cls : '');
- if(this.header){
- el.appendChild(this.el.dom.firstChild.cloneNode(true));
- }
- Ext.fly(el.appendChild(document.createElement('ul'))).setHeight(this.bwrap.getHeight());
- el.style.width = this.el.dom.offsetWidth + 'px';;
- if(!appendTo){
- this.container.dom.appendChild(el);
- }else{
- Ext.getDom(appendTo).appendChild(el);
- }
- if(useShim !== false && this.el.useShim !== false){
- var layer = new Ext.Layer({shadow:false, useDisplay:true, constrain:false}, el);
- layer.show();
- return layer;
- }else{
- return new Ext.Element(el);
- }
+ next: function(anim, wrap) {
+
+
+
+ return this.setActiveItem(this.getNext(wrap), anim);
},
- doAutoLoad : function(){
- var u = this.body.getUpdater();
- if(this.renderer){
- u.setRenderer(this.renderer);
- }
- u.update(Ext.isObject(this.autoLoad) ? this.autoLoad : {url: this.autoLoad});
+ getPrev: function(wrap) {
+
+
+
+ var items = this.getLayoutItems(),
+ index = Ext.Array.indexOf(items, this.activeItem);
+ return items[index - 1] || (wrap ? items[items.length - 1] : false);
},
- getTool : function(id) {
- return this.tools[id];
+ prev: function(anim, wrap) {
+
+
+
+ return this.setActiveItem(this.getPrev(wrap), anim);
}
-
-
});
-Ext.reg('panel', Ext.Panel);
-Ext.Editor = function(field, config){
- if(field.field){
- this.field = Ext.create(field.field, 'textfield');
- config = Ext.apply({}, field);
- delete config.field;
- }else{
- this.field = field;
- }
- Ext.Editor.superclass.constructor.call(this, config);
-};
-Ext.extend(Ext.Editor, Ext.Component, {
-
-
- allowBlur: true,
-
-
+Ext.define('Ext.selection.Model', {
+ extend: 'Ext.util.Observable',
+ alternateClassName: 'Ext.AbstractStoreSelectionModel',
+ requires: ['Ext.data.StoreManager'],
+
- value : "",
-
- alignment: "c-c?",
-
- offsets: [0, 0],
-
- shadow : "frame",
- constrain : false,
+ allowDeselect: false,
+
- swallowKeys : true,
+ selected: null,
- completeOnEnter : true,
- cancelOnEsc : true,
- updateEl : false,
+ pruneRemoved: true,
- initComponent : function(){
- Ext.Editor.superclass.initComponent.call(this);
- this.addEvents(
-
- "beforestartedit",
-
- "startedit",
-
- "beforecomplete",
-
- "complete",
-
- "canceledit",
+ constructor: function(cfg) {
+ var me = this;
+
+ cfg = cfg || {};
+ Ext.apply(me, cfg);
+
+ me.addEvents(
- "specialkey"
+ 'selectionchange'
);
- },
-
- onRender : function(ct, position){
- this.el = new Ext.Layer({
- shadow: this.shadow,
- cls: "x-editor",
- parentEl : ct,
- shim : this.shim,
- shadowOffset: this.shadowOffset || 4,
- id: this.id,
- constrain: this.constrain
- });
- if(this.zIndex){
- this.el.setZIndex(this.zIndex);
- }
- this.el.setStyle("overflow", Ext.isGecko ? "auto" : "hidden");
- if(this.field.msgTarget != 'title'){
- this.field.msgTarget = 'qtip';
- }
- this.field.inEditor = true;
- this.mon(this.field, {
- scope: this,
- blur: this.onBlur,
- specialkey: this.onSpecialKey
- });
- if(this.field.grow){
- this.mon(this.field, "autosize", this.el.sync, this.el, {delay:1});
- }
- this.field.render(this.el).show();
- this.field.getEl().dom.name = '';
- if(this.swallowKeys){
- this.field.el.swallowEvent([
- 'keypress',
- 'keydown'
- ]);
- }
+ me.modes = {
+ SINGLE: true,
+ SIMPLE: true,
+ MULTI: true
+ };
+
+
+ me.setSelectionMode(cfg.mode || me.mode);
+
+
+ me.selected = Ext.create('Ext.util.MixedCollection');
+
+ me.callParent(arguments);
},
- onSpecialKey : function(field, e){
- var key = e.getKey(),
- complete = this.completeOnEnter && key == e.ENTER,
- cancel = this.cancelOnEsc && key == e.ESC;
- if(complete || cancel){
- e.stopEvent();
- if(complete){
- this.completeEdit();
+ bind : function(store, initial){
+ var me = this;
+
+ if(!initial && me.store){
+ if(store !== me.store && me.store.autoDestroy){
+ me.store.destroy();
}else{
- this.cancelEdit();
- }
- if(field.triggerBlur){
- field.triggerBlur();
+ me.store.un("add", me.onStoreAdd, me);
+ me.store.un("clear", me.onStoreClear, me);
+ me.store.un("remove", me.onStoreRemove, me);
+ me.store.un("update", me.onStoreUpdate, me);
}
}
- this.fireEvent('specialkey', field, e);
- },
-
-
- startEdit : function(el, value){
- if(this.editing){
- this.completeEdit();
- }
- this.boundEl = Ext.get(el);
- var v = value !== undefined ? value : this.boundEl.dom.innerHTML;
- if(!this.rendered){
- this.render(this.parentEl || document.body);
+ if(store){
+ store = Ext.data.StoreManager.lookup(store);
+ store.on({
+ add: me.onStoreAdd,
+ clear: me.onStoreClear,
+ remove: me.onStoreRemove,
+ update: me.onStoreUpdate,
+ scope: me
+ });
}
- if(this.fireEvent("beforestartedit", this, this.boundEl, v) !== false){
- this.startValue = v;
- this.field.reset();
- this.field.setValue(v);
- this.realign(true);
- this.editing = true;
- this.show();
+ me.store = store;
+ if(store && !initial) {
+ me.refresh();
}
},
-
- doAutoSize : function(){
- if(this.autoSize){
- var sz = this.boundEl.getSize(),
- fs = this.field.getSize();
-
- switch(this.autoSize){
- case "width":
- this.setSize(sz.width, fs.height);
- break;
- case "height":
- this.setSize(fs.width, sz.height);
- break;
- case "none":
- this.setSize(fs.width, fs.height);
- break;
- default:
- this.setSize(sz.width, sz.height);
- }
+ selectAll: function(silent) {
+ var selections = this.store.getRange(),
+ i = 0,
+ len = selections.length;
+
+ for (; i < len; i++) {
+ this.doSelect(selections[i], true, silent);
}
},
-
- setSize : function(w, h){
- delete this.field.lastSize;
- this.field.setSize(w, h);
- if(this.el){
+ deselectAll: function() {
+ var selections = this.getSelection(),
+ i = 0,
+ len = selections.length;
- if(Ext.isGecko2 || Ext.isOpera || (Ext.isIE7 && Ext.isStrict)){
-
- this.el.setSize(w, h);
- }
- this.el.sync();
+ for (; i < len; i++) {
+ this.doDeselect(selections[i]);
}
},
- realign : function(autoSize){
- if(autoSize === true){
- this.doAutoSize();
+
+
+ selectWithEvent: function(record, e) {
+ var me = this;
+
+ switch (me.selectionMode) {
+ case 'MULTI':
+ if (e.ctrlKey && me.isSelected(record)) {
+ me.doDeselect(record, false);
+ } else if (e.shiftKey && me.lastFocused) {
+ me.selectRange(me.lastFocused, record, e.ctrlKey);
+ } else if (e.ctrlKey) {
+ me.doSelect(record, true, false);
+ } else if (me.isSelected(record) && !e.shiftKey && !e.ctrlKey && me.selected.getCount() > 1) {
+ me.doSelect(record, false, false);
+ } else {
+ me.doSelect(record, false);
+ }
+ break;
+ case 'SIMPLE':
+ if (me.isSelected(record)) {
+ me.doDeselect(record);
+ } else {
+ me.doSelect(record, true);
+ }
+ break;
+ case 'SINGLE':
+
+ if (me.allowDeselect && me.isSelected(record)) {
+ me.doDeselect(record);
+
+ } else {
+ me.doSelect(record, false);
+ }
+ break;
}
- this.el.alignTo(this.boundEl, this.alignment, this.offsets);
},
- completeEdit : function(remainVisible){
- if(!this.editing){
+ selectRange : function(startRow, endRow, keepExisting, dir){
+ var me = this,
+ store = me.store,
+ selectedCount = 0,
+ i,
+ tmp,
+ dontDeselect,
+ records = [];
+
+ if (me.isLocked()){
return;
}
- if (this.field.assertValue) {
- this.field.assertValue();
+ if (!keepExisting) {
+ me.clearSelections();
+ }
+
+ if (!Ext.isNumber(startRow)) {
+ startRow = store.indexOf(startRow);
+ }
+ if (!Ext.isNumber(endRow)) {
+ endRow = store.indexOf(endRow);
+ }
+
+
+ if (startRow > endRow){
+ tmp = endRow;
+ endRow = startRow;
+ startRow = tmp;
}
- var v = this.getValue();
- if(!this.field.isValid()){
- if(this.revertInvalid !== false){
- this.cancelEdit(remainVisible);
+
+ for (i = startRow; i <= endRow; i++) {
+ if (me.isSelected(store.getAt(i))) {
+ selectedCount++;
}
- return;
}
- if(String(v) === String(this.startValue) && this.ignoreNoChange){
- this.hideEdit(remainVisible);
- return;
+
+ if (!dir) {
+ dontDeselect = -1;
+ } else {
+ dontDeselect = (dir == 'up') ? startRow : endRow;
}
- if(this.fireEvent("beforecomplete", this, v, this.startValue) !== false){
- v = this.getValue();
- if(this.updateEl && this.boundEl){
- this.boundEl.update(v);
+
+ for (i = startRow; i <= endRow; i++){
+ if (selectedCount == (endRow - startRow + 1)) {
+ if (i != dontDeselect) {
+ me.doDeselect(i, true);
+ }
+ } else {
+ records.push(store.getAt(i));
}
- this.hideEdit(remainVisible);
- this.fireEvent("complete", this, v, this.startValue);
}
+ me.doMultiSelect(records, true);
},
-
- onShow : function(){
- this.el.show();
- if(this.hideEl !== false){
- this.boundEl.hide();
- }
- this.field.show().focus(false, true);
- this.fireEvent("startedit", this.boundEl, this.startValue);
+
+ select: function(records, keepExisting, suppressEvent) {
+ this.doSelect(records, keepExisting, suppressEvent);
},
- cancelEdit : function(remainVisible){
- if(this.editing){
- var v = this.getValue();
- this.setValue(this.startValue);
- this.hideEdit(remainVisible);
- this.fireEvent("canceledit", this, v, this.startValue);
- }
+ deselect: function(records, suppressEvent) {
+ this.doDeselect(records, suppressEvent);
},
-
- hideEdit: function(remainVisible){
- if(remainVisible !== true){
- this.editing = false;
- this.hide();
+ doSelect: function(records, keepExisting, suppressEvent) {
+ var me = this,
+ record;
+
+ if (me.locked) {
+ return;
+ }
+ if (typeof records === "number") {
+ records = [me.store.getAt(records)];
+ }
+ if (me.selectionMode == "SINGLE" && records) {
+ record = records.length ? records[0] : records;
+ me.doSingleSelect(record, suppressEvent);
+ } else {
+ me.doMultiSelect(records, keepExisting, suppressEvent);
}
},
-
- onBlur : function(){
+ doMultiSelect: function(records, keepExisting, suppressEvent) {
+ var me = this,
+ selected = me.selected,
+ change = false,
+ i = 0,
+ len, record;
+
+ if (me.locked) {
+ return;
+ }
- if(this.allowBlur === true && this.editing && this.selectSameEditor !== true){
- this.completeEdit();
+
+ records = !Ext.isArray(records) ? [records] : records;
+ len = records.length;
+ if (!keepExisting && selected.getCount() > 0) {
+ change = true;
+ me.doDeselect(me.getSelection(), true);
+ }
+
+ for (; i < len; i++) {
+ record = records[i];
+ if (keepExisting && me.isSelected(record)) {
+ continue;
+ }
+ change = true;
+ me.lastSelected = record;
+ selected.add(record);
+
+ me.onSelectChange(record, true, suppressEvent);
}
+ me.setLastFocused(record, suppressEvent);
+
+ me.maybeFireSelectionChange(change && !suppressEvent);
},
- onHide : function(){
- if(this.editing){
- this.completeEdit();
+ doDeselect: function(records, suppressEvent) {
+ var me = this,
+ selected = me.selected,
+ change = false,
+ i = 0,
+ len, record;
+
+ if (me.locked) {
return;
}
- this.field.blur();
- if(this.field.collapse){
- this.field.collapse();
+
+ if (typeof records === "number") {
+ records = [me.store.getAt(records)];
}
- this.el.hide();
- if(this.hideEl !== false){
- this.boundEl.show();
+
+ records = !Ext.isArray(records) ? [records] : records;
+ len = records.length;
+ for (; i < len; i++) {
+ record = records[i];
+ if (selected.remove(record)) {
+ if (me.lastSelected == record) {
+ me.lastSelected = selected.last();
+ }
+ me.onSelectChange(record, false, suppressEvent);
+ change = true;
+ }
}
+
+ me.maybeFireSelectionChange(change && !suppressEvent);
},
-
- setValue : function(v){
- this.field.setValue(v);
+ doSingleSelect: function(record, suppressEvent) {
+ var me = this,
+ selected = me.selected;
+
+ if (me.locked) {
+ return;
+ }
+
+
+ if (me.isSelected(record)) {
+ return;
+ }
+ if (selected.getCount() > 0) {
+ me.doDeselect(me.lastSelected, suppressEvent);
+ }
+ selected.add(record);
+ me.lastSelected = record;
+ me.onSelectChange(record, true, suppressEvent);
+ if (!suppressEvent) {
+ me.setLastFocused(record);
+ }
+ me.maybeFireSelectionChange(!suppressEvent);
},
- getValue : function(){
- return this.field.getValue();
+ setLastFocused: function(record, supressFocus) {
+ var me = this,
+ recordBeforeLast = me.lastFocused;
+ me.lastFocused = record;
+ me.onLastFocusChanged(recordBeforeLast, record, supressFocus);
+ },
+
+
+ isFocused: function(record) {
+ return record === this.getLastFocused();
},
- beforeDestroy : function(){
- Ext.destroyMembers(this, 'field');
-
- delete this.parentEl;
- delete this.boundEl;
- }
-});
-Ext.reg('editor', Ext.Editor);
-Ext.ColorPalette = Ext.extend(Ext.Component, {
-
- itemCls : 'x-color-palette',
- value : null,
+ maybeFireSelectionChange: function(fireEvent) {
+ if (fireEvent) {
+ var me = this;
+ me.fireEvent('selectionchange', me, me.getSelection());
+ }
+ },
+
- clickEvent :'click',
+ getLastSelected: function() {
+ return this.lastSelected;
+ },
- ctype : 'Ext.ColorPalette',
+ getLastFocused: function() {
+ return this.lastFocused;
+ },
- allowReselect : false,
+ getSelection: function() {
+ return this.selected.getRange();
+ },
- colors : [
- '000000', '993300', '333300', '003300', '003366', '000080', '333399', '333333',
- '800000', 'FF6600', '808000', '008000', '008080', '0000FF', '666699', '808080',
- 'FF0000', 'FF9900', '99CC00', '339966', '33CCCC', '3366FF', '800080', '969696',
- 'FF00FF', 'FFCC00', 'FFFF00', '00FF00', '00FFFF', '00CCFF', '993366', 'C0C0C0',
- 'FF99CC', 'FFCC99', 'FFFF99', 'CCFFCC', 'CCFFFF', '99CCFF', 'CC99FF', 'FFFFFF'
- ],
+ getSelectionMode: function() {
+ return this.selectionMode;
+ },
-
-
-
- initComponent : function(){
- Ext.ColorPalette.superclass.initComponent.call(this);
- this.addEvents(
-
- 'select'
- );
-
- if(this.handler){
- this.on('select', this.handler, this.scope, true);
- }
+ setSelectionMode: function(selMode) {
+ selMode = selMode ? selMode.toUpperCase() : 'SINGLE';
+
+
+ this.selectionMode = this.modes[selMode] ? selMode : 'SINGLE';
},
- onRender : function(container, position){
- this.autoEl = {
- tag: 'div',
- cls: this.itemCls
- };
- Ext.ColorPalette.superclass.onRender.call(this, container, position);
- var t = this.tpl || new Ext.XTemplate(
- ' '
- );
- t.overwrite(this.el, this.colors);
- this.mon(this.el, this.clickEvent, this.handleClick, this, {delegate: 'a'});
- if(this.clickEvent != 'click'){
- this.mon(this.el, 'click', Ext.emptyFn, this, {delegate: 'a', preventDefault: true});
- }
+ isLocked: function() {
+ return this.locked;
},
- afterRender : function(){
- Ext.ColorPalette.superclass.afterRender.call(this);
- if(this.value){
- var s = this.value;
- this.value = null;
- this.select(s, true);
- }
+ setLocked: function(locked) {
+ this.locked = !!locked;
},
- handleClick : function(e, t){
- e.preventDefault();
- if(!this.disabled){
- var c = t.className.match(/(?:^|\s)color-(.{6})(?:\s|$)/)[1];
- this.select(c.toUpperCase());
- }
+ isSelected: function(record) {
+ record = Ext.isNumber(record) ? this.store.getAt(record) : record;
+ return this.selected.indexOf(record) !== -1;
},
-
- select : function(color, suppressEvent){
- color = color.replace('#', '');
- if(color != this.value || this.allowReselect){
- var el = this.el;
- if(this.value){
- el.child('a.color-'+this.value).removeClass('x-color-palette-sel');
- }
- el.child('a.color-'+color).addClass('x-color-palette-sel');
- this.value = color;
- if(suppressEvent !== true){
- this.fireEvent('select', this, color);
+
+ hasSelection: function() {
+ return this.selected.getCount() > 0;
+ },
+
+ refresh: function() {
+ var me = this,
+ toBeSelected = [],
+ oldSelections = me.getSelection(),
+ len = oldSelections.length,
+ selection,
+ change,
+ i = 0,
+ lastFocused = this.getLastFocused();
+
+
+
+
+ for (; i < len; i++) {
+ selection = oldSelections[i];
+ if (!this.pruneRemoved || me.store.indexOf(selection) !== -1) {
+ toBeSelected.push(selection);
}
}
- }
+
+
+
+ if (me.selected.getCount() != toBeSelected.length) {
+ change = true;
+ }
+
+ me.clearSelections();
+
+ if (me.store.indexOf(lastFocused) !== -1) {
+
+ this.setLastFocused(lastFocused, true);
+ }
+
+ if (toBeSelected.length) {
+
+ me.doSelect(toBeSelected, false, true);
+ }
+
+ me.maybeFireSelectionChange(change);
+ },
+
+ clearSelections: function() {
+
+ var me = this;
+ me.selected.clear();
+ me.lastSelected = null;
+ me.setLastFocused(null);
+ },
-});
-Ext.reg('colorpalette', Ext.ColorPalette);
-Ext.DatePicker = Ext.extend(Ext.BoxComponent, {
-
- todayText : 'Today',
-
- okText : ' OK ',
-
- cancelText : 'Cancel',
-
-
-
- todayTip : '{0} (Spacebar)',
-
- minText : 'This date is before the minimum date',
-
- maxText : 'This date is after the maximum date',
-
- format : 'm/d/y',
-
- disabledDaysText : 'Disabled',
-
- disabledDatesText : 'Disabled',
-
- monthNames : Date.monthNames,
-
- dayNames : Date.dayNames,
-
- nextText : 'Next Month (Control+Right)',
-
- prevText : 'Previous Month (Control+Left)',
-
- monthYearText : 'Choose a month (Control+Up/Down to move years)',
-
- startDay : 0,
-
- showToday : true,
-
-
-
-
-
+ onStoreAdd: function() {
+
+ },
- focusOnSelect: true,
+ onStoreClear: function() {
+ var me = this,
+ selected = this.selected;
+
+ if (selected.getCount > 0) {
+ selected.clear();
+ me.lastSelected = null;
+ me.setLastFocused(null);
+ me.maybeFireSelectionChange(true);
+ }
+ },
- initHour: 12,
-
- initComponent : function(){
- Ext.DatePicker.superclass.initComponent.call(this);
-
- this.value = this.value ?
- this.value.clearTime(true) : new Date().clearTime();
-
- this.addEvents(
+ onStoreRemove: function(store, record) {
+ var me = this,
+ selected = me.selected;
- 'select'
- );
+ if (me.locked || !me.pruneRemoved) {
+ return;
+ }
- if(this.handler){
- this.on('select', this.handler, this.scope || this);
+ if (selected.remove(record)) {
+ if (me.lastSelected == record) {
+ me.lastSelected = null;
+ }
+ if (me.getLastFocused() == record) {
+ me.setLastFocused(null);
+ }
+ me.maybeFireSelectionChange(true);
}
+ },
- this.initDisabledDays();
+ getCount: function() {
+ return this.selected.getCount();
},
- initDisabledDays : function(){
- if(!this.disabledDatesRE && this.disabledDates){
- var dd = this.disabledDates,
- len = dd.length - 1,
- re = '(?:';
+ destroy: function() {
- Ext.each(dd, function(d, i){
- re += Ext.isDate(d) ? '^' + Ext.escapeRe(d.dateFormat(this.format)) + '$' : dd[i];
- if(i != len){
- re += '|';
- }
- }, this);
- this.disabledDatesRE = new RegExp(re + ')');
- }
},
- setDisabledDates : function(dd){
- if(Ext.isArray(dd)){
- this.disabledDates = dd;
- this.disabledDatesRE = null;
- }else{
- this.disabledDatesRE = dd;
- }
- this.initDisabledDays();
- this.update(this.value, true);
+ onStoreUpdate: function() {
+
},
- setDisabledDays : function(dd){
- this.disabledDays = dd;
- this.update(this.value, true);
+ onSelectChange: function(record, isSelected, suppressEvent) {
+
},
- setMinDate : function(dt){
- this.minDate = dt;
- this.update(this.value, true);
+ onLastFocusChanged: function(oldFocused, newFocused) {
+
},
- setMaxDate : function(dt){
- this.maxDate = dt;
- this.update(this.value, true);
+ onEditorKey: function(field, e) {
+
},
- setValue : function(value){
- this.value = value.clearTime(true);
- this.update(this.value);
- },
+ bindComponent: function(cmp) {
+
+ }
+});
+Ext.define('Ext.selection.DataViewModel', {
+ extend: 'Ext.selection.Model',
- getValue : function(){
- return this.value;
- },
+ requires: ['Ext.util.KeyNav'],
+ deselectOnContainerClick: true,
- focus : function(){
- this.update(this.activeDate);
+
+ enableKeyNav: true,
+
+ constructor: function(cfg){
+ this.addEvents(
+
+ 'deselect',
+
+
+ 'select'
+ );
+ this.callParent(arguments);
},
-
- onEnable: function(initial){
- Ext.DatePicker.superclass.onEnable.call(this);
- this.doDisabled(false);
- this.update(initial ? this.value : this.activeDate);
- if(Ext.isIE){
- this.el.repaint();
+ bindComponent: function(view) {
+ var me = this,
+ eventListeners = {
+ refresh: me.refresh,
+ scope: me
+ };
+
+ me.view = view;
+ me.bind(view.getStore());
+
+ view.on(view.triggerEvent, me.onItemClick, me);
+ view.on(view.triggerCtEvent, me.onContainerClick, me);
+
+ view.on(eventListeners);
+
+ if (me.enableKeyNav) {
+ me.initKeyNav(view);
}
+ },
+ onItemClick: function(view, record, item, index, e) {
+ this.selectWithEvent(record, e);
},
+ onContainerClick: function() {
+ if (this.deselectOnContainerClick) {
+ this.deselectAll();
+ }
+ },
- onDisable : function(){
- Ext.DatePicker.superclass.onDisable.call(this);
- this.doDisabled(true);
- if(Ext.isIE && !Ext.isIE8){
-
- Ext.each([].concat(this.textNodes, this.el.query('th span')), function(el){
- Ext.fly(el).repaint();
- });
+ initKeyNav: function(view) {
+ var me = this;
+
+ if (!view.rendered) {
+ view.on('render', Ext.Function.bind(me.initKeyNav, me, [view], 0), me, {single: true});
+ return;
}
+
+ view.el.set({
+ tabIndex: -1
+ });
+ me.keyNav = Ext.create('Ext.util.KeyNav', view.el, {
+ down: Ext.pass(me.onNavKey, [1], me),
+ right: Ext.pass(me.onNavKey, [1], me),
+ left: Ext.pass(me.onNavKey, [-1], me),
+ up: Ext.pass(me.onNavKey, [-1], me),
+ scope: me
+ });
},
-
- doDisabled : function(disabled){
- this.keyNav.setDisabled(disabled);
- this.prevRepeater.setDisabled(disabled);
- this.nextRepeater.setDisabled(disabled);
- if(this.showToday){
- this.todayKeyListener.setDisabled(disabled);
- this.todayBtn.setDisabled(disabled);
+ onNavKey: function(step) {
+ step = step || 1;
+ var me = this,
+ view = me.view,
+ selected = me.getSelection()[0],
+ numRecords = me.view.store.getCount(),
+ idx;
+
+ if (selected) {
+ idx = view.indexOf(view.getNode(selected)) + step;
+ } else {
+ idx = 0;
+ }
+
+ if (idx < 0) {
+ idx = numRecords - 1;
+ } else if (idx >= numRecords) {
+ idx = 0;
}
+
+ me.select(idx);
},
- onRender : function(container, position){
- var m = [
- ''];
- for(var i = 0; i < 6; i++){
- buf.push(
- '
'
- );
- this.monthPicker.update(buf.join(''));
- this.mon(this.monthPicker, 'click', this.onMonthClick, this);
- this.mon(this.monthPicker, 'dblclick', this.onMonthDblClick, this);
+ constructor: function(x, y) {
+ this.callParent([y, x, y, x]);
+ },
+
+
+ toString: function() {
+ return "Point[" + this.x + "," + this.y + "]";
+ },
- this.mpMonths = this.monthPicker.select('td.x-date-mp-month');
- this.mpYears = this.monthPicker.select('td.x-date-mp-year');
+
+ equals: function(p) {
+ return (this.x == p.x && this.y == p.y);
+ },
- this.mpMonths.each(function(m, a, i){
- i += 1;
- if((i%2) === 0){
- m.dom.xmonth = 5 + Math.round(i * 0.5);
- }else{
- m.dom.xmonth = Math.round((i-1) * 0.5);
- }
- });
+
+ isWithin: function(p, threshold) {
+ if (!Ext.isObject(threshold)) {
+ threshold = {
+ x: threshold,
+ y: threshold
+ };
}
+
+ return (this.x <= p.x + threshold.x && this.x >= p.x - threshold.x &&
+ this.y <= p.y + threshold.y && this.y >= p.y - threshold.y);
},
- showMonthPicker : function(){
- if(!this.disabled){
- this.createMonthPicker();
- var size = this.el.getSize();
- this.monthPicker.setSize(size);
- this.monthPicker.child('table').setSize(size);
+ roundedEquals: function(p) {
+ return (Math.round(this.x) == Math.round(p.x) && Math.round(this.y) == Math.round(p.y));
+ }
+}, function() {
+
+ this.prototype.translate = Ext.util.Region.prototype.translateBy;
+});
- this.mpSelMonth = (this.activeDate || this.value).getMonth();
- this.updateMPMonth(this.mpSelMonth);
- this.mpSelYear = (this.activeDate || this.value).getFullYear();
- this.updateMPYear(this.mpSelYear);
- this.monthPicker.slideIn('t', {duration:0.2});
+Ext.define('Ext.view.AbstractView', {
+ extend: 'Ext.Component',
+ alternateClassName: 'Ext.view.AbstractView',
+ requires: [
+ 'Ext.LoadMask',
+ 'Ext.data.StoreManager',
+ 'Ext.CompositeElementLite',
+ 'Ext.DomQuery',
+ 'Ext.selection.DataViewModel'
+ ],
+
+ inheritableStatics: {
+ getRecord: function(node) {
+ return this.getBoundView(node).getRecord(node);
+ },
+
+ getBoundView: function(node) {
+ return Ext.getCmp(node.boundView);
}
},
+
+
+
- updateMPYear : function(y){
- this.mpyear = y;
- var ys = this.mpYears.elements;
- for(var i = 1; i <= 10; i++){
- var td = ys[i-1], y2;
- if((i%2) === 0){
- y2 = y + Math.round(i * 0.5);
- td.firstChild.innerHTML = y2;
- td.xyear = y2;
- }else{
- y2 = y - (5-Math.round(i * 0.5));
- td.firstChild.innerHTML = y2;
- td.xyear = y2;
- }
- this.mpYears.item(i-1)[y2 == this.mpSelYear ? 'addClass' : 'removeClass']('x-date-mp-sel');
- }
- },
+
+
+ itemCls: Ext.baseCSSPrefix + 'dataview-item',
+
+
- updateMPMonth : function(sm){
- this.mpMonths.each(function(m, a, i){
- m[m.dom.xmonth == sm ? 'addClass' : 'removeClass']('x-date-mp-sel');
- });
- },
- selectMPMonth : function(m){
+ loadingText: 'Loading...',
+
+
+
+
+ loadingUseMsg: true,
+
- },
+
- onMonthClick : function(e, t){
- e.stopEvent();
- var el = new Ext.Element(t), pn;
- if(el.is('button.x-date-mp-cancel')){
- this.hideMonthPicker();
- }
- else if(el.is('button.x-date-mp-ok')){
- var d = new Date(this.mpSelYear, this.mpSelMonth, (this.activeDate || this.value).getDate());
- if(d.getMonth() != this.mpSelMonth){
-
- d = new Date(this.mpSelYear, this.mpSelMonth, 1).getLastDateOfMonth();
- }
- this.update(d);
- this.hideMonthPicker();
- }
- else if((pn = el.up('td.x-date-mp-month', 2))){
- this.mpMonths.removeClass('x-date-mp-sel');
- pn.addClass('x-date-mp-sel');
- this.mpSelMonth = pn.dom.xmonth;
- }
- else if((pn = el.up('td.x-date-mp-year', 2))){
- this.mpYears.removeClass('x-date-mp-sel');
- pn.addClass('x-date-mp-sel');
- this.mpSelYear = pn.dom.xyear;
- }
- else if(el.is('a.x-date-mp-prev')){
- this.updateMPYear(this.mpyear-10);
- }
- else if(el.is('a.x-date-mp-next')){
- this.updateMPYear(this.mpyear+10);
- }
- },
+ selectedItemCls: Ext.baseCSSPrefix + 'item-selected',
- onMonthDblClick : function(e, t){
- e.stopEvent();
- var el = new Ext.Element(t), pn;
- if((pn = el.up('td.x-date-mp-month', 2))){
- this.update(new Date(this.mpSelYear, pn.dom.xmonth, (this.activeDate || this.value).getDate()));
- this.hideMonthPicker();
- }
- else if((pn = el.up('td.x-date-mp-year', 2))){
- this.update(new Date(pn.dom.xyear, this.mpSelMonth, (this.activeDate || this.value).getDate()));
- this.hideMonthPicker();
- }
- },
+ emptyText: "",
- hideMonthPicker : function(disableAnim){
- if(this.monthPicker){
- if(disableAnim === true){
- this.monthPicker.hide();
- }else{
- this.monthPicker.slideOut('t', {duration:0.2});
- }
- }
- },
+ deferEmptyText: true,
- showPrevMonth : function(e){
- this.update(this.activeDate.add('mo', -1));
- },
+ trackOver: false,
- showNextMonth : function(e){
- this.update(this.activeDate.add('mo', 1));
- },
+ blockRefresh: false,
- showPrevYear : function(){
- this.update(this.activeDate.add('y', -1));
- },
+
- showNextYear : function(){
- this.update(this.activeDate.add('y', 1));
+ last: false,
+
+ triggerEvent: 'itemclick',
+ triggerCtEvent: 'containerclick',
+
+ addCmpEvents: function() {
+
},
- handleMouseWheel : function(e){
- e.stopEvent();
- if(!this.disabled){
- var delta = e.getWheelDelta();
- if(delta > 0){
- this.showPrevMonth();
- } else if(delta < 0){
- this.showNextMonth();
+ initComponent : function(){
+ var me = this,
+ isDef = Ext.isDefined,
+ itemTpl = me.itemTpl,
+ memberFn = {};
+
+ if (itemTpl) {
+ if (Ext.isArray(itemTpl)) {
+
+ itemTpl = itemTpl.join('');
+ } else if (Ext.isObject(itemTpl)) {
+
+ memberFn = Ext.apply(memberFn, itemTpl.initialConfig);
+ itemTpl = itemTpl.html;
}
+
+ if (!me.itemSelector) {
+ me.itemSelector = '.' + me.itemCls;
+ }
+
+ itemTpl = Ext.String.format('= this.minX; i = i - iTickSize) {
- if (!tickMap[i]) {
- this.xTicks[this.xTicks.length] = i;
- tickMap[i] = true;
- }
- }
+ alias: 'widget.splitbutton',
- for (i = this.initPageX; i <= this.maxX; i = i + iTickSize) {
- if (!tickMap[i]) {
- this.xTicks[this.xTicks.length] = i;
- tickMap[i] = true;
- }
- }
+ extend: 'Ext.button.Button',
+ alternateClassName: 'Ext.SplitButton',
- this.xTicks.sort(this.DDM.numericSort) ;
- },
+
+ arrowCls : 'split',
+ split : true,
- setYTicks: function(iStartY, iTickSize) {
- this.yTicks = [];
- this.yTickSize = iTickSize;
+ initComponent : function(){
+ this.callParent();
+
+ this.addEvents("arrowclick");
+ },
- var tickMap = {};
+
+ setArrowHandler : function(handler, scope){
+ this.arrowHandler = handler;
+ this.scope = scope;
+ },
- for (var i = this.initPageY; i >= this.minY; i = i - iTickSize) {
- if (!tickMap[i]) {
- this.yTicks[this.yTicks.length] = i;
- tickMap[i] = true;
+
+ onClick : function(e, t) {
+ var me = this;
+
+ e.preventDefault();
+ if (!me.disabled) {
+ if (me.overMenuTrigger) {
+ if (me.menu && !me.menu.isVisible() && !me.ignoreNextClick) {
+ me.showMenu();
+ }
+ me.fireEvent("arrowclick", me, e);
+ if (me.arrowHandler) {
+ me.arrowHandler.call(me.scope || me, me, e);
+ }
+ } else {
+ if (me.enableToggle) {
+ me.toggle();
+ }
+ me.fireEvent("click", me, e);
+ if (me.handler) {
+ me.handler.call(me.scope || me, me, e);
+ }
+ me.onBlur();
}
}
+ }
+});
- for (i = this.initPageY; i <= this.maxY; i = i + iTickSize) {
- if (!tickMap[i]) {
- this.yTicks[this.yTicks.length] = i;
- tickMap[i] = true;
- }
- }
- this.yTicks.sort(this.DDM.numericSort) ;
- },
+Ext.define('Ext.button.Cycle', {
- setXConstraint: function(iLeft, iRight, iTickSize) {
- this.leftConstraint = iLeft;
- this.rightConstraint = iRight;
- this.minX = this.initPageX - iLeft;
- this.maxX = this.initPageX + iRight;
- if (iTickSize) { this.setXTicks(this.initPageX, iTickSize); }
+ alias: 'widget.cycle',
- this.constrainX = true;
- },
+ extend: 'Ext.button.Split',
+ alternateClassName: 'Ext.CycleButton',
- clearConstraints: function() {
- this.constrainX = false;
- this.constrainY = false;
- this.clearTicks();
- },
- clearTicks: function() {
- this.xTicks = null;
- this.yTicks = null;
- this.xTickSize = 0;
- this.yTickSize = 0;
- },
+
+
+
+
+
- setYConstraint: function(iUp, iDown, iTickSize) {
- this.topConstraint = iUp;
- this.bottomConstraint = iDown;
+ getButtonText: function(item) {
+ var me = this,
+ text = '';
- this.minY = this.initPageY - iUp;
- this.maxY = this.initPageY + iDown;
- if (iTickSize) { this.setYTicks(this.initPageY, iTickSize); }
+ if (item && me.showText === true) {
+ if (me.prependText) {
+ text += me.prependText;
+ }
+ text += item.text;
+ return text;
+ }
+ return me.text;
+ },
- this.constrainY = true;
+
+ setActiveItem: function(item, suppressEvent) {
+ var me = this;
+
+ if (!Ext.isObject(item)) {
+ item = me.menu.getComponent(item);
+ }
+ if (item) {
+ if (!me.rendered) {
+ me.text = me.getButtonText(item);
+ me.iconCls = item.iconCls;
+ } else {
+ me.setText(me.getButtonText(item));
+ me.setIconCls(item.iconCls);
+ }
+ me.activeItem = item;
+ if (!item.checked) {
+ item.setChecked(true, false);
+ }
+ if (me.forceIcon) {
+ me.setIconCls(me.forceIcon);
+ }
+ if (!suppressEvent) {
+ me.fireEvent('change', me, item);
+ }
+ }
+ },
+
+ getActiveItem: function() {
+ return this.activeItem;
},
- resetConstraints: function() {
-
- if (this.initPageX || this.initPageX === 0) {
+ initComponent: function() {
+ var me = this,
+ checked = 0,
+ items;
+
+ me.addEvents(
- var dx = (this.maintainOffset) ? this.lastPageX - this.initPageX : 0;
- var dy = (this.maintainOffset) ? this.lastPageY - this.initPageY : 0;
+ "change"
+ );
- this.setInitPosition(dx, dy);
+ if (me.changeHandler) {
+ me.on('change', me.changeHandler, me.scope || me);
+ delete me.changeHandler;
+ }
- } else {
- this.setInitPosition();
- }
+
+ items = (me.menu.items||[]).concat(me.items||[]);
+ me.menu = Ext.applyIf({
+ cls: Ext.baseCSSPrefix + 'cycle-menu',
+ items: []
+ }, me.menu);
- if (this.constrainX) {
- this.setXConstraint( this.leftConstraint,
- this.rightConstraint,
- this.xTickSize );
- }
+
+ Ext.each(items, function(item, i) {
+ item = Ext.applyIf({
+ group: me.id,
+ itemIndex: i,
+ checkHandler: me.checkHandler,
+ scope: me,
+ checked: item.checked || false
+ }, item);
+ me.menu.items.push(item);
+ if (item.checked) {
+ checked = i;
+ }
+ });
+ me.itemCount = me.menu.items.length;
+ me.callParent(arguments);
+ me.on('click', me.toggleSelected, me);
+ me.setActiveItem(checked, me);
- if (this.constrainY) {
- this.setYConstraint( this.topConstraint,
- this.bottomConstraint,
- this.yTickSize );
+
+ if (me.width && me.showText) {
+ me.addCls(Ext.baseCSSPrefix + 'cycle-fixed-width');
}
},
- getTick: function(val, tickArray) {
- if (!tickArray) {
-
-
- return val;
- } else if (tickArray[0] >= val) {
-
-
- return tickArray[0];
- } else {
- for (var i=0, len=tickArray.length; i= val) {
- var diff1 = val - tickArray[i];
- var diff2 = tickArray[next] - val;
- return (diff2 > diff1) ? tickArray[i] : tickArray[next];
- }
- }
-
-
-
- return tickArray[tickArray.length - 1];
+ checkHandler: function(item, pressed) {
+ if (pressed) {
+ this.setActiveItem(item);
}
},
- toString: function() {
- return ("DragDrop " + this.id);
- }
+ toggleSelected: function() {
+ var me = this,
+ m = me.menu,
+ checkItem;
-};
+ checkItem = me.activeItem.next(':not([disabled])') || m.items.getAt(0);
+ checkItem.setChecked(true);
+ }
+});
-})();
+Ext.define('Ext.container.ButtonGroup', {
+ extend: 'Ext.panel.Panel',
+ alias: 'widget.buttongroup',
+ alternateClassName: 'Ext.ButtonGroup',
+
+
+ baseCls: Ext.baseCSSPrefix + 'btn-group',
+
+ layout: {
+ type: 'table'
+ },
-if (!Ext.dd.DragDropMgr) {
+ defaultType: 'button',
+
+ frame: true,
+
+ frameHeader: false,
+
+ internalDefaults: {removeMode: 'container', hideParent: true},
-Ext.dd.DragDropMgr = function() {
+ initComponent : function(){
+
+ var me = this,
+ cols = me.columns;
- var Event = Ext.EventManager;
+ me.noTitleCls = me.baseCls + '-notitle';
+ if (cols) {
+ me.layout = Ext.apply({}, {columns: cols}, me.layout);
+ }
- return {
+ if (!me.title) {
+ me.addCls(me.noTitleCls);
+ }
+ me.callParent(arguments);
+ },
+ afterLayout: function() {
+ var me = this;
- ids: {},
+ me.callParent(arguments);
- handleIds: {},
-
- dragCurrent: null,
+ if (me.layout.table && (Ext.isIEQuirks || Ext.isIE6) && !me.width) {
+ var t = me.getTargetEl();
+ t.setWidth(me.layout.table.offsetWidth + t.getPadding('lr'));
+ }
+ },
+ afterRender: function() {
+ var me = this;
- dragOvers: {},
-
- deltaX: 0,
-
+ if (me.header) {
+ me.header.insert(0, {
+ xtype: 'component',
+ ui : me.ui,
+ html : ' ',
+ flex : 1
+ });
+ }
- deltaY: 0,
+ me.callParent(arguments);
+ },
+
+
+ onBeforeAdd: function(component) {
+ if (component.is('button')) {
+ component.ui = component.ui + '-toolbar';
+ }
+ this.callParent(arguments);
+ },
-
- preventDefault: true,
+
+ applyDefaults: function(c) {
+ if (!Ext.isString(c)) {
+ c = this.callParent(arguments);
+ var d = this.internalDefaults;
+ if (c.events) {
+ Ext.applyIf(c.initialConfig, d);
+ Ext.apply(c, d);
+ } else {
+ Ext.applyIf(c, d);
+ }
+ }
+ return c;
+ }
-
- stopPropagation: true,
+
+
+
+
+
+});
-
- initialized: false,
-
- locked: false,
+Ext.define('Ext.container.Viewport', {
+ extend: 'Ext.container.Container',
+ alias: 'widget.viewport',
+ requires: ['Ext.EventManager'],
+ alternateClassName: 'Ext.Viewport',
-
- init: function() {
- this.initialized = true;
- },
+
+
+
+
+
+
+
+
+
+
+
+
-
- POINT: 0,
+ isViewport: true,
+ ariaRole: 'application',
+ initComponent : function() {
+ var me = this,
+ html = Ext.fly(document.body.parentNode),
+ el;
+ me.callParent(arguments);
+ html.addCls(Ext.baseCSSPrefix + 'viewport');
+ if (me.autoScroll) {
+ html.setStyle('overflow', 'auto');
+ }
+ me.el = el = Ext.getBody();
+ el.setHeight = Ext.emptyFn;
+ el.setWidth = Ext.emptyFn;
+ el.setSize = Ext.emptyFn;
+ el.dom.scroll = 'no';
+ me.allowDomMove = false;
- INTERSECT: 1,
-
- mode: 0,
+ Ext.EventManager.onWindowResize(me.fireResize, me);
+ me.renderTo = me.el;
+ },
+ fireResize : function(w, h){
- _execOnAll: function(sMethod, args) {
- for (var i in this.ids) {
- for (var j in this.ids[i]) {
- var oDD = this.ids[i][j];
- if (! this.isTypeOfDD(oDD)) {
- continue;
- }
- oDD[sMethod].apply(oDD, args);
- }
- }
- },
-
+ this.setSize(w, h);
- _onLoad: function() {
+ }
+});
- this.init();
- Event.on(document, "mouseup", this.handleMouseUp, this, true);
- Event.on(document, "mousemove", this.handleMouseMove, this, true);
- Event.on(window, "unload", this._onUnload, this, true);
- Event.on(window, "resize", this._onResize, this, true);
-
- },
-
- _onResize: function(e) {
- this._execOnAll("resetConstraints", []);
- },
+Ext.define('Ext.dd.DDTarget', {
+ extend: 'Ext.dd.DragDrop',
+ constructor: function(id, sGroup, config) {
+ if (id) {
+ this.initTarget(id, sGroup, config);
+ }
+ },
-
- lock: function() { this.locked = true; },
+
+ getDragEl: Ext.emptyFn,
+
+ isValidHandleChild: Ext.emptyFn,
+
+ startDrag: Ext.emptyFn,
+
+ endDrag: Ext.emptyFn,
+
+ onDrag: Ext.emptyFn,
+
+ onDragDrop: Ext.emptyFn,
+
+ onDragEnter: Ext.emptyFn,
+
+ onDragOut: Ext.emptyFn,
+
+ onDragOver: Ext.emptyFn,
+
+ onInvalidDrop: Ext.emptyFn,
+
+ onMouseDown: Ext.emptyFn,
+
+ onMouseUp: Ext.emptyFn,
+
+ setXConstraint: Ext.emptyFn,
+
+ setYConstraint: Ext.emptyFn,
+
+ resetConstraints: Ext.emptyFn,
+
+ clearConstraints: Ext.emptyFn,
+
+ clearTicks: Ext.emptyFn,
+
+ setInitPosition: Ext.emptyFn,
+
+ setDragElId: Ext.emptyFn,
+
+ setHandleElId: Ext.emptyFn,
+
+ setOuterHandleElId: Ext.emptyFn,
+
+ addInvalidHandleClass: Ext.emptyFn,
+
+ addInvalidHandleId: Ext.emptyFn,
+
+ addInvalidHandleType: Ext.emptyFn,
+
+ removeInvalidHandleClass: Ext.emptyFn,
+
+ removeInvalidHandleId: Ext.emptyFn,
+
+ removeInvalidHandleType: Ext.emptyFn,
-
- unlock: function() { this.locked = false; },
+ toString: function() {
+ return ("DDTarget " + this.id);
+ }
+});
-
- isLocked: function() { return this.locked; },
+Ext.define('Ext.dd.DragTracker', {
-
- locationCache: {},
+ uses: ['Ext.util.Region'],
-
- useCache: true,
+ mixins: {
+ observable: 'Ext.util.Observable'
+ },
-
- clickPixelThresh: 3,
+
+ active: false,
-
- clickTimeThresh: 350,
+
-
- dragThreshMet: false,
+
+ trackOver: false,
-
- clickTimeout: null,
+
-
- startX: 0,
+
-
- startY: 0,
+
+ tolerance: 5,
-
- regDragDrop: function(oDD, sGroup) {
- if (!this.initialized) { this.init(); }
+
+ autoStart: false,
- if (!this.ids[sGroup]) {
- this.ids[sGroup] = {};
- }
- this.ids[sGroup][oDD.id] = oDD;
- },
+
-
- removeDDFromGroup: function(oDD, sGroup) {
- if (!this.ids[sGroup]) {
- this.ids[sGroup] = {};
- }
+
- var obj = this.ids[sGroup];
- if (obj && obj[oDD.id]) {
- delete obj[oDD.id];
- }
- },
+
-
- _remove: function(oDD) {
- for (var g in oDD.groups) {
- if (g && this.ids[g] && this.ids[g][oDD.id]) {
- delete this.ids[g][oDD.id];
- }
- }
- delete this.handleIds[oDD.id];
- },
+ constructor : function(config){
+ Ext.apply(this, config);
+ this.addEvents(
+
+ 'mouseover',
-
- regHandle: function(sDDId, sHandleId) {
- if (!this.handleIds[sDDId]) {
- this.handleIds[sDDId] = {};
- }
- this.handleIds[sDDId][sHandleId] = sHandleId;
- },
+
+ 'mouseout',
-
- isDragDrop: function(id) {
- return ( this.getDDById(id) ) ? true : false;
- },
+
+ 'mousedown',
-
- getRelated: function(p_oDD, bTargetsOnly) {
- var oDDs = [];
- for (var i in p_oDD.groups) {
- for (var j in this.ids[i]) {
- var dd = this.ids[i][j];
- if (! this.isTypeOfDD(dd)) {
- continue;
- }
- if (!bTargetsOnly || dd.isTarget) {
- oDDs[oDDs.length] = dd;
- }
- }
- }
+
+ 'mouseup',
- return oDDs;
- },
+
+ 'mousemove',
-
- isLegalTarget: function (oDD, oTargetDD) {
- var targets = this.getRelated(oDD, true);
- for (var i=0, len=targets.length;i this.clickPixelThresh ||
- diffY > this.clickPixelThresh) {
- this.startDrag(this.startX, this.startY);
- }
+ if (this.preventDefault !== false) {
+ e.preventDefault();
}
-
- if (this.dragThreshMet) {
- this.dragCurrent.b4Drag(e);
- this.dragCurrent.onDrag(e);
- if(!this.dragCurrent.moveOnly){
- this.fireEvents(e, false);
- }
+ Ext.getDoc().on({
+ scope: this,
+ mouseup: this.onMouseUp,
+ mousemove: this.onMouseMove,
+ selectstart: this.stopSelect
+ });
+ if (this.autoStart) {
+ this.timer = Ext.defer(this.triggerStart, this.autoStart === true ? 1000 : this.autoStart, this, [e]);
}
+ }
+ },
- this.stopEvent(e);
-
- return true;
- },
-
+ onMouseMove: function(e, target){
- fireEvents: function(e, isDrop) {
- var dc = this.dragCurrent;
+
+ if (this.active && Ext.isIE && !e.browserEvent.button) {
+ e.preventDefault();
+ this.onMouseUp(e);
+ return;
+ }
-
-
- if (!dc || dc.isLocked()) {
+ e.preventDefault();
+ var xy = e.getXY(),
+ s = this.startXY;
+
+ this.lastXY = xy;
+ if (!this.active) {
+ if (Math.max(Math.abs(s[0]-xy[0]), Math.abs(s[1]-xy[1])) > this.tolerance) {
+ this.triggerStart(e);
+ } else {
return;
}
+ }
- var pt = e.getPoint();
+
+ if (this.fireEvent('mousemove', this, e) === false) {
+ this.onMouseUp(e);
+ } else {
+ this.onDrag(e);
+ this.fireEvent('drag', this, e);
+ }
+ },
-
- var oldOvers = [];
+ onMouseUp: function(e) {
+
+
+ this.mouseIsDown = false;
- var outEvts = [];
- var overEvts = [];
- var dropEvts = [];
- var enterEvts = [];
+
+ delete e.dragTracked;
-
-
- for (var i in this.dragOvers) {
+
+ if (this.mouseIsOut) {
+ this.mouseIsOut = false;
+ this.onMouseOut(e);
+ }
+ e.preventDefault();
+ this.fireEvent('mouseup', this, e);
+ this.endDrag(e);
+ },
- var ddo = this.dragOvers[i];
+
+ endDrag: function(e) {
+ var doc = Ext.getDoc(),
+ wasActive = this.active;
- if (! this.isTypeOfDD(ddo)) {
- continue;
- }
+ doc.un('mousemove', this.onMouseMove, this);
+ doc.un('mouseup', this.onMouseUp, this);
+ doc.un('selectstart', this.stopSelect, this);
+ this.clearStart();
+ this.active = false;
+ if (wasActive) {
+ this.onEnd(e);
+ this.fireEvent('dragend', this, e);
+ }
+
+ delete this._constrainRegion;
+ },
- if (! this.isOverTarget(pt, ddo, this.mode)) {
- outEvts.push( ddo );
- }
+ triggerStart: function(e) {
+ this.clearStart();
+ this.active = true;
+ this.onStart(e);
+ this.fireEvent('dragstart', this, e);
+ },
- oldOvers[i] = true;
- delete this.dragOvers[i];
- }
+ clearStart : function() {
+ if (this.timer) {
+ clearTimeout(this.timer);
+ delete this.timer;
+ }
+ },
+
+ stopSelect : function(e) {
+ e.stopEvent();
+ return false;
+ },
- for (var sGroup in dc.groups) {
+
+ onBeforeStart : function(e) {
- if ("string" != typeof sGroup) {
- continue;
- }
+ },
- for (i in this.ids[sGroup]) {
- var oDD = this.ids[sGroup][i];
- if (! this.isTypeOfDD(oDD)) {
- continue;
- }
+
+ onStart : function(xy) {
- if (oDD.isTarget && !oDD.isLocked() && ((oDD != dc) || (dc.ignoreSelf === false))) {
- if (this.isOverTarget(pt, oDD, this.mode)) {
-
- if (isDrop) {
- dropEvts.push( oDD );
-
- } else {
+ },
-
- if (!oldOvers[oDD.id]) {
- enterEvts.push( oDD );
-
- } else {
- overEvts.push( oDD );
- }
+
+ onDrag : function(e) {
- this.dragOvers[oDD.id] = oDD;
- }
- }
- }
- }
- }
+ },
- if (this.mode) {
- if (outEvts.length) {
- dc.b4DragOut(e, outEvts);
- dc.onDragOut(e, outEvts);
- }
+
+ onEnd : function(e) {
- if (enterEvts.length) {
- dc.onDragEnter(e, enterEvts);
- }
+ },
- if (overEvts.length) {
- dc.b4DragOver(e, overEvts);
- dc.onDragOver(e, overEvts);
- }
+
+ getDragTarget : function(){
+ return this.dragTarget;
+ },
- if (dropEvts.length) {
- dc.b4DragDrop(e, dropEvts);
- dc.onDragDrop(e, dropEvts);
- }
+
+ getDragCt : function(){
+ return this.el;
+ },
- } else {
-
- var len = 0;
- for (i=0, len=outEvts.length; i constrainTo.right) {
+ xy[0] += adjust = (constrainTo.right - dr.right);
+ dr.left += adjust;
+ }
+ if (dr.left < constrainTo.left) {
+ xy[0] += (constrainTo.left - dr.left);
+ }
- if (len == 1) {
- winner = dds[0];
- } else {
-
- for (var i=0; i constrainTo.bottom) {
+ xy[1] += adjust = (constrainTo.bottom - dr.bottom);
+ dr.top += adjust;
}
+ if (dr.top < constrainTo.top) {
+ xy[1] += (constrainTo.top - dr.top);
+ }
+ return xy;
+ }
+ }
+});
- return winner;
- },
+Ext.define('Ext.dd.DragZone', {
-
- refreshCache: function(groups) {
- for (var sGroup in groups) {
- if ("string" != typeof sGroup) {
- continue;
- }
- for (var i in this.ids[sGroup]) {
- var oDD = this.ids[sGroup][i];
+ extend: 'Ext.dd.DragSource',
- if (this.isTypeOfDD(oDD)) {
-
- var loc = this.getLocation(oDD);
- if (loc) {
- this.locationCache[oDD.id] = loc;
- } else {
- delete this.locationCache[oDD.id];
-
-
-
- }
- }
- }
- }
- },
+ constructor : function(el, config){
+ this.callParent([el, config]);
+ if (this.containerScroll) {
+ Ext.dd.ScrollManager.register(this.el);
+ }
+ },
-
- verifyEl: function(el) {
- if (el) {
- var parent;
- if(Ext.isIE){
- try{
- parent = el.offsetParent;
- }catch(e){}
- }else{
- parent = el.offsetParent;
- }
- if (parent) {
- return true;
- }
- }
+
- return false;
- },
+
-
- getLocation: function(oDD) {
- if (! this.isTypeOfDD(oDD)) {
- return null;
- }
+
+ getDragData : function(e){
+ return Ext.dd.Registry.getHandleFromEvent(e);
+ },
- var el = oDD.getEl(), pos, x1, x2, y1, y2, t, r, b, l;
+
+ onInitDrag : function(x, y){
+ this.proxy.update(this.dragData.ddel.cloneNode(true));
+ this.onStartDrag(x, y);
+ return true;
+ },
- try {
- pos= Ext.lib.Dom.getXY(el);
- } catch (e) { }
+
+ afterRepair : function(){
+ var me = this;
+ if (Ext.enableFx) {
+ Ext.fly(me.dragData.ddel).highlight(me.repairHighlightColor);
+ }
+ me.dragging = false;
+ },
- if (!pos) {
- return null;
- }
+
+ getRepairXY : function(e){
+ return Ext.core.Element.fly(this.dragData.ddel).getXY();
+ },
- x1 = pos[0];
- x2 = x1 + el.offsetWidth;
- y1 = pos[1];
- y2 = y1 + el.offsetHeight;
+ destroy : function(){
+ this.callParent();
+ if (this.containerScroll) {
+ Ext.dd.ScrollManager.unregister(this.el);
+ }
+ }
+});
- t = y1 - oDD.padding[0];
- r = x2 + oDD.padding[1];
- b = y2 + oDD.padding[2];
- l = x1 - oDD.padding[3];
- return new Ext.lib.Region( t, r, b, l );
- },
+Ext.define('Ext.dd.ScrollManager', {
+ singleton: true,
+ requires: [
+ 'Ext.dd.DragDropManager'
+ ],
-
- isOverTarget: function(pt, oTarget, intersect) {
-
- var loc = this.locationCache[oTarget.id];
- if (!loc || !this.useCache) {
- loc = this.getLocation(oTarget);
- this.locationCache[oTarget.id] = loc;
+ constructor: function() {
+ var ddm = Ext.dd.DragDropManager;
+ ddm.fireEvents = Ext.Function.createSequence(ddm.fireEvents, this.onFire, this);
+ ddm.stopDrag = Ext.Function.createSequence(ddm.stopDrag, this.onStop, this);
+ this.doScroll = Ext.Function.bind(this.doScroll, this);
+ this.ddmInstance = ddm;
+ this.els = {};
+ this.dragEl = null;
+ this.proc = {};
+ },
- }
+ onStop: function(e){
+ var sm = Ext.dd.ScrollManager;
+ sm.dragEl = null;
+ sm.clearProc();
+ },
- if (!loc) {
- return false;
- }
+ triggerRefresh: function() {
+ if (this.ddmInstance.dragCurrent) {
+ this.ddmInstance.refreshCache(this.ddmInstance.dragCurrent.groups);
+ }
+ },
- oTarget.cursorIsOver = loc.contains( pt );
+ doScroll: function() {
+ if (this.ddmInstance.dragCurrent) {
+ var proc = this.proc,
+ procEl = proc.el,
+ ddScrollConfig = proc.el.ddScrollConfig,
+ inc = ddScrollConfig ? ddScrollConfig.increment : this.increment;
-
-
-
-
-
- var dc = this.dragCurrent;
- if (!dc || !dc.getTargetCoord ||
- (!intersect && !dc.constrainX && !dc.constrainY)) {
- return oTarget.cursorIsOver;
+ if (!this.animate) {
+ if (procEl.scroll(proc.dir, inc)) {
+ this.triggerRefresh();
+ }
+ } else {
+ procEl.scroll(proc.dir, inc, true, this.animDuration, this.triggerRefresh);
}
+ }
+ },
- oTarget.overlap = null;
+ clearProc: function() {
+ var proc = this.proc;
+ if (proc.id) {
+ clearInterval(proc.id);
+ }
+ proc.id = 0;
+ proc.el = null;
+ proc.dir = "";
+ },
+ startProc: function(el, dir) {
+ this.clearProc();
+ this.proc.el = el;
+ this.proc.dir = dir;
+ var group = el.ddScrollConfig ? el.ddScrollConfig.ddGroup : undefined,
+ freq = (el.ddScrollConfig && el.ddScrollConfig.frequency)
+ ? el.ddScrollConfig.frequency
+ : this.frequency;
+
+ if (group === undefined || this.ddmInstance.dragCurrent.ddGroup == group) {
+ this.proc.id = setInterval(this.doScroll, freq);
+ }
+ },
+
+ onFire: function(e, isDrop) {
+ if (isDrop || !this.ddmInstance.dragCurrent) {
+ return;
+ }
+ if (!this.dragEl || this.dragEl != this.ddmInstance.dragCurrent) {
+ this.dragEl = this.ddmInstance.dragCurrent;
-
-
-
- var pos = dc.getTargetCoord(pt.x, pt.y);
+ this.refreshCache();
+ }
- var el = dc.getDragEl();
- var curRegion = new Ext.lib.Region( pos.y,
- pos.x + el.offsetWidth,
- pos.y + el.offsetHeight,
- pos.x );
+ var xy = e.getXY(),
+ pt = e.getPoint(),
+ proc = this.proc,
+ els = this.els;
- var overlap = curRegion.intersect(loc);
+ for (var id in els) {
+ var el = els[id], r = el._region;
+ var c = el.ddScrollConfig ? el.ddScrollConfig : this;
+ if (r && r.contains(pt) && el.isScrollable()) {
+ if (r.bottom - pt.y <= c.vthresh) {
+ if(proc.el != el){
+ this.startProc(el, "down");
+ }
+ return;
+ }else if (r.right - pt.x <= c.hthresh) {
+ if (proc.el != el) {
+ this.startProc(el, "left");
+ }
+ return;
+ } else if(pt.y - r.top <= c.vthresh) {
+ if (proc.el != el) {
+ this.startProc(el, "up");
+ }
+ return;
+ } else if(pt.x - r.left <= c.hthresh) {
+ if (proc.el != el) {
+ this.startProc(el, "right");
+ }
+ return;
+ }
+ }
+ }
+ this.clearProc();
+ },
- if (overlap) {
- oTarget.overlap = overlap;
- return (intersect) ? true : oTarget.cursorIsOver;
- } else {
- return false;
+
+ register : function(el){
+ if (Ext.isArray(el)) {
+ for(var i = 0, len = el.length; i < len; i++) {
+ this.register(el[i]);
}
- },
+ } else {
+ el = Ext.get(el);
+ this.els[el.id] = el;
+ }
+ },
-
- _onUnload: function(e, me) {
- Ext.dd.DragDropMgr.unregAll();
- },
+
+ unregister : function(el){
+ if(Ext.isArray(el)){
+ for (var i = 0, len = el.length; i < len; i++) {
+ this.unregister(el[i]);
+ }
+ }else{
+ el = Ext.get(el);
+ delete this.els[el.id];
+ }
+ },
-
- unregAll: function() {
+
+ vthresh : 25,
+
+ hthresh : 25,
- if (this.dragCurrent) {
- this.stopDrag();
- this.dragCurrent = null;
- }
+
+ increment : 100,
- this._execOnAll("unreg", []);
+
+ frequency : 500,
- for (var i in this.elementCache) {
- delete this.elementCache[i];
- }
+
+ animate: true,
- this.elementCache = {};
- this.ids = {};
- },
+
+ animDuration: 0.4,
-
- elementCache: {},
+
+ ddGroup: undefined,
-
- getElWrapper: function(id) {
- var oWrapper = this.elementCache[id];
- if (!oWrapper || !oWrapper.el) {
- oWrapper = this.elementCache[id] =
- new this.ElementWrapper(Ext.getDom(id));
+
+ refreshCache : function(){
+ var els = this.els,
+ id;
+ for (id in els) {
+ if(typeof els[id] == 'object'){
+ els[id]._region = els[id].getRegion();
}
- return oWrapper;
- },
+ }
+ }
+});
-
- getElement: function(id) {
- return Ext.getDom(id);
- },
-
- getCss: function(id) {
- var el = Ext.getDom(id);
- return (el) ? el.style : null;
- },
+Ext.define('Ext.dd.DropTarget', {
+ extend: 'Ext.dd.DDTarget',
+ requires: ['Ext.dd.ScrollManager'],
-
- ElementWrapper: function(el) {
-
- this.el = el || null;
-
- this.id = this.el && el.id;
-
- this.css = this.el && el.style;
- },
+ constructor : function(el, config){
+ this.el = Ext.get(el);
-
- getPosX: function(el) {
- return Ext.lib.Dom.getX(el);
- },
+ Ext.apply(this, config);
-
- getPosY: function(el) {
- return Ext.lib.Dom.getY(el);
- },
+ if(this.containerScroll){
+ Ext.dd.ScrollManager.register(this.el);
+ }
-
- swapNode: function(n1, n2) {
- if (n1.swapNode) {
- n1.swapNode(n2);
- } else {
- var p = n2.parentNode;
- var s = n2.nextSibling;
+ this.callParent([this.el.dom, this.ddGroup || this.group,
+ {isTarget: true}]);
+ },
- if (s == n1) {
- p.insertBefore(n1, n2);
- } else if (n2 == n1.nextSibling) {
- p.insertBefore(n2, n1);
- } else {
- n1.parentNode.replaceChild(n2, n1);
- p.insertBefore(n1, s);
- }
- }
- },
+
+
+
+ dropAllowed : Ext.baseCSSPrefix + 'dd-drop-ok',
+
+ dropNotAllowed : Ext.baseCSSPrefix + 'dd-drop-nodrop',
-
- getScroll: function () {
- var t, l, dde=document.documentElement, db=document.body;
- if (dde && (dde.scrollTop || dde.scrollLeft)) {
- t = dde.scrollTop;
- l = dde.scrollLeft;
- } else if (db) {
- t = db.scrollTop;
- l = db.scrollLeft;
- } else {
+
+ isTarget : true,
- }
- return { top: t, left: l };
- },
+
+ isNotifyTarget : true,
-
- getStyle: function(el, styleProp) {
- return Ext.fly(el).getStyle(styleProp);
- },
+
+ notifyEnter : function(dd, e, data){
+ if(this.overClass){
+ this.el.addCls(this.overClass);
+ }
+ return this.dropAllowed;
+ },
-
- getScrollTop: function () {
- return this.getScroll().top;
- },
+
+ notifyOver : function(dd, e, data){
+ return this.dropAllowed;
+ },
-
- getScrollLeft: function () {
- return this.getScroll().left;
- },
+
+ notifyOut : function(dd, e, data){
+ if(this.overClass){
+ this.el.removeCls(this.overClass);
+ }
+ },
-
- moveToEl: function (moveEl, targetEl) {
- var aCoord = Ext.lib.Dom.getXY(targetEl);
- Ext.lib.Dom.setXY(moveEl, aCoord);
- },
+
+ notifyDrop : function(dd, e, data){
+ return false;
+ },
-
- numericSort: function(a, b) {
- return (a - b);
- },
+ destroy : function(){
+ this.callParent();
+ if(this.containerScroll){
+ Ext.dd.ScrollManager.unregister(this.el);
+ }
+ }
+});
-
- _timeoutCount: 0,
-
- _addListeners: function() {
- var DDM = Ext.dd.DDM;
- if ( Ext.lib.Event && document ) {
- DDM._onLoad();
- } else {
- if (DDM._timeoutCount > 2000) {
- } else {
- setTimeout(DDM._addListeners, 10);
- if (document && document.body) {
- DDM._timeoutCount += 1;
- }
- }
+Ext.define('Ext.dd.Registry', {
+ singleton: true,
+ constructor: function() {
+ this.elements = {};
+ this.handles = {};
+ this.autoIdSeed = 0;
+ },
+
+ getId: function(el, autogen){
+ if(typeof el == "string"){
+ return el;
+ }
+ var id = el.id;
+ if(!id && autogen !== false){
+ id = "extdd-" + (++this.autoIdSeed);
+ el.id = id;
+ }
+ return id;
+ },
+
+
+ register : function(el, data){
+ data = data || {};
+ if (typeof el == "string") {
+ el = document.getElementById(el);
+ }
+ data.ddel = el;
+ this.elements[this.getId(el)] = data;
+ if (data.isHandle !== false) {
+ this.handles[data.ddel.id] = data;
+ }
+ if (data.handles) {
+ var hs = data.handles;
+ for (var i = 0, len = hs.length; i < len; i++) {
+ this.handles[this.getId(hs[i])] = data;
}
- },
-
-
- handleWasClicked: function(node, id) {
- if (this.isHandle(id, node.id)) {
- return true;
- } else {
-
- var p = node.parentNode;
+ }
+ },
- while (p) {
- if (this.isHandle(id, p.id)) {
- return true;
- } else {
- p = p.parentNode;
- }
+
+ unregister : function(el){
+ var id = this.getId(el, false);
+ var data = this.elements[id];
+ if(data){
+ delete this.elements[id];
+ if(data.handles){
+ var hs = data.handles;
+ for (var i = 0, len = hs.length; i < len; i++) {
+ delete this.handles[this.getId(hs[i], false)];
}
}
-
- return false;
}
+ },
- };
+
+ getHandle : function(id){
+ if(typeof id != "string"){
+ id = id.id;
+ }
+ return this.handles[id];
+ },
-}();
+
+ getHandleFromEvent : function(e){
+ var t = e.getTarget();
+ return t ? this.handles[t.id] : null;
+ },
+
+ getTarget : function(id){
+ if(typeof id != "string"){
+ id = id.id;
+ }
+ return this.elements[id];
+ },
-Ext.dd.DDM = Ext.dd.DragDropMgr;
-Ext.dd.DDM._addListeners();
+
+ getTargetFromEvent : function(e){
+ var t = e.getTarget();
+ return t ? this.elements[t.id] || this.handles[t.id] : null;
+ }
+});
-}
+Ext.define('Ext.dd.DropZone', {
+ extend: 'Ext.dd.DropTarget',
+ requires: ['Ext.dd.Registry'],
+
+ getTargetFromEvent : function(e){
+ return Ext.dd.Registry.getTargetFromEvent(e);
+ },
-Ext.dd.DD = function(id, sGroup, config) {
- if (id) {
- this.init(id, sGroup, config);
- }
-};
+
+ onNodeEnter : function(n, dd, e, data){
+
+ },
-Ext.extend(Ext.dd.DD, Ext.dd.DragDrop, {
+
+ onNodeOver : function(n, dd, e, data){
+ return this.dropAllowed;
+ },
- scroll: true,
+ onNodeOut : function(n, dd, e, data){
+
+ },
- autoOffset: function(iPageX, iPageY) {
- var x = iPageX - this.startPageX;
- var y = iPageY - this.startPageY;
- this.setDelta(x, y);
+ onNodeDrop : function(n, dd, e, data){
+ return false;
},
- setDelta: function(iDeltaX, iDeltaY) {
- this.deltaX = iDeltaX;
- this.deltaY = iDeltaY;
+ onContainerOver : function(dd, e, data){
+ return this.dropNotAllowed;
},
- setDragElPos: function(iPageX, iPageY) {
-
-
+ onContainerDrop : function(dd, e, data){
+ return false;
+ },
- var el = this.getDragEl();
- this.alignElWithMouse(el, iPageX, iPageY);
+
+ notifyEnter : function(dd, e, data){
+ return this.dropNotAllowed;
},
- alignElWithMouse: function(el, iPageX, iPageY) {
- var oCoord = this.getTargetCoord(iPageX, iPageY);
- var fly = el.dom ? el : Ext.fly(el, '_dd');
- if (!this.deltaSetXY) {
- var aCoord = [oCoord.x, oCoord.y];
- fly.setXY(aCoord);
- var newLeft = fly.getLeft(true);
- var newTop = fly.getTop(true);
- this.deltaSetXY = [ newLeft - oCoord.x, newTop - oCoord.y ];
- } else {
- fly.setLeftTop(oCoord.x + this.deltaSetXY[0], oCoord.y + this.deltaSetXY[1]);
+ notifyOver : function(dd, e, data){
+ var n = this.getTargetFromEvent(e);
+ if(!n) {
+ if(this.lastOverNode){
+ this.onNodeOut(this.lastOverNode, dd, e, data);
+ this.lastOverNode = null;
+ }
+ return this.onContainerOver(dd, e, data);
+ }
+ if(this.lastOverNode != n){
+ if(this.lastOverNode){
+ this.onNodeOut(this.lastOverNode, dd, e, data);
+ }
+ this.onNodeEnter(n, dd, e, data);
+ this.lastOverNode = n;
}
+ return this.onNodeOver(n, dd, e, data);
+ },
- this.cachePosition(oCoord.x, oCoord.y);
- this.autoScroll(oCoord.x, oCoord.y, el.offsetHeight, el.offsetWidth);
- return oCoord;
+
+ notifyOut : function(dd, e, data){
+ if(this.lastOverNode){
+ this.onNodeOut(this.lastOverNode, dd, e, data);
+ this.lastOverNode = null;
+ }
},
- cachePosition: function(iPageX, iPageY) {
- if (iPageX) {
- this.lastPageX = iPageX;
- this.lastPageY = iPageY;
- } else {
- var aCoord = Ext.lib.Dom.getXY(this.getEl());
- this.lastPageX = aCoord[0];
- this.lastPageY = aCoord[1];
+ notifyDrop : function(dd, e, data){
+ if(this.lastOverNode){
+ this.onNodeOut(this.lastOverNode, dd, e, data);
+ this.lastOverNode = null;
}
+ var n = this.getTargetFromEvent(e);
+ return n ?
+ this.onNodeDrop(n, dd, e, data) :
+ this.onContainerDrop(dd, e, data);
},
- autoScroll: function(x, y, h, w) {
+ triggerCacheRefresh : function() {
+ Ext.dd.DDM.refreshCache(this.groups);
+ }
+});
- if (this.scroll) {
-
- var clientH = Ext.lib.Dom.getViewHeight();
+Ext.define('Ext.flash.Component', {
+ extend: 'Ext.Component',
+ alternateClassName: 'Ext.FlashComponent',
+ alias: 'widget.flash',
-
- var clientW = Ext.lib.Dom.getViewWidth();
+
+ flashVersion : '9.0.115',
-
- var st = this.DDM.getScrollTop();
+
+ backgroundColor: '#ffffff',
-
- var sl = this.DDM.getScrollLeft();
+
+ wmode: 'opaque',
-
- var bot = h + y;
+
-
- var right = w + x;
+
-
-
-
- var toBot = (clientH + st - y - this.deltaY);
+
-
- var toRight = (clientW + sl - x - this.deltaX);
+
+
+ swfWidth: '100%',
-
-
- var thresh = 40;
+
+ swfHeight: '100%',
-
-
-
- var scrAmt = (document.all) ? 80 : 30;
+
+ expressInstall: false,
-
-
- if ( bot > clientH && toBot < thresh ) {
- window.scrollTo(sl, st + scrAmt);
- }
+
+
+
+ renderTpl: [''],
-
-
- if ( y < st && st > 0 && y - st < thresh ) {
- window.scrollTo(sl, st - scrAmt);
- }
+ initComponent: function() {
+ if (!('swfobject' in window)) {
+ Ext.Error.raise('The SWFObject library is not loaded. Ext.flash.Component requires SWFObject version 2.2 or later: http://code.google.com/p/swfobject/');
+ }
+ if (!this.url) {
+ Ext.Error.raise('The "url" config is required for Ext.flash.Component');
+ }
+ this.callParent();
+ this.addEvents(
-
- if ( right > clientW && toRight < thresh ) {
- window.scrollTo(sl + scrAmt, st);
- }
+ 'success',
-
- if ( x < sl && sl > 0 && x - sl < thresh ) {
- window.scrollTo(sl - scrAmt, st);
- }
- }
+ 'failure'
+ );
},
-
- getTargetCoord: function(iPageX, iPageY) {
- var x = iPageX - this.deltaX;
- var y = iPageY - this.deltaY;
-
- if (this.constrainX) {
- if (x < this.minX) { x = this.minX; }
- if (x > this.maxX) { x = this.maxX; }
- }
-
- if (this.constrainY) {
- if (y < this.minY) { y = this.minY; }
- if (y > this.maxY) { y = this.maxY; }
- }
+ onRender: function() {
+ var me = this,
+ params, vars, undef,
+ swfId = me.getSwfId();
- x = this.getTick(x, this.xTicks);
- y = this.getTick(y, this.yTicks);
+ me.renderData.swfId = swfId;
+ me.callParent(arguments);
- return {x:x, y:y};
+ params = Ext.apply({
+ allowScriptAccess: 'always',
+ bgcolor: me.backgroundColor,
+ wmode: me.wmode
+ }, me.flashParams);
+
+ vars = Ext.apply({
+ allowedDomain: document.location.hostname
+ }, me.flashVars);
+
+ new swfobject.embedSWF(
+ me.url,
+ swfId,
+ me.swfWidth,
+ me.swfHeight,
+ me.flashVersion,
+ me.expressInstall ? me.statics.EXPRESS_INSTALL_URL : undef,
+ vars,
+ params,
+ me.flashAttributes,
+ Ext.bind(me.swfCallback, me)
+ );
},
- applyConfig: function() {
- Ext.dd.DD.superclass.applyConfig.call(this);
- this.scroll = (this.config.scroll !== false);
+ swfCallback: function(e) {
+ var me = this;
+ if (e.success) {
+ me.swf = Ext.get(e.ref);
+ me.onSuccess();
+ me.fireEvent('success', me);
+ } else {
+ me.onFailure();
+ me.fireEvent('failure', me);
+ }
},
- b4MouseDown: function(e) {
+ getSwfId: function() {
+ return this.swfId || (this.swfId = "extswf" + this.getAutoId());
+ },
+
+ onSuccess: function() {
- this.autoOffset(e.getPageX(),
- e.getPageY());
+
+ this.swf.setStyle('visibility', 'inherit');
},
-
- b4Drag: function(e) {
- this.setDragElPos(e.getPageX(),
- e.getPageY());
+ onFailure: Ext.emptyFn,
+
+ beforeDestroy: function() {
+ var me = this,
+ swf = me.swf;
+ if (swf) {
+ swfobject.removeSWF(me.getSwfId());
+ Ext.destroy(swf);
+ delete me.swf;
+ }
+ me.callParent();
},
- toString: function() {
- return ("DD " + this.id);
+ statics: {
+
+ EXPRESS_INSTALL_URL: 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf'
}
+});
+
+
+Ext.define('Ext.form.action.Action', {
+ alternateClassName: 'Ext.form.Action',
+
-
+
-});
+
-Ext.dd.DDProxy = function(id, sGroup, config) {
- if (id) {
- this.init(id, sGroup, config);
- this.initFrame();
- }
-};
+
+
-Ext.dd.DDProxy.dragElId = "ygddfdiv";
+
-Ext.extend(Ext.dd.DDProxy, Ext.dd.DD, {
+
- resizeFrame: true,
- centerFrame: false,
- createFrame: function() {
- var self = this;
- var body = document.body;
- if (!body || !body.firstChild) {
- setTimeout( function() { self.createFrame(); }, 50 );
- return;
- }
+
- var div = this.getDragEl();
+
- if (!div) {
- div = document.createElement("div");
- div.id = this.dragElId;
- var s = div.style;
+
- s.position = "absolute";
- s.visibility = "hidden";
- s.cursor = "move";
- s.border = "2px solid #aaa";
- s.zIndex = 999;
+
-
-
-
- body.insertBefore(div, body.firstChild);
- }
- },
+
- initFrame: function() {
- this.createFrame();
- },
- applyConfig: function() {
- Ext.dd.DDProxy.superclass.applyConfig.call(this);
- this.resizeFrame = (this.config.resizeFrame !== false);
- this.centerFrame = (this.config.centerFrame);
- this.setDragElId(this.config.dragElId || Ext.dd.DDProxy.dragElId);
+
+ constructor: function(config) {
+ if (config) {
+ Ext.apply(this, config);
+ }
+
+
+ var params = config.params;
+ if (Ext.isString(params)) {
+ this.params = Ext.Object.fromQueryString(params);
+ }
},
- showFrame: function(iPageX, iPageY) {
- var el = this.getEl();
- var dragEl = this.getDragEl();
- var s = dragEl.style;
-
- this._resizeProxy();
+ run: Ext.emptyFn,
- if (this.centerFrame) {
- this.setDelta( Math.round(parseInt(s.width, 10)/2),
- Math.round(parseInt(s.height, 10)/2) );
- }
+
- this.setDragElPos(iPageX, iPageY);
+
- Ext.fly(dragEl).show();
+
+ onFailure : function(response){
+ this.response = response;
+ this.failureType = Ext.form.action.Action.CONNECT_FAILURE;
+ this.form.afterAction(this, false);
},
- _resizeProxy: function() {
- if (this.resizeFrame) {
- var el = this.getEl();
- Ext.fly(this.getDragEl()).setSize(el.offsetWidth, el.offsetHeight);
+ processResponse : function(response){
+ this.response = response;
+ if (!response.responseText && !response.responseXML) {
+ return true;
}
+ return (this.result = this.handleResponse(response));
},
- b4MouseDown: function(e) {
- var x = e.getPageX();
- var y = e.getPageY();
- this.autoOffset(x, y);
- this.setDragElPos(x, y);
+ getUrl: function() {
+ return this.url || this.form.url;
},
- b4StartDrag: function(x, y) {
-
- this.showFrame(x, y);
+ getMethod: function() {
+ return (this.method || this.form.method || 'POST').toUpperCase();
},
- b4EndDrag: function(e) {
- Ext.fly(this.getDragEl()).hide();
+ getParams: function() {
+ return Ext.apply({}, this.params, this.form.baseParams);
},
-
-
- endDrag: function(e) {
-
- var lel = this.getEl();
- var del = this.getDragEl();
+ createCallback: function() {
+ var me = this,
+ undef,
+ form = me.form;
+ return {
+ success: me.onSuccess,
+ failure: me.onFailure,
+ scope: me,
+ timeout: (this.timeout * 1000) || (form.timeout * 1000),
+ upload: form.fileUpload ? me.onSuccess : undef
+ };
+ },
+ statics: {
- del.style.visibility = "";
+ CLIENT_INVALID: 'client',
- this.beforeMove();
-
- lel.style.visibility = "hidden";
- Ext.dd.DDM.moveToEl(lel, del);
- del.style.visibility = "hidden";
- lel.style.visibility = "";
+ SERVER_INVALID: 'server',
- this.afterDrag();
- },
-
- beforeMove : function(){
-
- },
+
+ CONNECT_FAILURE: 'connect',
- afterDrag : function(){
+
+ LOAD_FAILURE: 'load'
- },
- toString: function() {
- return ("DDProxy " + this.id);
}
-
});
-Ext.dd.DDTarget = function(id, sGroup, config) {
- if (id) {
- this.initTarget(id, sGroup, config);
- }
-};
+Ext.define('Ext.form.action.Submit', {
+ extend:'Ext.form.action.Action',
+ alternateClassName: 'Ext.form.Action.Submit',
+ alias: 'formaction.submit',
+
+ type: 'submit',
-Ext.extend(Ext.dd.DDTarget, Ext.dd.DragDrop, {
-
- getDragEl: Ext.emptyFn,
-
- isValidHandleChild: Ext.emptyFn,
-
- startDrag: Ext.emptyFn,
-
- endDrag: Ext.emptyFn,
-
- onDrag: Ext.emptyFn,
-
- onDragDrop: Ext.emptyFn,
-
- onDragEnter: Ext.emptyFn,
-
- onDragOut: Ext.emptyFn,
-
- onDragOver: Ext.emptyFn,
-
- onInvalidDrop: Ext.emptyFn,
-
- onMouseDown: Ext.emptyFn,
-
- onMouseUp: Ext.emptyFn,
-
- setXConstraint: Ext.emptyFn,
-
- setYConstraint: Ext.emptyFn,
-
- resetConstraints: Ext.emptyFn,
-
- clearConstraints: Ext.emptyFn,
-
- clearTicks: Ext.emptyFn,
-
- setInitPosition: Ext.emptyFn,
-
- setDragElId: Ext.emptyFn,
-
- setHandleElId: Ext.emptyFn,
-
- setOuterHandleElId: Ext.emptyFn,
-
- addInvalidHandleClass: Ext.emptyFn,
-
- addInvalidHandleId: Ext.emptyFn,
-
- addInvalidHandleType: Ext.emptyFn,
-
- removeInvalidHandleClass: Ext.emptyFn,
- removeInvalidHandleId: Ext.emptyFn,
+
- removeInvalidHandleType: Ext.emptyFn,
+ run : function(){
+ var form = this.form;
+ if (this.clientValidation === false || form.isValid()) {
+ this.doSubmit();
+ } else {
+
+ this.failureType = Ext.form.action.Action.CLIENT_INVALID;
+ form.afterAction(this, false);
+ }
+ },
- toString: function() {
- return ("DDTarget " + this.id);
- }
-});
-Ext.dd.DragTracker = Ext.extend(Ext.util.Observable, {
-
- active: false,
-
- tolerance: 5,
-
- autoStart: false,
- constructor : function(config){
- Ext.apply(this, config);
- this.addEvents(
-
- 'mousedown',
-
- 'mouseup',
-
- 'mousemove',
-
- 'dragstart',
-
- 'dragend',
-
- 'drag'
- );
-
- this.dragRegion = new Ext.lib.Region(0,0,0,0);
-
- if(this.el){
- this.initEl(this.el);
- }
- Ext.dd.DragTracker.superclass.constructor.call(this, config);
- },
-
- initEl: function(el){
- this.el = Ext.get(el);
- el.on('mousedown', this.onMouseDown, this,
- this.delegate ? {delegate: this.delegate} : undefined);
+ doSubmit: function() {
+ var formEl,
+ ajaxOptions = Ext.apply(this.createCallback(), {
+ url: this.getUrl(),
+ method: this.getMethod(),
+ headers: this.headers
+ });
+
+
+
+ if (this.form.hasUpload()) {
+ formEl = ajaxOptions.form = this.buildForm();
+ ajaxOptions.isUpload = true;
+ } else {
+ ajaxOptions.params = this.getParams();
+ }
+
+ Ext.Ajax.request(ajaxOptions);
+
+ if (formEl) {
+ Ext.removeNode(formEl);
+ }
},
- destroy : function(){
- this.el.un('mousedown', this.onMouseDown, this);
- delete this.el;
+
+ getParams: function() {
+ var nope = false,
+ configParams = this.callParent(),
+ fieldParams = this.form.getValues(nope, nope, this.submitEmptyText !== nope);
+ return Ext.apply({}, fieldParams, configParams);
},
- onMouseDown: function(e, target){
- if(this.fireEvent('mousedown', this, e) !== false && this.onBeforeStart(e) !== false){
- this.startXY = this.lastXY = e.getXY();
- this.dragTarget = this.delegate ? target : this.el.dom;
- if(this.preventDefault !== false){
- e.preventDefault();
+
+ buildForm: function() {
+ var fieldsSpec = [],
+ formSpec,
+ formEl,
+ basicForm = this.form,
+ params = this.getParams(),
+ uploadFields = [];
+
+ basicForm.getFields().each(function(field) {
+ if (field.isFileUpload()) {
+ uploadFields.push(field);
}
- Ext.getDoc().on({
- scope: this,
- mouseup: this.onMouseUp,
- mousemove: this.onMouseMove,
- selectstart: this.stopSelect
+ });
+
+ function addField(name, val) {
+ fieldsSpec.push({
+ tag: 'input',
+ type: 'hidden',
+ name: name,
+ value: val
});
- if(this.autoStart){
- this.timer = this.triggerStart.defer(this.autoStart === true ? 1000 : this.autoStart, this, [e]);
- }
}
- },
- onMouseMove: function(e, target){
- if(this.active && Ext.isIE && !e.browserEvent.button){
- e.preventDefault();
- this.onMouseUp(e);
- return;
+ Ext.iterate(params, function(key, val) {
+ if (Ext.isArray(val)) {
+ Ext.each(val, function(v) {
+ addField(key, v);
+ });
+ } else {
+ addField(key, val);
+ }
+ });
+
+ formSpec = {
+ tag: 'form',
+ action: this.getUrl(),
+ method: this.getMethod(),
+ target: this.target || '_self',
+ style: 'display:none',
+ cn: fieldsSpec
+ };
+
+
+ if (uploadFields.length) {
+ formSpec.encoding = formSpec.enctype = 'multipart/form-data';
}
- e.preventDefault();
- var xy = e.getXY(), s = this.startXY;
- this.lastXY = xy;
- if(!this.active){
- if(Math.abs(s[0]-xy[0]) > this.tolerance || Math.abs(s[1]-xy[1]) > this.tolerance){
- this.triggerStart(e);
- }else{
- return;
+
+ formEl = Ext.core.DomHelper.append(Ext.getBody(), formSpec);
+
+
+
+
+ Ext.Array.each(uploadFields, function(field) {
+ if (field.rendered) {
+ formEl.appendChild(field.extractFileInput());
}
- }
- this.fireEvent('mousemove', this, e);
- this.onDrag(e);
- this.fireEvent('drag', this, e);
- },
+ });
- onMouseUp: function(e) {
- var doc = Ext.getDoc(),
- wasActive = this.active;
-
- doc.un('mousemove', this.onMouseMove, this);
- doc.un('mouseup', this.onMouseUp, this);
- doc.un('selectstart', this.stopSelect, this);
- e.preventDefault();
- this.clearStart();
- this.active = false;
- delete this.elRegion;
- this.fireEvent('mouseup', this, e);
- if(wasActive){
- this.onEnd(e);
- this.fireEvent('dragend', this, e);
- }
+ return formEl;
},
- triggerStart: function(e) {
- this.clearStart();
- this.active = true;
- this.onStart(e);
- this.fireEvent('dragstart', this, e);
- },
- clearStart : function() {
- if(this.timer){
- clearTimeout(this.timer);
- delete this.timer;
+
+
+ onSuccess: function(response) {
+ var form = this.form,
+ success = true,
+ result = this.processResponse(response);
+ if (result !== true && !result.success) {
+ if (result.errors) {
+ form.markInvalid(result.errors);
+ }
+ this.failureType = Ext.form.action.Action.SERVER_INVALID;
+ success = false;
}
+ form.afterAction(this, success);
},
- stopSelect : function(e) {
- e.stopEvent();
- return false;
- },
-
- onBeforeStart : function(e) {
+ handleResponse: function(response) {
+ var form = this.form,
+ errorReader = form.errorReader,
+ rs, errors, i, len, records;
+ if (errorReader) {
+ rs = errorReader.read(response);
+ records = rs.records;
+ errors = [];
+ if (records) {
+ for(i = 0, len = records.length; i < len; i++) {
+ errors[i] = records[i].data;
+ }
+ }
+ if (errors.length < 1) {
+ errors = null;
+ }
+ return {
+ success : rs.success,
+ errors : errors
+ };
+ }
+ return Ext.decode(response.responseText);
+ }
+});
- },
+
+Ext.define('Ext.util.ComponentDragger', {
- onStart : function(xy) {
- },
+
- onDrag : function(e) {
- },
+ extend: 'Ext.dd.DragTracker',
-
- onEnd : function(e) {
+ autoStart: 500,
+ constructor: function(comp, config) {
+ this.comp = comp;
+ this.initialConstrainTo = config.constrainTo;
+ this.callParent([ config ]);
},
-
- getDragTarget : function(){
- return this.dragTarget;
- },
+ onStart: function(e) {
+ var me = this,
+ comp = me.comp;
- getDragCt : function(){
- return this.el;
- },
+
+ this.startPosition = comp.getPosition();
- getXY : function(constrain){
- return constrain ?
- this.constrainModes[constrain].call(this, this.lastXY) : this.lastXY;
- },
+
+
+ if (comp.ghost && !comp.liveDrag) {
+ me.proxy = comp.ghost();
+ me.dragTarget = me.proxy.header.el;
+ }
- getOffset : function(constrain){
- var xy = this.getXY(constrain),
- s = this.startXY;
- return [s[0]-xy[0], s[1]-xy[1]];
+
+ if (me.constrain || me.constrainDelegate) {
+ me.constrainTo = me.calculateConstrainRegion();
+ }
},
- constrainModes: {
- 'point' : function(xy){
+ calculateConstrainRegion: function() {
+ var me = this,
+ comp = me.comp,
+ c = me.initialConstrainTo,
+ delegateRegion,
+ elRegion,
+ shadowSize = comp.el.shadow ? comp.el.shadow.offset : 0;
- if(!this.elRegion){
- this.elRegion = this.getDragCt().getRegion();
- }
+
+ if (!(c instanceof Ext.util.Region)) {
+ c = Ext.fly(c).getViewRegion();
+ }
- var dr = this.dragRegion;
+
+ if (shadowSize) {
+ c.adjust(0, -shadowSize, -shadowSize, shadowSize);
+ }
- dr.left = xy[0];
- dr.top = xy[1];
- dr.right = xy[0];
- dr.bottom = xy[1];
+
+
+
+ if (!me.constrainDelegate) {
+ delegateRegion = Ext.fly(me.dragTarget).getRegion();
+ elRegion = me.proxy ? me.proxy.el.getRegion() : comp.el.getRegion();
- dr.constrainTo(this.elRegion);
+ c.adjust(
+ delegateRegion.top - elRegion.top,
+ delegateRegion.right - elRegion.right,
+ delegateRegion.bottom - elRegion.bottom,
+ delegateRegion.left - elRegion.left
+ );
+ }
+ return c;
+ },
- return [dr.left, dr.top];
+
+ onDrag: function(e) {
+ var me = this,
+ comp = (me.proxy && !me.comp.liveDrag) ? me.proxy : me.comp,
+ offset = me.getOffset(me.constrain || me.constrainDelegate ? 'dragTarget' : null);
+
+ comp.setPosition.apply(comp, [me.startPosition[0] + offset[0], me.startPosition[1] + offset[1]]);
+ },
+
+ onEnd: function(e) {
+ if (this.proxy && !this.comp.liveDrag) {
+ this.comp.unghost();
}
}
});
-Ext.dd.ScrollManager = function(){
- var ddm = Ext.dd.DragDropMgr;
- var els = {};
- var dragEl = null;
- var proc = {};
-
- var onStop = function(e){
- dragEl = null;
- clearProc();
- };
+
+Ext.define("Ext.form.Labelable", {
+ requires: ['Ext.XTemplate'],
+
- var triggerRefresh = function(){
- if(ddm.dragCurrent){
- ddm.refreshCache(ddm.dragCurrent.groups);
+ labelableRenderTpl: [
+ '',
+ ' for="{inputId}" class="{labelCls}" style="{labelStyle}" >',
+ '{fieldLabel}{labelSeparator} ',
+ '',
+ '',
+ '',
+ ' ',
+ ''
+ ],
+
- var clearProc = function(){
- if(proc.id){
- clearInterval(proc.id);
- }
- proc.id = 0;
- proc.el = null;
- proc.dir = "";
- };
+ isFieldLabelable: true,
- var startProc = function(el, dir){
- clearProc();
- proc.el = el;
- proc.dir = dir;
- var group = el.ddScrollConfig ? el.ddScrollConfig.ddGroup : undefined,
- freq = (el.ddScrollConfig && el.ddScrollConfig.frequency)
- ? el.ddScrollConfig.frequency
- : Ext.dd.ScrollManager.frequency;
+
+ formItemCls: Ext.baseCSSPrefix + 'form-item',
- if (group === undefined || ddm.dragCurrent.ddGroup == group) {
- proc.id = setInterval(doScroll, freq);
- }
- };
- var onFire = function(e, isDrop){
- if(isDrop || !ddm.dragCurrent){ return; }
- var dds = Ext.dd.ScrollManager;
- if(!dragEl || dragEl != ddm.dragCurrent){
- dragEl = ddm.dragCurrent;
-
- dds.refreshCache();
- }
-
- var xy = Ext.lib.Event.getXY(e);
- var pt = new Ext.lib.Point(xy[0], xy[1]);
- for(var id in els){
- var el = els[id], r = el._region;
- var c = el.ddScrollConfig ? el.ddScrollConfig : dds;
- if(r && r.contains(pt) && el.isScrollable()){
- if(r.bottom - pt.y <= c.vthresh){
- if(proc.el != el){
- startProc(el, "down");
- }
- return;
- }else if(r.right - pt.x <= c.hthresh){
- if(proc.el != el){
- startProc(el, "left");
- }
- return;
- }else if(pt.y - r.top <= c.vthresh){
- if(proc.el != el){
- startProc(el, "up");
- }
- return;
- }else if(pt.x - r.left <= c.hthresh){
- if(proc.el != el){
- startProc(el, "right");
- }
- return;
- }
- }
- }
- clearProc();
- };
+ labelCls: Ext.baseCSSPrefix + 'form-item-label',
+
- ddm.fireEvents = ddm.fireEvents.createSequence(onFire, ddm);
- ddm.stopDrag = ddm.stopDrag.createSequence(onStop, ddm);
+ errorMsgCls: Ext.baseCSSPrefix + 'form-error-msg',
+
- return {
-
- register : function(el){
- if(Ext.isArray(el)){
- for(var i = 0, len = el.length; i < len; i++) {
- this.register(el[i]);
- }
- }else{
- el = Ext.get(el);
- els[el.id] = el;
- }
- },
-
-
- unregister : function(el){
- if(Ext.isArray(el)){
- for(var i = 0, len = el.length; i < len; i++) {
- this.unregister(el[i]);
- }
- }else{
- el = Ext.get(el);
- delete els[el.id];
- }
- },
-
-
- vthresh : 25,
-
- hthresh : 25,
+ baseBodyCls: Ext.baseCSSPrefix + 'form-item-body',
-
- increment : 100,
-
-
- frequency : 500,
-
-
- animate: true,
-
-
- animDuration: .4,
-
-
- ddGroup: undefined,
-
-
- refreshCache : function(){
- for(var id in els){
- if(typeof els[id] == 'object'){
- els[id]._region = els[id].getRegion();
- }
- }
- }
- };
-}();
-Ext.dd.Registry = function(){
- var elements = {};
- var handles = {};
- var autoIdSeed = 0;
+
+ fieldBodyCls: '',
- var getId = function(el, autogen){
- if(typeof el == "string"){
- return el;
- }
- var id = el.id;
- if(!id && autogen !== false){
- id = "extdd-" + (++autoIdSeed);
- el.id = id;
- }
- return id;
- };
- return {
+ clearCls: Ext.baseCSSPrefix + 'clear',
+
- register : function(el, data){
- data = data || {};
- if(typeof el == "string"){
- el = document.getElementById(el);
- }
- data.ddel = el;
- elements[getId(el)] = data;
- if(data.isHandle !== false){
- handles[data.ddel.id] = data;
- }
- if(data.handles){
- var hs = data.handles;
- for(var i = 0, len = hs.length; i < len; i++){
- handles[getId(hs[i])] = data;
- }
- }
- },
+ invalidCls : Ext.baseCSSPrefix + 'form-invalid',
- unregister : function(el){
- var id = getId(el, false);
- var data = elements[id];
- if(data){
- delete elements[id];
- if(data.handles){
- var hs = data.handles;
- for(var i = 0, len = hs.length; i < len; i++){
- delete handles[getId(hs[i], false)];
- }
- }
- }
- },
+ fieldLabel: undefined,
- getHandle : function(id){
- if(typeof id != "string"){
- id = id.id;
- }
- return handles[id];
- },
+ labelAlign : 'left',
- getHandleFromEvent : function(e){
- var t = Ext.lib.Event.getTarget(e);
- return t ? handles[t.id] : null;
- },
+ labelWidth: 100,
+
+
+ labelPad : 5,
+
+
+ labelSeparator : ':',
+
+
+
+
+ hideLabel: false,
+
+
+ hideEmptyLabel: true,
+
+
+ preventMark: false,
+
+
+ autoFitErrors: true,
- getTarget : function(id){
- if(typeof id != "string"){
- id = id.id;
- }
- return elements[id];
- },
+ msgTarget: 'qtip',
- getTargetFromEvent : function(e){
- var t = Ext.lib.Event.getTarget(e);
- return t ? elements[t.id] || handles[t.id] : null;
- }
- };
-}();
-Ext.dd.StatusProxy = function(config){
- Ext.apply(this, config);
- this.id = this.id || Ext.id();
- this.el = new Ext.Layer({
- dh: {
- id: this.id, tag: "div", cls: "x-dd-drag-proxy "+this.dropNotAllowed, children: [
- {tag: "div", cls: "x-dd-drop-icon"},
- {tag: "div", cls: "x-dd-drag-ghost"}
- ]
- },
- shadow: !config || config.shadow !== false
- });
- this.ghost = Ext.get(this.el.dom.childNodes[1]);
- this.dropStatus = this.dropNotAllowed;
-};
-Ext.dd.StatusProxy.prototype = {
+
- dropAllowed : "x-dd-drop-ok",
+ initLabelable: function() {
+ this.addCls(this.formItemCls);
+
+ this.addEvents(
+
+ 'errorchange'
+ );
+ },
+
- dropNotAllowed : "x-dd-drop-nodrop",
+ getFieldLabel: function() {
+ return this.fieldLabel || '';
+ },
- setStatus : function(cssClass){
- cssClass = cssClass || this.dropNotAllowed;
- if(this.dropStatus != cssClass){
- this.el.replaceClass(this.dropStatus, cssClass);
- this.dropStatus = cssClass;
+ getLabelableRenderData: function() {
+ var me = this,
+ labelAlign = me.labelAlign,
+ labelPad = me.labelPad,
+ labelStyle;
+
+
+
+ if (labelAlign === 'top') {
+ labelStyle = 'margin-bottom:' + labelPad + 'px;';
+ } else {
+ labelStyle = 'margin-right:' + labelPad + 'px;';
+
+ if (Ext.isBorderBox) {
+ labelStyle += 'width:' + me.labelWidth + 'px;';
+ }
}
+
+ return Ext.copyTo(
+ {
+ inputId: me.getInputId(),
+ fieldLabel: me.getFieldLabel(),
+ labelStyle: labelStyle + (me.labelStyle || ''),
+ subTplMarkup: me.getSubTplMarkup()
+ },
+ me,
+ 'hideLabel,hideEmptyLabel,labelCls,fieldBodyCls,baseBodyCls,errorMsgCls,clearCls,labelSeparator',
+ true
+ );
},
- reset : function(clearGhost){
- this.el.dom.className = "x-dd-drag-proxy " + this.dropNotAllowed;
- this.dropStatus = this.dropNotAllowed;
- if(clearGhost){
- this.ghost.update("");
- }
+ getLabelableSelectors: function() {
+ return {
+
+ labelEl: 'label.' + this.labelCls,
+
+
+ bodyEl: '.' + this.baseBodyCls,
+
+
+ errorEl: '.' + this.errorMsgCls
+ };
},
- update : function(html){
- if(typeof html == "string"){
- this.ghost.update(html);
- }else{
- this.ghost.update("");
- html.style.margin = "0";
- this.ghost.dom.appendChild(html);
- }
- var el = this.ghost.dom.firstChild;
- if(el){
- Ext.fly(el).setStyle('float', 'none');
- }
+ getSubTplMarkup: function() {
+ return '';
},
- getEl : function(){
- return this.el;
+ getInputId: function() {
+ return '';
},
- getGhost : function(){
- return this.ghost;
+ getActiveError : function() {
+ return this.activeError || '';
},
- hide : function(clear){
- this.el.hide();
- if(clear){
- this.reset(true);
- }
+ hasActiveError: function() {
+ return !!this.getActiveError();
},
- stop : function(){
- if(this.anim && this.anim.isAnimated && this.anim.isAnimated()){
- this.anim.stop();
- }
+ setActiveError: function(msg) {
+ this.activeError = msg;
+ this.activeErrors = [msg];
+ this.renderActiveError();
},
- show : function(){
- this.el.show();
+ getActiveErrors: function() {
+ return this.activeErrors || [];
},
- sync : function(){
- this.el.sync();
+ setActiveErrors: function(errors) {
+ this.activeErrors = errors;
+ this.activeError = this.getTpl('activeErrorsTpl').apply({errors: errors});
+ this.renderActiveError();
},
- repair : function(xy, callback, scope){
- this.callback = callback;
- this.scope = scope;
- if(xy && this.animRepair !== false){
- this.el.addClass("x-dd-drag-repair");
- this.el.hideUnders(true);
- this.anim = this.el.shift({
- duration: this.repairDuration || .5,
- easing: 'easeOut',
- xy: xy,
- stopFx: true,
- callback: this.afterRepair,
- scope: this
- });
- }else{
- this.afterRepair();
- }
+ unsetActiveError: function() {
+ delete this.activeError;
+ delete this.activeErrors;
+ this.renderActiveError();
},
- afterRepair : function(){
- this.hide(true);
- if(typeof this.callback == "function"){
- this.callback.call(this.scope || this);
+ renderActiveError: function() {
+ var me = this,
+ activeError = me.getActiveError(),
+ hasError = !!activeError;
+
+ if (activeError !== me.lastActiveError) {
+ me.fireEvent('errorchange', me, activeError);
+ me.lastActiveError = activeError;
+ }
+
+ if (me.rendered && !me.isDestroyed && !me.preventMark) {
+
+ me.el[hasError ? 'addCls' : 'removeCls'](me.invalidCls);
+
+
+ me.getActionEl().dom.setAttribute('aria-invalid', hasError);
+
+
+ me.errorEl.dom.innerHTML = activeError;
}
- this.callback = null;
- this.scope = null;
},
+
- destroy: function(){
- Ext.destroy(this.ghost, this.el);
- }
-};
-Ext.dd.DragSource = function(el, config){
- this.el = Ext.get(el);
- if(!this.dragData){
- this.dragData = {};
- }
-
- Ext.apply(this, config);
+ setFieldDefaults: function(defaults) {
+ var me = this;
+ Ext.iterate(defaults, function(key, val) {
+ if (!me.hasOwnProperty(key)) {
+ me[key] = val;
+ }
+ });
+ },
+
- if(!this.proxy){
- this.proxy = new Ext.dd.StatusProxy();
+ getBodyNaturalWidth: function() {
+ return this.bodyEl.getWidth();
}
- Ext.dd.DragSource.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group,
- {dragElId : this.proxy.id, resizeFrame: false, isTarget: false, scroll: this.scroll === true});
+
+});
+
+
+Ext.define('Ext.form.field.Field', {
+
- this.dragging = false;
-};
+ isFormField : true,
-Ext.extend(Ext.dd.DragSource, Ext.dd.DDProxy, {
- dropAllowed : "x-dd-drop-ok",
- dropNotAllowed : "x-dd-drop-nodrop",
- getDragData : function(e){
- return this.dragData;
- },
+ disabled : false,
- onDragEnter : function(e, id){
- var target = Ext.dd.DragDropMgr.getDDById(id);
- this.cachedTarget = target;
- if(this.beforeDragEnter(target, e, id) !== false){
- if(target.isNotifyTarget){
- var status = target.notifyEnter(this, e, this.dragData);
- this.proxy.setStatus(status);
- }else{
- this.proxy.setStatus(this.dropAllowed);
- }
-
- if(this.afterDragEnter){
-
- this.afterDragEnter(target, e, id);
- }
- }
- },
+ submitValue: true,
- beforeDragEnter : function(target, e, id){
- return true;
- },
+ validateOnChange: true,
- alignElWithMouse: function() {
- Ext.dd.DragSource.superclass.alignElWithMouse.apply(this, arguments);
- this.proxy.sync();
- },
+ suspendCheckChange: 0,
- onDragOver : function(e, id){
- var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
- if(this.beforeDragOver(target, e, id) !== false){
- if(target.isNotifyTarget){
- var status = target.notifyOver(this, e, this.dragData);
- this.proxy.setStatus(status);
- }
+ initField: function() {
+ this.addEvents(
+
+ 'change',
+
+ 'validitychange',
+
+ 'dirtychange'
+ );
- if(this.afterDragOver){
-
- this.afterDragOver(target, e, id);
- }
- }
+ this.initValue();
},
- beforeDragOver : function(target, e, id){
- return true;
+ initValue: function() {
+ var me = this;
+
+
+ me.originalValue = me.lastValue = me.value;
+
+
+ me.suspendCheckChange++;
+ me.setValue(me.value);
+ me.suspendCheckChange--;
},
- onDragOut : function(e, id){
- var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
- if(this.beforeDragOut(target, e, id) !== false){
- if(target.isNotifyTarget){
- target.notifyOut(this, e, this.dragData);
- }
- this.proxy.reset();
- if(this.afterDragOut){
-
- this.afterDragOut(target, e, id);
- }
- }
- this.cachedTarget = null;
+ getName: function() {
+ return this.name;
},
- beforeDragOut : function(target, e, id){
- return true;
+ getValue: function() {
+ return this.value;
},
- onDragDrop : function(e, id){
- var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
- if(this.beforeDragDrop(target, e, id) !== false){
- if(target.isNotifyTarget){
- if(target.notifyDrop(this, e, this.dragData)){
- this.onValidDrop(target, e, id);
- }else{
- this.onInvalidDrop(target, e, id);
- }
- }else{
- this.onValidDrop(target, e, id);
- }
-
- if(this.afterDragDrop){
-
- this.afterDragDrop(target, e, id);
- }
- }
- delete this.cachedTarget;
+ setValue: function(value) {
+ var me = this;
+ me.value = value;
+ me.checkChange();
+ return me;
},
- beforeDragDrop : function(target, e, id){
- return true;
+ isEqual: function(value1, value2) {
+ return String(value1) === String(value2);
},
- onValidDrop : function(target, e, id){
- this.hideProxy();
- if(this.afterValidDrop){
-
- this.afterValidDrop(target, e, id);
+ getSubmitData: function() {
+ var me = this,
+ data = null;
+ if (!me.disabled && me.submitValue && !me.isFileUpload()) {
+ data = {};
+ data[me.getName()] = '' + me.getValue();
}
+ return data;
},
- getRepairXY : function(e, data){
- return this.el.getXY();
- },
-
-
- onInvalidDrop : function(target, e, id){
- this.beforeInvalidDrop(target, e, id);
- if(this.cachedTarget){
- if(this.cachedTarget.isNotifyTarget){
- this.cachedTarget.notifyOut(this, e, this.dragData);
- }
- this.cacheTarget = null;
- }
- this.proxy.repair(this.getRepairXY(e, this.dragData), this.afterRepair, this);
-
- if(this.afterInvalidDrop){
-
- this.afterInvalidDrop(e, id);
+ getModelData: function() {
+ var me = this,
+ data = null;
+ if (!me.disabled && !me.isFileUpload()) {
+ data = {};
+ data[me.getName()] = me.getValue();
}
+ return data;
},
- afterRepair : function(){
- if(Ext.enableFx){
- this.el.highlight(this.hlColor || "c3daf9");
- }
- this.dragging = false;
+ reset : function(){
+ var me = this;
+
+ me.setValue(me.originalValue);
+ me.clearInvalid();
+
+ delete me.wasValid;
},
- beforeInvalidDrop : function(target, e, id){
- return true;
+ resetOriginalValue: function() {
+ this.originalValue = this.getValue();
+ this.checkDirty();
},
- handleMouseDown : function(e){
- if(this.dragging) {
- return;
+ checkChange: function() {
+ if (!this.suspendCheckChange) {
+ var me = this,
+ newVal = me.getValue(),
+ oldVal = me.lastValue;
+ if (!me.isEqual(newVal, oldVal) && !me.isDestroyed) {
+ me.lastValue = newVal;
+ me.fireEvent('change', me, newVal, oldVal);
+ me.onChange(newVal, oldVal);
+ }
}
- var data = this.getDragData(e);
- if(data && this.onBeforeDrag(data, e) !== false){
- this.dragData = data;
- this.proxy.stop();
- Ext.dd.DragSource.superclass.handleMouseDown.apply(this, arguments);
- }
},
- onBeforeDrag : function(data, e){
- return true;
+ onChange: function(newVal, oldVal) {
+ if (this.validateOnChange) {
+ this.validate();
+ }
+ this.checkDirty();
},
- onStartDrag : Ext.emptyFn,
+ isDirty : function() {
+ var me = this;
+ return !me.disabled && !me.isEqual(me.getValue(), me.originalValue);
+ },
- startDrag : function(x, y){
- this.proxy.reset();
- this.dragging = true;
- this.proxy.update("");
- this.onInitDrag(x, y);
- this.proxy.show();
+ checkDirty: function() {
+ var me = this,
+ isDirty = me.isDirty();
+ if (isDirty !== me.wasDirty) {
+ me.fireEvent('dirtychange', me, isDirty);
+ me.onDirtyChange(isDirty);
+ me.wasDirty = isDirty;
+ }
},
- onInitDrag : function(x, y){
- var clone = this.el.dom.cloneNode(true);
- clone.id = Ext.id();
- this.proxy.update(clone);
- this.onStartDrag(x, y);
- return true;
- },
+ onDirtyChange: Ext.emptyFn,
- getProxy : function(){
- return this.proxy;
+ getErrors: function(value) {
+ return [];
},
- hideProxy : function(){
- this.proxy.hide();
- this.proxy.reset(true);
- this.dragging = false;
+ isValid : function() {
+ var me = this;
+ return me.disabled || Ext.isEmpty(me.getErrors());
},
- triggerCacheRefresh : function(){
- Ext.dd.DDM.refreshCache(this.groups);
+ validate : function() {
+ var me = this,
+ isValid = me.isValid();
+ if (isValid !== me.wasValid) {
+ me.wasValid = isValid;
+ me.fireEvent('validitychange', me, isValid);
+ }
+ return isValid;
},
- b4EndDrag: function(e) {
+ batchChanges: function(fn) {
+ this.suspendCheckChange++;
+ fn();
+ this.suspendCheckChange--;
+ this.checkChange();
},
- endDrag : function(e){
- this.onEndDrag(this.dragData, e);
+ isFileUpload: function() {
+ return false;
},
- onEndDrag : function(data, e){
+ extractFileInput: function() {
+ return null;
},
+
+ markInvalid: Ext.emptyFn,
+
- autoOffset : function(x, y) {
- this.setDelta(-12, -20);
- },
-
- destroy: function(){
- Ext.dd.DragSource.superclass.destroy.call(this);
- Ext.destroy(this.proxy);
- }
+ clearInvalid: Ext.emptyFn
+
});
-Ext.dd.DropTarget = Ext.extend(Ext.dd.DDTarget, {
-
- constructor : function(el, config){
- this.el = Ext.get(el);
-
- Ext.apply(this, config);
+
+
+Ext.define('Ext.layout.component.field.Field', {
+
- if(this.containerScroll){
- Ext.dd.ScrollManager.register(this.el);
- }
+
+ alias: ['layout.field'],
+
+ extend: 'Ext.layout.component.Component',
+
+ uses: ['Ext.tip.QuickTip', 'Ext.util.TextMetrics'],
+
- Ext.dd.DropTarget.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group,
- {isTarget: true});
+
+ type: 'field',
+
+ beforeLayout: function(width, height) {
+ var me = this;
+ return me.callParent(arguments) || (!me.owner.preventMark && me.activeError !== me.owner.getActiveError());
},
-
-
-
-
- dropAllowed : "x-dd-drop-ok",
-
- dropNotAllowed : "x-dd-drop-nodrop",
-
- isTarget : true,
+ onLayout: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ labelStrategy = me.getLabelStrategy(),
+ errorStrategy = me.getErrorStrategy(),
+ isDefined = Ext.isDefined,
+ isNumber = Ext.isNumber,
+ lastSize, autoWidth, autoHeight, info, undef;
-
- isNotifyTarget : true,
+ lastSize = me.lastComponentSize || {};
+ if (!isDefined(width)) {
+ width = lastSize.width;
+ if (width < 0) {
+ width = undef;
+ }
+ }
+ if (!isDefined(height)) {
+ height = lastSize.height;
+ if (height < 0) {
+ height = undef;
+ }
+ }
+ autoWidth = !isNumber(width);
+ autoHeight = !isNumber(height);
-
- notifyEnter : function(dd, e, data){
- if(this.overClass){
- this.el.addClass(this.overClass);
+ info = {
+ autoWidth: autoWidth,
+ autoHeight: autoHeight,
+ width: autoWidth ? owner.getBodyNaturalWidth() : width,
+ height: height,
+
+
+ insets: {
+ top: 0,
+ right: 0,
+ bottom: 0,
+ left: 0
+ }
+ };
+
+
+
+
+
+
+ labelStrategy.prepare(owner, info);
+ errorStrategy.prepare(owner, info);
+
+
+ labelStrategy.adjustHorizInsets(owner, info);
+ errorStrategy.adjustHorizInsets(owner, info);
+
+
+ labelStrategy.layoutHoriz(owner, info);
+ errorStrategy.layoutHoriz(owner, info);
+
+
+ labelStrategy.adjustVertInsets(owner, info);
+ errorStrategy.adjustVertInsets(owner, info);
+
+
+ labelStrategy.layoutVert(owner, info);
+ errorStrategy.layoutVert(owner, info);
+
+
+ if (autoWidth && autoHeight) {
+
+ me.setElementSize(owner.el, info.width, info.height);
+ } else {
+ me.setTargetSize(info.width, info.height);
}
- return this.dropAllowed;
+ me.sizeBody(info);
+
+ me.activeError = owner.getActiveError();
},
+
- notifyOver : function(dd, e, data){
- return this.dropAllowed;
+ sizeBody: function(info) {
+ var me = this,
+ owner = me.owner,
+ insets = info.insets,
+ totalWidth = info.width,
+ totalHeight = info.height,
+ width = Ext.isNumber(totalWidth) ? totalWidth - insets.left - insets.right : totalWidth,
+ height = Ext.isNumber(totalHeight) ? totalHeight - insets.top - insets.bottom : totalHeight;
+
+
+ me.setElementSize(owner.bodyEl, width, height);
+
+
+ me.sizeBodyContents(width, height);
},
- notifyOut : function(dd, e, data){
- if(this.overClass){
- this.el.removeClass(this.overClass);
- }
+ sizeBodyContents: Ext.emptyFn,
+
+
+
+ getLabelStrategy: function() {
+ var me = this,
+ strategies = me.labelStrategies,
+ labelAlign = me.owner.labelAlign;
+ return strategies[labelAlign] || strategies.base;
},
- notifyDrop : function(dd, e, data){
- return false;
+ getErrorStrategy: function() {
+ var me = this,
+ owner = me.owner,
+ strategies = me.errorStrategies,
+ msgTarget = owner.msgTarget;
+ return !owner.preventMark && Ext.isString(msgTarget) ?
+ (strategies[msgTarget] || strategies.elementId) :
+ strategies.none;
},
+
+
+
- destroy : function(){
- Ext.dd.DropTarget.superclass.destroy.call(this);
- if(this.containerScroll){
- Ext.dd.ScrollManager.unregister(this.el);
+ labelStrategies: (function() {
+ var applyIf = Ext.applyIf,
+ emptyFn = Ext.emptyFn,
+ base = {
+ prepare: function(owner, info) {
+ var cls = owner.labelCls + '-' + owner.labelAlign,
+ labelEl = owner.labelEl;
+ if (labelEl && !labelEl.hasCls(cls)) {
+ labelEl.addCls(cls);
+ }
+ },
+ adjustHorizInsets: emptyFn,
+ adjustVertInsets: emptyFn,
+ layoutHoriz: emptyFn,
+ layoutVert: emptyFn
+ },
+ left = applyIf({
+ prepare: function(owner, info) {
+ base.prepare(owner, info);
+
+ if (info.autoWidth) {
+ info.width += (!owner.labelEl ? 0 : owner.labelWidth + owner.labelPad);
+ }
+ },
+ adjustHorizInsets: function(owner, info) {
+ if (owner.labelEl) {
+ info.insets.left += owner.labelWidth + owner.labelPad;
+ }
+ },
+ layoutHoriz: function(owner, info) {
+
+
+
+
+
+ var labelEl = owner.labelEl;
+ if (labelEl && !owner.isLabelSized && !Ext.isBorderBox) {
+ labelEl.setWidth(owner.labelWidth);
+ owner.isLabelSized = true;
+ }
+ }
+ }, base);
+
+
+ return {
+ base: base,
+
+
+ top: applyIf({
+ adjustVertInsets: function(owner, info) {
+ var labelEl = owner.labelEl;
+ if (labelEl) {
+ info.insets.top += Ext.util.TextMetrics.measure(labelEl, owner.fieldLabel, info.width).height +
+ labelEl.getFrameWidth('tb') + owner.labelPad;
+ }
+ }
+ }, base),
+
+
+ left: left,
+
+
+ right: left
+ };
+ })(),
+
+
+
+
+ errorStrategies: (function() {
+ function setDisplayed(el, displayed) {
+ var wasDisplayed = el.getStyle('display') !== 'none';
+ if (displayed !== wasDisplayed) {
+ el.setDisplayed(displayed);
+ }
+ }
+
+ function setStyle(el, name, value) {
+ if (el.getStyle(name) !== value) {
+ el.setStyle(name, value);
+ }
+ }
+
+ var applyIf = Ext.applyIf,
+ emptyFn = Ext.emptyFn,
+ base = {
+ prepare: function(owner) {
+ setDisplayed(owner.errorEl, false);
+ },
+ adjustHorizInsets: emptyFn,
+ adjustVertInsets: emptyFn,
+ layoutHoriz: emptyFn,
+ layoutVert: emptyFn
+ };
+
+ return {
+ none: base,
+
+
+ side: applyIf({
+ prepare: function(owner) {
+ var errorEl = owner.errorEl;
+ errorEl.addCls(Ext.baseCSSPrefix + 'form-invalid-icon');
+ Ext.layout.component.field.Field.initTip();
+ errorEl.dom.setAttribute('data-errorqtip', owner.getActiveError() || '');
+ setDisplayed(errorEl, owner.hasActiveError());
+ },
+ adjustHorizInsets: function(owner, info) {
+ if (owner.autoFitErrors && owner.hasActiveError()) {
+ info.insets.right += owner.errorEl.getWidth();
+ }
+ },
+ layoutHoriz: function(owner, info) {
+ if (owner.hasActiveError()) {
+ setStyle(owner.errorEl, 'left', info.width - info.insets.right + 'px');
+ }
+ },
+ layoutVert: function(owner, info) {
+ if (owner.hasActiveError()) {
+ setStyle(owner.errorEl, 'top', info.insets.top + 'px');
+ }
+ }
+ }, base),
+
+
+ under: applyIf({
+ prepare: function(owner) {
+ var errorEl = owner.errorEl,
+ cls = Ext.baseCSSPrefix + 'form-invalid-under';
+ if (!errorEl.hasCls(cls)) {
+ errorEl.addCls(cls);
+ }
+ setDisplayed(errorEl, owner.hasActiveError());
+ },
+ adjustVertInsets: function(owner, info) {
+ if (owner.autoFitErrors) {
+ info.insets.bottom += owner.errorEl.getHeight();
+ }
+ },
+ layoutHoriz: function(owner, info) {
+ var errorEl = owner.errorEl,
+ insets = info.insets;
+
+ setStyle(errorEl, 'width', info.width - insets.right - insets.left + 'px');
+ setStyle(errorEl, 'marginLeft', insets.left + 'px');
+ }
+ }, base),
+
+
+ qtip: applyIf({
+ prepare: function(owner) {
+ setDisplayed(owner.errorEl, false);
+ Ext.layout.component.field.Field.initTip();
+ owner.getActionEl().dom.setAttribute('data-errorqtip', owner.getActiveError() || '');
+ }
+ }, base),
+
+
+ title: applyIf({
+ prepare: function(owner) {
+ setDisplayed(owner.errorEl, false);
+ owner.el.dom.title = owner.getActiveError() || '';
+ }
+ }, base),
+
+
+ elementId: applyIf({
+ prepare: function(owner) {
+ setDisplayed(owner.errorEl, false);
+ var targetEl = Ext.fly(owner.msgTarget);
+ if (targetEl) {
+ targetEl.dom.innerHTML = owner.getActiveError() || '';
+ targetEl.setDisplayed(owner.hasActiveError());
+ }
+ }
+ }, base)
+ };
+ })(),
+
+ statics: {
+
+ initTip: function() {
+ var tip = this.tip;
+ if (!tip) {
+ tip = this.tip = Ext.create('Ext.tip.QuickTip', {
+ baseCls: Ext.baseCSSPrefix + 'form-invalid-tip',
+ renderTo: Ext.getBody()
+ });
+ tip.tagConfig = Ext.apply({}, {attribute: 'errorqtip'}, tip.tagConfig);
+ }
+ },
+
+
+ destroyTip: function() {
+ var tip = this.tip;
+ if (tip) {
+ tip.destroy();
+ delete this.tip;
+ }
}
}
+
});
-Ext.dd.DragZone = Ext.extend(Ext.dd.DragSource, {
-
- constructor : function(el, config){
- Ext.dd.DragZone.superclass.constructor.call(this, el, config);
- if(this.containerScroll){
- Ext.dd.ScrollManager.register(this.el);
- }
- },
-
-
-
-
+
+Ext.define('Ext.form.field.VTypes', (function(){
- getDragData : function(e){
- return Ext.dd.Registry.getHandleFromEvent(e);
- },
-
-
- onInitDrag : function(x, y){
- this.proxy.update(this.dragData.ddel.cloneNode(true));
- this.onStartDrag(x, y);
- return true;
- },
-
+ var alpha = /^[a-zA-Z_]+$/,
+ alphanum = /^[a-zA-Z0-9_]+$/,
+ email = /^(\w+)([\-+.][\w]+)*@(\w[\-\w]*\.){1,5}([A-Za-z]){2,6}$/,
+ url = /(((^https?)|(^ftp)):\/\/([\-\w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*(([\w\-\.\?\\\/+@&#;`~=%!]*)(\.\w{2,})?)*\/?)/i;
+
- afterRepair : function(){
- if(Ext.enableFx){
- Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9");
- }
- this.dragging = false;
+ return {
+ singleton: true,
+ alternateClassName: 'Ext.form.VTypes',
+
+
+ 'email' : function(v){
+ return email.test(v);
+ },
+
+ 'emailText' : 'This field should be an e-mail address in the format "user@example.com"',
+
+ 'emailMask' : /[a-z0-9_\.\-@\+]/i,
+
+
+ 'url' : function(v){
+ 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.define('Ext.layout.component.field.Text', {
+ extend: 'Ext.layout.component.field.Field',
+ alias: 'layout.textfield',
+ requires: ['Ext.util.TextMetrics'],
+
+ type: 'textfield',
+
+
+
+ beforeLayout: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ lastValue = this.lastValue,
+ value = owner.getRawValue();
+ this.lastValue = value;
+ return me.callParent(arguments) || (owner.grow && value !== lastValue);
},
+
- getRepairXY : function(e){
- return Ext.Element.fly(this.dragData.ddel).getXY();
+ sizeBodyContents: function(width, height) {
+ var size = this.adjustForGrow(width, height);
+ this.setElementSize(this.owner.inputEl, size[0], size[1]);
},
+
+
- destroy : function(){
- Ext.dd.DragZone.superclass.destroy.call(this);
- if(this.containerScroll){
- Ext.dd.ScrollManager.unregister(this.el);
+ adjustForGrow: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ inputEl, value, calcWidth,
+ result = [width, height];
+
+ if (owner.grow) {
+ inputEl = owner.inputEl;
+
+
+ value = (inputEl.dom.value || (owner.hasFocus ? '' : owner.emptyText) || '') + owner.growAppend;
+ calcWidth = inputEl.getTextWidth(value) + inputEl.getBorderWidth("lr") + inputEl.getPadding("lr");
+
+
+ result[0] = Ext.Number.constrain(calcWidth, owner.growMin,
+ Math.max(owner.growMin, Math.min(owner.growMax, Ext.isNumber(width) ? width : Infinity)));
}
+
+ return result;
}
+
});
-Ext.dd.DropZone = function(el, config){
- Ext.dd.DropZone.superclass.constructor.call(this, el, config);
-};
-Ext.extend(Ext.dd.DropZone, Ext.dd.DropTarget, {
-
- getTargetFromEvent : function(e){
- return Ext.dd.Registry.getTargetFromEvent(e);
- },
-
- onNodeEnter : function(n, dd, e, data){
-
- },
+Ext.define('Ext.layout.component.field.TextArea', {
+ extend: 'Ext.layout.component.field.Text',
+ alias: 'layout.textareafield',
-
- onNodeOver : function(n, dd, e, data){
- return this.dropAllowed;
- },
+ type: 'textareafield',
-
- onNodeOut : function(n, dd, e, data){
-
- },
- onNodeDrop : function(n, dd, e, data){
- return false;
- },
+ adjustForGrow: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ inputEl, value, max,
+ curWidth, curHeight, calcHeight,
+ result = [width, height];
-
- onContainerOver : function(dd, e, data){
- return this.dropNotAllowed;
- },
+ if (owner.grow) {
+ inputEl = owner.inputEl;
+ curWidth = inputEl.getWidth(true);
+ curHeight = inputEl.getHeight();
-
- onContainerDrop : function(dd, e, data){
- return false;
- },
+
+ value = inputEl.dom.value || ' ';
+ value += owner.growAppend;
-
- notifyEnter : function(dd, e, data){
- return this.dropNotAllowed;
- },
+
+ value = value.replace(/\n/g, '
'); - - notifyOver : function(dd, e, data){ - var n = this.getTargetFromEvent(e); - if(!n){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; - } - return this.onContainerOver(dd, e, data); - } - if(this.lastOverNode != n){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - } - this.onNodeEnter(n, dd, e, data); - this.lastOverNode = n; - } - return this.onNodeOver(n, dd, e, data); - }, + + calcHeight = Ext.util.TextMetrics.measure(inputEl, value, curWidth).height + + inputEl.getBorderWidth("tb") + inputEl.getPadding("tb"); - - notifyOut : function(dd, e, data){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; + + max = owner.growMax; + if (Ext.isNumber(height)) { + max = Math.min(max, height); + } + result[1] = Ext.Number.constrain(calcHeight, owner.growMin, max); } - }, - - notifyDrop : function(dd, e, data){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; - } - var n = this.getTargetFromEvent(e); - return n ? - this.onNodeDrop(n, dd, e, data) : - this.onContainerDrop(dd, e, data); - }, + return result; + } - - triggerCacheRefresh : function(){ - Ext.dd.DDM.refreshCache(this.groups); - } }); -Ext.Element.addMethods({ - - initDD : function(group, config, overrides){ - var dd = new Ext.dd.DD(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - }, - - initDDProxy : function(group, config, overrides){ - var dd = new Ext.dd.DDProxy(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - }, + +Ext.define('Ext.layout.container.Anchor', { - initDDTarget : function(group, config, overrides){ - var dd = new Ext.dd.DDTarget(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - } -}); -Ext.data.Api = (function() { + alias: 'layout.anchor', + extend: 'Ext.layout.container.Container', + alternateClassName: 'Ext.layout.AnchorLayout', + + + type: 'anchor', + + defaultAnchor: '100%', + + parseAnchorRE: /^(r|right|b|bottom)$/i, + - var validActions = {}; + onLayout: function() { + this.callParent(arguments); - return { - - actions : { - create : 'create', - read : 'read', - update : 'update', - destroy : 'destroy' - }, + var me = this, + size = me.getLayoutTargetSize(), + owner = me.owner, + target = me.getTarget(), + ownerWidth = size.width, + ownerHeight = size.height, + overflow = target.getStyle('overflow'), + components = me.getVisibleItems(owner), + len = components.length, + boxes = [], + box, newTargetSize, anchorWidth, anchorHeight, component, anchorSpec, calcWidth, calcHeight, + anchorsArray, anchor, i, el; - - restActions : { - create : 'POST', - read : 'GET', - update : 'PUT', - destroy : 'DELETE' - }, + if (ownerWidth < 20 && ownerHeight < 20) { + return; + } - isAction : function(action) { - return (Ext.data.Api.actions[action]) ? true : false; - }, + + + if (!me.clearEl) { + me.clearEl = target.createChild({ + cls: Ext.baseCSSPrefix + 'clear', + role: 'presentation' + }); + } - getVerb : function(name) { - if (validActions[name]) { - return validActions[name]; + if (owner.anchorSize) { + if (typeof owner.anchorSize == 'number') { + anchorWidth = owner.anchorSize; } - for (var verb in this.actions) { - if (this.actions[verb] === name) { - validActions[name] = verb; - break; - } + else { + anchorWidth = owner.anchorSize.width; + anchorHeight = owner.anchorSize.height; } - return (validActions[name] !== undefined) ? validActions[name] : null; - }, + } + else { + anchorWidth = owner.initialConfig.width; + anchorHeight = owner.initialConfig.height; + } - isValid : function(api){ - var invalid = []; - var crud = this.actions; - for (var action in api) { - if (!(action in crud)) { - invalid.push(action); - } - } - return (!invalid.length) ? true : invalid; - }, + if (!Ext.supports.RightMargin) { + target.addCls(Ext.baseCSSPrefix + 'inline-children'); + } - - hasUniqueUrl : function(proxy, verb) { - var url = (proxy.api[verb]) ? proxy.api[verb].url : null; - var unique = true; - for (var action in proxy.api) { - if ((unique = (action === verb) ? true : (proxy.api[action].url != url) ? true : false) === false) { - break; - } - } - return unique; - }, + for (i = 0; i < len; i++) { + component = components[i]; + el = component.el; + anchor = component.anchor; - - prepare : function(proxy) { - if (!proxy.api) { - proxy.api = {}; + if (!component.anchor && component.items && !Ext.isNumber(component.width) && !(Ext.isIE6 && Ext.isStrict)) { + component.anchor = anchor = me.defaultAnchor; } - for (var verb in this.actions) { - var action = this.actions[verb]; - proxy.api[action] = proxy.api[action] || proxy.url || proxy.directFn; - if (typeof(proxy.api[action]) == 'string') { - proxy.api[action] = { - url: proxy.api[action], - method: (proxy.restful === true) ? Ext.data.Api.restActions[action] : undefined + + if (anchor) { + anchorSpec = component.anchorSpec; + + if (!anchorSpec) { + anchorsArray = anchor.split(' '); + component.anchorSpec = anchorSpec = { + right: me.parseAnchor(anchorsArray[0], component.initialConfig.width, anchorWidth), + bottom: me.parseAnchor(anchorsArray[1], component.initialConfig.height, anchorHeight) }; } + calcWidth = anchorSpec.right ? me.adjustWidthAnchor(anchorSpec.right(ownerWidth) - el.getMargin('lr'), component) : undefined; + calcHeight = anchorSpec.bottom ? me.adjustHeightAnchor(anchorSpec.bottom(ownerHeight) - el.getMargin('tb'), component) : undefined; + + boxes.push({ + component: component, + anchor: true, + width: calcWidth || undefined, + height: calcHeight || undefined + }); + } else { + boxes.push({ + component: component, + anchor: false + }); } - }, + } - restify : function(proxy) { - proxy.restful = true; - for (var verb in this.restActions) { - proxy.api[this.actions[verb]].method || - (proxy.api[this.actions[verb]].method = this.restActions[verb]); - } - - - proxy.onWrite = proxy.onWrite.createInterceptor(function(action, o, response, rs) { - var reader = o.reader; - var res = new Ext.data.Response({ - action: action, - raw: response - }); - - switch (response.status) { - case 200: - return true; - break; - case 201: - if (Ext.isEmpty(res.raw.responseText)) { - res.success = true; - } else { - - return true; - } - break; - case 204: - res.success = true; - res.data = null; - break; - default: - return true; - break; - } - if (res.success === true) { - this.fireEvent("write", this, action, res.data, res, rs, o.request.arg); - } else { - this.fireEvent('exception', this, 'remote', action, o, res, rs); - } - o.request.callback.call(o.request.scope, res.data, res, res.success); - - return false; - }, proxy); + if (!Ext.supports.RightMargin) { + target.removeCls(Ext.baseCSSPrefix + 'inline-children'); } - }; -})(); + for (i = 0; i < len; i++) { + box = boxes[i]; + me.setItemSize(box.component, box.width, box.height); + } -Ext.data.Response = function(params, response) { - Ext.apply(this, params, { - raw: response - }); -}; -Ext.data.Response.prototype = { - message : null, - success : false, - status : null, - root : null, - raw : null, + if (overflow && overflow != 'hidden' && !me.adjustmentPass) { + newTargetSize = me.getLayoutTargetSize(); + if (newTargetSize.width != size.width || newTargetSize.height != size.height) { + me.adjustmentPass = true; + me.onLayout(); + } + } - getMessage : function() { - return this.message; - }, - getSuccess : function() { - return this.success; + delete me.adjustmentPass; }, - getStatus : function() { - return this.status; - }, - getRoot : function() { - return this.root; - }, - getRawResponse : function() { - return this.raw; - } -}; + + parseAnchor: function(a, start, cstart) { + if (a && a != 'none') { + var ratio; + + if (this.parseAnchorRE.test(a)) { + var diff = cstart - start; + return function(v) { + return v - diff; + }; + } + + else if (a.indexOf('%') != -1) { + ratio = parseFloat(a.replace('%', '')) * 0.01; + return function(v) { + return Math.floor(v * ratio); + }; + } + + else { + a = parseInt(a, 10); + if (!isNaN(a)) { + return function(v) { + return v + a; + }; + } + } + } + return null; + }, -Ext.data.Api.Error = Ext.extend(Ext.Error, { - constructor : function(message, arg) { - this.arg = arg; - Ext.Error.call(this, message); + + adjustWidthAnchor: function(value, comp) { + return value; }, - name: 'Ext.data.Api' -}); -Ext.apply(Ext.data.Api.Error.prototype, { - lang: { - 'action-url-undefined': 'No fallback url defined for this action. When defining a DataProxy api, please be sure to define an url for each CRUD action in Ext.data.Api.actions or define a default url in addition to your api-configuration.', - 'invalid': 'received an invalid API-configuration. Please ensure your proxy API-configuration contains only the actions defined in Ext.data.Api.actions', - 'invalid-url': 'Invalid url. Please review your proxy configuration.', - 'execute': 'Attempted to execute an unknown action. Valid API actions are defined in Ext.data.Api.actions"' + + + adjustHeightAnchor: function(value, comp) { + return value; } -}); +}); +Ext.define('Ext.form.action.Load', { + extend:'Ext.form.action.Action', + requires: ['Ext.data.Connection'], + alternateClassName: 'Ext.form.Action.Load', + alias: 'formaction.load', + type: 'load', -Ext.data.SortTypes = { - none : function(s){ - return s; + run: function() { + Ext.Ajax.request(Ext.apply( + this.createCallback(), + { + method: this.getMethod(), + url: this.getUrl(), + headers: this.headers, + params: this.getParams() + } + )); }, + - - stripTagsRE : /<\/?[^>]+>/gi, - - - asText : function(s){ - return String(s).replace(this.stripTagsRE, ""); + onSuccess: function(response){ + var result = this.processResponse(response), + form = this.form; + if (result === true || !result.success || !result.data) { + this.failureType = Ext.form.action.Action.LOAD_FAILURE; + form.afterAction(this, false); + return; + } + form.clearInvalid(); + form.setValues(result.data); + form.afterAction(this, true); }, + + handleResponse: function(response) { + var reader = this.form.reader, + rs, data; + if (reader) { + rs = reader.read(response); + data = rs.records && rs.records[0] ? rs.records[0].data : null; + return { + success : rs.success, + data : data + }; + } + return Ext.decode(response.responseText); + } +}); + + + +Ext.define('Ext.window.Window', { + extend: 'Ext.panel.Panel', + + alternateClassName: 'Ext.Window', + + requires: ['Ext.util.ComponentDragger', 'Ext.util.Region', 'Ext.EventManager'], + + alias: 'widget.window', + - asUCText : function(s){ - return String(s).toUpperCase().replace(this.stripTagsRE, ""); - }, - asUCString : function(s) { - return String(s).toUpperCase(); - }, - asDate : function(s) { - if(!s){ - return 0; - } - if(Ext.isDate(s)){ - return s.getTime(); - } - return Date.parse(String(s)); - }, - asFloat : function(s) { - var val = parseFloat(String(s).replace(/,/g, "")); - return isNaN(val) ? 0 : val; - }, + - asInt : function(s) { - var val = parseInt(String(s).replace(/,/g, ""), 10); - return isNaN(val) ? 0 : val; - } -}; -Ext.data.Record = function(data, id){ + baseCls: Ext.baseCSSPrefix + 'window', + - this.id = (id || id === 0) ? id : Ext.data.Record.id(this); - this.data = data || {}; -}; + resizable: true, + + draggable: true, -Ext.data.Record.create = function(o){ - var f = Ext.extend(Ext.data.Record, {}); - var p = f.prototype; - p.fields = new Ext.util.MixedCollection(false, function(field){ - return field.name; - }); - for(var i = 0, len = o.length; i < len; i++){ - p.fields.add(new Ext.data.Field(o[i])); - } - f.getField = function(name){ - return p.fields.get(name); - }; - return f; -}; + + constrain: false, -Ext.data.Record.PREFIX = 'ext-record'; -Ext.data.Record.AUTO_ID = 1; -Ext.data.Record.EDIT = 'edit'; -Ext.data.Record.REJECT = 'reject'; -Ext.data.Record.COMMIT = 'commit'; + + constrainHeader: false, + + plain: false, + + minimizable: false, -Ext.data.Record.id = function(rec) { - rec.phantom = true; - return [Ext.data.Record.PREFIX, '-', Ext.data.Record.AUTO_ID++].join(''); -}; + + maximizable: false, -Ext.data.Record.prototype = { + minHeight: 100, + + minWidth: 200, + + expandOnShow: true, + + collapsible: false, + + closable: true, + - dirty : false, - editing : false, - error : null, + hidden: true, + - modified : null, + autoRender: true, + - phantom : false, + hideMode: 'visibility', - join : function(store){ - - this.store = store; - }, + floating: true, + ariaRole: 'alertdialog', - set : function(name, value){ - var encode = Ext.isPrimitive(value) ? String : Ext.encode; - if(encode(this.data[name]) == encode(value)) { - return; - } - this.dirty = true; - if(!this.modified){ - this.modified = {}; - } - if(this.modified[name] === undefined){ - this.modified[name] = this.data[name]; - } - this.data[name] = value; - if(!this.editing){ - this.afterEdit(); - } - }, + itemCls: 'x-window-item', + overlapHeader: true, - afterEdit : function(){ - if (this.store != undefined && typeof this.store.afterEdit == "function") { - this.store.afterEdit(this); - } - }, + ignoreHeaderBorderManagement: true, - afterReject : function(){ - if(this.store){ - this.store.afterReject(this); + initComponent: function() { + var me = this; + me.callParent(); + me.addEvents( + + + + 'resize', + + 'maximize', + + 'minimize', + + 'restore' + ); + + if (me.plain) { + me.addClsWithUI('plain'); } - }, - - afterCommit : function(){ - if(this.store){ - this.store.afterCommit(this); + if (me.modal) { + me.ariaRole = 'dialog'; } }, - get : function(name){ - return this.data[name]; - }, - - beginEdit : function(){ - this.editing = true; - this.modified = this.modified || {}; - }, - - cancelEdit : function(){ - this.editing = false; - delete this.modified; + initStateEvents: function(){ + var events = this.stateEvents; + + Ext.each(['maximize', 'restore', 'resize', 'dragend'], function(event){ + if (Ext.Array.indexOf(events, event)) { + events.push(event); + } + }); + this.callParent(); }, - - endEdit : function(){ - this.editing = false; - if(this.dirty){ - this.afterEdit(); - } + getState: function() { + var me = this, + state = me.callParent() || {}, + maximized = !!me.maximized; + + state.maximized = maximized; + Ext.apply(state, { + size: maximized ? me.restoreSize : me.getSize(), + pos: maximized ? me.restorePos : me.getPosition() + }); + return state; }, - - reject : function(silent){ - var m = this.modified; - for(var n in m){ - if(typeof m[n] != "function"){ - this.data[n] = m[n]; + applyState: function(state){ + var me = this; + + if (state) { + me.maximized = state.maximized; + if (me.maximized) { + me.hasSavedRestore = true; + me.restoreSize = state.size; + me.restorePos = state.pos; + } else { + Ext.apply(me, { + width: state.size.width, + height: state.size.height, + x: state.pos[0], + y: state.pos[1] + }); } } - this.dirty = false; - delete this.modified; - this.editing = false; - if(silent !== true){ - this.afterReject(); - } }, - commit : function(silent){ - this.dirty = false; - delete this.modified; - this.editing = false; - if(silent !== true){ - this.afterCommit(); + onMouseDown: function () { + if (this.floating) { + this.toFront(); } }, - getChanges : function(){ - var m = this.modified, cs = {}; - for(var n in m){ - if(m.hasOwnProperty(n)){ - cs[n] = this.data[n]; - } - } - return cs; - }, + onRender: function(ct, position) { + var me = this; + me.callParent(arguments); + me.focusEl = me.el; - - hasError : function(){ - return this.error !== null; + + if (me.maximizable) { + me.header.on({ + dblclick: { + fn: me.toggleMaximize, + element: 'el', + scope: me + } + }); + } }, - clearError : function(){ - this.error = null; - }, + afterRender: function() { + var me = this, + hidden = me.hidden, + keyMap; - - copy : function(newId) { - return new this.constructor(Ext.apply({}, this.data), newId || this.id); - }, + me.hidden = false; + + me.callParent(); + me.hidden = hidden; - - isModified : function(fieldName){ - return !!(this.modified && this.modified.hasOwnProperty(fieldName)); - }, + + me.proxy = me.getProxy(); - - isValid : function() { - return this.fields.find(function(f) { - return (f.allowBlank === false && Ext.isEmpty(this.data[f.name])) ? true : false; - },this) ? false : true; - }, + + me.mon(me.el, 'mousedown', me.onMouseDown, me); - - markDirty : function(){ - this.dirty = true; - if(!this.modified){ - this.modified = {}; + + if (me.maximized) { + me.maximized = false; + me.maximize(); } - this.fields.each(function(f) { - this.modified[f.name] = this.data[f.name]; - },this); - } -}; - -Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), { - - - register : function(){ - for(var i = 0, s; (s = arguments[i]); i++){ - this.add(s); + if (me.closable) { + keyMap = me.getKeyMap(); + keyMap.on(27, me.onEsc, me); + keyMap.disable(); } }, - unregister : function(){ - for(var i = 0, s; (s = arguments[i]); i++){ - this.remove(this.lookup(s)); + initDraggable: function() { + var me = this, + ddConfig; + + if (!me.header) { + me.updateHeader(true); } - }, - - lookup : function(id){ - if(Ext.isArray(id)){ - var fields = ['field1'], expand = !Ext.isArray(id[0]); - if(!expand){ - for(var i = 2, len = id[0].length; i <= len; ++i){ - fields.push('field' + i); - } - } - return new Ext.data.ArrayStore({ - fields: fields, - data: id, - expandData: expand, - autoDestroy: true, - autoCreated: true + ddConfig = Ext.applyIf({ + el: me.el, + delegate: '#' + me.header.id + }, me.draggable); - }); + + if (me.constrain || me.constrainHeader) { + ddConfig.constrain = me.constrain; + ddConfig.constrainDelegate = me.constrainHeader; + ddConfig.constrainTo = me.constrainTo || me.container; } - return Ext.isObject(id) ? (id.events ? id : Ext.create(id, 'store')) : this.get(id); + + + me.dd = Ext.create('Ext.util.ComponentDragger', this, ddConfig); + me.relayEvents(me.dd, ['dragstart', 'drag', 'dragend']); }, - getKey : function(o){ - return o.storeId; - } -}); -Ext.data.Store = Ext.extend(Ext.util.Observable, { - - - - - - - - writer : undefined, - - - - remoteSort : false, + onEsc: function(k, e) { + e.stopEvent(); + this[this.closeAction](); + }, - autoDestroy : false, + beforeDestroy: function() { + var me = this; + if (me.rendered) { + delete this.animateTarget; + me.hide(); + Ext.destroy( + me.keyMap + ); + } + me.callParent(); + }, - pruneModifiedRecords : false, + addTools: function() { + var me = this; - - lastOptions : null, + + me.callParent(); - - autoSave : true, + if (me.minimizable) { + me.addTool({ + type: 'minimize', + handler: Ext.Function.bind(me.minimize, me, []) + }); + } + if (me.maximizable) { + me.addTool({ + type: 'maximize', + handler: Ext.Function.bind(me.maximize, me, []) + }); + me.addTool({ + type: 'restore', + handler: Ext.Function.bind(me.restore, me, []), + hidden: true + }); + } + }, - batch : true, + getFocusEl: function() { + var me = this, + f = me.focusEl, + defaultComp = me.defaultButton || me.defaultFocus, + t = typeof db, + el, + ct; - - restful: false, + if (Ext.isDefined(defaultComp)) { + if (Ext.isNumber(defaultComp)) { + f = me.query('button')[defaultComp]; + } else if (Ext.isString(defaultComp)) { + f = me.down('#' + defaultComp); + } else { + f = defaultComp; + } + } + return f || me.focusEl; + }, - paramNames : undefined, + beforeShow: function() { + this.callParent(); - - defaultParamNames : { - start : 'start', - limit : 'limit', - sort : 'sort', - dir : 'dir' + if (this.expandOnShow) { + this.expand(false); + } }, - isDestroyed: false, - hasMultiSort: false, - - batchKey : '_ext_batch_', + afterShow: function(animateTarget) { + var me = this, + size; - constructor : function(config){ - - - this.data = new Ext.util.MixedCollection(false); - this.data.getKey = function(o){ - return o.id; - }; - + me.callParent(arguments); - - this.removed = []; + if (me.maximized) { + me.fitContainer(); + } - if(config && config.data){ - this.inlineData = config.data; - delete config.data; + if (me.monitorResize || me.constrain || me.constrainHeader) { + Ext.EventManager.onWindowResize(me.onWindowResize, me); + } + me.doConstrain(); + if (me.keyMap) { + me.keyMap.enable(); } + }, - Ext.apply(this, config); + + doClose: function() { + var me = this; - this.baseParams = Ext.isObject(this.baseParams) ? this.baseParams : {}; + if (me.hidden) { + me.fireEvent('close', me); + me[me.closeAction](); + } else { + + me.hide(me.animTarget, me.doClose, me); + } + }, - this.paramNames = Ext.applyIf(this.paramNames || {}, this.defaultParamNames); + + afterHide: function() { + var me = this; - if((this.url || this.api) && !this.proxy){ - this.proxy = new Ext.data.HttpProxy({url: this.url, api: this.api}); - } - if (this.restful === true && this.proxy) { - - - this.batch = false; - Ext.data.Api.restify(this.proxy); + if (me.monitorResize || me.constrain || me.constrainHeader) { + Ext.EventManager.removeResizeListener(me.onWindowResize, me); } - if(this.reader){ - if(!this.recordType){ - this.recordType = this.reader.recordType; - } - if(this.reader.onMetaChange){ - this.reader.onMetaChange = this.reader.onMetaChange.createSequence(this.onMetaChange, this); - } - if (this.writer) { - if (this.writer instanceof(Ext.data.DataWriter) === false) { - this.writer = this.buildWriter(this.writer); - } - this.writer.meta = this.reader.meta; - this.pruneModifiedRecords = true; - } + + if (me.keyMap) { + me.keyMap.disable(); } + me.callParent(arguments); + }, - if(this.recordType){ - - this.fields = this.recordType.prototype.fields; + + onWindowResize: function() { + if (this.maximized) { + this.fitContainer(); } - this.modified = []; + this.doConstrain(); + }, - this.addEvents( - - 'datachanged', - - 'metachange', - - 'add', - - 'remove', - - 'update', - - 'clear', - - 'exception', - - 'beforeload', - - 'load', - - 'loadexception', - - 'beforewrite', - - 'write', - - 'beforesave', - - 'save' + + minimize: function() { + this.fireEvent('minimize', this); + return this; + }, - ); + afterCollapse: function() { + var me = this; - if(this.proxy){ - - this.relayEvents(this.proxy, ['loadexception', 'exception']); - } - - if (this.writer) { - this.on({ - scope: this, - add: this.createRecords, - remove: this.destroyRecord, - update: this.updateRecord, - clear: this.onClear - }); + if (me.maximizable) { + me.tools.maximize.hide(); + me.tools.restore.hide(); } - - this.sortToggle = {}; - if(this.sortField){ - this.setDefaultSort(this.sortField, this.sortDir); - }else if(this.sortInfo){ - this.setDefaultSort(this.sortInfo.field, this.sortInfo.direction); + if (me.resizer) { + me.resizer.disable(); } + me.callParent(arguments); + }, - Ext.data.Store.superclass.constructor.call(this); + afterExpand: function() { + var me = this; - if(this.id){ - this.storeId = this.id; - delete this.id; - } - if(this.storeId){ - Ext.StoreMgr.register(this); + if (me.maximized) { + me.tools.restore.show(); + } else if (me.maximizable) { + me.tools.maximize.show(); } - if(this.inlineData){ - this.loadData(this.inlineData); - delete this.inlineData; - }else if(this.autoLoad){ - this.load.defer(10, this, [ - typeof this.autoLoad == 'object' ? - this.autoLoad : undefined]); + if (me.resizer) { + me.resizer.enable(); } - - this.batchCounter = 0; - this.batches = {}; + me.callParent(arguments); }, - - buildWriter : function(config) { - var klass = undefined, - type = (config.format || 'json').toLowerCase(); - switch (type) { - case 'json': - klass = Ext.data.JsonWriter; - break; - case 'xml': - klass = Ext.data.XmlWriter; - break; - default: - klass = Ext.data.JsonWriter; + + maximize: function() { + var me = this; + + if (!me.maximized) { + me.expand(false); + if (!me.hasSavedRestore) { + me.restoreSize = me.getSize(); + me.restorePos = me.getPosition(true); + } + if (me.maximizable) { + me.tools.maximize.hide(); + me.tools.restore.show(); + } + me.maximized = true; + me.el.disableShadow(); + + if (me.dd) { + me.dd.disable(); + } + if (me.collapseTool) { + me.collapseTool.hide(); + } + me.el.addCls(Ext.baseCSSPrefix + 'window-maximized'); + me.container.addCls(Ext.baseCSSPrefix + 'window-maximized-ct'); + + me.setPosition(0, 0); + me.fitContainer(); + me.fireEvent('maximize', me); } - return new klass(config); + return me; }, - destroy : function(){ - if(!this.isDestroyed){ - if(this.storeId){ - Ext.StoreMgr.unregister(this); + restore: function() { + var me = this, + tools = me.tools; + + if (me.maximized) { + delete me.hasSavedRestore; + me.removeCls(Ext.baseCSSPrefix + 'window-maximized'); + + + if (tools.restore) { + tools.restore.hide(); + } + if (tools.maximize) { + tools.maximize.show(); + } + if (me.collapseTool) { + me.collapseTool.show(); } - this.clearData(); - this.data = null; - Ext.destroy(this.proxy); - this.reader = this.writer = null; - this.purgeListeners(); - this.isDestroyed = true; - } - }, - - add : function(records) { - var i, len, record, index; - - records = [].concat(records); - if (records.length < 1) { - return; - } - - for (i = 0, len = records.length; i < len; i++) { - record = records[i]; - record.join(this); + me.setPosition(me.restorePos); + me.setSize(me.restoreSize); + + + delete me.restorePos; + delete me.restoreSize; + + me.maximized = false; + + me.el.enableShadow(true); + - if (record.dirty || record.phantom) { - this.modified.push(record); + if (me.dd) { + me.dd.enable(); } + + me.container.removeCls(Ext.baseCSSPrefix + 'window-maximized-ct'); + + me.doConstrain(); + me.fireEvent('restore', me); } - - index = this.data.length; - this.data.addAll(records); - - if (this.snapshot) { - this.snapshot.addAll(records); - } - - this.fireEvent('add', this, records, index); + return me; }, - addSorted : function(record){ - var index = this.findInsertIndex(record); - this.insert(index, record); - }, - + toggleMaximize: function() { + return this[this.maximized ? 'restore': 'maximize'](); + } + - doUpdate : function(rec){ - this.data.replace(rec.id, rec); - if(this.snapshot){ - this.snapshot.replace(rec.id, rec); +}); + +Ext.define('Ext.form.field.Base', { + extend: 'Ext.Component', + mixins: { + labelable: 'Ext.form.Labelable', + field: 'Ext.form.field.Field' + }, + alias: 'widget.field', + alternateClassName: ['Ext.form.Field', 'Ext.form.BaseField'], + requires: ['Ext.util.DelayedTask', 'Ext.XTemplate', 'Ext.layout.component.field.Field'], + + fieldSubTpl: [ + 'name="{name}" ', + 'size="{size}" ',
+ 'tabIndex="{tabIdx}" ',
+ 'class="{fieldCls} {typeCls}" autocomplete="off" />',
+ {
+ compiled: true,
+ disableFormats: true
}
- this.fireEvent('update', this, rec, Ext.data.Record.COMMIT);
- },
+ ],
- remove : function(record){
- if(Ext.isArray(record)){
- Ext.each(record, function(r){
- this.remove(r);
- }, this);
- return;
- }
- var index = this.data.indexOf(record);
- if(index > -1){
- record.join(null);
- this.data.removeAt(index);
- }
- if(this.pruneModifiedRecords){
- this.modified.remove(record);
- }
- if(this.snapshot){
- this.snapshot.remove(record);
- }
- if(index > -1){
- this.fireEvent('remove', this, record, index);
- }
- },
- removeAt : function(index){
- this.remove(this.getAt(index));
- },
+ inputType: 'text',
- removeAll : function(silent){
- var items = [];
- this.each(function(rec){
- items.push(rec);
- });
- this.clearData();
- if(this.snapshot){
- this.snapshot.clear();
- }
- if(this.pruneModifiedRecords){
- this.modified = [];
- }
- if (silent !== true) {
- this.fireEvent('clear', this, items);
- }
- },
- onClear: function(store, records){
- Ext.each(records, function(rec, index){
- this.destroyRecord(this, rec, index);
- }, this);
- },
+ invalidText : 'The value in this field is invalid',
- insert : function(index, records) {
- var i, len, record;
-
- records = [].concat(records);
- for (i = 0, len = records.length; i < len; i++) {
- record = records[i];
-
- this.data.insert(index + i, record);
- record.join(this);
-
- if (record.dirty || record.phantom) {
- this.modified.push(record);
- }
- }
-
- if (this.snapshot) {
- this.snapshot.addAll(records);
- }
-
- this.fireEvent('add', this, records, index);
- },
+ fieldCls : Ext.baseCSSPrefix + 'form-field',
- indexOf : function(record){
- return this.data.indexOf(record);
- },
- indexOfId : function(id){
- return this.data.indexOfKey(id);
- },
+ focusCls : Ext.baseCSSPrefix + 'form-focus',
- getById : function(id){
- return (this.snapshot || this.data).key(id);
- },
+ dirtyCls : Ext.baseCSSPrefix + 'form-dirty',
- getAt : function(index){
- return this.data.itemAt(index);
- },
+ checkChangeEvents: Ext.isIE && (!document.documentMode || document.documentMode < 9) ?
+ ['change', 'propertychange'] :
+ ['change', 'input', 'textInput', 'keyup', 'dragdrop'],
- getRange : function(start, end){
- return this.data.getRange(start, end);
- },
+ checkChangeBuffer: 50,
+
+ componentLayout: 'field',
- storeOptions : function(o){
- o = Ext.apply({}, o);
- delete o.callback;
- delete o.scope;
- this.lastOptions = o;
- },
+ readOnly : false,
- clearData: function(){
- this.data.each(function(rec) {
- rec.join(null);
- });
- this.data.clear();
- },
+ readOnlyCls: Ext.baseCSSPrefix + 'form-readonly',
- load : function(options) {
- options = Ext.apply({}, options);
- this.storeOptions(options);
- if(this.sortInfo && this.remoteSort){
- var pn = this.paramNames;
- options.params = Ext.apply({}, options.params);
- options.params[pn.sort] = this.sortInfo.field;
- options.params[pn.dir] = this.sortInfo.direction;
- }
- try {
- return this.execute('read', null, options);
- } catch(e) {
- this.handleException(e);
- return false;
- }
- },
- updateRecord : function(store, record, action) {
- if (action == Ext.data.Record.EDIT && this.autoSave === true && (!record.phantom || (record.phantom && record.isValid()))) {
- this.save();
- }
- },
+ validateOnBlur: true,
- createRecords : function(store, records, index) {
- var modified = this.modified,
- length = records.length,
- record, i;
-
- for (i = 0; i < length; i++) {
- record = records[i];
-
- if (record.phantom && record.isValid()) {
- record.markDirty();
-
- if (modified.indexOf(record) == -1) {
- modified.push(record);
- }
- }
- }
- if (this.autoSave === true) {
- this.save();
- }
- },
+ hasFocus : false,
+
+ baseCls: Ext.baseCSSPrefix + 'field',
+
+ maskOnDisable: false,
- destroyRecord : function(store, record, index) {
- if (this.modified.indexOf(record) != -1) {
- this.modified.remove(record);
- }
- if (!record.phantom) {
- this.removed.push(record);
+ initComponent : function() {
+ var me = this;
+
+ me.callParent();
+
+ me.subTplData = me.subTplData || {};
+ me.addEvents(
+ 'focus',
+ 'blur',
- record.lastIndex = index;
+ 'specialkey'
+ );
- if (this.autoSave === true) {
- this.save();
- }
+
+ me.initLabelable();
+ me.initField();
+
+
+ if (!me.name) {
+ me.name = me.getInputId();
}
},
- execute : function(action, rs, options, batch) {
-
- if (!Ext.data.Api.isAction(action)) {
- throw new Ext.data.Api.Error('execute', action);
- }
-
- options = Ext.applyIf(options||{}, {
- params: {}
- });
- if(batch !== undefined){
- this.addToBatch(batch);
- }
-
-
- var doRequest = true;
+ getInputId: function() {
+ return this.inputId || (this.inputId = Ext.id());
+ },
- if (action === 'read') {
- doRequest = this.fireEvent('beforeload', this, options);
- Ext.applyIf(options.params, this.baseParams);
- }
- else {
-
-
- if (this.writer.listful === true && this.restful !== true) {
- rs = (Ext.isArray(rs)) ? rs : [rs];
- }
-
- else if (Ext.isArray(rs) && rs.length == 1) {
- rs = rs.shift();
- }
-
- if ((doRequest = this.fireEvent('beforewrite', this, action, rs, options)) !== false) {
- this.writer.apply(options.params, this.baseParams, action, rs);
- }
- }
- if (doRequest !== false) {
-
- if (this.writer && this.proxy.url && !this.proxy.restful && !Ext.data.Api.hasUniqueUrl(this.proxy, action)) {
- options.params.xaction = action;
- }
-
-
-
-
-
- this.proxy.request(Ext.data.Api.actions[action], rs, options.params, this.reader, this.createCallback(action, rs, batch), this, options);
- }
- return doRequest;
+
+ getSubTplData: function() {
+ var me = this,
+ type = me.inputType,
+ inputId = me.getInputId();
+
+ return Ext.applyIf(me.subTplData, {
+ id: inputId,
+ name: me.name || inputId,
+ type: type,
+ size: me.size || 20,
+ cls: me.cls,
+ fieldCls: me.fieldCls,
+ tabIdx: me.tabIndex,
+ typeCls: Ext.baseCSSPrefix + 'form-' + (type === 'password' ? 'text' : type)
+ });
},
- save : function() {
- if (!this.writer) {
- throw new Ext.data.Store.Error('writer-undefined');
- }
+ getSubTplMarkup: function() {
+ return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
+ },
- var queue = [],
- len,
- trans,
- batch,
- data = {},
- i;
-
- if(this.removed.length){
- queue.push(['destroy', this.removed]);
+ initRenderTpl: function() {
+ var me = this;
+ if (!me.hasOwnProperty('renderTpl')) {
+ me.renderTpl = me.getTpl('labelableRenderTpl');
}
+ return me.callParent();
+ },
-
- var rs = [].concat(this.getModifiedRecords());
- if(rs.length){
-
- var phantoms = [];
- for(i = rs.length-1; i >= 0; i--){
- if(rs[i].phantom === true){
- var rec = rs.splice(i, 1).shift();
- if(rec.isValid()){
- phantoms.push(rec);
- }
- }else if(!rs[i].isValid()){
- rs.splice(i,1);
- }
- }
-
- if(phantoms.length){
- queue.push(['create', phantoms]);
- }
-
-
- if(rs.length){
- queue.push(['update', rs]);
- }
- }
- len = queue.length;
- if(len){
- batch = ++this.batchCounter;
- for(i = 0; i < len; ++i){
- trans = queue[i];
- data[trans[0]] = trans[1];
- }
- if(this.fireEvent('beforesave', this, data) !== false){
- for(i = 0; i < len; ++i){
- trans = queue[i];
- this.doTransaction(trans[0], trans[1], batch);
- }
- return batch;
- }
- }
- return -1;
+ initRenderData: function() {
+ return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
},
- doTransaction : function(action, rs, batch) {
- function transaction(records) {
- try{
- this.execute(action, records, undefined, batch);
- }catch (e){
- this.handleException(e);
- }
- }
- if(this.batch === false){
- for(var i = 0, len = rs.length; i < len; i++){
- transaction.call(this, rs[i]);
- }
- }else{
- transaction.call(this, rs);
+ setFieldStyle: function(style) {
+ var me = this,
+ inputEl = me.inputEl;
+ if (inputEl) {
+ inputEl.applyStyles(style);
}
+ me.fieldStyle = style;
},
- addToBatch : function(batch){
- var b = this.batches,
- key = this.batchKey + batch,
- o = b[key];
+ onRender : function() {
+ var me = this,
+ fieldStyle = me.fieldStyle,
+ renderSelectors = me.renderSelectors;
- if(!o){
- b[key] = o = {
- id: batch,
- count: 0,
- data: {}
- };
+ Ext.applyIf(renderSelectors, me.getLabelableSelectors());
+
+ Ext.applyIf(renderSelectors, {
+
+ inputEl: '.' + me.fieldCls
+ });
+
+ me.callParent(arguments);
+
+
+ me.setRawValue(me.rawValue);
+
+ if (me.readOnly) {
+ me.setReadOnly(true);
}
- ++o.count;
+ if (me.disabled) {
+ me.disable();
+ }
+ if (fieldStyle) {
+ me.setFieldStyle(fieldStyle);
+ }
+
+ me.renderActiveError();
},
- removeFromBatch : function(batch, action, data){
- var b = this.batches,
- key = this.batchKey + batch,
- o = b[key],
- arr;
+ initAria: function() {
+ var me = this;
+ me.callParent();
+
+ me.getActionEl().dom.setAttribute('aria-describedby', Ext.id(me.errorEl));
+ },
- if(o){
- arr = o.data[action] || [];
- o.data[action] = arr.concat(data);
- if(o.count === 1){
- data = o.data;
- delete b[key];
- this.fireEvent('save', this, batch, data);
- }else{
- --o.count;
- }
- }
+ getFocusEl: function() {
+ return this.inputEl;
},
-
-
- createCallback : function(action, rs, batch) {
- var actions = Ext.data.Api.actions;
- return (action == 'read') ? this.loadRecords : function(data, response, success) {
-
- this['on' + Ext.util.Format.capitalize(action) + 'Records'](success, rs, [].concat(data));
-
- if (success === true) {
- this.fireEvent('write', this, action, data, response, rs);
- }
- this.removeFromBatch(batch, action, data);
- };
+ isFileUpload: function() {
+ return this.inputType === 'file';
},
-
-
-
- clearModified : function(rs) {
- if (Ext.isArray(rs)) {
- for (var n=rs.length-1;n>=0;n--) {
- this.modified.splice(this.modified.indexOf(rs[n]), 1);
- }
- } else {
- this.modified.splice(this.modified.indexOf(rs), 1);
+ extractFileInput: function() {
+ var me = this,
+ fileInput = me.isFileUpload() ? me.inputEl.dom : null,
+ clone;
+ if (fileInput) {
+ clone = fileInput.cloneNode(true);
+ fileInput.parentNode.replaceChild(clone, fileInput);
+ me.inputEl = Ext.get(clone);
}
+ return fileInput;
},
- reMap : function(record) {
- if (Ext.isArray(record)) {
- for (var i = 0, len = record.length; i < len; i++) {
- this.reMap(record[i]);
+ getSubmitData: function() {
+ var me = this,
+ data = null,
+ val;
+ if (!me.disabled && me.submitValue && !me.isFileUpload()) {
+ val = me.getSubmitValue();
+ if (val !== null) {
+ data = {};
+ data[me.getName()] = val;
}
- } else {
- delete this.data.map[record._phid];
- this.data.map[record.id] = record;
- var index = this.data.keys.indexOf(record._phid);
- this.data.keys.splice(index, 1, record.id);
- delete record._phid;
}
+ return data;
},
- onCreateRecords : function(success, rs, data) {
- if (success === true) {
- try {
- this.reader.realize(rs, data);
- this.reMap(rs);
- }
- catch (e) {
- this.handleException(e);
- if (Ext.isArray(rs)) {
-
- this.onCreateRecords(success, rs, data);
- }
- }
- }
+ getSubmitValue: function() {
+ return this.processRawValue(this.getRawValue());
},
- onUpdateRecords : function(success, rs, data) {
- if (success === true) {
- try {
- this.reader.update(rs, data);
- } catch (e) {
- this.handleException(e);
- if (Ext.isArray(rs)) {
-
- this.onUpdateRecords(success, rs, data);
- }
- }
- }
+ getRawValue: function() {
+ var me = this,
+ v = (me.inputEl ? me.inputEl.getValue() : Ext.value(me.rawValue, ''));
+ me.rawValue = v;
+ return v;
},
- onDestroyRecords : function(success, rs, data) {
+ setRawValue: function(value) {
+ var me = this;
+ value = Ext.value(value, '');
+ me.rawValue = value;
+
- rs = (rs instanceof Ext.data.Record) ? [rs] : [].concat(rs);
- for (var i=0,len=rs.length;i=0;i--) {
- this.insert(rs[i].lastIndex, rs[i]);
- }
+ if (me.inputEl) {
+ me.inputEl.dom.value = value;
}
+ return value;
},
- handleException : function(e) {
-
- Ext.handleError(e);
+ valueToRaw: function(value) {
+ return '' + Ext.value(value, '');
},
- reload : function(options){
- this.load(Ext.applyIf(options||{}, this.lastOptions));
+ rawToValue: function(rawValue) {
+ return rawValue;
},
+ processRawValue: function(value) {
+ return value;
+ },
+
- loadRecords : function(o, options, success){
- var i, len;
-
- if (this.isDestroyed === true) {
- return;
- }
- if(!o || success === false){
- if(success !== false){
- this.fireEvent('load', this, [], options);
- }
- if(options.callback){
- options.callback.call(options.scope || this, [], options, false, o);
- }
- return;
- }
- var r = o.records, t = o.totalRecords || r.length;
- if(!options || options.add !== true){
- if(this.pruneModifiedRecords){
- this.modified = [];
- }
- for(i = 0, len = r.length; i < len; i++){
- r[i].join(this);
- }
- if(this.snapshot){
- this.data = this.snapshot;
- delete this.snapshot;
- }
- this.clearData();
- this.data.addAll(r);
- this.totalLength = t;
- this.applySort();
- this.fireEvent('datachanged', this);
- }else{
- var toAdd = [],
- rec,
- cnt = 0;
- for(i = 0, len = r.length; i < len; ++i){
- rec = r[i];
- if(this.indexOfId(rec.id) > -1){
- this.doUpdate(rec);
- }else{
- toAdd.push(rec);
- ++cnt;
- }
- }
- this.totalLength = Math.max(t, this.data.length + cnt);
- this.add(toAdd);
- }
- this.fireEvent('load', this, r, options);
- if(options.callback){
- options.callback.call(options.scope || this, r, options, true);
- }
+ getValue: function() {
+ var me = this,
+ val = me.rawToValue(me.processRawValue(me.getRawValue()));
+ me.value = val;
+ return val;
},
- loadData : function(o, append){
- var r = this.reader.readRecords(o);
- this.loadRecords(r, {add: append}, true);
+ setValue: function(value) {
+ var me = this;
+ me.setRawValue(me.valueToRaw(value));
+ return me.mixins.field.setValue.call(me, value);
},
+
- getCount : function(){
- return this.data.length || 0;
+ onDisable: function() {
+ var me = this,
+ inputEl = me.inputEl;
+ me.callParent();
+ if (inputEl) {
+ inputEl.dom.disabled = true;
+ }
},
- getTotalCount : function(){
- return this.totalLength || 0;
+ onEnable: function() {
+ var me = this,
+ inputEl = me.inputEl;
+ me.callParent();
+ if (inputEl) {
+ inputEl.dom.disabled = false;
+ }
},
- getSortState : function(){
- return this.sortInfo;
+ setReadOnly: function(readOnly) {
+ var me = this,
+ inputEl = me.inputEl;
+ if (inputEl) {
+ inputEl.dom.readOnly = readOnly;
+ inputEl.dom.setAttribute('aria-readonly', readOnly);
+ }
+ me[readOnly ? 'addCls' : 'removeCls'](me.readOnlyCls);
+ me.readOnly = readOnly;
},
- applySort : function(){
- if ((this.sortInfo || this.multiSortInfo) && !this.remoteSort) {
- this.sortData();
+ fireKey: function(e){
+ if(e.isSpecialKey()){
+ this.fireEvent('specialkey', this, Ext.create('Ext.EventObjectImpl', e));
}
},
- sortData : function() {
- var sortInfo = this.hasMultiSort ? this.multiSortInfo : this.sortInfo,
- direction = sortInfo.direction || "ASC",
- sorters = sortInfo.sorters,
- sortFns = [];
+ initEvents : function(){
+ var me = this,
+ inputEl = me.inputEl,
+ onChangeTask,
+ onChangeEvent;
+ if (inputEl) {
+ me.mon(inputEl, Ext.EventManager.getKeyEvent(), me.fireKey, me);
+ me.mon(inputEl, 'focus', me.onFocus, me);
-
- if (!this.hasMultiSort) {
- sorters = [{direction: direction, field: sortInfo.field}];
- }
+
+
+ me.mon(inputEl, 'blur', me.onBlur, me, me.inEditor ? {buffer:10} : null);
-
- for (var i=0, j = sorters.length; i < j; i++) {
- sortFns.push(this.createSortFunction(sorters[i].field, sorters[i].direction));
- }
-
- if (sortFns.length == 0) {
- return;
+
+ onChangeTask = Ext.create('Ext.util.DelayedTask', me.checkChange, me);
+ me.onChangeEvent = onChangeEvent = function() {
+ onChangeTask.delay(me.checkChangeBuffer);
+ };
+ Ext.each(me.checkChangeEvents, function(eventName) {
+ if (eventName === 'propertychange') {
+ me.usesPropertychange = true;
+ }
+ me.mon(inputEl, eventName, onChangeEvent);
+ }, me);
}
+ me.callParent();
+ },
-
-
- var directionModifier = direction.toUpperCase() == "DESC" ? -1 : 1;
+ doComponentLayout: function() {
+ var me = this,
+ inputEl = me.inputEl,
+ usesPropertychange = me.usesPropertychange,
+ ename = 'propertychange',
+ onChangeEvent = me.onChangeEvent;
- var fn = function(r1, r2) {
- var result = sortFns[0].call(this, r1, r2);
-
-
- if (sortFns.length > 1) {
- for (var i=1, j = sortFns.length; i < j; i++) {
- result = result || sortFns[i].call(this, r1, r2);
- }
- }
-
- return directionModifier * result;
- };
-
- this.data.sort(direction, fn);
- if (this.snapshot && this.snapshot != this.data) {
- this.snapshot.sort(direction, fn);
+
+ if (usesPropertychange) {
+ me.mun(inputEl, ename, onChangeEvent);
+ }
+ me.callParent(arguments);
+ if (usesPropertychange) {
+ me.mon(inputEl, ename, onChangeEvent);
}
},
- createSortFunction: function(field, direction) {
- direction = direction || "ASC";
- var directionModifier = direction.toUpperCase() == "DESC" ? -1 : 1;
+ preFocus: Ext.emptyFn,
- var sortType = this.fields.get(field).sortType;
+
+ onFocus: function() {
+ var me = this,
+ focusCls = me.focusCls,
+ inputEl = me.inputEl;
+ me.preFocus();
+ if (focusCls && inputEl) {
+ inputEl.addCls(focusCls);
+ }
+ if (!me.hasFocus) {
+ me.hasFocus = true;
+ me.fireEvent('focus', me);
+ }
+ },
-
-
- return function(r1, r2) {
- var v1 = sortType(r1.data[field]),
- v2 = sortType(r2.data[field]);
+
+ beforeBlur : Ext.emptyFn,
- return directionModifier * (v1 > v2 ? 1 : (v1 < v2 ? -1 : 0));
- };
+
+ onBlur : function(){
+ var me = this,
+ focusCls = me.focusCls,
+ inputEl = me.inputEl;
+ me.beforeBlur();
+ if (focusCls && inputEl) {
+ inputEl.removeCls(focusCls);
+ }
+ if (me.validateOnBlur) {
+ me.validate();
+ }
+ me.hasFocus = false;
+ me.fireEvent('blur', me);
+ me.postBlur();
},
- setDefaultSort : function(field, dir) {
- dir = dir ? dir.toUpperCase() : 'ASC';
- this.sortInfo = {field: field, direction: dir};
- this.sortToggle[field] = dir;
- },
+ postBlur : Ext.emptyFn,
+
- sort : function(fieldName, dir) {
- if (Ext.isArray(arguments[0])) {
- return this.multiSort.call(this, fieldName, dir);
- } else {
- return this.singleSort(fieldName, dir);
- }
+ onDirtyChange: function(isDirty) {
+ this[isDirty ? 'addCls' : 'removeCls'](this.dirtyCls);
},
+
- singleSort: function(fieldName, dir) {
- var field = this.fields.get(fieldName);
- if (!field) {
- return false;
- }
+ isValid : function() {
+ var me = this;
+ return me.disabled || me.validateValue(me.processRawValue(me.getRawValue()));
+ },
- var name = field.name,
- sortInfo = this.sortInfo || null,
- sortToggle = this.sortToggle ? this.sortToggle[name] : null;
- if (!dir) {
- if (sortInfo && sortInfo.field == name) {
- dir = (this.sortToggle[name] || 'ASC').toggle('ASC', 'DESC');
+
+ validateValue: function(value) {
+ var me = this,
+ errors = me.getErrors(value),
+ isValid = Ext.isEmpty(errors);
+ if (!me.preventMark) {
+ if (isValid) {
+ me.clearInvalid();
} else {
- dir = field.sortDir;
+ me.markInvalid(errors);
}
}
- this.sortToggle[name] = dir;
- this.sortInfo = {field: name, direction: dir};
- this.hasMultiSort = false;
-
- if (this.remoteSort) {
- if (!this.load(this.lastOptions)) {
- if (sortToggle) {
- this.sortToggle[name] = sortToggle;
- }
- if (sortInfo) {
- this.sortInfo = sortInfo;
- }
- }
- } else {
- this.applySort();
- this.fireEvent('datachanged', this);
- }
- return true;
+ return isValid;
},
- multiSort: function(sorters, direction) {
- this.hasMultiSort = true;
- direction = direction || "ASC";
-
+ markInvalid : function(errors) {
- if (this.multiSortInfo && direction == this.multiSortInfo.direction) {
- direction = direction.toggle("ASC", "DESC");
+ var me = this,
+ oldMsg = me.getActiveError();
+ me.setActiveErrors(Ext.Array.from(errors));
+ if (oldMsg !== me.getActiveError()) {
+ me.doComponentLayout();
}
+ },
+
+ clearInvalid : function() {
- this.multiSortInfo = {
- sorters : sorters,
- direction: direction
- };
-
- if (this.remoteSort) {
- this.singleSort(sorters[0].field, sorters[0].direction);
-
- } else {
- this.applySort();
- this.fireEvent('datachanged', this);
+ var me = this,
+ hadError = me.hasActiveError();
+ me.unsetActiveError();
+ if (hadError) {
+ me.doComponentLayout();
}
},
- each : function(fn, scope){
- this.data.each(fn, scope);
+ renderActiveError: function() {
+ var me = this,
+ hasError = me.hasActiveError();
+ if (me.inputEl) {
+
+ me.inputEl[hasError ? 'addCls' : 'removeCls'](me.invalidCls + '-field');
+ }
+ me.mixins.labelable.renderActiveError.call(me);
},
+
+ getActionEl: function() {
+ return this.inputEl || this.el;
+ }
+
+});
+
+
+Ext.define('Ext.form.field.Text', {
+ extend:'Ext.form.field.Base',
+ alias: 'widget.textfield',
+ requires: ['Ext.form.field.VTypes', 'Ext.layout.component.field.Text'],
+ alternateClassName: ['Ext.form.TextField', 'Ext.form.Text'],
+
+
+
- getModifiedRecords : function(){
- return this.modified;
- },
- sum : function(property, start, end){
- var rs = this.data.items, v = 0;
- start = start || 0;
- end = (end || end === 0) ? end : rs.length-1;
+ size: 20,
- for(var i = start; i <= end; i++){
- v += (rs[i].data[property] || 0);
- }
- return v;
- },
+
- createFilterFn : function(property, value, anyMatch, caseSensitive, exactMatch){
- if(Ext.isEmpty(value, false)){
- return false;
- }
- value = this.data.createValueMatcher(value, anyMatch, caseSensitive, exactMatch);
- return function(r) {
- return value.test(r.data[property]);
- };
- },
+ growMin : 30,
+
+
+ growMax : 800,
- createMultipleFilterFn: function(filters) {
- return function(record) {
- var isMatch = true;
+ growAppend: 'W',
+
+
- for (var i=0, j = filters.length; i < j; i++) {
- var filter = filters[i],
- fn = filter.fn,
- scope = filter.scope;
+
- isMatch = isMatch && fn.call(scope, record);
- }
+
- return isMatch;
- };
- },
+
+ allowBlank : true,
+
+
+ minLength : 0,
+
+
+ maxLength : Number.MAX_VALUE,
+
+
+
+
+ minLengthText : 'The minimum length for this field is {0}',
+
+
+ maxLengthText : 'The maximum length for this field is {0}',
+
+
+
+
+ blankText : 'This field is required',
+
+
- filter : function(property, value, anyMatch, caseSensitive, exactMatch){
- var fn;
-
- if (Ext.isObject(property)) {
- property = [property];
- }
- if (Ext.isArray(property)) {
- var filters = [];
+
+ regexText : '',
+
+
-
- for (var i=0, j = property.length; i < j; i++) {
- var filter = property[i],
- func = filter.fn,
- scope = filter.scope || this;
+
+ emptyCls : Ext.baseCSSPrefix + 'form-empty-field',
-
- if (!Ext.isFunction(func)) {
- func = this.createFilterFn(filter.property, filter.value, filter.anyMatch, filter.caseSensitive, filter.exactMatch);
- }
+ ariaRole: 'textbox',
- filters.push({fn: func, scope: scope});
- }
+
- fn = this.createMultipleFilterFn(filters);
- } else {
+ componentLayout: 'textfield',
+
+ initComponent : function(){
+ this.callParent();
+ this.addEvents(
- fn = this.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch);
- }
+ 'autosize',
- return fn ? this.filterBy(fn) : this.clearFilter();
+
+ 'keydown',
+
+ 'keyup',
+
+ 'keypress'
+ );
},
- filterBy : function(fn, scope){
- this.snapshot = this.snapshot || this.data;
- this.data = this.queryBy(fn, scope || this);
- this.fireEvent('datachanged', this);
- },
+ initEvents : function(){
+ var me = this,
+ el = me.inputEl;
+
+ me.callParent();
+ if(me.selectOnFocus || me.emptyText){
+ me.mon(el, 'mousedown', me.onMouseDown, me);
+ }
+ if(me.maskRe || (me.vtype && me.disableKeyFilter !== true && (me.maskRe = Ext.form.field.VTypes[me.vtype+'Mask']))){
+ me.mon(el, 'keypress', me.filterKeys, me);
+ }
-
- clearFilter : function(suppressEvent){
- if(this.isFiltered()){
- this.data = this.snapshot;
- delete this.snapshot;
- if(suppressEvent !== true){
- this.fireEvent('datachanged', this);
- }
+ if (me.enableKeyEvents) {
+ me.mon(el, {
+ scope: me,
+ keyup: me.onKeyUp,
+ keydown: me.onKeyDown,
+ keypress: me.onKeyPress
+ });
}
},
- isFiltered : function(){
- return !!this.snapshot && this.snapshot != this.data;
+ isEqual: function(value1, value2) {
+ return String(Ext.value(value1, '')) === String(Ext.value(value2, ''));
},
- query : function(property, value, anyMatch, caseSensitive){
- var fn = this.createFilterFn(property, value, anyMatch, caseSensitive);
- return fn ? this.queryBy(fn) : this.data.clone();
+ onChange: function() {
+ this.callParent();
+ this.autoSize();
},
-
- queryBy : function(fn, scope){
- var data = this.snapshot || this.data;
- return data.filterBy(fn, scope||this);
+ afterRender: function(){
+ var me = this;
+ if (me.enforceMaxLength) {
+ me.inputEl.dom.maxLength = me.maxLength;
+ }
+ me.applyEmptyText();
+ me.autoSize();
+ me.callParent();
},
-
- find : function(property, value, start, anyMatch, caseSensitive){
- var fn = this.createFilterFn(property, value, anyMatch, caseSensitive);
- return fn ? this.data.findIndexBy(fn, null, start) : -1;
+ onMouseDown: function(e){
+ var me = this;
+ if(!me.hasFocus){
+ me.mon(me.inputEl, 'mouseup', Ext.emptyFn, me, { single: true, preventDefault: true });
+ }
},
- findExact: function(property, value, start){
- return this.data.findIndexBy(function(rec){
- return rec.get(property) === value;
- }, this, start);
+ processRawValue: function(value) {
+ var me = this,
+ stripRe = me.stripCharsRe,
+ newValue;
+
+ if (stripRe) {
+ newValue = value.replace(stripRe, '');
+ if (newValue !== value) {
+ me.setRawValue(newValue);
+ value = newValue;
+ }
+ }
+ return value;
},
- findBy : function(fn, scope, start){
- return this.data.findIndexBy(fn, scope, start);
+ onDisable: function(){
+ this.callParent();
+ if (Ext.isIE) {
+ this.inputEl.dom.unselectable = 'on';
+ }
},
- collect : function(dataIndex, allowNull, bypassFilter){
- var d = (bypassFilter === true && this.snapshot) ?
- this.snapshot.items : this.data.items;
- var v, sv, r = [], l = {};
- for(var i = 0, len = d.length; i < len; i++){
- v = d[i].data[dataIndex];
- sv = String(v);
- if((allowNull || !Ext.isEmpty(v)) && !l[sv]){
- l[sv] = true;
- r[r.length] = v;
- }
+ onEnable: function(){
+ this.callParent();
+ if (Ext.isIE) {
+ this.inputEl.dom.unselectable = '';
}
- return r;
+ },
+
+ onKeyDown: function(e) {
+ this.fireEvent('keydown', this, e);
+ },
+
+ onKeyUp: function(e) {
+ this.fireEvent('keyup', this, e);
+ },
+
+ onKeyPress: function(e) {
+ this.fireEvent('keypress', this, e);
},
- afterEdit : function(record){
- if(this.modified.indexOf(record) == -1){
- this.modified.push(record);
+ reset : function(){
+ this.callParent();
+ this.applyEmptyText();
+ },
+
+ applyEmptyText : function(){
+ var me = this,
+ emptyText = me.emptyText,
+ isEmpty;
+
+ if (me.rendered && emptyText) {
+ isEmpty = me.getRawValue().length < 1 && !me.hasFocus;
+
+ if (Ext.supports.Placeholder) {
+ me.inputEl.dom.placeholder = emptyText;
+ } else if (isEmpty) {
+ me.setRawValue(emptyText);
+ }
+
+
+
+ if (isEmpty) {
+ me.inputEl.addCls(me.emptyCls);
+ }
+
+ me.autoSize();
}
- this.fireEvent('update', this, record, Ext.data.Record.EDIT);
},
- afterReject : function(record){
- this.modified.remove(record);
- this.fireEvent('update', this, record, Ext.data.Record.REJECT);
+ preFocus : function(){
+ var me = this,
+ inputEl = me.inputEl,
+ emptyText = me.emptyText,
+ isEmpty;
+
+ if (emptyText && !Ext.supports.Placeholder && inputEl.dom.value === emptyText) {
+ me.setRawValue('');
+ isEmpty = true;
+ inputEl.removeCls(me.emptyCls);
+ } else if (Ext.supports.Placeholder) {
+ me.inputEl.removeCls(me.emptyCls);
+ }
+ if (me.selectOnFocus || isEmpty) {
+ inputEl.dom.select();
+ }
},
-
- afterCommit : function(record){
- this.modified.remove(record);
- this.fireEvent('update', this, record, Ext.data.Record.COMMIT);
+ onFocus: function() {
+ var me = this;
+ me.callParent(arguments);
+ if (me.emptyText) {
+ me.autoSize();
+ }
},
- commitChanges : function(){
- var modified = this.modified.slice(0),
- length = modified.length,
- i;
-
- for (i = 0; i < length; i++){
- modified[i].commit();
- }
-
- this.modified = [];
- this.removed = [];
+ postBlur : function(){
+ this.applyEmptyText();
},
- rejectChanges : function() {
- var modified = this.modified.slice(0),
- removed = this.removed.slice(0).reverse(),
- mLength = modified.length,
- rLength = removed.length,
- i;
-
- for (i = 0; i < mLength; i++) {
- modified[i].reject();
+ filterKeys : function(e){
+ if(e.ctrlKey){
+ return;
}
-
- for (i = 0; i < rLength; i++) {
- this.insert(removed[i].lastIndex || 0, removed[i]);
- removed[i].reject();
+ var key = e.getKey(),
+ charCode = String.fromCharCode(e.getCharCode());
+
+ if(Ext.isGecko && (e.isNavKeyPress() || key === e.BACKSPACE || (key === e.DELETE && e.button === -1))){
+ return;
}
- this.modified = [];
- this.removed = [];
- },
-
-
- onMetaChange : function(meta){
- this.recordType = this.reader.recordType;
- this.fields = this.recordType.prototype.fields;
- delete this.snapshot;
- if(this.reader.meta.sortInfo){
- this.sortInfo = this.reader.meta.sortInfo;
- }else if(this.sortInfo && !this.fields.get(this.sortInfo.field)){
- delete this.sortInfo;
+ if(!Ext.isGecko && e.isSpecialKey() && !charCode){
+ return;
}
- if(this.writer){
- this.writer.meta = this.reader.meta;
+ if(!this.maskRe.test(charCode)){
+ e.stopEvent();
}
- this.modified = [];
- this.fireEvent('metachange', this, this.reader.meta);
},
- findInsertIndex : function(record){
- this.suspendEvents();
- var data = this.data.clone();
- this.data.add(record);
- this.applySort();
- var index = this.data.indexOf(record);
- this.data = data;
- this.resumeEvents();
- return index;
+ getRawValue: function() {
+ var me = this,
+ v = me.callParent();
+ if (v === me.emptyText) {
+ v = '';
+ }
+ return v;
},
- setBaseParam : function (name, value){
- this.baseParams = this.baseParams || {};
- this.baseParams[name] = value;
- }
-});
-
-Ext.reg('store', Ext.data.Store);
-
+ setValue: function(value) {
+ var me = this,
+ inputEl = me.inputEl;
+
+ if (inputEl && me.emptyText && !Ext.isEmpty(value)) {
+ inputEl.removeCls(me.emptyCls);
+ }
+
+ me.callParent(arguments);
-Ext.data.Store.Error = Ext.extend(Ext.Error, {
- name: 'Ext.data.Store'
-});
-Ext.apply(Ext.data.Store.Error.prototype, {
- lang: {
- 'writer-undefined' : 'Attempted to execute a write-action without a DataWriter installed.'
- }
-});
+ me.applyEmptyText();
+ return me;
+ },
-Ext.data.Field = Ext.extend(Object, {
- constructor : function(config){
- if(Ext.isString(config)){
- config = {name: config};
+ getErrors: function(value) {
+ var me = this,
+ errors = me.callParent(arguments),
+ validator = me.validator,
+ emptyText = me.emptyText,
+ allowBlank = me.allowBlank,
+ vtype = me.vtype,
+ vtypes = Ext.form.field.VTypes,
+ regex = me.regex,
+ format = Ext.String.format,
+ msg;
+
+ value = value || me.processRawValue(me.getRawValue());
+
+ if (Ext.isFunction(validator)) {
+ msg = validator.call(me, value);
+ if (msg !== true) {
+ errors.push(msg);
+ }
}
- Ext.apply(this, config);
-
- var types = Ext.data.Types,
- st = this.sortType,
- t;
- if(this.type){
- if(Ext.isString(this.type)){
- this.type = Ext.data.Types[this.type.toUpperCase()] || types.AUTO;
+ if (value.length < 1 || value === emptyText) {
+ if (!allowBlank) {
+ errors.push(me.blankText);
}
- }else{
- this.type = types.AUTO;
+
+ return errors;
}
-
- if(Ext.isString(st)){
- this.sortType = Ext.data.SortTypes[st];
- }else if(Ext.isEmpty(st)){
- this.sortType = this.type.sortType;
+ if (value.length < me.minLength) {
+ errors.push(format(me.minLengthText, me.minLength));
}
- if(!this.convert){
- this.convert = this.type.convert;
+ if (value.length > me.maxLength) {
+ errors.push(format(me.maxLengthText, me.maxLength));
}
- },
-
-
-
-
-
- dateFormat: null,
-
-
- useNull: false,
-
-
- defaultValue: "",
-
- mapping: null,
-
- sortType : null,
-
- sortDir : "ASC",
-
- allowBlank : true
-});
-
-Ext.data.DataReader = function(meta, recordType){
-
- this.meta = meta;
-
- this.recordType = Ext.isArray(recordType) ?
- Ext.data.Record.create(recordType) : recordType;
-
-
- if (this.recordType){
- this.buildExtractors();
- }
-};
-Ext.data.DataReader.prototype = {
-
-
- getTotal: Ext.emptyFn,
-
- getRoot: Ext.emptyFn,
-
- getMessage: Ext.emptyFn,
-
- getSuccess: Ext.emptyFn,
-
- getId: Ext.emptyFn,
-
- buildExtractors : Ext.emptyFn,
-
- extractValues : Ext.emptyFn,
-
-
- realize: function(rs, data){
- if (Ext.isArray(rs)) {
- for (var i = rs.length - 1; i >= 0; i--) {
-
- if (Ext.isArray(data)) {
- this.realize(rs.splice(i,1).shift(), data.splice(i,1).shift());
- }
- else {
-
-
- this.realize(rs.splice(i,1).shift(), data);
- }
+ if (vtype) {
+ if(!vtypes[vtype](value, me)){
+ errors.push(me.vtypeText || vtypes[vtype +'Text']);
}
}
- else {
-
- if (Ext.isArray(data) && data.length == 1) {
- data = data.shift();
- }
- if (!this.isData(data)) {
-
-
- throw new Ext.data.DataReader.Error('realize', rs);
- }
- rs.phantom = false;
- rs._phid = rs.id;
- rs.id = this.getId(data);
- rs.data = data;
- rs.commit();
+ if (regex && !regex.test(value)) {
+ errors.push(me.regexText || me.invalidText);
}
+
+ return errors;
},
- update : function(rs, data) {
- if (Ext.isArray(rs)) {
- for (var i=rs.length-1; i >= 0; i--) {
- if (Ext.isArray(data)) {
- this.update(rs.splice(i,1).shift(), data.splice(i,1).shift());
- }
- else {
-
-
- this.update(rs.splice(i,1).shift(), data);
- }
+ selectText : function(start, end){
+ var me = this,
+ v = me.getRawValue(),
+ doFocus = true,
+ el = me.inputEl.dom,
+ undef,
+ range;
+
+ if (v.length > 0) {
+ start = start === undef ? 0 : start;
+ end = end === undef ? v.length : end;
+ if (el.setSelectionRange) {
+ el.setSelectionRange(start, end);
+ }
+ else if(el.createTextRange) {
+ range = el.createTextRange();
+ range.moveStart('character', start);
+ range.moveEnd('character', end - v.length);
+ range.select();
}
+ doFocus = Ext.isGecko || Ext.isOpera;
}
- else {
-
- if (Ext.isArray(data) && data.length == 1) {
- data = data.shift();
- }
- if (this.isData(data)) {
- rs.data = Ext.apply(rs.data, data);
- }
- rs.commit();
+ if (doFocus) {
+ me.focus();
}
},
- extractData : function(root, returnRecords) {
-
- var rawName = (this instanceof Ext.data.JsonReader) ? 'json' : 'node';
-
- var rs = [];
-
-
-
- if (this.isData(root) && !(this instanceof Ext.data.XmlReader)) {
- root = [root];
- }
- var f = this.recordType.prototype.fields,
- fi = f.items,
- fl = f.length,
- rs = [];
- if (returnRecords === true) {
- var Record = this.recordType;
- for (var i = 0; i < root.length; i++) {
- var n = root[i];
- var record = new Record(this.extractValues(n, fi, fl), this.getId(n));
- record[rawName] = n;
- rs.push(record);
- }
- }
- else {
- for (var i = 0; i < root.length; i++) {
- var data = this.extractValues(root[i], fi, fl);
- data[this.meta.idProperty] = this.getId(root[i]);
- rs.push(data);
+ autoSize: function() {
+ var me = this,
+ width;
+ if (me.grow && me.rendered) {
+ me.doComponentLayout();
+ width = me.inputEl.getWidth();
+ if (width !== me.lastInputWidth) {
+ me.fireEvent('autosize', width);
+ me.lastInputWidth = width;
}
}
- return rs;
},
-
- isData : function(data) {
- return (data && Ext.isObject(data) && !Ext.isEmpty(this.getId(data))) ? true : false;
+ initAria: function() {
+ this.callParent();
+ this.getActionEl().dom.setAttribute('aria-required', this.allowBlank === false);
},
- onMetaChange : function(meta){
- delete this.ef;
- this.meta = meta;
- this.recordType = Ext.data.Record.create(meta.fields);
- this.buildExtractors();
+ getBodyNaturalWidth: function() {
+ return Math.round(this.size * 6.5) + 20;
}
-};
-
-Ext.data.DataReader.Error = Ext.extend(Ext.Error, {
- constructor : function(message, arg) {
- this.arg = arg;
- Ext.Error.call(this, message);
- },
- name: 'Ext.data.DataReader'
-});
-Ext.apply(Ext.data.DataReader.Error.prototype, {
- lang : {
- 'update': "#update received invalid data from server. Please see docs for DataReader#update and review your DataReader configuration.",
- 'realize': "#realize was called with invalid remote-data. Please see the docs for DataReader#realize and review your DataReader configuration.",
- 'invalid-response': "#readResponse received an invalid response from the server."
- }
});
-Ext.data.DataWriter = function(config){
- Ext.apply(this, config);
-};
-Ext.data.DataWriter.prototype = {
-
-
- writeAllFields : false,
-
- listful : false,
-
- apply : function(params, baseParams, action, rs) {
- var data = [],
- renderer = action + 'Record';
-
- if (Ext.isArray(rs)) {
- Ext.each(rs, function(rec){
- data.push(this[renderer](rec));
- }, this);
+Ext.define('Ext.form.field.TextArea', {
+ extend:'Ext.form.field.Text',
+ alias: ['widget.textareafield', 'widget.textarea'],
+ alternateClassName: 'Ext.form.TextArea',
+ requires: ['Ext.XTemplate', 'Ext.layout.component.field.TextArea'],
+
+ fieldSubTpl: [
+ '',
+ {
+ compiled: true,
+ disableFormats: true
}
- else if (rs instanceof Ext.data.Record) {
- data = this[renderer](rs);
- }
- this.render(params, baseParams, data);
- },
+ ],
- render : Ext.emptyFn,
+ growMin: 60,
- updateRecord : Ext.emptyFn,
+ growMax: 1000,
- createRecord : Ext.emptyFn,
+ growAppend: '\n-',
- destroyRecord : Ext.emptyFn,
+ cols: 20,
- toHash : function(rec, config) {
- var map = rec.fields.map,
- data = {},
- raw = (this.writeAllFields === false && rec.phantom === false) ? rec.getChanges() : rec.data,
- m;
- Ext.iterate(raw, function(prop, value){
- if((m = map[prop])){
- data[m.mapping ? m.mapping : m.name] = value;
- }
- });
-
-
-
- if (rec.phantom) {
- if (rec.fields.containsKey(this.meta.idProperty) && Ext.isEmpty(rec.data[this.meta.idProperty])) {
- delete data[this.meta.idProperty];
- }
- } else {
- data[this.meta.idProperty] = rec.id;
- }
- return data;
- },
+ rows: 4,
- toArray : function(data) {
- var fields = [];
- Ext.iterate(data, function(k, v) {fields.push({name: k, value: v});},this);
- return fields;
- }
-};
-Ext.data.DataProxy = function(conn){
-
-
- conn = conn || {};
+ enterIsSpecial: false,
-
-
-
- this.api = conn.api;
- this.url = conn.url;
- this.restful = conn.restful;
- this.listeners = conn.listeners;
+ preventScrollbars: false,
- this.prettyUrls = conn.prettyUrls;
+ componentLayout: 'textareafield',
+ onRender: function(ct, position) {
+ var me = this;
+ Ext.applyIf(me.subTplData, {
+ cols: me.cols,
+ rows: me.rows
+ });
- this.addEvents(
-
- 'exception',
-
- 'beforeload',
-
- 'load',
-
- 'loadexception',
-
- 'beforewrite',
-
- 'write'
- );
- Ext.data.DataProxy.superclass.constructor.call(this);
+ me.callParent(arguments);
+ },
- try {
- Ext.data.Api.prepare(this);
- } catch (e) {
- if (e instanceof Ext.data.Api.Error) {
- e.toConsole();
- }
- }
-
- Ext.data.DataProxy.relayEvents(this, ['beforewrite', 'write', 'exception']);
-};
+ afterRender: function(){
+ var me = this;
-Ext.extend(Ext.data.DataProxy, Ext.util.Observable, {
-
- restful: false,
+ me.callParent(arguments);
-
- setApi : function() {
- if (arguments.length == 1) {
- var valid = Ext.data.Api.isValid(arguments[0]);
- if (valid === true) {
- this.api = arguments[0];
- }
- else {
- throw new Ext.data.Api.Error('invalid', valid);
- }
- }
- else if (arguments.length == 2) {
- if (!Ext.data.Api.isAction(arguments[0])) {
- throw new Ext.data.Api.Error('invalid', arguments[0]);
+ if (me.grow) {
+ if (me.preventScrollbars) {
+ me.inputEl.setStyle('overflow', 'hidden');
}
- this.api[arguments[0]] = arguments[1];
+ me.inputEl.setHeight(me.growMin);
}
- Ext.data.Api.prepare(this);
},
- isApiAction : function(action) {
- return (this.api[action]) ? true : false;
- },
-
-
- request : function(action, rs, params, reader, callback, scope, options) {
- if (!this.api[action] && !this.load) {
- throw new Ext.data.DataProxy.Error('action-undefined', action);
- }
- params = params || {};
- if ((action === Ext.data.Api.actions.read) ? this.fireEvent("beforeload", this, params) : this.fireEvent("beforewrite", this, action, rs, params) !== false) {
- this.doRequest.apply(this, arguments);
- }
- else {
- callback.call(scope || this, null, options, false);
+ fireKey: function(e) {
+ if (e.isSpecialKey() && (this.enterIsSpecial || (e.getKey() !== e.ENTER || e.hasModifier()))) {
+ this.fireEvent('specialkey', this, e);
}
},
-
- load : null,
+ autoSize: function() {
+ var me = this,
+ height;
-
- doRequest : function(action, rs, params, reader, callback, scope, options) {
-
-
-
- this.load(params, reader, callback, scope, options);
+ if (me.grow && me.rendered) {
+ me.doComponentLayout();
+ height = me.inputEl.getHeight();
+ if (height !== me.lastInputHeight) {
+ me.fireEvent('autosize', height);
+ me.lastInputHeight = height;
+ }
+ }
},
- onRead : Ext.emptyFn,
-
- onWrite : Ext.emptyFn,
-
- buildUrl : function(action, record) {
- record = record || null;
-
-
-
-
- var url = (this.conn && this.conn.url) ? this.conn.url : (this.api[action]) ? this.api[action].url : this.url;
- if (!url) {
- throw new Ext.data.Api.Error('invalid-url', action);
- }
-
-
-
-
-
-
-
- var provides = null;
- var m = url.match(/(.*)(\.json|\.xml|\.html)$/);
- if (m) {
- provides = m[2];
- url = m[1];
- }
-
- if ((this.restful === true || this.prettyUrls === true) && record instanceof Ext.data.Record && !record.phantom) {
- url += '/' + record.id;
- }
- return (provides === null) ? url : url + provides;
+ initAria: function() {
+ this.callParent(arguments);
+ this.getActionEl().dom.setAttribute('aria-multiline', true);
},
- destroy: function(){
- this.purgeListeners();
+ getBodyNaturalWidth: function() {
+ return Math.round(this.cols * 6.5) + 20;
}
-});
-
-
-
-Ext.apply(Ext.data.DataProxy, Ext.util.Observable.prototype);
-Ext.util.Observable.call(Ext.data.DataProxy);
-
-Ext.data.DataProxy.Error = Ext.extend(Ext.Error, {
- constructor : function(message, arg) {
- this.arg = arg;
- Ext.Error.call(this, message);
- },
- name: 'Ext.data.DataProxy'
-});
-Ext.apply(Ext.data.DataProxy.Error.prototype, {
- lang: {
- 'action-undefined': "DataProxy attempted to execute an API-action but found an undefined url / function. Please review your Proxy url/api-configuration.",
- 'api-invalid': 'Recieved an invalid API-configuration. Please ensure your proxy API-configuration contains only the actions from Ext.data.Api.actions.'
- }
});
-Ext.data.Request = function(params) {
- Ext.apply(this, params);
-};
-Ext.data.Request.prototype = {
-
- action : undefined,
-
- rs : undefined,
-
- params: undefined,
-
- callback : Ext.emptyFn,
-
- scope : undefined,
+Ext.define('Ext.window.MessageBox', {
+ extend: 'Ext.window.Window',
+
+ requires: [
+ 'Ext.toolbar.Toolbar',
+ 'Ext.form.field.Text',
+ 'Ext.form.field.TextArea',
+ 'Ext.button.Button',
+ 'Ext.layout.container.Anchor',
+ 'Ext.layout.container.HBox',
+ 'Ext.ProgressBar'
+ ],
- reader : undefined
-};
+ alternateClassName: 'Ext.MessageBox',
+
+ alias: 'widget.messagebox',
-Ext.data.Response = function(params) {
- Ext.apply(this, params);
-};
-Ext.data.Response.prototype = {
- action: undefined,
+ OK : 1,
- success : undefined,
+ YES : 2,
- message : undefined,
+ NO : 4,
- data: undefined,
+ CANCEL : 8,
- raw: undefined,
+ OKCANCEL : 9,
- records: undefined
-};
-
-Ext.data.ScriptTagProxy = function(config){
- Ext.apply(this, config);
-
- Ext.data.ScriptTagProxy.superclass.constructor.call(this, config);
-
- this.head = document.getElementsByTagName("head")[0];
-
+ YESNO : 6,
-};
-
-Ext.data.ScriptTagProxy.TRANS_ID = 1000;
-
-Ext.extend(Ext.data.ScriptTagProxy, Ext.data.DataProxy, {
+ YESNOCANCEL : 14,
+ INFO : 'ext-mb-info',
- timeout : 30000,
+ WARNING : 'ext-mb-warning',
- callbackParam : "callback",
+ QUESTION : 'ext-mb-question',
- nocache : true,
+ ERROR : 'ext-mb-error',
- doRequest : function(action, rs, params, reader, callback, scope, arg) {
- var p = Ext.urlEncode(Ext.apply(params, this.extraParams));
-
- var url = this.buildUrl(action, rs);
- if (!url) {
- throw new Ext.data.Api.Error('invalid-url', url);
- }
- url = Ext.urlAppend(url, p);
-
- if(this.nocache){
- url = Ext.urlAppend(url, '_dc=' + (new Date().getTime()));
- }
- var transId = ++Ext.data.ScriptTagProxy.TRANS_ID;
- var trans = {
- id : transId,
- action: action,
- cb : "stcCallback"+transId,
- scriptId : "stcScript"+transId,
- params : params,
- arg : arg,
- url : url,
- callback : callback,
- scope : scope,
- reader : reader
- };
- window[trans.cb] = this.createCallback(action, rs, trans);
- url += String.format("&{0}={1}", this.callbackParam, trans.cb);
- if(this.autoAbort !== false){
- this.abort();
- }
+ hideMode: 'offsets',
+ closeAction: 'hide',
+ resizable: false,
+ title: ' ',
- trans.timeoutId = this.handleFailure.defer(this.timeout, this, [trans]);
+ width: 600,
+ height: 500,
+ minWidth: 250,
+ maxWidth: 600,
+ minHeight: 110,
+ maxHeight: 500,
+ constrain: true,
- var script = document.createElement("script");
- script.setAttribute("src", url);
- script.setAttribute("type", "text/javascript");
- script.setAttribute("id", trans.scriptId);
- this.head.appendChild(script);
+ cls: Ext.baseCSSPrefix + 'message-box',
- this.trans = trans;
+ layout: {
+ type: 'anchor'
},
- createCallback : function(action, rs, trans) {
- var self = this;
- return function(res) {
- self.trans = false;
- self.destroyTrans(trans, true);
- if (action === Ext.data.Api.actions.read) {
- self.onRead.call(self, action, trans, res);
- } else {
- self.onWrite.call(self, action, trans, res, rs);
- }
- };
- },
+ defaultTextHeight : 75,
- onRead : function(action, trans, res) {
- var result;
- try {
- result = trans.reader.readRecords(res);
- }catch(e){
-
- this.fireEvent("loadexception", this, trans, res, e);
-
- this.fireEvent('exception', this, 'response', action, trans, res, e);
- trans.callback.call(trans.scope||window, null, trans.arg, false);
- return;
- }
- if (result.success === false) {
-
- this.fireEvent('loadexception', this, trans, res);
-
- this.fireEvent('exception', this, 'remote', action, trans, res, null);
- } else {
- this.fireEvent("load", this, res, trans.arg);
- }
- trans.callback.call(trans.scope||window, result, trans.arg, result.success);
- },
+ minProgressWidth : 250,
- onWrite : function(action, trans, response, rs) {
- var reader = trans.reader;
- try {
-
- var res = reader.readResponse(action, response);
- } catch (e) {
- this.fireEvent('exception', this, 'response', action, trans, res, e);
- trans.callback.call(trans.scope||window, null, res, false);
- return;
- }
- if(!res.success === true){
- this.fireEvent('exception', this, 'remote', action, trans, res, rs);
- trans.callback.call(trans.scope||window, null, res, false);
- return;
- }
- this.fireEvent("write", this, action, res.data, res, rs, trans.arg );
- trans.callback.call(trans.scope||window, res.data, res, true);
- },
-
+ minPromptWidth: 250,
- isLoading : function(){
- return this.trans ? true : false;
+ buttonText: {
+ ok: 'OK',
+ yes: 'Yes',
+ no: 'No',
+ cancel: 'Cancel'
},
-
- abort : function(){
- if(this.isLoading()){
- this.destroyTrans(this.trans);
- }
- },
+ buttonIds: [
+ 'ok', 'yes', 'no', 'cancel'
+ ],
-
- destroyTrans : function(trans, isLoaded){
- this.head.removeChild(document.getElementById(trans.scriptId));
- clearTimeout(trans.timeoutId);
- if(isLoaded){
- window[trans.cb] = undefined;
- try{
- delete window[trans.cb];
- }catch(e){}
- }else{
-
- window[trans.cb] = function(){
- window[trans.cb] = undefined;
- try{
- delete window[trans.cb];
- }catch(e){}
- };
- }
+ titleText: {
+ confirm: 'Confirm',
+ prompt: 'Prompt',
+ wait: 'Loading...',
+ alert: 'Attention'
},
-
- handleFailure : function(trans){
- this.trans = false;
- this.destroyTrans(trans, false);
- if (trans.action === Ext.data.Api.actions.read) {
-
- this.fireEvent("loadexception", this, null, trans.arg);
- }
+ iconHeight: 35,
- this.fireEvent('exception', this, 'response', trans.action, {
- response: null,
- options: trans.arg
+ makeButton: function(btnIdx) {
+ var btnId = this.buttonIds[btnIdx];
+ return Ext.create('Ext.button.Button', {
+ handler: this.btnCallback,
+ itemId: btnId,
+ scope: this,
+ text: this.buttonText[btnId],
+ minWidth: 75
});
- trans.callback.call(trans.scope||window, null, trans.arg, false);
},
-
- destroy: function(){
- this.abort();
- Ext.data.ScriptTagProxy.superclass.destroy.call(this);
- }
-});
-Ext.data.HttpProxy = function(conn){
- Ext.data.HttpProxy.superclass.constructor.call(this, conn);
-
-
- this.conn = conn;
-
-
-
-
-
- this.conn.url = null;
-
- this.useAjax = !conn || !conn.events;
+ btnCallback: function(btn) {
+ var me = this,
+ value,
+ field;
-
- var actions = Ext.data.Api.actions;
- this.activeRequest = {};
- for (var verb in actions) {
- this.activeRequest[actions[verb]] = undefined;
- }
-};
+ if (me.cfg.prompt || me.cfg.multiline) {
+ if (me.cfg.multiline) {
+ field = me.textArea;
+ } else {
+ field = me.textField;
+ }
+ value = field.getValue();
+ field.reset();
+ }
-Ext.extend(Ext.data.HttpProxy, Ext.data.DataProxy, {
-
- getConnection : function() {
- return this.useAjax ? Ext.Ajax : this.conn;
+
+ btn.blur();
+ me.hide();
+ me.userCallback(btn.itemId, value, me.cfg);
},
-
- setUrl : function(url, makePermanent) {
- this.conn.url = url;
- if (makePermanent === true) {
- this.url = url;
- this.api = null;
- Ext.data.Api.prepare(this);
- }
+ hide: function() {
+ var me = this;
+ me.dd.endDrag();
+ me.progressBar.reset();
+ me.removeCls(me.cfg.cls);
+ me.callParent();
},
-
- doRequest : function(action, rs, params, reader, cb, scope, arg) {
- var o = {
- method: (this.api[action]) ? this.api[action]['method'] : undefined,
- request: {
- callback : cb,
- scope : scope,
- arg : arg
- },
- reader: reader,
- callback : this.createCallback(action, rs),
- scope: this
- };
+ initComponent: function() {
+ var me = this,
+ i, button;
-
-
- if (params.jsonData) {
- o.jsonData = params.jsonData;
- } else if (params.xmlData) {
- o.xmlData = params.xmlData;
- } else {
- o.params = params || {};
- }
-
-
-
- this.conn.url = this.buildUrl(action, rs);
+ me.title = ' ';
- if(this.useAjax){
+ me.topContainer = Ext.create('Ext.container.Container', {
+ anchor: '100%',
+ style: {
+ padding: '10px',
+ overflow: 'hidden'
+ },
+ items: [
+ me.iconComponent = Ext.create('Ext.Component', {
+ cls: 'ext-mb-icon',
+ width: 50,
+ height: me.iconHeight,
+ style: {
+ 'float': 'left'
+ }
+ }),
+ me.promptContainer = Ext.create('Ext.container.Container', {
+ layout: {
+ type: 'anchor'
+ },
+ items: [
+ me.msg = Ext.create('Ext.Component', {
+ autoEl: { tag: 'span' },
+ cls: 'ext-mb-text'
+ }),
+ me.textField = Ext.create('Ext.form.field.Text', {
+ anchor: '100%',
+ enableKeyEvents: true,
+ listeners: {
+ keydown: me.onPromptKey,
+ scope: me
+ }
+ }),
+ me.textArea = Ext.create('Ext.form.field.TextArea', {
+ anchor: '100%',
+ height: 75
+ })
+ ]
+ })
+ ]
+ });
+ me.progressBar = Ext.create('Ext.ProgressBar', {
+ anchor: '-10',
+ style: 'margin-left:10px'
+ });
- Ext.applyIf(o, this.conn);
+ me.items = [me.topContainer, me.progressBar];
-
- if (this.activeRequest[action]) {
-
-
-
-
-
- }
- this.activeRequest[action] = Ext.Ajax.request(o);
- }else{
- this.conn.request(o);
- }
- this.conn.url = null;
+ me.msgButtons = [];
+ for (i = 0; i < 4; i++) {
+ button = me.makeButton(i);
+ me.msgButtons[button.itemId] = button;
+ me.msgButtons.push(button);
+ }
+ me.bottomTb = Ext.create('Ext.toolbar.Toolbar', {
+ ui: 'footer',
+ dock: 'bottom',
+ layout: {
+ pack: 'center'
+ },
+ items: [
+ me.msgButtons[0],
+ me.msgButtons[1],
+ me.msgButtons[2],
+ me.msgButtons[3]
+ ]
+ });
+ me.dockedItems = [me.bottomTb];
+
+ me.callParent();
},
-
- createCallback : function(action, rs) {
- return function(o, success, response) {
- this.activeRequest[action] = undefined;
- if (!success) {
- if (action === Ext.data.Api.actions.read) {
-
-
- this.fireEvent('loadexception', this, o, response);
- }
- this.fireEvent('exception', this, 'response', action, o, response);
- o.request.callback.call(o.request.scope, null, o.request.arg, false);
- return;
+ onPromptKey: function(textField, e) {
+ var me = this,
+ blur;
+
+ if (e.keyCode === Ext.EventObject.RETURN || e.keyCode === 10) {
+ if (me.msgButtons.ok.isVisible()) {
+ blur = true;
+ me.msgButtons.ok.handler.call(me, me.msgButtons.ok);
+ } else if (me.msgButtons.yes.isVisible()) {
+ me.msgButtons.yes.handler.call(me, me.msgButtons.yes);
+ blur = true;
}
- if (action === Ext.data.Api.actions.read) {
- this.onRead(action, o, response);
- } else {
- this.onWrite(action, o, response, rs);
+
+ if (blur) {
+ me.textField.blur();
}
- };
+ }
},
-
- onRead : function(action, o, response) {
- var result;
- try {
- result = o.reader.read(response);
- }catch(e){
-
-
- this.fireEvent('loadexception', this, o, response, e);
+ reconfigure: function(cfg) {
+ var me = this,
+ buttons = cfg.buttons || 0,
+ hideToolbar = true,
+ initialWidth = me.maxWidth,
+ i;
- this.fireEvent('exception', this, 'response', action, o, response, e);
- o.request.callback.call(o.request.scope, null, o.request.arg, false);
- return;
+ cfg = cfg || {};
+ me.cfg = cfg;
+ if (cfg.width) {
+ initialWidth = cfg.width;
}
- if (result.success === false) {
-
-
- this.fireEvent('loadexception', this, o, response);
-
- var res = o.reader.readResponse(action, response);
- this.fireEvent('exception', this, 'remote', action, o, res, null);
- }
- else {
- this.fireEvent('load', this, o, o.request.arg);
- }
-
-
- o.request.callback.call(o.request.scope, result, o.request.arg, result.success);
- },
-
- onWrite : function(action, o, response, rs) {
- var reader = o.reader;
- var res;
- try {
- res = reader.readResponse(action, response);
- } catch (e) {
- this.fireEvent('exception', this, 'response', action, o, response, e);
- o.request.callback.call(o.request.scope, null, o.request.arg, false);
- return;
- }
- if (res.success === true) {
- this.fireEvent('write', this, action, res.data, res, rs, o.request.arg);
- } else {
- this.fireEvent('exception', this, 'remote', action, o, res, rs);
- }
+ delete me.defaultFocus;
+ me.animateTarget = cfg.animateTarget || undefined;
+
- o.request.callback.call(o.request.scope, res.data, res, res.success);
- },
+ me.modal = cfg.modal !== false;
-
- destroy: function(){
- if(!this.useAjax){
- this.conn.abort();
- }else if(this.activeRequest){
- var actions = Ext.data.Api.actions;
- for (var verb in actions) {
- if(this.activeRequest[actions[verb]]){
- Ext.Ajax.abort(this.activeRequest[actions[verb]]);
- }
- }
+
+ if (cfg.title) {
+ me.setTitle(cfg.title||' ');
}
- Ext.data.HttpProxy.superclass.destroy.call(this);
- }
-});
-Ext.data.MemoryProxy = function(data){
-
- var api = {};
- api[Ext.data.Api.actions.read] = true;
- Ext.data.MemoryProxy.superclass.constructor.call(this, {
- api: api
- });
- this.data = data;
-};
-Ext.extend(Ext.data.MemoryProxy, Ext.data.DataProxy, {
-
+ if (!me.rendered) {
+ me.width = initialWidth;
+ me.render(Ext.getBody());
+ } else {
+ me.setSize(initialWidth, me.maxHeight);
+ }
+ me.setPosition(-10000, -10000);
-
- doRequest : function(action, rs, params, reader, callback, scope, arg) {
- params = params || {};
- var result;
- try {
- result = reader.readRecords(this.data);
- }catch(e){
-
- this.fireEvent("loadexception", this, null, arg, e);
-
- this.fireEvent('exception', this, 'response', action, arg, null, e);
- callback.call(scope, null, arg, false);
- return;
+ me.closable = cfg.closable && !cfg.wait;
+ if (cfg.closable === false) {
+ me.tools.close.hide();
+ } else {
+ me.tools.close.show();
}
- callback.call(scope, result, arg, true);
- }
-});
-Ext.data.Types = new function(){
- var st = Ext.data.SortTypes;
- Ext.apply(this, {
-
- stripRe: /[\$,%]/g,
-
-
- AUTO: {
- convert: function(v){ return v; },
- sortType: st.none,
- type: 'auto'
- },
- STRING: {
- convert: function(v){ return (v === undefined || v === null) ? '' : String(v); },
- sortType: st.asUCString,
- type: 'string'
- },
+ if (!cfg.title && !me.closable) {
+ me.header.hide();
+ } else {
+ me.header.show();
+ }
- INT: {
- convert: function(v){
- return v !== undefined && v !== null && v !== '' ?
- parseInt(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
- },
- sortType: st.none,
- type: 'int'
- },
-
-
- FLOAT: {
- convert: function(v){
- return v !== undefined && v !== null && v !== '' ?
- parseFloat(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
- },
- sortType: st.none,
- type: 'float'
- },
-
+ me.liveDrag = !cfg.proxyDrag;
+
- BOOL: {
- convert: function(v){ return v === true || v === 'true' || v == 1; },
- sortType: st.none,
- type: 'bool'
- },
+ me.userCallback = Ext.Function.bind(cfg.callback ||cfg.fn || Ext.emptyFn, cfg.scope || Ext.global);
+
+ me.setIcon(cfg.icon);
+
- DATE: {
- convert: function(v){
- var df = this.dateFormat;
- if(!v){
- return null;
- }
- if(Ext.isDate(v)){
- return v;
- }
- if(df){
- if(df == 'timestamp'){
- return new Date(v*1000);
- }
- if(df == 'time'){
- return new Date(parseInt(v, 10));
- }
- return Date.parseDate(v, df);
- }
- var parsed = Date.parse(v);
- return parsed ? new Date(parsed) : null;
- },
- sortType: st.asDate,
- type: 'date'
+ if (cfg.msg) {
+ me.msg.update(cfg.msg);
+ me.msg.show();
+ } else {
+ me.msg.hide();
}
- });
-
- Ext.apply(this, {
+
- BOOLEAN: this.BOOL,
+ if (cfg.prompt || cfg.multiline) {
+ me.multiline = cfg.multiline;
+ if (cfg.multiline) {
+ me.textArea.setValue(cfg.value);
+ me.textArea.setHeight(cfg.defaultTextHeight || me.defaultTextHeight);
+ me.textArea.show();
+ me.textField.hide();
+ me.defaultFocus = me.textArea;
+ } else {
+ me.textField.setValue(cfg.value);
+ me.textArea.hide();
+ me.textField.show();
+ me.defaultFocus = me.textField;
+ }
+ } else {
+ me.textArea.hide();
+ me.textField.hide();
+ }
+
- INTEGER: this.INT,
+ if (cfg.progress || cfg.wait) {
+ me.progressBar.show();
+ me.updateProgress(0, cfg.progressText);
+ if(cfg.wait === true){
+ me.progressBar.wait(cfg.waitConfig);
+ }
+ } else {
+ me.progressBar.hide();
+ }
+
- NUMBER: this.FLOAT
- });
-};
-Ext.data.JsonWriter = Ext.extend(Ext.data.DataWriter, {
-
- encode : true,
-
- encodeDelete: false,
-
- constructor : function(config){
- Ext.data.JsonWriter.superclass.constructor.call(this, config);
+ for (i = 0; i < 4; i++) {
+ if (buttons & Math.pow(2, i)) {
+
+
+ if (!me.defaultFocus) {
+ me.defaultFocus = me.msgButtons[i];
+ }
+ me.msgButtons[i].show();
+ hideToolbar = false;
+ } else {
+ me.msgButtons[i].hide();
+ }
+ }
+
+
+ if (hideToolbar) {
+ me.bottomTb.hide();
+ } else {
+ me.bottomTb.show();
+ }
+ me.hidden = true;
},
- render : function(params, baseParams, data) {
- if (this.encode === true) {
+ show: function(cfg) {
+ var me = this;
- Ext.apply(params, baseParams);
- params[this.meta.root] = Ext.encode(data);
+ me.reconfigure(cfg);
+ me.addCls(cfg.cls);
+ if (cfg.animateTarget) {
+ me.doAutoSize(false);
+ me.callParent();
} else {
-
- var jdata = Ext.apply({}, baseParams);
- jdata[this.meta.root] = data;
- params.jsonData = jdata;
+ me.callParent();
+ me.doAutoSize(true);
}
+ return me;
},
- createRecord : function(rec) {
- return this.toHash(rec);
- },
-
- updateRecord : function(rec) {
- return this.toHash(rec);
-
+ afterShow: function(){
+ if (this.animateTarget) {
+ this.center();
+ }
+ this.callParent(arguments);
},
-
- destroyRecord : function(rec){
- if(this.encodeDelete){
- var data = {};
- data[this.meta.idProperty] = rec.id;
- return data;
- }else{
- return rec.id;
- }
- }
-});
-Ext.data.JsonReader = function(meta, recordType){
- meta = meta || {};
-
-
-
-
- Ext.applyIf(meta, {
- idProperty: 'id',
- successProperty: 'success',
- totalProperty: 'total'
- });
- Ext.data.JsonReader.superclass.constructor.call(this, meta, recordType || meta.fields);
-};
-Ext.extend(Ext.data.JsonReader, Ext.data.DataReader, {
-
-
- read : function(response){
- var json = response.responseText;
- var o = Ext.decode(json);
- if(!o) {
- throw {message: 'JsonReader.read: Json object not found'};
- }
- return this.readRecords(o);
- },
+ doAutoSize: function(center) {
+ var me = this,
+ icon = me.iconComponent,
+ iconHeight = me.iconHeight;
-
-
- readResponse : function(action, response) {
- var o = (response.responseText !== undefined) ? Ext.decode(response.responseText) : response;
- if(!o) {
- throw new Ext.data.JsonReader.Error('response');
+ if (!Ext.isDefined(me.frameWidth)) {
+ me.frameWidth = me.el.getWidth() - me.body.getWidth();
}
+
+
+ icon.setHeight(iconHeight);
- var root = this.getRoot(o);
- if (action === Ext.data.Api.actions.create) {
- var def = Ext.isDefined(root);
- if (def && Ext.isEmpty(root)) {
- throw new Ext.data.JsonReader.Error('root-empty', this.meta.root);
- }
- else if (!def) {
- throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root);
- }
- }
+
+ me.minWidth = me.cfg.minWidth || Ext.getClass(this).prototype.minWidth;
- var res = new Ext.data.Response({
- action: action,
- success: this.getSuccess(o),
- data: (root) ? this.extractData(root, false) : [],
- message: this.getMessage(o),
- raw: o
- });
+
+ me.topContainer.doLayout();
+ if (Ext.isIE6 || Ext.isIEQuirks) {
+
+
+
+ me.textField.setCalculatedSize(9);
+ me.textArea.setCalculatedSize(9);
+ }
+ var width = me.cfg.width || me.msg.getWidth() + icon.getWidth() + 25,
+ height = (me.header.rendered ? me.header.getHeight() : 0) +
+ Math.max(me.promptContainer.getHeight(), icon.getHeight()) +
+ me.progressBar.getHeight() +
+ (me.bottomTb.rendered ? me.bottomTb.getHeight() : 0) + 20 ;
- if (Ext.isEmpty(res.success)) {
- throw new Ext.data.JsonReader.Error('successProperty-response', this.meta.successProperty);
+ icon.setHeight(Math.max(iconHeight, me.msg.getHeight()));
+ me.setSize(width + me.frameWidth, height + me.frameWidth);
+ if (center) {
+ me.center();
}
- return res;
+ return me;
+ },
+
+ updateText: function(text) {
+ this.msg.update(text);
+ return this.doAutoSize(true);
},
- readRecords : function(o){
-
- this.jsonData = o;
- if(o.metaData){
- this.onMetaChange(o.metaData);
+ setIcon : function(icon) {
+ var me = this;
+ me.iconComponent.removeCls(me.iconCls);
+ if (icon) {
+ me.iconComponent.show();
+ me.iconComponent.addCls(Ext.baseCSSPrefix + 'dlg-icon');
+ me.iconComponent.addCls(me.iconCls = icon);
+ } else {
+ me.iconComponent.removeCls(Ext.baseCSSPrefix + 'dlg-icon');
+ me.iconComponent.hide();
}
- var s = this.meta, Record = this.recordType,
- f = Record.prototype.fields, fi = f.items, fl = f.length, v;
+ return me;
+ },
- var root = this.getRoot(o), c = root.length, totalRecords = c, success = true;
- if(s.totalProperty){
- v = parseInt(this.getTotal(o), 10);
- if(!isNaN(v)){
- totalRecords = v;
- }
- }
- if(s.successProperty){
- v = this.getSuccess(o);
- if(v === false || v === 'false'){
- success = false;
- }
+
+ updateProgress : function(value, progressText, msg){
+ this.progressBar.updateProgress(value, progressText);
+ if (msg){
+ this.updateText(msg);
}
+ return this;
+ },
-
- return {
- success : success,
- records : this.extractData(root, true),
- totalRecords : totalRecords
- };
+ onEsc: function() {
+ if (this.closable !== false) {
+ this.callParent(arguments);
+ }
},
- buildExtractors : function() {
- if(this.ef){
- return;
+ confirm: function(cfg, msg, fn, scope) {
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title: cfg,
+ icon: 'ext-mb-question',
+ msg: msg,
+ buttons: this.YESNO,
+ callback: fn,
+ scope: scope
+ };
}
- var s = this.meta, Record = this.recordType,
- f = Record.prototype.fields, fi = f.items, fl = f.length;
+ return this.show(cfg);
+ },
- if(s.totalProperty) {
- this.getTotal = this.createAccessor(s.totalProperty);
- }
- if(s.successProperty) {
- this.getSuccess = this.createAccessor(s.successProperty);
- }
- if (s.messageProperty) {
- this.getMessage = this.createAccessor(s.messageProperty);
- }
- this.getRoot = s.root ? this.createAccessor(s.root) : function(p){return p;};
- if (s.id || s.idProperty) {
- var g = this.createAccessor(s.id || s.idProperty);
- this.getId = function(rec) {
- var r = g(rec);
- return (r === undefined || r === '') ? null : r;
+
+ prompt : function(cfg, msg, fn, scope, multiline, value){
+ if (Ext.isString(cfg)) {
+ cfg = {
+ prompt: true,
+ title: cfg,
+ minWidth: this.minPromptWidth,
+ msg: msg,
+ buttons: this.OKCANCEL,
+ callback: fn,
+ scope: scope,
+ multiline: multiline,
+ value: value
};
- } else {
- this.getId = function(){return null;};
}
- var ef = [];
- for(var i = 0; i < fl; i++){
- f = fi[i];
- var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name;
- ef.push(this.createAccessor(map));
- }
- this.ef = ef;
+ return this.show(cfg);
},
- simpleAccess : function(obj, subsc) {
- return obj[subsc];
+ wait : function(cfg, title, config){
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title : title,
+ msg : cfg,
+ closable: false,
+ wait: true,
+ modal: true,
+ minWidth: this.minProgressWidth,
+ waitConfig: config
+ };
+ }
+ return this.show(cfg);
},
- createAccessor : function(){
- var re = /[\[\.]/;
- return function(expr) {
- if(Ext.isEmpty(expr)){
- return Ext.emptyFn;
- }
- if(Ext.isFunction(expr)){
- return expr;
- }
- var i = String(expr).search(re);
- if(i >= 0){
- return new Function('obj', 'return obj' + (i > 0 ? '.' : '') + expr);
- }
- return function(obj){
- return obj[expr];
+ alert: function(cfg, msg, fn, scope) {
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title : cfg,
+ msg : msg,
+ buttons: this.OK,
+ fn: fn,
+ scope : scope,
+ minWidth: this.minWidth
};
-
- };
- }(),
+ }
+ return this.show(cfg);
+ },
- extractValues : function(data, items, len) {
- var f, values = {};
- for(var j = 0; j < len; j++){
- f = items[j];
- var v = this.ef[j](data);
- values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data);
+ progress : function(cfg, msg, progressText){
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title: cfg,
+ msg: msg,
+ progressText: progressText
+ };
}
- return values;
+ return this.show(cfg);
}
+}, function() {
+ Ext.MessageBox = Ext.Msg = new this();
});
-Ext.data.JsonReader.Error = Ext.extend(Ext.Error, {
- constructor : function(message, arg) {
- this.arg = arg;
- Ext.Error.call(this, message);
- },
- name : 'Ext.data.JsonReader'
-});
-Ext.apply(Ext.data.JsonReader.Error.prototype, {
- lang: {
- 'response': 'An error occurred while json-decoding your server response',
- 'successProperty-response': 'Could not locate your "successProperty" in your server response. Please review your JsonReader config to ensure the config-property "successProperty" matches the property in your server-response. See the JsonReader docs.',
- 'root-undefined-config': 'Your JsonReader was configured without a "root" property. Please review your JsonReader config and make sure to define the root property. See the JsonReader docs.',
- 'idProperty-undefined' : 'Your JsonReader was configured without an "idProperty" Please review your JsonReader configuration and ensure the "idProperty" is set (e.g.: "id"). See the JsonReader docs.',
- 'root-empty': 'Data was expected to be returned by the server in the "root" property of the response. Please review your JsonReader configuration to ensure the "root" property matches that returned in the server-response. See JsonReader docs.'
- }
-});
-Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
-
-
-
-
- readRecords : function(o){
- this.arrayData = o;
- var s = this.meta,
- sid = s ? Ext.num(s.idIndex, s.id) : null,
- recordType = this.recordType,
- fields = recordType.prototype.fields,
- records = [],
- success = true,
- v;
- var root = this.getRoot(o);
+Ext.define('Ext.form.Basic', {
+ extend: 'Ext.util.Observable',
+ alternateClassName: 'Ext.form.BasicForm',
+ requires: ['Ext.util.MixedCollection', 'Ext.form.action.Load', 'Ext.form.action.Submit',
+ 'Ext.window.MessageBox', 'Ext.data.Errors'],
- for(var i = 0, len = root.length; i < len; i++) {
- var n = root[i],
- values = {},
- id = ((sid || sid === 0) && n[sid] !== undefined && n[sid] !== "" ? n[sid] : null);
- for(var j = 0, jlen = fields.length; j < jlen; j++) {
- var f = fields.items[j],
- k = f.mapping !== undefined && f.mapping !== null ? f.mapping : j;
- v = n[k] !== undefined ? n[k] : f.defaultValue;
- v = f.convert(v, n);
- values[f.name] = v;
- }
- var record = new recordType(values, id);
- record.json = n;
- records[records.length] = record;
- }
+ constructor: function(owner, config) {
+ var me = this,
+ onItemAddOrRemove = me.onItemAddOrRemove;
- var totalRecords = records.length;
+
+ me.owner = owner;
- if(s.totalProperty) {
- v = parseInt(this.getTotal(o), 10);
- if(!isNaN(v)) {
- totalRecords = v;
- }
- }
- if(s.successProperty){
- v = this.getSuccess(o);
- if(v === false || v === 'false'){
- success = false;
- }
- }
+
+ me.mon(owner, {
+ add: onItemAddOrRemove,
+ remove: onItemAddOrRemove,
+ scope: me
+ });
- return {
- success : success,
- records : records,
- totalRecords : totalRecords
- };
- }
-});
-Ext.data.ArrayStore = Ext.extend(Ext.data.Store, {
-
- constructor: function(config){
- Ext.data.ArrayStore.superclass.constructor.call(this, Ext.apply(config, {
- reader: new Ext.data.ArrayReader(config)
- }));
- },
+ Ext.apply(me, config);
- loadData : function(data, append){
- if(this.expandData === true){
- var r = [];
- for(var i = 0, len = data.length; i < len; i++){
- r[r.length] = [data[i]];
- }
- data = r;
+
+ if (Ext.isString(me.paramOrder)) {
+ me.paramOrder = me.paramOrder.split(/[\s,|]/);
}
- Ext.data.ArrayStore.superclass.loadData.call(this, data, append);
- }
-});
-Ext.reg('arraystore', Ext.data.ArrayStore);
+ me.addEvents(
+
+ 'beforeaction',
+
+ 'actionfailed',
+
+ 'actioncomplete',
+
+ 'validitychange',
+
+ 'dirtychange'
+ );
+ me.callParent();
+ },
-Ext.data.SimpleStore = Ext.data.ArrayStore;
-Ext.reg('simplestore', Ext.data.SimpleStore);
-Ext.data.JsonStore = Ext.extend(Ext.data.Store, {
- constructor: function(config){
- Ext.data.JsonStore.superclass.constructor.call(this, Ext.apply(config, {
- reader: new Ext.data.JsonReader(config)
- }));
- }
-});
-Ext.reg('jsonstore', Ext.data.JsonStore);
-Ext.data.XmlWriter = function(params) {
- Ext.data.XmlWriter.superclass.constructor.apply(this, arguments);
+ initialize: function(){
+ this.initialized = true;
+ this.onValidityChange(!this.hasInvalidField());
+ },
+
- this.tpl = (typeof(this.tpl) === 'string') ? new Ext.XTemplate(this.tpl).compile() : this.tpl.compile();
-};
-Ext.extend(Ext.data.XmlWriter, Ext.data.DataWriter, {
- documentRoot: 'xrequest',
- forceDocumentRoot: false,
+
- root: 'records',
+
- xmlVersion : '1.0',
+
- xmlEncoding: 'ISO-8859-15',
+ timeout: 30,
+
+
- tpl: '<\u003fxml version="{version}" encoding="{encoding}"\u003f><{documentRoot}><{name}>{value} <{root}> <{parent.record}><{name}>{value} ',
+
+ paramsAsHash: false,
- render : function(params, baseParams, data) {
- baseParams = this.toArray(baseParams);
- params.xmlData = this.tpl.applyTemplate({
- version: this.xmlVersion,
- encoding: this.xmlEncoding,
- documentRoot: (baseParams.length > 0 || this.forceDocumentRoot === true) ? this.documentRoot : false,
- record: this.meta.record,
- root: this.root,
- baseParams: baseParams,
- records: (Ext.isArray(data[0])) ? data : [data]
- });
- },
+ waitTitle: 'Please Wait...',
- createRecord : function(rec) {
- return this.toArray(this.toHash(rec));
- },
+ trackResetOnLoad: false,
- updateRecord : function(rec) {
- return this.toArray(this.toHash(rec));
- },
- destroyRecord : function(rec) {
- var data = {};
- data[this.meta.idProperty] = rec.id;
- return this.toArray(data);
- }
-});
-Ext.data.XmlReader = function(meta, recordType){
- meta = meta || {};
- Ext.applyIf(meta, {
- idProperty: meta.idProperty || meta.idPath || meta.id,
- successProperty: meta.successProperty || meta.success
- });
+ wasDirty: false,
+
- Ext.data.XmlReader.superclass.constructor.call(this, meta, recordType || meta.fields);
-};
-Ext.extend(Ext.data.XmlReader, Ext.data.DataReader, {
- read : function(response){
- var doc = response.responseXML;
- if(!doc) {
- throw {message: "XmlReader.read: XML Document not available"};
- }
- return this.readRecords(doc);
+ destroy: function() {
+ this.clearListeners();
},
- readRecords : function(doc){
-
- this.xmlData = doc;
+ onItemAddOrRemove: function(parent, child) {
+ var me = this,
+ isAdding = !!child.ownerCt,
+ isContainer = child.isContainer;
- var root = doc.documentElement || doc,
- q = Ext.DomQuery,
- totalRecords = 0,
- success = true;
+ function handleField(field) {
+
+ me[isAdding ? 'mon' : 'mun'](field, {
+ validitychange: me.checkValidity,
+ dirtychange: me.checkDirty,
+ scope: me,
+ buffer: 100
+ });
+
+ delete me._fields;
+ }
- if(this.meta.totalProperty){
- totalRecords = this.getTotal(root, 0);
+ if (child.isFormField) {
+ handleField(child);
}
- if(this.meta.successProperty){
- success = this.getSuccess(root);
+ else if (isContainer) {
+
+ Ext.Array.forEach(child.query('[isFormField]'), handleField);
}
- var records = this.extractData(q.select(this.meta.record, root), true);
+
+ delete this._boundItems;
- return {
- success : success,
- records : records,
- totalRecords : totalRecords || records.length
- };
+ if (me.initialized) {
+ me.onValidityChange(!me.hasInvalidField());
+ }
},
- readResponse : function(action, response) {
- var q = Ext.DomQuery,
- doc = response.responseXML,
- root = doc.documentElement || doc;
-
-
- var res = new Ext.data.Response({
- action: action,
- success : this.getSuccess(root),
- message: this.getMessage(root),
- data: this.extractData(q.select(this.meta.record, root) || q.select(this.meta.root, root), false),
- raw: doc
- });
-
- if (Ext.isEmpty(res.success)) {
- throw new Ext.data.DataReader.Error('successProperty-response', this.meta.successProperty);
+ getFields: function() {
+ var fields = this._fields;
+ if (!fields) {
+ fields = this._fields = Ext.create('Ext.util.MixedCollection');
+ fields.addAll(this.owner.query('[isFormField]'));
}
+ return fields;
+ },
-
- if (action === Ext.data.Api.actions.create) {
- var def = Ext.isDefined(res.data);
- if (def && Ext.isEmpty(res.data)) {
- throw new Ext.data.JsonReader.Error('root-empty', this.meta.root);
- }
- else if (!def) {
- throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root);
- }
+ getBoundItems: function() {
+ var boundItems = this._boundItems;
+ if (!boundItems) {
+ boundItems = this._boundItems = Ext.create('Ext.util.MixedCollection');
+ boundItems.addAll(this.owner.query('[formBind]'));
}
- return res;
+ return boundItems;
},
- getSuccess : function() {
- return true;
+
+ hasInvalidField: function() {
+ return !!this.getFields().findBy(function(field) {
+ var preventMark = field.preventMark,
+ isValid;
+ field.preventMark = true;
+ isValid = field.isValid();
+ field.preventMark = preventMark;
+ return !isValid;
+ });
},
- buildExtractors : function() {
- if(this.ef){
- return;
- }
- var s = this.meta,
- Record = this.recordType,
- f = Record.prototype.fields,
- fi = f.items,
- fl = f.length;
+ isValid: function() {
+ var me = this,
+ invalid;
+ me.batchLayouts(function() {
+ invalid = me.getFields().filterBy(function(field) {
+ return !field.validate();
+ });
+ });
+ return invalid.length < 1;
+ },
- if(s.totalProperty) {
- this.getTotal = this.createAccessor(s.totalProperty);
- }
- if(s.successProperty) {
- this.getSuccess = this.createAccessor(s.successProperty);
- }
- if (s.messageProperty) {
- this.getMessage = this.createAccessor(s.messageProperty);
- }
- this.getRoot = function(res) {
- return (!Ext.isEmpty(res[this.meta.record])) ? res[this.meta.record] : res[this.meta.root];
- };
- if (s.idPath || s.idProperty) {
- var g = this.createAccessor(s.idPath || s.idProperty);
- this.getId = function(rec) {
- var id = g(rec) || rec.id;
- return (id === undefined || id === '') ? null : id;
- };
- } else {
- this.getId = function(){return null;};
+
+ checkValidity: function() {
+ var me = this,
+ valid = !me.hasInvalidField();
+ if (valid !== me.wasValid) {
+ me.onValidityChange(valid);
+ me.fireEvent('validitychange', me, valid);
+ me.wasValid = valid;
}
- var ef = [];
- for(var i = 0; i < fl; i++){
- f = fi[i];
- var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name;
- ef.push(this.createAccessor(map));
+ },
+
+
+ onValidityChange: function(valid) {
+ var boundItems = this.getBoundItems();
+ if (boundItems) {
+ boundItems.each(function(cmp) {
+ if (cmp.disabled === valid) {
+ cmp.setDisabled(!valid);
+ }
+ });
}
- this.ef = ef;
},
- createAccessor : function(){
- var q = Ext.DomQuery;
- return function(key) {
- if (Ext.isFunction(key)) {
- return key;
- }
- switch(key) {
- case this.meta.totalProperty:
- return function(root, def){
- return q.selectNumber(key, root, def);
- };
- break;
- case this.meta.successProperty:
- return function(root, def) {
- var sv = q.selectValue(key, root, true);
- var success = sv !== false && sv !== 'false';
- return success;
- };
- break;
- default:
- return function(root, def) {
- return q.selectValue(key, root, def);
- };
- break;
- }
- };
- }(),
+ isDirty: function() {
+ return !!this.getFields().findBy(function(f) {
+ return f.isDirty();
+ });
+ },
- extractValues : function(data, items, len) {
- var f, values = {};
- for(var j = 0; j < len; j++){
- f = items[j];
- var v = this.ef[j](data);
- values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data);
+ checkDirty: function() {
+ var dirty = this.isDirty();
+ if (dirty !== this.wasDirty) {
+ this.fireEvent('dirtychange', this, dirty);
+ this.wasDirty = dirty;
}
- return values;
- }
-});
-Ext.data.XmlStore = Ext.extend(Ext.data.Store, {
-
- constructor: function(config){
- Ext.data.XmlStore.superclass.constructor.call(this, Ext.apply(config, {
- reader: new Ext.data.XmlReader(config)
- }));
- }
-});
-Ext.reg('xmlstore', Ext.data.XmlStore);
-Ext.data.GroupingStore = Ext.extend(Ext.data.Store, {
+ },
- constructor: function(config) {
- config = config || {};
+ hasUpload: function() {
+ return !!this.getFields().findBy(function(f) {
+ return f.isFileUpload();
+ });
+ },
-
-
-
-
- this.hasMultiSort = true;
- this.multiSortInfo = this.multiSortInfo || {sorters: []};
+
+ doAction: function(action, options) {
+ if (Ext.isString(action)) {
+ action = Ext.ClassManager.instantiateByAlias('formaction.' + action, Ext.apply({}, options, {form: this}));
+ }
+ if (this.fireEvent('beforeaction', this, action) !== false) {
+ this.beforeAction(action);
+ Ext.defer(action.run, 100, action);
+ }
+ return this;
+ },
- var sorters = this.multiSortInfo.sorters,
- groupField = config.groupField || this.groupField,
- sortInfo = config.sortInfo || this.sortInfo,
- groupDir = config.groupDir || this.groupDir;
+
+ submit: function(options) {
+ return this.doAction(this.standardSubmit ? 'standardsubmit' : this.api ? 'directsubmit' : 'submit', options);
+ },
-
- if(groupField){
- sorters.push({
- field : groupField,
- direction: groupDir
- });
- }
+
+ load: function(options) {
+ return this.doAction(this.api ? 'directload' : 'load', options);
+ },
-
- if (sortInfo) {
- sorters.push(sortInfo);
- }
+
+ updateRecord: function(record) {
+ var fields = record.fields,
+ values = this.getFieldValues(),
+ name,
+ obj = {};
- Ext.data.GroupingStore.superclass.constructor.call(this, config);
+ fields.each(function(f) {
+ name = f.name;
+ if (name in values) {
+ obj[name] = values[name];
+ }
+ });
- this.addEvents(
-
- 'groupchange'
- );
+ record.beginEdit();
+ record.set(obj);
+ record.endEdit();
- this.applyGroupField();
+ return this;
},
+ loadRecord: function(record) {
+ this._record = record;
+ return this.setValues(record.data);
+ },
- remoteGroup : false,
-
- groupOnSort:false,
-
- groupDir : 'ASC',
+ getRecord: function() {
+ return this._record;
+ },
- clearGrouping : function(){
- this.groupField = false;
+ beforeAction: function(action) {
+ var waitMsg = action.waitMsg,
+ maskCls = Ext.baseCSSPrefix + 'mask-loading',
+ waitMsgTarget;
- if(this.remoteGroup){
- if(this.baseParams){
- delete this.baseParams.groupBy;
- delete this.baseParams.groupDir;
- }
- var lo = this.lastOptions;
- if(lo && lo.params){
- delete lo.params.groupBy;
- delete lo.params.groupDir;
+
+ this.getFields().each(function(f) {
+ if (f.isFormField && f.syncValue) {
+ f.syncValue();
}
+ });
- this.reload();
- }else{
- this.sort();
- this.fireEvent('datachanged', this);
+ if (waitMsg) {
+ waitMsgTarget = this.waitMsgTarget;
+ if (waitMsgTarget === true) {
+ this.owner.el.mask(waitMsg, maskCls);
+ } else if (waitMsgTarget) {
+ waitMsgTarget = this.waitMsgTarget = Ext.get(waitMsgTarget);
+ waitMsgTarget.mask(waitMsg, maskCls);
+ } else {
+ Ext.MessageBox.wait(waitMsg, action.waitTitle || this.waitTitle);
+ }
}
},
- groupBy : function(field, forceRegroup, direction) {
- direction = direction ? (String(direction).toUpperCase() == 'DESC' ? 'DESC' : 'ASC') : this.groupDir;
-
- if (this.groupField == field && this.groupDir == direction && !forceRegroup) {
- return;
+ afterAction: function(action, success) {
+ if (action.waitMsg) {
+ var MessageBox = Ext.MessageBox,
+ waitMsgTarget = this.waitMsgTarget;
+ if (waitMsgTarget === true) {
+ this.owner.el.unmask();
+ } else if (waitMsgTarget) {
+ waitMsgTarget.unmask();
+ } else {
+ MessageBox.updateProgress(1);
+ MessageBox.hide();
+ }
}
-
-
-
- var sorters = this.multiSortInfo.sorters;
- if (sorters.length > 0 && sorters[0].field == this.groupField) {
- sorters.shift();
+ if (success) {
+ if (action.reset) {
+ this.reset();
+ }
+ Ext.callback(action.success, action.scope || action, [this, action]);
+ this.fireEvent('actioncomplete', this, action);
+ } else {
+ Ext.callback(action.failure, action.scope || action, [this, action]);
+ this.fireEvent('actionfailed', this, action);
}
+ },
- this.groupField = field;
- this.groupDir = direction;
- this.applyGroupField();
- var fireGroupEvent = function() {
- this.fireEvent('groupchange', this, this.getGroupState());
- };
+
+ findField: function(id) {
+ return this.getFields().findBy(function(f) {
+ return f.id === id || f.getName() === id;
+ });
+ },
- if (this.groupOnSort) {
- this.sort(field, direction);
- fireGroupEvent.call(this);
- return;
+
+
+ markInvalid: function(errors) {
+ var me = this;
+
+ function mark(fieldId, msg) {
+ var field = me.findField(fieldId);
+ if (field) {
+ field.markInvalid(msg);
+ }
}
- if (this.remoteGroup) {
- this.on('load', fireGroupEvent, this, {single: true});
- this.reload();
- } else {
- this.sort(sorters);
- fireGroupEvent.call(this);
+ if (Ext.isArray(errors)) {
+ Ext.each(errors, function(err) {
+ mark(err.id, err.msg);
+ });
}
+ else if (errors instanceof Ext.data.Errors) {
+ errors.each(function(err) {
+ mark(err.field, err.message);
+ });
+ }
+ else {
+ Ext.iterate(errors, mark);
+ }
+ return this;
},
-
- sort : function(fieldName, dir) {
- if (this.remoteSort) {
- return Ext.data.GroupingStore.superclass.sort.call(this, fieldName, dir);
- }
+ setValues: function(values) {
+ var me = this;
- var sorters = [];
+ function setVal(fieldId, val) {
+ var field = me.findField(fieldId);
+ if (field) {
+ field.setValue(val);
+ if (me.trackResetOnLoad) {
+ field.resetOriginalValue();
+ }
+ }
+ }
-
- if (Ext.isArray(arguments[0])) {
- sorters = arguments[0];
- } else if (fieldName == undefined) {
+ if (Ext.isArray(values)) {
-
- sorters = this.sortInfo ? [this.sortInfo] : [];
+ Ext.each(values, function(val) {
+ setVal(val.id, val.value);
+ });
} else {
-
- var field = this.fields.get(fieldName);
- if (!field) return false;
+ Ext.iterate(values, setVal);
+ }
+ return this;
+ },
- var name = field.name,
- sortInfo = this.sortInfo || null,
- sortToggle = this.sortToggle ? this.sortToggle[name] : null;
+
+ getValues: function(asString, dirtyOnly, includeEmptyText, useDataValues) {
+ var values = {};
- if (!dir) {
- if (sortInfo && sortInfo.field == name) {
- dir = (this.sortToggle[name] || 'ASC').toggle('ASC', 'DESC');
- } else {
- dir = field.sortDir;
+ this.getFields().each(function(field) {
+ if (!dirtyOnly || field.isDirty()) {
+ var data = field[useDataValues ? 'getModelData' : 'getSubmitData'](includeEmptyText);
+ if (Ext.isObject(data)) {
+ Ext.iterate(data, function(name, val) {
+ if (includeEmptyText && val === '') {
+ val = field.emptyText || '';
+ }
+ if (name in values) {
+ var bucket = values[name],
+ isArray = Ext.isArray;
+ if (!isArray(bucket)) {
+ bucket = values[name] = [bucket];
+ }
+ if (isArray(val)) {
+ values[name] = bucket.concat(val);
+ } else {
+ bucket.push(val);
+ }
+ } else {
+ values[name] = val;
+ }
+ });
}
}
+ });
- this.sortToggle[name] = dir;
- this.sortInfo = {field: name, direction: dir};
-
- sorters = [this.sortInfo];
- }
-
-
- if (this.groupField) {
- sorters.unshift({direction: this.groupDir, field: this.groupField});
+ if (asString) {
+ values = Ext.Object.toQueryString(values);
}
-
- return this.multiSort.call(this, sorters, dir);
+ return values;
},
- applyGroupField: function(){
- if (this.remoteGroup) {
- if(!this.baseParams){
- this.baseParams = {};
- }
+ getFieldValues: function(dirtyOnly) {
+ return this.getValues(false, dirtyOnly, false, true);
+ },
- Ext.apply(this.baseParams, {
- groupBy : this.groupField,
- groupDir: this.groupDir
+
+ clearInvalid: function() {
+ var me = this;
+ me.batchLayouts(function() {
+ me.getFields().each(function(f) {
+ f.clearInvalid();
});
+ });
+ return me;
+ },
- var lo = this.lastOptions;
- if (lo && lo.params) {
- lo.params.groupDir = this.groupDir;
+
+ reset: function() {
+ var me = this;
+ me.batchLayouts(function() {
+ me.getFields().each(function(f) {
+ f.reset();
+ });
+ });
+ return me;
+ },
-
- delete lo.params.groupBy;
- }
- }
+
+ applyToFields: function(obj) {
+ this.getFields().each(function(f) {
+ Ext.apply(f, obj);
+ });
+ return this;
},
- applyGrouping : function(alwaysFireChange){
- if(this.groupField !== false){
- this.groupBy(this.groupField, true, this.groupDir);
- return true;
- }else{
- if(alwaysFireChange === true){
- this.fireEvent('datachanged', this);
- }
- return false;
- }
+ applyIfToFields: function(obj) {
+ this.getFields().each(function(f) {
+ Ext.applyIf(f, obj);
+ });
+ return this;
},
- getGroupState : function(){
- return this.groupOnSort && this.groupField !== false ?
- (this.sortInfo ? this.sortInfo.field : undefined) : this.groupField;
+ batchLayouts: function(fn) {
+ var me = this,
+ suspended = new Ext.util.HashMap();
+
+
+ me.getFields().each(function(field) {
+ var ownerCt = field.ownerCt;
+ if (!suspended.contains(ownerCt)) {
+ suspended.add(ownerCt);
+ ownerCt.oldSuspendLayout = ownerCt.suspendLayout;
+ ownerCt.suspendLayout = true;
+ }
+ });
+
+
+ fn();
+
+
+ suspended.each(function(id, ct) {
+ ct.suspendLayout = ct.oldSuspendLayout;
+ delete ct.oldSuspendLayout;
+ });
+
+
+ me.owner.doComponentLayout();
}
});
-Ext.reg('groupingstore', Ext.data.GroupingStore);
-Ext.data.DirectProxy = function(config){
- Ext.apply(this, config);
- if(typeof this.paramOrder == 'string'){
- this.paramOrder = this.paramOrder.split(/[\s,|]/);
- }
- Ext.data.DirectProxy.superclass.constructor.call(this, config);
-};
-Ext.extend(Ext.data.DirectProxy, Ext.data.DataProxy, {
-
- paramOrder: undefined,
+Ext.define('Ext.form.FieldAncestor', {
- paramsAsHash: true,
+
- directFn : undefined,
+ initFieldAncestor: function() {
+ var me = this,
+ onSubtreeChange = me.onFieldAncestorSubtreeChange;
+
+ me.addEvents(
+
+ 'fieldvaliditychange',
+
+
+ 'fielderrorchange'
+ );
+
+
+ me.on('add', onSubtreeChange, me);
+ me.on('remove', onSubtreeChange, me);
+
+ me.initFieldDefaults();
+ },
- doRequest : function(action, rs, params, reader, callback, scope, options) {
- var args = [],
- directFn = this.api[action] || this.directFn;
+ initFieldDefaults: function() {
+ if (!this.fieldDefaults) {
+ this.fieldDefaults = {};
+ }
+ },
- switch (action) {
- case Ext.data.Api.actions.create:
- args.push(params.jsonData);
- break;
- case Ext.data.Api.actions.read:
-
- if(directFn.directCfg.method.len > 0){
- if(this.paramOrder){
- for(var i = 0, len = this.paramOrder.length; i < len; i++){
- args.push(params[this.paramOrder[i]]);
- }
- }else if(this.paramsAsHash){
- args.push(params);
- }
+
+ onFieldAncestorSubtreeChange: function(parent, child) {
+ var me = this,
+ isAdding = !!child.ownerCt;
+
+ function handleCmp(cmp) {
+ var isLabelable = cmp.isFieldLabelable,
+ isField = cmp.isFormField;
+ if (isLabelable || isField) {
+ if (isLabelable) {
+ me['onLabelable' + (isAdding ? 'Added' : 'Removed')](cmp);
}
- break;
- case Ext.data.Api.actions.update:
- args.push(params.jsonData);
- break;
- case Ext.data.Api.actions.destroy:
- args.push(params.jsonData);
- break;
+ if (isField) {
+ me['onField' + (isAdding ? 'Added' : 'Removed')](cmp);
+ }
+ }
+ else if (cmp.isContainer) {
+ Ext.Array.forEach(cmp.getRefItems(), handleCmp);
+ }
}
+ handleCmp(child);
+ },
- var trans = {
- params : params || {},
- request: {
- callback : callback,
- scope : scope,
- arg : options
- },
- reader: reader
- };
+
+ onLabelableAdded: function(labelable) {
+ var me = this;
- args.push(this.createCallback(action, rs, trans), this);
- directFn.apply(window, args);
+
+ me.mon(labelable, 'errorchange', me.handleFieldErrorChange, me, {buffer: 10});
+
+ labelable.setFieldDefaults(me.fieldDefaults);
},
- createCallback : function(action, rs, trans) {
+ onFieldAdded: function(field) {
var me = this;
- return function(result, res) {
- if (!res.status) {
-
- if (action === Ext.data.Api.actions.read) {
- me.fireEvent("loadexception", me, trans, res, null);
+ me.mon(field, 'validitychange', me.handleFieldValidityChange, me);
+ },
+
+
+ onLabelableRemoved: function(labelable) {
+ var me = this;
+ me.mun(labelable, 'errorchange', me.handleFieldErrorChange, me);
+ },
+
+
+ onFieldRemoved: function(field) {
+ var me = this;
+ me.mun(field, 'validitychange', me.handleFieldValidityChange, me);
+ },
+
+
+ handleFieldValidityChange: function(field, isValid) {
+ var me = this;
+ me.fireEvent('fieldvaliditychange', me, field, isValid);
+ me.onFieldValidityChange();
+ },
+
+
+ handleFieldErrorChange: function(labelable, activeError) {
+ var me = this;
+ me.fireEvent('fielderrorchange', me, labelable, activeError);
+ me.onFieldErrorChange();
+ },
+
+
+ onFieldValidityChange: Ext.emptyFn,
+
+
+ onFieldErrorChange: Ext.emptyFn
+
+});
+
+Ext.define('Ext.layout.container.CheckboxGroup', {
+ extend: 'Ext.layout.container.Container',
+ alias: ['layout.checkboxgroup'],
+
+
+ onLayout: function() {
+ var numCols = this.getColCount(),
+ shadowCt = this.getShadowCt(),
+ owner = this.owner,
+ items = owner.items,
+ shadowItems = shadowCt.items,
+ numItems = items.length,
+ colIndex = 0,
+ i, numRows;
+
+
+
+
+
+
+ shadowItems.each(function(col) {
+ col.items.clear();
+ });
+
+
+
+ while (shadowItems.length > numCols) {
+ shadowCt.remove(shadowItems.last());
+ }
+ while (shadowItems.length < numCols) {
+ shadowCt.add({
+ xtype: 'container',
+ cls: owner.groupCls,
+ flex: 1
+ });
+ }
+
+ if (owner.vertical) {
+ numRows = Math.ceil(numItems / numCols);
+ for (i = 0; i < numItems; i++) {
+ if (i > 0 && i % numRows === 0) {
+ colIndex++;
}
- me.fireEvent('exception', me, 'remote', action, trans, res, null);
- trans.request.callback.call(trans.request.scope, null, trans.request.arg, false);
- return;
+ shadowItems.getAt(colIndex).items.add(items.getAt(i));
}
- if (action === Ext.data.Api.actions.read) {
- me.onRead(action, trans, result, res);
- } else {
- me.onWrite(action, trans, result, res, rs);
+ } else {
+ for (i = 0; i < numItems; i++) {
+ colIndex = i % numCols;
+ shadowItems.getAt(colIndex).items.add(items.getAt(i));
}
- };
+ }
+
+ if (!shadowCt.rendered) {
+ shadowCt.render(this.getRenderTarget());
+ } else {
+
+
+ shadowItems.each(function(col) {
+ var layout = col.getLayout();
+ layout.renderItems(layout.getLayoutItems(), layout.getRenderTarget());
+ });
+ }
+
+ shadowCt.doComponentLayout();
},
+
- onRead : function(action, trans, result, res) {
- var records;
- try {
- records = trans.reader.readRecords(result);
- }
- catch (ex) {
-
- this.fireEvent("loadexception", this, trans, res, ex);
+ renderItems: Ext.emptyFn,
- this.fireEvent('exception', this, 'response', action, trans, res, ex);
- trans.request.callback.call(trans.request.scope, null, trans.request.arg, false);
- return;
+
+
+ getShadowCt: function() {
+ var me = this,
+ shadowCt = me.shadowCt,
+ owner, items, item, columns, columnsIsArray, numCols, i;
+
+ if (!shadowCt) {
+
+ owner = me.owner;
+ columns = owner.columns;
+ columnsIsArray = Ext.isArray(columns);
+ numCols = me.getColCount();
+ items = [];
+ for(i = 0; i < numCols; i++) {
+ item = {
+ xtype: 'container',
+ cls: owner.groupCls
+ };
+ if (columnsIsArray) {
+
+
+ if (columns[i] < 1) {
+ item.flex = columns[i];
+ } else {
+ item.width = columns[i];
+ }
+ }
+ else {
+
+ item.flex = 1;
+ }
+ items.push(item);
+ }
+
+
+ shadowCt = me.shadowCt = Ext.createWidget('container', {
+ layout: 'hbox',
+ items: items,
+ ownerCt: owner
+ });
}
- this.fireEvent("load", this, res, trans.request.arg);
- trans.request.callback.call(trans.request.scope, records, trans.request.arg, true);
+
+ return shadowCt;
},
+
+
- onWrite : function(action, trans, result, res, rs) {
- var data = trans.reader.extractData(trans.reader.getRoot(result), false);
- var success = trans.reader.getSuccess(result);
- success = (success !== false);
- if (success){
- this.fireEvent("write", this, action, data, res, rs, trans.request.arg);
- }else{
- this.fireEvent('exception', this, 'remote', action, trans, result, rs);
- }
- trans.request.callback.call(trans.request.scope, data, res, success);
+ getColCount: function() {
+ var owner = this.owner,
+ colsCfg = owner.columns;
+ return Ext.isArray(colsCfg) ? colsCfg.length : (Ext.isNumber(colsCfg) ? colsCfg : owner.items.length);
}
-});
-Ext.data.DirectStore = Ext.extend(Ext.data.Store, {
- constructor : function(config){
-
- var c = Ext.apply({}, {
- batchTransactions: false
- }, config);
- Ext.data.DirectStore.superclass.constructor.call(this, Ext.apply(c, {
- proxy: Ext.isDefined(c.proxy) ? c.proxy : new Ext.data.DirectProxy(Ext.copyTo({}, c, 'paramOrder,paramsAsHash,directFn,api')),
- reader: (!Ext.isDefined(c.reader) && c.fields) ? new Ext.data.JsonReader(Ext.copyTo({}, c, 'totalProperty,root,idProperty'), c.fields) : c.reader
- }));
- }
});
-Ext.reg('directstore', Ext.data.DirectStore);
-Ext.Direct = Ext.extend(Ext.util.Observable, {
-
-
- exceptions: {
- TRANSPORT: 'xhr',
- PARSE: 'parse',
- LOGIN: 'login',
- SERVER: 'exception'
+Ext.define('Ext.form.FieldContainer', {
+ extend: 'Ext.container.Container',
+ mixins: {
+ labelable: 'Ext.form.Labelable',
+ fieldAncestor: 'Ext.form.FieldAncestor'
},
+ alias: 'widget.fieldcontainer',
-
- constructor: function(){
- this.addEvents(
-
- 'event',
-
- 'exception'
- );
- this.transactions = {};
- this.providers = {};
- },
+ componentLayout: 'field',
- addProvider : function(provider){
- var a = arguments;
- if(a.length > 1){
- for(var i = 0, len = a.length; i < len; i++){
- this.addProvider(a[i]);
- }
- return;
- }
+ combineLabels: false,
-
- if(!provider.events){
- provider = new Ext.Direct.PROVIDERS[provider.type](provider);
- }
- provider.id = provider.id || Ext.id();
- this.providers[provider.id] = provider;
+
+ labelConnector: ', ',
- provider.on('data', this.onProviderData, this);
- provider.on('exception', this.onProviderException, this);
+
+ combineErrors: false,
+
+ maskOnDisable: false,
+ initComponent: function() {
+ var me = this,
+ onSubCmpAddOrRemove = me.onSubCmpAddOrRemove;
- if(!provider.isConnected()){
- provider.connect();
- }
+
+ me.initLabelable();
+ me.initFieldAncestor();
- return provider;
+ me.callParent();
},
- getProvider : function(id){
- return this.providers[id];
+ onLabelableAdded: function(labelable) {
+ var me = this;
+ me.mixins.fieldAncestor.onLabelableAdded.call(this, labelable);
+ me.updateLabel();
},
- removeProvider : function(id){
- var provider = id.id ? id : this.providers[id];
- provider.un('data', this.onProviderData, this);
- provider.un('exception', this.onProviderException, this);
- delete this.providers[provider.id];
- return provider;
+
+ onLabelableRemoved: function(labelable) {
+ var me = this;
+ me.mixins.fieldAncestor.onLabelableRemoved.call(this, labelable);
+ me.updateLabel();
},
- addTransaction: function(t){
- this.transactions[t.tid] = t;
- return t;
+ onRender: function() {
+ var me = this,
+ renderSelectors = me.renderSelectors,
+ applyIf = Ext.applyIf;
+
+ applyIf(renderSelectors, me.getLabelableSelectors());
+
+ me.callParent(arguments);
},
- removeTransaction: function(t){
- delete this.transactions[t.tid || t];
- return t;
+ initRenderTpl: function() {
+ var me = this;
+ if (!me.hasOwnProperty('renderTpl')) {
+ me.renderTpl = me.getTpl('labelableRenderTpl');
+ }
+ return me.callParent();
},
- getTransaction: function(tid){
- return this.transactions[tid.tid || tid];
+ initRenderData: function() {
+ return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
},
- onProviderData : function(provider, e){
- if(Ext.isArray(e)){
- for(var i = 0, len = e.length; i < len; i++){
- this.onProviderData(provider, e[i]);
- }
- return;
+
+ getFieldLabel: function() {
+ var label = this.fieldLabel || '';
+ if (!label && this.combineLabels) {
+ label = Ext.Array.map(this.query('[isFieldLabelable]'), function(field) {
+ return field.getFieldLabel();
+ }).join(this.labelConnector);
}
- if(e.name && e.name != 'event' && e.name != 'exception'){
- this.fireEvent(e.name, e);
- }else if(e.type == 'exception'){
- this.fireEvent('exception', e);
+ return label;
+ },
+
+
+ updateLabel: function() {
+ var me = this,
+ label = me.labelEl;
+ if (label) {
+ label.update(me.getFieldLabel());
}
- this.fireEvent('event', e, provider);
},
- createEvent : function(response, extraProps){
- return new Ext.Direct.eventTypes[response.type](Ext.apply(response, extraProps));
- }
-});
-Ext.Direct = new Ext.Direct();
+
+ onFieldErrorChange: function(field, activeError) {
+ if (this.combineErrors) {
+ var me = this,
+ oldError = me.getActiveError(),
+ invalidFields = Ext.Array.filter(me.query('[isFormField]'), function(field) {
+ return field.hasActiveError();
+ }),
+ newErrors = me.getCombinedErrors(invalidFields);
-Ext.Direct.TID = 1;
-Ext.Direct.PROVIDERS = {};
-Ext.Direct.Transaction = function(config){
- Ext.apply(this, config);
- this.tid = ++Ext.Direct.TID;
- this.retryCount = 0;
-};
-Ext.Direct.Transaction.prototype = {
- send: function(){
- this.provider.queueTransaction(this);
- },
+ if (newErrors) {
+ me.setActiveErrors(newErrors);
+ } else {
+ me.unsetActiveError();
+ }
- retry: function(){
- this.retryCount++;
- this.send();
+ if (oldError !== me.getActiveError()) {
+ me.doComponentLayout();
+ }
+ }
},
- getProvider: function(){
- return this.provider;
- }
-};Ext.Direct.Event = function(config){
- Ext.apply(this, config);
-};
-
-Ext.Direct.Event.prototype = {
- status: true,
- getData: function(){
- return this.data;
- }
-};
+
+ getCombinedErrors: function(invalidFields) {
+ var forEach = Ext.Array.forEach,
+ errors = [];
+ forEach(invalidFields, function(field) {
+ forEach(field.getActiveErrors(), function(error) {
+ var label = field.getFieldLabel();
+ errors.push((label ? label + ': ' : '') + error);
+ });
+ });
+ return errors;
+ },
-Ext.Direct.RemotingEvent = Ext.extend(Ext.Direct.Event, {
- type: 'rpc',
- getTransaction: function(){
- return this.transaction || Ext.Direct.getTransaction(this.tid);
+ getTargetEl: function() {
+ return this.bodyEl || this.callParent();
}
});
-Ext.Direct.ExceptionEvent = Ext.extend(Ext.Direct.RemotingEvent, {
- status: false,
- type: 'exception'
-});
-Ext.Direct.eventTypes = {
- 'rpc': Ext.Direct.RemotingEvent,
- 'event': Ext.Direct.Event,
- 'exception': Ext.Direct.ExceptionEvent
-};
+Ext.define('Ext.form.CheckboxGroup', {
+ extend:'Ext.form.FieldContainer',
+ mixins: {
+ field: 'Ext.form.field.Field'
+ },
+ alias: 'widget.checkboxgroup',
+ requires: ['Ext.layout.container.CheckboxGroup', 'Ext.form.field.Base'],
-Ext.direct.Provider = Ext.extend(Ext.util.Observable, {
-
-
- priority: 1,
-
-
- constructor : function(config){
- Ext.apply(this, config);
- this.addEvents(
-
- 'connect',
-
- 'disconnect',
-
- 'data',
-
- 'exception'
- );
- Ext.direct.Provider.superclass.constructor.call(this, config);
- },
- isConnected: function(){
- return false;
- },
+ columns : 'auto',
- connect: Ext.emptyFn,
-
-
- disconnect: Ext.emptyFn
-});
-
-Ext.direct.JsonProvider = Ext.extend(Ext.direct.Provider, {
- parseResponse: function(xhr){
- if(!Ext.isEmpty(xhr.responseText)){
- if(typeof xhr.responseText == 'object'){
- return xhr.responseText;
- }
- return Ext.decode(xhr.responseText);
- }
- return null;
- },
+ vertical : false,
- getEvents: function(xhr){
- var data = null;
- try{
- data = this.parseResponse(xhr);
- }catch(e){
- var event = new Ext.Direct.ExceptionEvent({
- data: e,
- xhr: xhr,
- code: Ext.Direct.exceptions.PARSE,
- message: 'Error parsing json response: \n\n ' + data
- });
- return [event];
- }
- var events = [];
- if(Ext.isArray(data)){
- for(var i = 0, len = data.length; i < len; i++){
- events.push(Ext.Direct.createEvent(data[i]));
- }
- }else{
- events.push(Ext.Direct.createEvent(data));
- }
- return events;
- }
-});
-Ext.direct.PollingProvider = Ext.extend(Ext.direct.JsonProvider, {
-
-
- priority: 3,
-
- interval: 3000,
+ allowBlank : true,
+ blankText : "You must select at least one item in this group",
+
+ defaultType : 'checkboxfield',
+
+ groupCls : Ext.baseCSSPrefix + 'form-check-group',
- constructor : function(config){
- Ext.direct.PollingProvider.superclass.constructor.call(this, config);
- this.addEvents(
-
- 'beforepoll',
-
- 'poll'
- );
- },
+ fieldBodyCls: Ext.baseCSSPrefix + 'form-checkboxgroup-body',
- isConnected: function(){
- return !!this.pollTask;
+ layout: 'checkboxgroup',
+
+ initComponent: function() {
+ var me = this;
+ me.callParent();
+ me.initField();
},
- connect: function(){
- if(this.url && !this.pollTask){
- this.pollTask = Ext.TaskMgr.start({
- run: function(){
- if(this.fireEvent('beforepoll', this) !== false){
- if(typeof this.url == 'function'){
- this.url(this.baseParams);
- }else{
- Ext.Ajax.request({
- url: this.url,
- callback: this.onData,
- scope: this,
- params: this.baseParams
- });
- }
- }
- },
- interval: this.interval,
- scope: this
- });
- this.fireEvent('connect', this);
- }else if(!this.url){
- throw 'Error initializing PollingProvider, no url configured.';
+ initValue: function() {
+ var me = this,
+ valueCfg = me.value;
+ me.originalValue = me.lastValue = valueCfg || me.getValue();
+ if (valueCfg) {
+ me.setValue(valueCfg);
}
},
- disconnect: function(){
- if(this.pollTask){
- Ext.TaskMgr.stop(this.pollTask);
- delete this.pollTask;
- this.fireEvent('disconnect', this);
+ onFieldAdded: function(field) {
+ var me = this;
+ if (field.isCheckbox) {
+ me.mon(field, 'change', me.checkChange, me);
}
+ me.callParent(arguments);
},
-
- onData: function(opt, success, xhr){
- if(success){
- var events = this.getEvents(xhr);
- for(var i = 0, len = events.length; i < len; i++){
- var e = events[i];
- this.fireEvent('data', this, e);
- }
- }else{
- var e = new Ext.Direct.ExceptionEvent({
- data: e,
- code: Ext.Direct.exceptions.TRANSPORT,
- message: 'Unable to connect to the server.',
- xhr: xhr
- });
- this.fireEvent('data', this, e);
+ onFieldRemoved: function(field) {
+ var me = this;
+ if (field.isCheckbox) {
+ me.mun(field, 'change', me.checkChange, me);
}
- }
-});
+ me.callParent(arguments);
+ },
-Ext.Direct.PROVIDERS['polling'] = Ext.direct.PollingProvider;
-Ext.direct.RemotingProvider = Ext.extend(Ext.direct.JsonProvider, {
-
-
-
-
-
-
-
-
-
- enableBuffer: 10,
-
-
- maxRetries: 1,
-
- timeout: undefined,
-
- constructor : function(config){
- Ext.direct.RemotingProvider.superclass.constructor.call(this, config);
- this.addEvents(
-
- 'beforecall',
-
- 'call'
- );
- this.namespace = (Ext.isString(this.namespace)) ? Ext.ns(this.namespace) : this.namespace || window;
- this.transactions = {};
- this.callBuffer = [];
+ isEqual: function(value1, value2) {
+ var toQueryString = Ext.Object.toQueryString;
+ return toQueryString(value1) === toQueryString(value2);
},
- initAPI : function(){
- var o = this.actions;
- for(var c in o){
- var cls = this.namespace[c] || (this.namespace[c] = {}),
- ms = o[c];
- for(var i = 0, len = ms.length; i < len; i++){
- var m = ms[i];
- cls[m.name] = this.createMethod(c, m);
- }
+ getErrors: function() {
+ var errors = [];
+ if (!this.allowBlank && Ext.isEmpty(this.getChecked())) {
+ errors.push(this.blankText);
}
+ return errors;
},
- isConnected: function(){
- return !!this.connected;
- },
-
- connect: function(){
- if(this.url){
- this.initAPI();
- this.connected = true;
- this.fireEvent('connect', this);
- }else if(!this.url){
- throw 'Error initializing RemotingProvider, no url configured.';
- }
+ getBoxes: function() {
+ return this.query('[isCheckbox]');
},
- disconnect: function(){
- if(this.connected){
- this.connected = false;
- this.fireEvent('disconnect', this);
- }
+
+ eachBox: function(fn, scope) {
+ Ext.Array.forEach(this.getBoxes(), fn, scope || this);
},
- onData: function(opt, success, xhr){
- if(success){
- var events = this.getEvents(xhr);
- for(var i = 0, len = events.length; i < len; i++){
- var e = events[i],
- t = this.getTransaction(e);
- this.fireEvent('data', this, e);
- if(t){
- this.doCallback(t, e, true);
- Ext.Direct.removeTransaction(t);
- }
- }
- }else{
- var ts = [].concat(opt.ts);
- for(var i = 0, len = ts.length; i < len; i++){
- var t = this.getTransaction(ts[i]);
- if(t && t.retryCount < this.maxRetries){
- t.retry();
- }else{
- var e = new Ext.Direct.ExceptionEvent({
- data: e,
- transaction: t,
- code: Ext.Direct.exceptions.TRANSPORT,
- message: 'Unable to connect to the server.',
- xhr: xhr
- });
- this.fireEvent('data', this, e);
- if(t){
- this.doCallback(t, e, false);
- Ext.Direct.removeTransaction(t);
- }
- }
- }
- }
+
+ getChecked: function() {
+ return Ext.Array.filter(this.getBoxes(), function(cb) {
+ return cb.getValue();
+ });
},
- getCallData: function(t){
- return {
- action: t.action,
- method: t.method,
- data: t.data,
- type: 'rpc',
- tid: t.tid
- };
+
+ isDirty: function(){
+ return Ext.Array.some(this.getBoxes(), function(cb) {
+ return cb.isDirty();
+ });
},
- doSend : function(data){
- var o = {
- url: this.url,
- callback: this.onData,
- scope: this,
- ts: data,
- timeout: this.timeout
- }, callData;
-
- if(Ext.isArray(data)){
- callData = [];
- for(var i = 0, len = data.length; i < len; i++){
- callData.push(this.getCallData(data[i]));
- }
- }else{
- callData = this.getCallData(data);
- }
-
- if(this.enableUrlEncode){
- var params = {};
- params[Ext.isString(this.enableUrlEncode) ? this.enableUrlEncode : 'data'] = Ext.encode(callData);
- o.params = params;
- }else{
- o.jsonData = callData;
- }
- Ext.Ajax.request(o);
+
+ setReadOnly: function(readOnly) {
+ this.eachBox(function(cb) {
+ cb.setReadOnly(readOnly);
+ });
+ this.readOnly = readOnly;
},
- combineAndSend : function(){
- var len = this.callBuffer.length;
- if(len > 0){
- this.doSend(len == 1 ? this.callBuffer[0] : this.callBuffer);
- this.callBuffer = [];
+
+ reset: function() {
+ var me = this,
+ hadError = me.hasActiveError(),
+ preventMark = me.preventMark;
+ me.preventMark = true;
+ me.batchChanges(function() {
+ me.eachBox(function(cb) {
+ cb.reset();
+ });
+ });
+ me.preventMark = preventMark;
+ me.unsetActiveError();
+ if (hadError) {
+ me.doComponentLayout();
}
},
- queueTransaction: function(t){
- if(t.form){
- this.processForm(t);
- return;
- }
- this.callBuffer.push(t);
- if(this.enableBuffer){
- if(!this.callTask){
- this.callTask = new Ext.util.DelayedTask(this.combineAndSend, this);
- }
- this.callTask.delay(Ext.isNumber(this.enableBuffer) ? this.enableBuffer : 10);
- }else{
- this.combineAndSend();
- }
+
+ resetOriginalValue: function() {
+
+
+ Ext.defer(function() {
+ this.callParent();
+ }, 1, this);
},
- doCall : function(c, m, args){
- var data = null, hs = args[m.len], scope = args[m.len+1];
- if(m.len !== 0){
- data = args.slice(0, m.len);
- }
-
- var t = new Ext.Direct.Transaction({
- provider: this,
- args: args,
- action: c,
- method: m.name,
- data: data,
- cb: scope && Ext.isFunction(hs) ? hs.createDelegate(scope) : hs
+
+ setValue: function(value) {
+ var me = this;
+ me.batchChanges(function() {
+ me.eachBox(function(cb) {
+ var name = cb.getName(),
+ cbValue = false;
+ if (value && name in value) {
+ if (Ext.isArray(value[name])) {
+ cbValue = Ext.Array.contains(value[name], cb.inputValue);
+ } else {
+
+ cbValue = value[name];
+ }
+ }
+ cb.setValue(cbValue);
+ });
});
-
- if(this.fireEvent('beforecall', this, t, m) !== false){
- Ext.Direct.addTransaction(t);
- this.queueTransaction(t);
- this.fireEvent('call', this, t, m);
- }
+ return me;
},
- doForm : function(c, m, form, callback, scope){
- var t = new Ext.Direct.Transaction({
- provider: this,
- action: c,
- method: m.name,
- args:[form, callback, scope],
- cb: scope && Ext.isFunction(callback) ? callback.createDelegate(scope) : callback,
- isForm: true
- });
- if(this.fireEvent('beforecall', this, t, m) !== false){
- Ext.Direct.addTransaction(t);
- var isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data',
- params = {
- extTID: t.tid,
- extAction: c,
- extMethod: m.name,
- extType: 'rpc',
- extUpload: String(isUpload)
- };
-
-
-
- Ext.apply(t, {
- form: Ext.getDom(form),
- isUpload: isUpload,
- params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
- });
- this.fireEvent('call', this, t, m);
- this.processForm(t);
- }
- },
- processForm: function(t){
- Ext.Ajax.request({
- url: this.url,
- params: t.params,
- callback: this.onData,
- scope: this,
- form: t.form,
- isUpload: t.isUpload,
- ts: t
+ getValue: function() {
+ var values = {};
+ this.eachBox(function(cb) {
+ var name = cb.getName(),
+ inputValue = cb.inputValue,
+ bucket;
+ if (cb.getValue()) {
+ if (name in values) {
+ bucket = values[name];
+ if (!Ext.isArray(bucket)) {
+ bucket = values[name] = [bucket];
+ }
+ bucket.push(inputValue);
+ } else {
+ values[name] = inputValue;
+ }
+ }
});
+ return values;
},
- createMethod : function(c, m){
- var f;
- if(!m.formHandler){
- f = function(){
- this.doCall(c, m, Array.prototype.slice.call(arguments, 0));
- }.createDelegate(this);
- }else{
- f = function(form, callback, scope){
- this.doForm(c, m, form, callback, scope);
- }.createDelegate(this);
- }
- f.directCfg = {
- action: c,
- method: m
- };
- return f;
+
+ getSubmitData: function() {
+ return null;
},
- getTransaction: function(opt){
- return opt && opt.tid ? Ext.Direct.getTransaction(opt.tid) : null;
+
+ getModelData: function() {
+ return null;
},
- doCallback: function(t, e){
- var fn = e.status ? 'success' : 'failure';
- if(t && t.cb){
- var hs = t.cb,
- result = Ext.isDefined(e.result) ? e.result : e.data;
- if(Ext.isFunction(hs)){
- hs(result, e);
- } else{
- Ext.callback(hs[fn], hs.scope, [result, e]);
- Ext.callback(hs.callback, hs.scope, [result, e]);
- }
+ validate: function() {
+ var me = this,
+ errors = me.getErrors(),
+ isValid = Ext.isEmpty(errors),
+ wasValid = !me.hasActiveError();
+
+ if (isValid) {
+ me.unsetActiveError();
+ } else {
+ me.setActiveError(errors);
}
+ if (isValid !== wasValid) {
+ me.fireEvent('validitychange', me, isValid);
+ me.doComponentLayout();
+ }
+
+ return isValid;
}
-});
-Ext.Direct.PROVIDERS['remoting'] = Ext.direct.RemotingProvider;
-Ext.Resizable = Ext.extend(Ext.util.Observable, {
- constructor: function(el, config){
- this.el = Ext.get(el);
- if(config && config.wrap){
- config.resizeChild = this.el;
- this.el = this.el.wrap(typeof config.wrap == 'object' ? config.wrap : {cls:'xresizable-wrap'});
- this.el.id = this.el.dom.id = config.resizeChild.id + '-rzwrap';
- this.el.setStyle('overflow', 'hidden');
- this.el.setPositioning(config.resizeChild.getPositioning());
- config.resizeChild.clearPositioning();
- if(!config.width || !config.height){
- var csize = config.resizeChild.getSize();
- this.el.setSize(csize.width, csize.height);
- }
- if(config.pinned && !config.adjustments){
- config.adjustments = 'auto';
- }
- }
+}, function() {
-
- this.proxy = this.el.createProxy({tag: 'div', cls: 'x-resizable-proxy', id: this.el.id + '-rzproxy'}, Ext.getBody());
- this.proxy.unselectable();
- this.proxy.enableDisplayMode('block');
+ this.borrow(Ext.form.field.Base, ['markInvalid', 'clearInvalid']);
- Ext.apply(this, config);
+});
- if(this.pinned){
- this.disableTrackOver = true;
- this.el.addClass('x-resizable-pinned');
- }
-
- var position = this.el.getStyle('position');
- if(position != 'absolute' && position != 'fixed'){
- this.el.setStyle('position', 'relative');
- }
- if(!this.handles){
- this.handles = 's,e,se';
- if(this.multiDirectional){
- this.handles += ',n,w';
- }
- }
- if(this.handles == 'all'){
- this.handles = 'n s e w ne nw se sw';
- }
- var hs = this.handles.split(/\s*?[,;]\s*?| /);
- var ps = Ext.Resizable.positions;
- for(var i = 0, len = hs.length; i < len; i++){
- if(hs[i] && ps[hs[i]]){
- var pos = ps[hs[i]];
- this[pos] = new Ext.Resizable.Handle(this, pos, this.disableTrackOver, this.transparent, this.handleCls);
- }
- }
-
- this.corner = this.southeast;
- if(this.handles.indexOf('n') != -1 || this.handles.indexOf('w') != -1){
- this.updateBox = true;
- }
- this.activeHandle = null;
+Ext.define('Ext.form.CheckboxManager', {
+ extend: 'Ext.util.MixedCollection',
+ singleton: true,
- if(this.resizeChild){
- if(typeof this.resizeChild == 'boolean'){
- this.resizeChild = Ext.get(this.el.dom.firstChild, true);
- }else{
- this.resizeChild = Ext.get(this.resizeChild, true);
- }
- }
+ getByName: function(name) {
+ return this.filterBy(function(item) {
+ return item.name == name;
+ });
+ },
- if(this.adjustments == 'auto'){
- var rc = this.resizeChild;
- var hw = this.west, he = this.east, hn = this.north, hs = this.south;
- if(rc && (hw || hn)){
- rc.position('relative');
- rc.setLeft(hw ? hw.el.getWidth() : 0);
- rc.setTop(hn ? hn.el.getHeight() : 0);
- }
- this.adjustments = [
- (he ? -he.el.getWidth() : 0) + (hw ? -hw.el.getWidth() : 0),
- (hn ? -hn.el.getHeight() : 0) + (hs ? -hs.el.getHeight() : 0) -1
- ];
- }
+ getWithValue: function(name, value) {
+ return this.filterBy(function(item) {
+ return item.name == name && item.inputValue == value;
+ });
+ },
- if(this.draggable){
- this.dd = this.dynamic ?
- this.el.initDD(null) : this.el.initDDProxy(null, {dragElId: this.proxy.id});
- this.dd.setHandleElId(this.resizeChild ? this.resizeChild.id : this.el.id);
- if(this.constrainTo){
- this.dd.constrainTo(this.constrainTo);
- }
- }
+ getChecked: function(name) {
+ return this.filterBy(function(item) {
+ return item.name == name && item.checked;
+ });
+ }
+});
- this.addEvents(
-
- 'beforeresize',
-
- 'resize'
- );
- if(this.width !== null && this.height !== null){
- this.resizeTo(this.width, this.height);
- }else{
- this.updateChildSize();
- }
- if(Ext.isIE){
- this.el.dom.style.zoom = 1;
- }
- Ext.Resizable.superclass.constructor.call(this);
- },
+Ext.define('Ext.form.FieldSet', {
+ extend: 'Ext.container.Container',
+ alias: 'widget.fieldset',
+ uses: ['Ext.form.field.Checkbox', 'Ext.panel.Tool', 'Ext.layout.container.Anchor', 'Ext.layout.component.FieldSet'],
- adjustments : [0, 0],
-
- animate : false,
-
-
- disableTrackOver : false,
-
- draggable: false,
-
- duration : 0.35,
-
- dynamic : false,
-
- easing : 'easeOutStrong',
-
- enabled : true,
-
-
- handles : false,
-
- multiDirectional : false,
-
- height : null,
-
- width : null,
-
- heightIncrement : 0,
-
- widthIncrement : 0,
-
- minHeight : 5,
-
- minWidth : 5,
-
- maxHeight : 10000,
-
- maxWidth : 10000,
-
- minX: 0,
-
- minY: 0,
+
- pinned : false,
+
- preserveRatio : false,
+
- resizeChild : false,
+
- transparent: false,
+ collapsed: false,
+
+
+ baseCls: Ext.baseCSSPrefix + 'fieldset',
+
+ layout: 'anchor',
+ componentLayout: 'fieldset',
- resizeTo : function(width, height){
- this.el.setSize(width, height);
- this.updateChildSize();
- this.fireEvent('resize', this, width, height, null);
- },
+ ariaRole: '',
+ renderTpl: [''],
- startSizing : function(e, handle){
- this.fireEvent('beforeresize', this, e);
- if(this.enabled){
+ maskOnDisable: false,
- if(!this.overlay){
- this.overlay = this.el.createProxy({tag: 'div', cls: 'x-resizable-overlay', html: ' '}, Ext.getBody());
- this.overlay.unselectable();
- this.overlay.enableDisplayMode('block');
- this.overlay.on({
- scope: this,
- mousemove: this.onMouseMove,
- mouseup: this.onMouseUp
- });
- }
- this.overlay.setStyle('cursor', handle.el.getStyle('cursor'));
+ getElConfig: function(){
+ return {tag: 'fieldset', id: this.id};
+ },
- this.resizing = true;
- this.startBox = this.el.getBox();
- this.startPoint = e.getXY();
- this.offsets = [(this.startBox.x + this.startBox.width) - this.startPoint[0],
- (this.startBox.y + this.startBox.height) - this.startPoint[1]];
+ initComponent: function() {
+ var me = this,
+ baseCls = me.baseCls;
- this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
- this.overlay.show();
+ me.callParent();
- if(this.constrainTo) {
- var ct = Ext.get(this.constrainTo);
- this.resizeRegion = ct.getRegion().adjust(
- ct.getFrameWidth('t'),
- ct.getFrameWidth('l'),
- -ct.getFrameWidth('b'),
- -ct.getFrameWidth('r')
- );
- }
+
+ me.initLegend();
- this.proxy.setStyle('visibility', 'hidden');
- this.proxy.show();
- this.proxy.setBox(this.startBox);
- if(!this.dynamic){
- this.proxy.setStyle('visibility', 'visible');
- }
- }
- },
+
+ Ext.applyIf(me.renderSelectors, {
+ body: '.' + baseCls + '-body'
+ });
-
- onMouseDown : function(handle, e){
- if(this.enabled){
- e.stopEvent();
- this.activeHandle = handle;
- this.startSizing(e, handle);
+ if (me.collapsed) {
+ me.addCls(baseCls + '-collapsed');
+ me.collapse();
}
},
- onMouseUp : function(e){
- this.activeHandle = null;
- var size = this.resizeElement();
- this.resizing = false;
- this.handleOut();
- this.overlay.hide();
- this.proxy.hide();
- this.fireEvent('resize', this, size.width, size.height, e);
+ onRender: function(container, position) {
+ this.callParent(arguments);
+
+ this.initLegend();
},
- updateChildSize : function(){
- if(this.resizeChild){
- var el = this.el;
- var child = this.resizeChild;
- var adj = this.adjustments;
- if(el.dom.offsetWidth){
- var b = el.getSize(true);
- child.setSize(b.width+adj[0], b.height+adj[1]);
- }
-
-
+ initLegend: function() {
+ var me = this,
+ legendItems,
+ legend = me.legend;
+
+
+ if (!legend && (me.title || me.checkboxToggle || me.collapsible)) {
+ legendItems = [];
+
+ if (me.checkboxToggle) {
+ legendItems.push(me.createCheckboxCmp());
+ }
- if(Ext.isIE){
- setTimeout(function(){
- if(el.dom.offsetWidth){
- var b = el.getSize(true);
- child.setSize(b.width+adj[0], b.height+adj[1]);
- }
- }, 10);
+ else if (me.collapsible) {
+ legendItems.push(me.createToggleCmp());
}
- }
- },
-
- snap : function(value, inc, min){
- if(!inc || !value){
- return value;
- }
- var newValue = value;
- var m = value % inc;
- if(m > 0){
- if(m > (inc/2)){
- newValue = value + (inc-m);
- }else{
- newValue = value - m;
- }
- }
- return Math.max(min, newValue);
- },
+
+ legendItems.push(me.createTitleCmp());
-
- resizeElement : function(){
- var box = this.proxy.getBox();
- if(this.updateBox){
- this.el.setBox(box, false, this.animate, this.duration, null, this.easing);
- }else{
- this.el.setSize(box.width, box.height, this.animate, this.duration, null, this.easing);
- }
- this.updateChildSize();
- if(!this.dynamic){
- this.proxy.hide();
+ legend = me.legend = Ext.create('Ext.container.Container', {
+ baseCls: me.baseCls + '-header',
+ ariaRole: '',
+ getElConfig: function(){
+ return {tag: 'legend', cls: this.baseCls};
+ },
+ items: legendItems
+ });
}
- if(this.draggable && this.constrainTo){
- this.dd.resetConstraints();
- this.dd.constrainTo(this.constrainTo);
+
+
+ if (legend && !legend.rendered && me.rendered) {
+ me.legend.render(me.el, me.body);
}
- return box;
},
- constrain : function(v, diff, m, mx){
- if(v - diff < m){
- diff = v - m;
- }else if(v - diff > mx){
- diff = v - mx;
- }
- return diff;
+ createTitleCmp: function() {
+ var me = this;
+ me.titleCmp = Ext.create('Ext.Component', {
+ html: me.title,
+ cls: me.baseCls + '-header-text'
+ });
+ return me.titleCmp;
+
},
- onMouseMove : function(e){
- if(this.enabled && this.activeHandle){
- try{
-
- if(this.resizeRegion && !this.resizeRegion.contains(e.getPoint())) {
- return;
- }
+
+ createCheckboxCmp: function() {
+ var me = this,
+ suffix = '-checkbox';
- var curSize = this.curSize || this.startBox,
- x = this.startBox.x, y = this.startBox.y,
- ox = x,
- oy = y,
- w = curSize.width,
- h = curSize.height,
- ow = w,
- oh = h,
- mw = this.minWidth,
- mh = this.minHeight,
- mxw = this.maxWidth,
- mxh = this.maxHeight,
- wi = this.widthIncrement,
- hi = this.heightIncrement,
- eventXY = e.getXY(),
- diffX = -(this.startPoint[0] - Math.max(this.minX, eventXY[0])),
- diffY = -(this.startPoint[1] - Math.max(this.minY, eventXY[1])),
- pos = this.activeHandle.position,
- tw,
- th;
-
- switch(pos){
- case 'east':
- w += diffX;
- w = Math.min(Math.max(mw, w), mxw);
- break;
- case 'south':
- h += diffY;
- h = Math.min(Math.max(mh, h), mxh);
- break;
- case 'southeast':
- w += diffX;
- h += diffY;
- w = Math.min(Math.max(mw, w), mxw);
- h = Math.min(Math.max(mh, h), mxh);
- break;
- case 'north':
- diffY = this.constrain(h, diffY, mh, mxh);
- y += diffY;
- h -= diffY;
- break;
- case 'west':
- diffX = this.constrain(w, diffX, mw, mxw);
- x += diffX;
- w -= diffX;
- break;
- case 'northeast':
- w += diffX;
- w = Math.min(Math.max(mw, w), mxw);
- diffY = this.constrain(h, diffY, mh, mxh);
- y += diffY;
- h -= diffY;
- break;
- case 'northwest':
- diffX = this.constrain(w, diffX, mw, mxw);
- diffY = this.constrain(h, diffY, mh, mxh);
- y += diffY;
- h -= diffY;
- x += diffX;
- w -= diffX;
- break;
- case 'southwest':
- diffX = this.constrain(w, diffX, mw, mxw);
- h += diffY;
- h = Math.min(Math.max(mh, h), mxh);
- x += diffX;
- w -= diffX;
- break;
+ me.checkboxCmp = Ext.create('Ext.form.field.Checkbox', {
+ name: me.checkboxName || me.id + suffix,
+ cls: me.baseCls + '-header' + suffix,
+ checked: !me.collapsed,
+ listeners: {
+ change: me.onCheckChange,
+ scope: me
}
+ });
+ return me.checkboxCmp;
+ },
- var sw = this.snap(w, wi, mw);
- var sh = this.snap(h, hi, mh);
- if(sw != w || sh != h){
- switch(pos){
- case 'northeast':
- y -= sh - h;
- break;
- case 'north':
- y -= sh - h;
- break;
- case 'southwest':
- x -= sw - w;
- break;
- case 'west':
- x -= sw - w;
- break;
- case 'northwest':
- x -= sw - w;
- y -= sh - h;
- break;
- }
- w = sw;
- h = sh;
- }
-
- if(this.preserveRatio){
- switch(pos){
- case 'southeast':
- case 'east':
- h = oh * (w/ow);
- h = Math.min(Math.max(mh, h), mxh);
- w = ow * (h/oh);
- break;
- case 'south':
- w = ow * (h/oh);
- w = Math.min(Math.max(mw, w), mxw);
- h = oh * (w/ow);
- break;
- case 'northeast':
- w = ow * (h/oh);
- w = Math.min(Math.max(mw, w), mxw);
- h = oh * (w/ow);
- break;
- case 'north':
- tw = w;
- w = ow * (h/oh);
- w = Math.min(Math.max(mw, w), mxw);
- h = oh * (w/ow);
- x += (tw - w) / 2;
- break;
- case 'southwest':
- h = oh * (w/ow);
- h = Math.min(Math.max(mh, h), mxh);
- tw = w;
- w = ow * (h/oh);
- x += tw - w;
- break;
- case 'west':
- th = h;
- h = oh * (w/ow);
- h = Math.min(Math.max(mh, h), mxh);
- y += (th - h) / 2;
- tw = w;
- w = ow * (h/oh);
- x += tw - w;
- break;
- case 'northwest':
- tw = w;
- th = h;
- h = oh * (w/ow);
- h = Math.min(Math.max(mh, h), mxh);
- w = ow * (h/oh);
- y += th - h;
- x += tw - w;
- break;
+
- }
- }
- this.proxy.setBounds(x, y, w, h);
- if(this.dynamic){
- this.resizeElement();
+
+ createToggleCmp: function() {
+ var me = this;
+ me.toggleCmp = Ext.create('Ext.panel.Tool', {
+ type: 'toggle',
+ handler: me.toggle,
+ scope: me
+ });
+ return me.toggleCmp;
+ },
+
+
+ setTitle: function(title) {
+ var me = this;
+ me.title = title;
+ me.initLegend();
+ me.titleCmp.update(title);
+ return me;
+ },
+
+ getTargetEl : function() {
+ return this.body || this.frameBody || this.el;
+ },
+
+ getContentTarget: function() {
+ return this.body;
+ },
+
+
+ getRefItems: function(deep) {
+ var refItems = this.callParent(arguments),
+ legend = this.legend;
+
+
+ if (legend) {
+ refItems.unshift(legend);
+ if (deep) {
+ refItems.unshift.apply(refItems, legend.getRefItems(true));
}
- }catch(ex){}
}
+ return refItems;
},
- handleOver : function(){
- if(this.enabled){
- this.el.addClass('x-resizable-over');
- }
+ expand : function(){
+ return this.setExpanded(true);
},
-
- handleOut : function(){
- if(!this.resizing){
- this.el.removeClass('x-resizable-over');
- }
+
+ collapse : function() {
+ return this.setExpanded(false);
},
- getEl : function(){
- return this.el;
+ setExpanded: function(expanded) {
+ var me = this,
+ checkboxCmp = me.checkboxCmp,
+ toggleCmp = me.toggleCmp;
+
+ expanded = !!expanded;
+
+ if (checkboxCmp) {
+ checkboxCmp.setValue(expanded);
+ }
+
+ if (expanded) {
+ me.removeCls(me.baseCls + '-collapsed');
+ } else {
+ me.addCls(me.baseCls + '-collapsed');
+ }
+ me.collapsed = !expanded;
+ me.doComponentLayout();
+ return me;
},
- getResizeChild : function(){
- return this.resizeChild;
+ toggle: function() {
+ this.setExpanded(!!this.collapsed);
},
- destroy : function(removeEl){
- Ext.destroy(this.dd, this.overlay, this.proxy);
- this.overlay = null;
- this.proxy = null;
-
- var ps = Ext.Resizable.positions;
- for(var k in ps){
- if(typeof ps[k] != 'function' && this[ps[k]]){
- this[ps[k]].destroy();
- }
- }
- if(removeEl){
- this.el.update('');
- Ext.destroy(this.el);
- this.el = null;
- }
- this.purgeListeners();
+ onCheckChange: function(cmp, checked) {
+ this.setExpanded(checked);
},
- syncHandleHeight : function(){
- var h = this.el.getHeight(true);
- if(this.west){
- this.west.el.setHeight(h);
- }
- if(this.east){
- this.east.el.setHeight(h);
+ beforeDestroy : function() {
+ var legend = this.legend;
+ if (legend) {
+ legend.destroy();
}
+ this.callParent();
}
});
-
-Ext.Resizable.positions = {
- n: 'north', s: 'south', e: 'east', w: 'west', se: 'southeast', sw: 'southwest', nw: 'northwest', ne: 'northeast'
-};
-
-Ext.Resizable.Handle = Ext.extend(Object, {
- constructor : function(rz, pos, disableTrackOver, transparent, cls){
- if(!this.tpl){
-
- var tpl = Ext.DomHelper.createTemplate(
- {tag: 'div', cls: 'x-resizable-handle x-resizable-handle-{0}'}
- );
- tpl.compile();
- Ext.Resizable.Handle.prototype.tpl = tpl;
- }
- this.position = pos;
- this.rz = rz;
- this.el = this.tpl.append(rz.el.dom, [this.position], true);
- this.el.unselectable();
- if(transparent){
- this.el.setOpacity(0);
- }
- if(!Ext.isEmpty(cls)){
- this.el.addClass(cls);
- }
- this.el.on('mousedown', this.onMouseDown, this);
- if(!disableTrackOver){
- this.el.on({
- scope: this,
- mouseover: this.onMouseOver,
- mouseout: this.onMouseOut
- });
- }
- },
+Ext.define('Ext.form.Label', {
+ extend:'Ext.Component',
+ alias: 'widget.label',
+ requires: ['Ext.util.Format'],
- afterResize : function(rz){
-
- },
- onMouseDown : function(e){
- this.rz.onMouseDown(this, e);
- },
- onMouseOver : function(e){
- this.rz.handleOver(this, e);
- },
- onMouseOut : function(e){
- this.rz.handleOut(this, e);
+ maskOnDisable: false,
+ getElConfig: function(){
+ var me = this;
+ return {
+ tag: 'label',
+ id: me.id,
+ htmlFor: me.forId || '',
+ html: me.text ? Ext.util.Format.htmlEncode(me.text) : (me.html || '')
+ };
},
+
- destroy : function(){
- Ext.destroy(this.el);
- this.el = null;
+ setText : function(text, encode){
+ var me = this;
+
+ encode = encode !== false;
+ if(encode) {
+ me.text = text;
+ delete me.html;
+ } else {
+ me.html = text;
+ delete me.text;
+ }
+
+ if(me.rendered){
+ me.el.dom.innerHTML = encode !== false ? Ext.util.Format.htmlEncode(text) : text;
+ }
+ return this;
}
});
-Ext.Window = Ext.extend(Ext.Panel, {
-
-
-
-
-
-
-
-
-
-
+
+
+Ext.define('Ext.form.Panel', {
+ extend:'Ext.panel.Panel',
+ mixins: {
+ fieldAncestor: 'Ext.form.FieldAncestor'
+ },
+ alias: 'widget.form',
+ alternateClassName: ['Ext.FormPanel', 'Ext.form.FormPanel'],
+ requires: ['Ext.form.Basic', 'Ext.util.TaskRunner'],
- baseCls : 'x-window',
-
- resizable : true,
-
- draggable : true,
+
- closable : true,
+
- closeAction : 'close',
+ layout: 'anchor',
+
+ ariaRole: 'form',
+
+ initComponent: function() {
+ var me = this;
+
+ if (me.frame) {
+ me.border = false;
+ }
+
+ me.initFieldAncestor();
+ me.callParent();
+
+ me.relayEvents(me.form, [
+ 'beforeaction',
+ 'actionfailed',
+ 'actioncomplete',
+ 'validitychange',
+ 'dirtychange'
+ ]);
+
+
+ if (me.pollForChanges) {
+ me.startPolling(me.pollInterval || 500);
+ }
+ },
+
+ initItems: function() {
+
+ var me = this;
+
+ me.form = me.createForm();
+ me.callParent();
+ me.form.initialize();
+ },
+
- constrain : false,
+ createForm: function() {
+ return Ext.create('Ext.form.Basic', this, Ext.applyIf({listeners: {}}, this.initialConfig));
+ },
+
- constrainHeader : false,
+ getForm: function() {
+ return this.form;
+ },
- plain : false,
- minimizable : false,
+ loadRecord: function(record) {
+ return this.getForm().loadRecord(record);
+ },
- maximizable : false,
- minHeight : 100,
+ getRecord: function() {
+ return this.getForm().getRecord();
+ },
- minWidth : 200,
- expandOnShow : true,
+ getValues: function() {
+ return this.getForm().getValues();
+ },
+
+ beforeDestroy: function() {
+ this.stopPolling();
+ this.form.destroy();
+ this.callParent();
+ },
+
+ load: function(options) {
+ this.form.load(options);
+ },
+
- showAnimDuration: 0.25,
+ submit: function(options) {
+ this.form.submit(options);
+ },
+
+ disable: function(silent) {
+ this.callParent(arguments);
+ this.form.getFields().each(function(field) {
+ field.disable();
+ });
+ },
+
- hideAnimDuration: 0.25,
+ enable: function(silent) {
+ this.callParent(arguments);
+ this.form.getFields().each(function(field) {
+ field.enable();
+ });
+ },
- collapsible : false,
+ startPolling: function(interval) {
+ this.stopPolling();
+ var task = Ext.create('Ext.util.TaskRunner', interval);
+ task.start({
+ interval: 0,
+ run: this.checkChange,
+ scope: this
+ });
+ this.pollTask = task;
+ },
- initHidden : undefined,
+ stopPolling: function() {
+ var task = this.pollTask;
+ if (task) {
+ task.stopAll();
+ delete this.pollTask;
+ }
+ },
- hidden : true,
+ checkChange: function() {
+ this.form.getFields().each(function(field) {
+ field.checkChange();
+ });
+ }
+});
+
+
+Ext.define('Ext.form.RadioGroup', {
+ extend: 'Ext.form.CheckboxGroup',
+ alias: 'widget.radiogroup',
+ allowBlank : true,
+ blankText : 'You must select one item in this group',
- elements : 'header,body',
+ defaultType : 'radiofield',
- frame : true,
- floating : true,
+ groupCls : Ext.baseCSSPrefix + 'form-radio-group',
-
- initComponent : function(){
- this.initTools();
- Ext.Window.superclass.initComponent.call(this);
- this.addEvents(
-
-
-
- 'resize',
-
- 'maximize',
-
- 'minimize',
-
- 'restore'
- );
-
- if(Ext.isDefined(this.initHidden)){
- this.hidden = this.initHidden;
- }
- if(this.hidden === false){
- this.hidden = true;
- this.show();
- }
+ getBoxes: function() {
+ return this.query('[isRadio]');
+ }
+
+});
+
+
+Ext.define('Ext.form.RadioManager', {
+ extend: 'Ext.util.MixedCollection',
+ singleton: true,
+
+ getByName: function(name) {
+ return this.filterBy(function(item) {
+ return item.name == name;
+ });
},
-
- getState : function(){
- return Ext.apply(Ext.Window.superclass.getState.call(this) || {}, this.getBox(true));
+ getWithValue: function(name, value) {
+ return this.filterBy(function(item) {
+ return item.name == name && item.inputValue == value;
+ });
},
-
- onRender : function(ct, position){
- Ext.Window.superclass.onRender.call(this, ct, position);
+ getChecked: function(name) {
+ return this.findBy(function(item) {
+ return item.name == name && item.checked;
+ });
+ }
+});
- if(this.plain){
- this.el.addClass('x-window-plain');
- }
-
- this.focusEl = this.el.createChild({
- tag: 'a', href:'#', cls:'x-dlg-focus',
- tabIndex:'-1', html: ' '});
- this.focusEl.swallowEvent('click', true);
+Ext.define('Ext.form.action.DirectLoad', {
+ extend:'Ext.form.action.Load',
+ requires: ['Ext.direct.Manager'],
+ alternateClassName: 'Ext.form.Action.DirectLoad',
+ alias: 'formaction.directload',
- this.proxy = this.el.createProxy('x-window-proxy');
- this.proxy.enableDisplayMode('block');
+ type: 'directload',
- if(this.modal){
- this.mask = this.container.createChild({cls:'ext-el-mask'}, this.el.dom);
- this.mask.enableDisplayMode('block');
- this.mask.hide();
- this.mon(this.mask, 'click', this.focus, this);
- }
- if(this.maximizable){
- this.mon(this.header, 'dblclick', this.toggleMaximize, this);
- }
+ run: function() {
+ this.form.api.load.apply(window, this.getArgs());
},
- initEvents : function(){
- Ext.Window.superclass.initEvents.call(this);
- if(this.animateTarget){
- this.setAnimateTarget(this.animateTarget);
- }
-
- if(this.resizable){
- this.resizer = new Ext.Resizable(this.el, {
- minWidth: this.minWidth,
- minHeight:this.minHeight,
- handles: this.resizeHandles || 'all',
- pinned: true,
- resizeElement : this.resizerAction,
- handleCls: 'x-window-handle'
- });
- this.resizer.window = this;
- this.mon(this.resizer, 'beforeresize', this.beforeResize, this);
- }
+ getArgs: function() {
+ var me = this,
+ args = [],
+ form = me.form,
+ paramOrder = form.paramOrder,
+ params = me.getParams(),
+ i, len;
- if(this.draggable){
- this.header.addClass('x-window-draggable');
- }
- this.mon(this.el, 'mousedown', this.toFront, this);
- this.manager = this.manager || Ext.WindowMgr;
- this.manager.register(this);
- if(this.maximized){
- this.maximized = false;
- this.maximize();
+
+ if (paramOrder) {
+ for (i = 0, len = paramOrder.length; i < len; i++) {
+ args.push(params[paramOrder[i]]);
+ }
}
- if(this.closable){
- var km = this.getKeyMap();
- km.on(27, this.onEsc, this);
- km.disable();
+
+ else if (form.paramsAsHash) {
+ args.push(params);
}
- },
- initDraggable : function(){
- this.dd = new Ext.Window.DD(this);
- },
+ args.push(me.onSuccess, me);
-
- onEsc : function(k, e){
- e.stopEvent();
- this[this.closeAction]();
+ return args;
},
- beforeDestroy : function(){
- if(this.rendered){
- this.hide();
- this.clearAnchor();
- Ext.destroy(
- this.focusEl,
- this.resizer,
- this.dd,
- this.proxy,
- this.mask
- );
- }
- Ext.Window.superclass.beforeDestroy.call(this);
- },
-
- onDestroy : function(){
- if(this.manager){
- this.manager.unregister(this);
- }
- Ext.Window.superclass.onDestroy.call(this);
+
+ processResponse: function(result) {
+ return (this.result = result);
},
-
- initTools : function(){
- if(this.minimizable){
- this.addTool({
- id: 'minimize',
- handler: this.minimize.createDelegate(this, [])
- });
- }
- if(this.maximizable){
- this.addTool({
- id: 'maximize',
- handler: this.maximize.createDelegate(this, [])
- });
- this.addTool({
- id: 'restore',
- handler: this.restore.createDelegate(this, []),
- hidden:true
- });
- }
- if(this.closable){
- this.addTool({
- id: 'close',
- handler: this[this.closeAction].createDelegate(this, [])
- });
+ onSuccess: function(result, trans) {
+ if (trans.type == Ext.direct.Manager.self.exceptions.SERVER) {
+ result = {};
}
- },
+ this.callParent([result]);
+ }
+});
-
- resizerAction : function(){
- var box = this.proxy.getBox();
- this.proxy.hide();
- this.window.handleResize(box);
- return box;
+
+
+
+Ext.define('Ext.form.action.DirectSubmit', {
+ extend:'Ext.form.action.Submit',
+ requires: ['Ext.direct.Manager'],
+ alternateClassName: 'Ext.form.Action.DirectSubmit',
+ alias: 'formaction.directsubmit',
+
+ type: 'directsubmit',
+
+ doSubmit: function() {
+ var me = this,
+ callback = Ext.Function.bind(me.onSuccess, me),
+ formEl = me.buildForm();
+ me.form.api.submit(formEl, callback, me);
+ Ext.removeNode(formEl);
},
- beforeResize : function(){
- this.resizer.minHeight = Math.max(this.minHeight, this.getFrameHeight() + 40);
- this.resizer.minWidth = Math.max(this.minWidth, this.getFrameWidth() + 40);
- this.resizeBox = this.el.getBox();
+
+
+ processResponse: function(result) {
+ return (this.result = result);
},
-
- updateHandles : function(){
- if(Ext.isIE && this.resizer){
- this.resizer.syncHandleHeight();
- this.el.repaint();
+ onSuccess: function(response, trans) {
+ if (trans.type === Ext.direct.Manager.self.exceptions.SERVER) {
+ response = {};
}
- },
+ this.callParent([response]);
+ }
+});
+
+
+Ext.define('Ext.form.action.StandardSubmit', {
+ extend:'Ext.form.action.Submit',
+ alias: 'formaction.standardsubmit',
- handleResize : function(box){
- var rz = this.resizeBox;
- if(rz.x != box.x || rz.y != box.y){
- this.updateBox(box);
- }else{
- this.setSize(box);
- if (Ext.isIE6 && Ext.isStrict) {
- this.doLayout();
- }
- }
- this.focus();
- this.updateHandles();
- this.saveState();
- },
- focus : function(){
- var f = this.focusEl,
- db = this.defaultButton,
- t = typeof db,
- el,
- ct;
- if(Ext.isDefined(db)){
- if(Ext.isNumber(db) && this.fbar){
- f = this.fbar.items.get(db);
- }else if(Ext.isString(db)){
- f = Ext.getCmp(db);
- }else{
- f = db;
- }
- el = f.getEl();
- ct = Ext.getDom(this.container);
- if (el && ct) {
- if (ct != document.body && !Ext.lib.Region.getRegion(ct).contains(Ext.lib.Region.getRegion(el.dom))){
- return;
- }
- }
+ doSubmit: function() {
+ var form = this.buildForm();
+ form.submit();
+ Ext.removeNode(form);
+ }
+
+});
+
+
+Ext.define('Ext.form.field.Checkbox', {
+ extend: 'Ext.form.field.Base',
+ alias: ['widget.checkboxfield', 'widget.checkbox'],
+ alternateClassName: 'Ext.form.Checkbox',
+ requires: ['Ext.XTemplate', 'Ext.form.CheckboxManager'],
+
+ fieldSubTpl: [
+ '',
+ '',
+ ' ',
+
+
+
+ 'tabIndex="{tabIdx}" ',
+ 'class="{fieldCls} {typeCls}" autocomplete="off" hidefocus="true" />',
+ '',
+ '',
+ ' ',
+ {
+ disableFormats: true,
+ compiled: true
}
- f = f || this.focusEl;
- f.focus.defer(10, f);
- },
+ ],
+
+ isCheckbox: true,
- setAnimateTarget : function(el){
- el = Ext.get(el);
- this.animateTarget = el;
- },
+ focusCls: Ext.baseCSSPrefix + 'form-cb-focus',
- beforeShow : function(){
- delete this.el.lastXY;
- delete this.el.lastLT;
- if(this.x === undefined || this.y === undefined){
- var xy = this.el.getAlignToXY(this.container, 'c-c');
- var pos = this.el.translatePoints(xy[0], xy[1]);
- this.x = this.x === undefined? pos.left : this.x;
- this.y = this.y === undefined? pos.top : this.y;
- }
- this.el.setLeftTop(this.x, this.y);
- if(this.expandOnShow){
- this.expand(false);
- }
+
+ fieldBodyCls: Ext.baseCSSPrefix + 'form-cb-wrap',
- if(this.modal){
- Ext.getBody().addClass('x-body-masked');
- this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
- this.mask.show();
- }
- },
+
+ checked: false,
- show : function(animateTarget, cb, scope){
- if(!this.rendered){
- this.render(Ext.getBody());
- }
- if(this.hidden === false){
- this.toFront();
- return this;
- }
- if(this.fireEvent('beforeshow', this) === false){
- return this;
- }
- if(cb){
- this.on('show', cb, scope, {single:true});
- }
- this.hidden = false;
- if(Ext.isDefined(animateTarget)){
- this.setAnimateTarget(animateTarget);
- }
- this.beforeShow();
- if(this.animateTarget){
- this.animShow();
- }else{
- this.afterShow();
- }
- return this;
- },
+ checkedCls: Ext.baseCSSPrefix + 'form-cb-checked',
- afterShow : function(isAnim){
- if (this.isDestroyed){
- return false;
- }
- this.proxy.hide();
- this.el.setStyle('display', 'block');
- this.el.show();
- if(this.maximized){
- this.fitContainer();
- }
- if(Ext.isMac && Ext.isGecko2){
- this.cascade(this.setAutoScroll);
- }
- if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){
- Ext.EventManager.onWindowResize(this.onWindowResize, this);
- }
- this.doConstrain();
- this.doLayout();
- if(this.keyMap){
- this.keyMap.enable();
- }
- this.toFront();
- this.updateHandles();
- if(isAnim && (Ext.isIE || Ext.isWebKit)){
- var sz = this.getSize();
- this.onResize(sz.width, sz.height);
- }
- this.onShow();
- this.fireEvent('show', this);
- },
+
+ boxLabelCls: Ext.baseCSSPrefix + 'form-cb-label',
- animShow : function(){
- this.proxy.show();
- this.proxy.setBox(this.animateTarget.getBox());
- this.proxy.setOpacity(0);
- var b = this.getBox();
- this.el.setStyle('display', 'none');
- this.proxy.shift(Ext.apply(b, {
- callback: this.afterShow.createDelegate(this, [true], false),
- scope: this,
- easing: 'easeNone',
- duration: this.showAnimDuration,
- opacity: 0.5
- }));
- },
+ boxLabelAlign: 'after',
- hide : function(animateTarget, cb, scope){
- if(this.hidden || this.fireEvent('beforehide', this) === false){
- return this;
- }
- if(cb){
- this.on('hide', cb, scope, {single:true});
- }
- this.hidden = true;
- if(animateTarget !== undefined){
- this.setAnimateTarget(animateTarget);
- }
- if(this.modal){
- this.mask.hide();
- Ext.getBody().removeClass('x-body-masked');
- }
- if(this.animateTarget){
- this.animHide();
- }else{
- this.el.hide();
- this.afterHide();
- }
- return this;
- },
+ inputValue: 'on',
- afterHide : function(){
- this.proxy.hide();
- if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){
- Ext.EventManager.removeResizeListener(this.onWindowResize, this);
- }
- if(this.keyMap){
- this.keyMap.disable();
- }
- this.onHide();
- this.fireEvent('hide', this);
- },
- animHide : function(){
- this.proxy.setOpacity(0.5);
- this.proxy.show();
- var tb = this.getBox(false);
- this.proxy.setBox(tb);
- this.el.hide();
- this.proxy.shift(Ext.apply(this.animateTarget.getBox(), {
- callback: this.afterHide,
- scope: this,
- duration: this.hideAnimDuration,
- easing: 'easeNone',
- opacity: 0
- }));
- },
- onShow : Ext.emptyFn,
- onHide : Ext.emptyFn,
+ checkChangeEvents: [],
+ inputType: 'checkbox',
+ ariaRole: 'checkbox',
- onWindowResize : function(){
- if(this.maximized){
- this.fitContainer();
- }
- if(this.modal){
- this.mask.setSize('100%', '100%');
- var force = this.mask.dom.offsetHeight;
- this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
- }
- this.doConstrain();
+ onRe: /^on$/i,
+
+ initComponent: function(){
+ this.callParent(arguments);
+ this.getManager().add(this);
},
-
- doConstrain : function(){
- if(this.constrain || this.constrainHeader){
- var offsets;
- if(this.constrain){
- offsets = {
- right:this.el.shadowOffset,
- left:this.el.shadowOffset,
- bottom:this.el.shadowOffset
- };
- }else {
- var s = this.getSize();
- offsets = {
- right:-(s.width - 100),
- bottom:-(s.height - 25)
- };
- }
+ initValue: function() {
+ var me = this,
+ checked = !!me.checked;
- var xy = this.el.getConstrainToXY(this.container, true, offsets);
- if(xy){
- this.setPosition(xy[0], xy[1]);
- }
- }
+
+ me.originalValue = me.lastValue = checked;
+
+
+ me.setValue(checked);
},
- ghost : function(cls){
- var ghost = this.createGhost(cls);
- var box = this.getBox(true);
- ghost.setLeftTop(box.x, box.y);
- ghost.setWidth(box.width);
- this.el.hide();
- this.activeGhost = ghost;
- return ghost;
+ onRender : function(ct, position) {
+ var me = this;
+ Ext.applyIf(me.renderSelectors, {
+
+ boxLabelEl: 'label.' + me.boxLabelCls
+ });
+ Ext.applyIf(me.subTplData, {
+ boxLabel: me.boxLabel,
+ boxLabelCls: me.boxLabelCls,
+ boxLabelAlign: me.boxLabelAlign
+ });
+
+ me.callParent(arguments);
+ },
+
+ initEvents: function() {
+ var me = this;
+ me.callParent();
+ me.mon(me.inputEl, 'click', me.onBoxClick, me);
},
- unghost : function(show, matchPosition){
- if(!this.activeGhost) {
- return;
- }
- if(show !== false){
- this.el.show();
- this.focus.defer(10, this);
- if(Ext.isMac && Ext.isGecko2){
- this.cascade(this.setAutoScroll);
- }
- }
- if(matchPosition !== false){
- this.setPosition(this.activeGhost.getLeft(true), this.activeGhost.getTop(true));
+ onBoxClick: function(e) {
+ var me = this;
+ if (!me.disabled && !me.readOnly) {
+ this.setValue(!this.checked);
}
- this.activeGhost.hide();
- this.activeGhost.remove();
- delete this.activeGhost;
},
- minimize : function(){
- this.fireEvent('minimize', this);
- return this;
+ getRawValue: function() {
+ return this.checked;
},
- close : function(){
- if(this.fireEvent('beforeclose', this) !== false){
- if(this.hidden){
- this.doClose();
- }else{
- this.hide(null, this.doClose, this);
- }
- }
+ getValue: function() {
+ return this.checked;
},
- doClose : function(){
- this.fireEvent('close', this);
- this.destroy();
+ getSubmitValue: function() {
+ return this.checked ? this.inputValue : (this.uncheckedValue || null);
},
-
- maximize : function(){
- if(!this.maximized){
- this.expand(false);
- this.restoreSize = this.getSize();
- this.restorePos = this.getPosition(true);
- if (this.maximizable){
- this.tools.maximize.hide();
- this.tools.restore.show();
- }
- this.maximized = true;
- this.el.disableShadow();
+ getModelData: function() {
+ return this.getSubmitData();
+ },
- if(this.dd){
- this.dd.lock();
- }
- if(this.collapsible){
- this.tools.toggle.hide();
- }
- this.el.addClass('x-window-maximized');
- this.container.addClass('x-window-maximized-ct');
+
+ setRawValue: function(value) {
+ var me = this,
+ inputEl = me.inputEl,
+ inputValue = me.inputValue,
+ checked = (value === true || value === 'true' || value === '1' ||
+ ((Ext.isString(value) && inputValue) ? value == inputValue : me.onRe.test(value)));
- this.setPosition(0, 0);
- this.fitContainer();
- this.fireEvent('maximize', this);
+ if (inputEl) {
+ inputEl.dom.setAttribute('aria-checked', checked);
+ me[checked ? 'addCls' : 'removeCls'](me.checkedCls);
}
- return this;
+
+ me.checked = me.rawValue = checked;
+ return checked;
},
- restore : function(){
- if(this.maximized){
- var t = this.tools;
- this.el.removeClass('x-window-maximized');
- if(t.restore){
- t.restore.hide();
- }
- if(t.maximize){
- t.maximize.show();
- }
- this.setPosition(this.restorePos[0], this.restorePos[1]);
- this.setSize(this.restoreSize.width, this.restoreSize.height);
- delete this.restorePos;
- delete this.restoreSize;
- this.maximized = false;
- this.el.enableShadow(true);
-
- if(this.dd){
- this.dd.unlock();
- }
- if(this.collapsible && t.toggle){
- t.toggle.show();
- }
- this.container.removeClass('x-window-maximized-ct');
+ setValue: function(checked) {
+ var me = this;
- this.doConstrain();
- this.fireEvent('restore', this);
+
+
+
+
+ if (Ext.isArray(checked)) {
+ me.getManager().getByName(me.name).each(function(cb) {
+ cb.setValue(Ext.Array.contains(checked, cb.inputValue));
+ });
+ } else {
+ me.callParent(arguments);
}
- return this;
+
+ return me;
},
- toggleMaximize : function(){
- return this[this.maximized ? 'restore' : 'maximize']();
+ valueToRaw: function(value) {
+
+ return value;
},
- fitContainer : function(){
- var vs = this.container.getViewSize(false);
- this.setSize(vs.width, vs.height);
+ onChange: function(newVal, oldVal) {
+ var me = this,
+ handler = me.handler;
+ if (handler) {
+ handler.call(me.scope || me, me, newVal);
+ }
+ me.callParent(arguments);
},
-
- setZIndex : function(index){
- if(this.modal){
- this.mask.setStyle('z-index', index);
- }
- this.el.setZIndex(++index);
- index += 5;
+ getManager: function() {
+ return Ext.form.CheckboxManager;
+ },
- if(this.resizer){
- this.resizer.proxy.setStyle('z-index', ++index);
+ onEnable: function() {
+ var me = this,
+ inputEl = me.inputEl;
+ me.callParent();
+ if (inputEl) {
+
+ inputEl.dom.disabled = me.readOnly;
}
+ },
- this.lastZIndex = index;
+ setReadOnly: function(readOnly) {
+ var me = this,
+ inputEl = me.inputEl;
+ if (inputEl) {
+
+ inputEl.dom.disabled = readOnly || me.disabled;
+ }
+ me.readOnly = readOnly;
},
- alignTo : function(element, position, offsets){
- var xy = this.el.getAlignToXY(element, position, offsets);
- this.setPagePosition(xy[0], xy[1]);
- return this;
- },
+ getBodyNaturalWidth: function() {
+ var me = this,
+ bodyEl = me.bodyEl,
+ ws = 'white-space',
+ width;
+ bodyEl.setStyle(ws, 'nowrap');
+ width = bodyEl.getWidth();
+ bodyEl.setStyle(ws, '');
+ return width;
+ }
+
+});
+
+
+
+Ext.define('Ext.layout.component.field.Trigger', {
- anchorTo : function(el, alignment, offsets, monitorScroll){
- this.clearAnchor();
- this.anchorTarget = {
- el: el,
- alignment: alignment,
- offsets: offsets
- };
- Ext.EventManager.onWindowResize(this.doAnchor, this);
- var tm = typeof monitorScroll;
- if(tm != 'undefined'){
- Ext.EventManager.on(window, 'scroll', this.doAnchor, this,
- {buffer: tm == 'number' ? monitorScroll : 50});
- }
- return this.doAnchor();
- },
+ alias: ['layout.triggerfield'],
+
+ extend: 'Ext.layout.component.field.Field',
- doAnchor : function(){
- var o = this.anchorTarget;
- this.alignTo(o.el, o.alignment, o.offsets);
- return this;
- },
+ type: 'triggerfield',
+
+ sizeBodyContents: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ inputEl = owner.inputEl,
+ triggerWrap = owner.triggerWrap,
+ triggerWidth = owner.getTriggerWidth();
+
+
+
+ if (owner.hideTrigger || owner.readOnly || triggerWidth > 0) {
+
+
+ me.setElementSize(inputEl, Ext.isNumber(width) ? width - triggerWidth : width);
- clearAnchor : function(){
- if(this.anchorTarget){
- Ext.EventManager.removeResizeListener(this.doAnchor, this);
- Ext.EventManager.un(window, 'scroll', this.doAnchor, this);
- delete this.anchorTarget;
+
+ triggerWrap.setWidth(triggerWidth);
}
- return this;
- },
+ }
+});
+Ext.define('Ext.view.View', {
+ extend: 'Ext.view.AbstractView',
+ alternateClassName: 'Ext.view.View',
+ alias: 'widget.dataview',
- toFront : function(e){
- if(this.manager.bringToFront(this)){
- if(!e || !e.getTarget().focus){
- this.focus();
- }
+ inheritableStatics: {
+ EventMap: {
+ mousedown: 'MouseDown',
+ mouseup: 'MouseUp',
+ click: 'Click',
+ dblclick: 'DblClick',
+ contextmenu: 'ContextMenu',
+ mouseover: 'MouseOver',
+ mouseout: 'MouseOut',
+ mouseenter: 'MouseEnter',
+ mouseleave: 'MouseLeave',
+ keydown: 'KeyDown'
}
- return this;
},
-
- setActive : function(active){
- if(active){
- if(!this.maximized){
- this.el.enableShadow(true);
- }
- this.fireEvent('activate', this);
- }else{
- this.el.disableShadow();
- this.fireEvent('deactivate', this);
+ addCmpEvents: function() {
+ this.addEvents(
+
+ 'beforeitemmousedown',
+
+ 'beforeitemmouseup',
+
+ 'beforeitemmouseenter',
+
+ 'beforeitemmouseleave',
+
+ 'beforeitemclick',
+
+ 'beforeitemdblclick',
+
+ 'beforeitemcontextmenu',
+
+ 'beforeitemkeydown',
+
+ 'itemmousedown',
+
+ 'itemmouseup',
+
+ 'itemmouseenter',
+
+ 'itemmouseleave',
+
+ 'itemclick',
+
+ 'itemdblclick',
+
+ 'itemcontextmenu',
+
+ 'itemkeydown',
+
+ 'beforecontainermousedown',
+
+ 'beforecontainermouseup',
+
+ 'beforecontainermouseover',
+
+ 'beforecontainermouseout',
+
+ 'beforecontainerclick',
+
+ 'beforecontainerdblclick',
+
+ 'beforecontainercontextmenu',
+
+ 'beforecontainerkeydown',
+
+ 'containermouseup',
+
+ 'containermouseover',
+
+ 'containermouseout',
+
+ 'containerclick',
+
+ 'containerdblclick',
+
+ 'containercontextmenu',
+
+ 'containerkeydown',
+
+
+ 'selectionchange',
+
+ 'beforeselect'
+ );
+ },
+
+ afterRender: function(){
+ var me = this,
+ listeners;
+
+ me.callParent();
+
+ listeners = {
+ scope: me,
+ click: me.handleEvent,
+ mousedown: me.handleEvent,
+ mouseup: me.handleEvent,
+ dblclick: me.handleEvent,
+ contextmenu: me.handleEvent,
+ mouseover: me.handleEvent,
+ mouseout: me.handleEvent,
+ keydown: me.handleEvent
+ };
+
+ me.mon(me.getTargetEl(), listeners);
+
+ if (me.store) {
+ me.bindStore(me.store, true);
}
},
-
- toBack : function(){
- this.manager.sendToBack(this);
- return this;
+ handleEvent: function(e) {
+ if (this.processUIEvent(e) !== false) {
+ this.processSpecialEvent(e);
+ }
},
-
- center : function(){
- var xy = this.el.getAlignToXY(this.container, 'c-c');
- this.setPagePosition(xy[0], xy[1]);
- return this;
- }
-
-});
-Ext.reg('window', Ext.Window);
-
-
-Ext.Window.DD = Ext.extend(Ext.dd.DD, {
+ processItemEvent: Ext.emptyFn,
+ processContainerEvent: Ext.emptyFn,
+ processSpecialEvent: Ext.emptyFn,
+
+ processUIEvent: function(e, type) {
+ type = type || e.type;
+ var me = this,
+ item = e.getTarget(me.getItemSelector(), me.getTargetEl()),
+ map = this.statics().EventMap,
+ index, record;
+
+ if (!item) {
+
+
+
+
+
+
+ if (type == 'mouseover' && me.mouseOverItem && typeof me.mouseOverItem.offsetParent === "object" && Ext.fly(me.mouseOverItem).getRegion().contains(e.getPoint())) {
+ item = me.mouseOverItem;
+ }
+
+
+ if (type == 'keydown') {
+ record = me.getSelectionModel().getLastSelected();
+ if (record) {
+ item = me.getNode(record);
+ }
+ }
+ }
+
+ if (item) {
+ index = me.indexOf(item);
+ if (!record) {
+ record = me.getRecord(item);
+ }
+
+ if (me.processItemEvent(type, record, item, index, e) === false) {
+ return false;
+ }
+
+ type = me.isNewItemEvent(type, item, e);
+ if (type === false) {
+ return false;
+ }
+
+ if (
+ (me['onBeforeItem' + map[type]](record, item, index, e) === false) ||
+ (me.fireEvent('beforeitem' + type, me, record, item, index, e) === false) ||
+ (me['onItem' + map[type]](record, item, index, e) === false)
+ ) {
+ return false;
+ }
+
+ me.fireEvent('item' + type, me, record, item, index, e);
+ }
+ else {
+ if (
+ (me.processContainerEvent(type, e) === false) ||
+ (me['onBeforeContainer' + map[type]](e) === false) ||
+ (me.fireEvent('beforecontainer' + type, me, e) === false) ||
+ (me['onContainer' + map[type]](e) === false)
+ ) {
+ return false;
+ }
+
+ me.fireEvent('container' + type, me, e);
+ }
+
+ return true;
+ },
- constructor : function(win){
- this.win = win;
- Ext.Window.DD.superclass.constructor.call(this, win.el.id, 'WindowDD-'+win.id);
- this.setHandleElId(win.header.id);
- this.scroll = false;
+ isNewItemEvent: function(type, item, e) {
+ var me = this,
+ overItem = me.mouseOverItem,
+ contains,
+ isItem;
+
+ switch (type) {
+ case 'mouseover':
+ if (item === overItem) {
+ return false;
+ }
+ me.mouseOverItem = item;
+ return 'mouseenter';
+ break;
+
+ case 'mouseout':
+
+ if (overItem && typeof overItem.offsetParent === "object") {
+ contains = Ext.fly(me.mouseOverItem).getRegion().contains(e.getPoint());
+ isItem = Ext.fly(e.getTarget()).hasCls(me.itemSelector);
+ if (contains && isItem) {
+ return false;
+ }
+ }
+ me.mouseOverItem = null;
+ return 'mouseleave';
+ break;
+ }
+ return type;
},
- moveOnly:true,
- headerOffsets:[100, 25],
- startDrag : function(){
- var w = this.win;
- this.proxy = w.ghost(w.initialConfig.cls);
- if(w.constrain !== false){
- var so = w.el.shadowOffset;
- this.constrainTo(w.container, {right: so, left: so, bottom: so});
- }else if(w.constrainHeader !== false){
- var s = this.proxy.getSize();
- this.constrainTo(w.container, {right: -(s.width-this.headerOffsets[0]), bottom: -(s.height-this.headerOffsets[1])});
+
+ onItemMouseEnter: function(record, item, index, e) {
+ if (this.trackOver) {
+ this.highlightItem(item);
}
},
- b4Drag : Ext.emptyFn,
- onDrag : function(e){
- this.alignElWithMouse(this.proxy, e.getPageX(), e.getPageY());
+
+ onItemMouseLeave : function(record, item, index, e) {
+ if (this.trackOver) {
+ this.clearHighlight();
+ }
},
- endDrag : function(e){
- this.win.unghost();
- this.win.saveState();
- }
-});
-
-Ext.WindowGroup = function(){
- var list = {};
- var accessList = [];
- var front = null;
-
- var sortWindows = function(d1, d2){
- return (!d1._lastAccess || d1._lastAccess < d2._lastAccess) ? -1 : 1;
- };
-
+ onItemMouseDown: Ext.emptyFn,
+ onItemMouseUp: Ext.emptyFn,
+ onItemClick: Ext.emptyFn,
+ onItemDblClick: Ext.emptyFn,
+ onItemContextMenu: Ext.emptyFn,
+ onItemKeyDown: Ext.emptyFn,
+ onBeforeItemMouseDown: Ext.emptyFn,
+ onBeforeItemMouseUp: Ext.emptyFn,
+ onBeforeItemMouseEnter: Ext.emptyFn,
+ onBeforeItemMouseLeave: Ext.emptyFn,
+ onBeforeItemClick: Ext.emptyFn,
+ onBeforeItemDblClick: Ext.emptyFn,
+ onBeforeItemContextMenu: Ext.emptyFn,
+ onBeforeItemKeyDown: Ext.emptyFn,
- var orderWindows = function(){
- var a = accessList, len = a.length;
- if(len > 0){
- a.sort(sortWindows);
- var seed = a[0].manager.zseed;
- for(var i = 0; i < len; i++){
- var win = a[i];
- if(win && !win.hidden){
- win.setZIndex(seed + (i*10));
- }
- }
- }
- activateLast();
- };
-
- var setActiveWin = function(win){
- if(win != front){
- if(front){
- front.setActive(false);
- }
- front = win;
- if(win){
- win.setActive(true);
- }
- }
- };
+ onContainerMouseDown: Ext.emptyFn,
+ onContainerMouseUp: Ext.emptyFn,
+ onContainerMouseOver: Ext.emptyFn,
+ onContainerMouseOut: Ext.emptyFn,
+ onContainerClick: Ext.emptyFn,
+ onContainerDblClick: Ext.emptyFn,
+ onContainerContextMenu: Ext.emptyFn,
+ onContainerKeyDown: Ext.emptyFn,
+ onBeforeContainerMouseDown: Ext.emptyFn,
+ onBeforeContainerMouseUp: Ext.emptyFn,
+ onBeforeContainerMouseOver: Ext.emptyFn,
+ onBeforeContainerMouseOut: Ext.emptyFn,
+ onBeforeContainerClick: Ext.emptyFn,
+ onBeforeContainerDblClick: Ext.emptyFn,
+ onBeforeContainerContextMenu: Ext.emptyFn,
+ onBeforeContainerKeyDown: Ext.emptyFn,
+
+
+ highlightItem: function(item) {
+ var me = this;
+ me.clearHighlight();
+ me.highlightedItem = item;
+ Ext.fly(item).addCls(me.overItemCls);
+ },
- var activateLast = function(){
- for(var i = accessList.length-1; i >=0; --i) {
- if(!accessList[i].hidden){
- setActiveWin(accessList[i]);
- return;
- }
+ clearHighlight: function() {
+ var me = this,
+ highlighted = me.highlightedItem;
+
+ if (highlighted) {
+ Ext.fly(highlighted).removeCls(me.overItemCls);
+ delete me.highlightedItem;
}
-
- setActiveWin(null);
- };
+ },
- return {
-
- zseed : 9000,
+ refresh: function() {
+ this.clearHighlight();
+ this.callParent(arguments);
+ }
+});
-
- register : function(win){
- if(win.manager){
- win.manager.unregister(win);
- }
- win.manager = this;
+Ext.define('Ext.layout.component.BoundList', {
+ extend: 'Ext.layout.component.Component',
+ alias: 'layout.boundlist',
- list[win.id] = win;
- accessList.push(win);
- win.on('hide', activateLast);
- },
+ type: 'component',
-
- unregister : function(win){
- delete win.manager;
- delete list[win.id];
- win.un('hide', activateLast);
- accessList.remove(win);
- },
+ beforeLayout: function() {
+ return this.callParent(arguments) || this.owner.refreshed > 0;
+ },
-
- get : function(id){
- return typeof id == "object" ? id : list[id];
- },
+ onLayout : function(width, height) {
+ var me = this,
+ owner = me.owner,
+ floating = owner.floating,
+ el = owner.el,
+ xy = el.getXY(),
+ isNumber = Ext.isNumber,
+ minWidth, maxWidth, minHeight, maxHeight,
+ naturalWidth, naturalHeight, constrainedWidth, constrainedHeight, undef;
-
- bringToFront : function(win){
- win = this.get(win);
- if(win != front){
- win._lastAccess = new Date().getTime();
- orderWindows();
- return true;
- }
- return false;
- },
+ if (floating) {
+
+ el.setXY([-9999,-9999]);
+ }
- sendToBack : function(win){
- win = this.get(win);
- win._lastAccess = -(new Date().getTime());
- orderWindows();
- return win;
- },
+ me.setTargetSize(width, height);
- hideAll : function(){
- for(var id in list){
- if(list[id] && typeof list[id] != "function" && list[id].isVisible()){
- list[id].hide();
+ if (!isNumber(width)) {
+ minWidth = owner.minWidth;
+ maxWidth = owner.maxWidth;
+ if (isNumber(minWidth) || isNumber(maxWidth)) {
+ naturalWidth = el.getWidth();
+ if (naturalWidth < minWidth) {
+ constrainedWidth = minWidth;
+ }
+ else if (naturalWidth > maxWidth) {
+ constrainedWidth = maxWidth;
+ }
+ if (constrainedWidth) {
+ me.setTargetSize(constrainedWidth);
}
}
- },
-
-
- getActive : function(){
- return front;
- },
-
+ }
- getBy : function(fn, scope){
- var r = [];
- for(var i = accessList.length-1; i >=0; --i) {
- var win = accessList[i];
- if(fn.call(scope||win, win) !== false){
- r.push(win);
+ if (!isNumber(height)) {
+ minHeight = owner.minHeight;
+ maxHeight = owner.maxHeight;
+ if (isNumber(minHeight) || isNumber(maxHeight)) {
+ naturalHeight = el.getHeight();
+ if (naturalHeight < minHeight) {
+ constrainedHeight = minHeight;
+ }
+ else if (naturalHeight > maxHeight) {
+ constrainedHeight = maxHeight;
+ }
+ if (constrainedHeight) {
+ me.setTargetSize(undef, constrainedHeight);
}
}
- return r;
- },
+ }
+
+ if (floating) {
+
+ el.setXY(xy);
+ }
+ },
+
+ afterLayout: function() {
+ var me = this,
+ toolbar = me.owner.pagingToolbar;
+ me.callParent();
+ if (toolbar) {
+ toolbar.doComponentLayout();
+ }
+ },
+
+ setTargetSize : function(width, height) {
+ var me = this,
+ owner = me.owner,
+ listHeight = null,
+ toolbar;
- each : function(fn, scope){
- for(var id in list){
- if(list[id] && typeof list[id] != "function"){
- if(fn.call(scope || list[id], list[id]) === false){
- return;
- }
- }
+ if (Ext.isNumber(height)) {
+ listHeight = height - owner.el.getFrameWidth('tb');
+ toolbar = owner.pagingToolbar;
+ if (toolbar) {
+ listHeight -= toolbar.getHeight();
}
}
- };
-};
+ me.setElementSize(owner.listEl, null, listHeight);
+ me.callParent(arguments);
+ }
+});
-Ext.WindowMgr = new Ext.WindowGroup();
-Ext.MessageBox = function(){
- var dlg, opt, mask, waitTimer,
- bodyEl, msgEl, textboxEl, textareaEl, progressBar, pp, iconEl, spacerEl,
- buttons, activeTextEl, bwidth, bufferIcon = '', iconCls = '',
- buttonNames = ['ok', 'yes', 'no', 'cancel'];
+Ext.define('Ext.toolbar.TextItem', {
+ extend: 'Ext.toolbar.Item',
+ requires: ['Ext.XTemplate'],
+ alias: 'widget.tbtext',
+ alternateClassName: 'Ext.Toolbar.TextItem',
- var handleButton = function(button){
- buttons[button].blur();
- if(dlg.isVisible()){
- dlg.hide();
- handleHide();
- Ext.callback(opt.fn, opt.scope||window, [button, activeTextEl.dom.value, opt], 1);
- }
- };
-
- var handleHide = function(){
- if(opt && opt.cls){
- dlg.el.removeClass(opt.cls);
- }
- progressBar.reset();
- };
+ text: '',
+
+ renderTpl: '{text}',
+
+ baseCls: Ext.baseCSSPrefix + 'toolbar-text',
+
+ onRender : function() {
+ Ext.apply(this.renderData, {
+ text: this.text
+ });
+ this.callParent(arguments);
+ },
- var handleEsc = function(d, k, e){
- if(opt && opt.closable !== false){
- dlg.hide();
- handleHide();
+ setText : function(t) {
+ if (this.rendered) {
+ this.el.update(t);
+ this.ownerCt.doLayout();
+ } else {
+ this.text = t;
}
- if(e){
- e.stopEvent();
+ }
+});
+
+Ext.define('Ext.form.field.Trigger', {
+ extend:'Ext.form.field.Text',
+ alias: ['widget.triggerfield', 'widget.trigger'],
+ requires: ['Ext.core.DomHelper', 'Ext.util.ClickRepeater', 'Ext.layout.component.field.Trigger'],
+ alternateClassName: ['Ext.form.TriggerField', 'Ext.form.TwinTriggerField', 'Ext.form.Trigger'],
+
+ fieldSubTpl: [
+ 'name="{name}" ',
+ 'size="{size}" ',
+ 'tabIndex="{tabIdx}" ',
+ 'class="{fieldCls} {typeCls}" autocomplete="off" />',
+ '
'
- });
- iconEl = Ext.get(bodyEl.dom.firstChild);
- var contentEl = bodyEl.dom.childNodes[1];
- msgEl = Ext.get(contentEl.firstChild);
- textboxEl = Ext.get(contentEl.childNodes[2].firstChild);
- textboxEl.enableDisplayMode();
- textboxEl.addKeyListener([10,13], function(){
- if(dlg.isVisible() && opt && opt.buttons){
- if(opt.buttons.ok){
- handleButton("ok");
- }else if(opt.buttons.yes){
- handleButton("yes");
- }
- }
- });
- textareaEl = Ext.get(contentEl.childNodes[2].childNodes[1]);
- textareaEl.enableDisplayMode();
- progressBar = new Ext.ProgressBar({
- renderTo:bodyEl
- });
- bodyEl.createChild({cls:'x-clear'});
- }
- return dlg;
- },
+
+ triggerBaseCls: Ext.baseCSSPrefix + 'form-trigger',
-
- updateText : function(text){
- if(!dlg.isVisible() && !opt.width){
- dlg.setSize(this.maxWidth, 100);
- }
-
- msgEl.update(text ? text + ' ' : ' ');
+
+ triggerWrapCls: Ext.baseCSSPrefix + 'form-trigger-wrap',
- var iw = iconCls != '' ? (iconEl.getWidth() + iconEl.getMargins('lr')) : 0,
- mw = msgEl.getWidth() + msgEl.getMargins('lr'),
- fw = dlg.getFrameWidth('lr'),
- bw = dlg.body.getFrameWidth('lr'),
- w;
-
- w = Math.max(Math.min(opt.width || iw+mw+fw+bw, opt.maxWidth || this.maxWidth),
- Math.max(opt.minWidth || this.minWidth, bwidth || 0));
+
+ hideTrigger: false,
- if(opt.prompt === true){
- activeTextEl.setWidth(w-iw-fw-bw);
- }
- if(opt.progress === true || opt.wait === true){
- progressBar.setSize(w-iw-fw-bw);
- }
- if(Ext.isIE && w == bwidth){
- w += 4;
- }
- msgEl.update(text || ' ');
- dlg.setSize(w, 'auto').center();
- return this;
- },
+
+ editable: true,
-
- updateProgress : function(value, progressText, msg){
- progressBar.updateProgress(value, progressText);
- if(msg){
- this.updateText(msg);
- }
- return this;
- },
+
+ readOnly: false,
-
- isVisible : function(){
- return dlg && dlg.isVisible();
- },
+
-
- hide : function(){
- var proxy = dlg ? dlg.activeGhost : null;
- if(this.isVisible() || proxy){
- dlg.hide();
- handleHide();
- if (proxy){
-
-
- dlg.unghost(false, false);
- }
- }
- return this;
- },
+
+ repeatTriggerClick: false,
-
- show : function(options){
- if(this.isVisible()){
- this.hide();
- }
- opt = options;
- var d = this.getDialog(opt.title || " ");
- d.setTitle(opt.title || " ");
- var allowClose = (opt.closable !== false && opt.progress !== true && opt.wait !== true);
- d.tools.close.setDisplayed(allowClose);
- activeTextEl = textboxEl;
- opt.prompt = opt.prompt || (opt.multiline ? true : false);
- if(opt.prompt){
- if(opt.multiline){
- textboxEl.hide();
- textareaEl.show();
- textareaEl.setHeight(Ext.isNumber(opt.multiline) ? opt.multiline : this.defaultTextHeight);
- activeTextEl = textareaEl;
- }else{
- textboxEl.show();
- textareaEl.hide();
- }
- }else{
- textboxEl.hide();
- textareaEl.hide();
- }
- activeTextEl.dom.value = opt.value || "";
- if(opt.prompt){
- d.focusEl = activeTextEl;
- }else{
- var bs = opt.buttons;
- var db = null;
- if(bs && bs.ok){
- db = buttons["ok"];
- }else if(bs && bs.yes){
- db = buttons["yes"];
- }
- if (db){
- d.focusEl = db;
- }
- }
- if(Ext.isDefined(opt.iconCls)){
- d.setIconClass(opt.iconCls);
- }
- this.setIcon(Ext.isDefined(opt.icon) ? opt.icon : bufferIcon);
- bwidth = updateButtons(opt.buttons);
- progressBar.setVisible(opt.progress === true || opt.wait === true);
- this.updateProgress(0, opt.progressText);
- this.updateText(opt.msg);
- if(opt.cls){
- d.el.addClass(opt.cls);
- }
- d.proxyDrag = opt.proxyDrag === true;
- d.modal = opt.modal !== false;
- d.mask = opt.modal !== false ? mask : false;
- if(!d.isVisible()){
-
- document.body.appendChild(dlg.el.dom);
- d.setAnimateTarget(opt.animEl);
-
- d.on('show', function(){
- if(allowClose === true){
- d.keyMap.enable();
- }else{
- d.keyMap.disable();
- }
- }, this, {single:true});
- d.show(opt.animEl);
- }
- if(opt.wait === true){
- progressBar.wait(opt.waitConfig);
- }
- return this;
- },
+
+ autoSize: Ext.emptyFn,
+
+ monitorTab: true,
+
+ mimicing: false,
+
+ triggerIndexRe: /trigger-index-(\d+)/,
-
- setIcon : function(icon){
- if(!dlg){
- bufferIcon = icon;
- return;
- }
- bufferIcon = undefined;
- if(icon && icon != ''){
- iconEl.removeClass('x-hidden');
- iconEl.replaceClass(iconCls, icon);
- bodyEl.addClass('x-dlg-icon');
- iconCls = icon;
- }else{
- iconEl.replaceClass(iconCls, 'x-hidden');
- bodyEl.removeClass('x-dlg-icon');
- iconCls = '';
- }
- return this;
- },
+ componentLayout: 'triggerfield',
-
- progress : function(title, msg, progressText){
- this.show({
- title : title,
- msg : msg,
- buttons: false,
- progress:true,
- closable:false,
- minWidth: this.minProgressWidth,
- progressText: progressText
- });
- return this;
- },
+ initComponent: function() {
+ this.wrapFocusCls = this.triggerWrapCls + '-focus';
+ this.callParent(arguments);
+ },
-
- wait : function(msg, title, config){
- this.show({
- title : title,
- msg : msg,
- buttons: false,
- closable:false,
- wait:true,
- modal:true,
- minWidth: this.minProgressWidth,
- waitConfig: config
- });
- return this;
- },
+
+ onRender: function(ct, position) {
+ var me = this,
+ triggerCls,
+ triggerBaseCls = me.triggerBaseCls,
+ triggerWrapCls = me.triggerWrapCls,
+ triggerConfigs = [],
+ i;
- alert : function(title, msg, fn, scope){
- this.show({
- title : title,
- msg : msg,
- buttons: this.OK,
- fn: fn,
- scope : scope,
- minWidth: this.minWidth
- });
- return this;
- },
-
- confirm : function(title, msg, fn, scope){
- this.show({
- title : title,
- msg : msg,
- buttons: this.YESNO,
- fn: fn,
- scope : scope,
- icon: this.QUESTION,
- minWidth: this.minWidth
- });
- return this;
- },
+
+
+ if (!me.trigger1Cls) {
+ me.trigger1Cls = me.triggerCls;
+ }
- prompt : function(title, msg, fn, scope, multiline, value){
- this.show({
- title : title,
- msg : msg,
- buttons: this.OKCANCEL,
- fn: fn,
- minWidth: this.minPromptWidth,
- scope : scope,
- prompt:true,
- multiline: multiline,
- value: value
+ for (i = 0; (triggerCls = me['trigger' + (i + 1) + 'Cls']) || i < 1; i++) {
+ triggerConfigs.push({
+ cls: [Ext.baseCSSPrefix + 'trigger-index-' + i, triggerBaseCls, triggerCls].join(' '),
+ role: 'button'
});
- return this;
- },
+ }
+ triggerConfigs[i - 1].cls += ' ' + triggerBaseCls + '-last';
-
- OK : {ok:true},
-
- CANCEL : {cancel:true},
-
- OKCANCEL : {ok:true, cancel:true},
-
- YESNO : {yes:true, no:true},
-
- YESNOCANCEL : {yes:true, no:true, cancel:true},
-
- INFO : 'ext-mb-info',
-
- WARNING : 'ext-mb-warning',
-
- QUESTION : 'ext-mb-question',
-
- ERROR : 'ext-mb-error',
+ Ext.applyIf(me.renderSelectors, {
+
+ triggerWrap: '.' + triggerWrapCls
+ });
+ Ext.applyIf(me.subTplData, {
+ triggerWrapCls: triggerWrapCls,
+ triggerEl: Ext.core.DomHelper.markup(triggerConfigs),
+ clearCls: me.clearCls
+ });
+
+ me.callParent(arguments);
- defaultTextHeight : 75,
-
- maxWidth : 600,
-
- minWidth : 100,
-
- minProgressWidth : 250,
-
- minPromptWidth: 250,
-
- buttonText : {
- ok : "OK",
- cancel : "Cancel",
- yes : "Yes",
- no : "No"
- }
- };
-}();
+ me.triggerEl = Ext.select('.' + triggerBaseCls, true, me.triggerWrap.dom);
+ me.doc = Ext.isIE ? Ext.getBody() : Ext.getDoc();
+ me.initTrigger();
+ },
-Ext.Msg = Ext.MessageBox;
-Ext.dd.PanelProxy = Ext.extend(Object, {
+ onEnable: function() {
+ this.callParent();
+ this.triggerWrap.unmask();
+ },
- constructor : function(panel, config){
- this.panel = panel;
- this.id = this.panel.id +'-ddproxy';
- Ext.apply(this, config);
+ onDisable: function() {
+ this.callParent();
+ this.triggerWrap.mask();
},
+ afterRender: function() {
+ this.callParent();
+ this.updateEditState();
+ },
+
+ updateEditState: function() {
+ var me = this,
+ inputEl = me.inputEl,
+ triggerWrap = me.triggerWrap,
+ noeditCls = Ext.baseCSSPrefix + 'trigger-noedit',
+ displayed,
+ readOnly;
+
+ if (me.rendered) {
+ if (me.readOnly) {
+ inputEl.addCls(noeditCls);
+ readOnly = true;
+ displayed = false;
+ } else {
+ if (me.editable) {
+ inputEl.removeCls(noeditCls);
+ readOnly = false;
+ } else {
+ inputEl.addCls(noeditCls);
+ readOnly = true;
+ }
+ displayed = !me.hideTrigger;
+ }
+
+ triggerWrap.setDisplayed(displayed);
+ inputEl.dom.readOnly = readOnly;
+ me.doComponentLayout();
+ }
+ },
+
- insertProxy : true,
+ getTriggerWidth: function() {
+ var me = this,
+ triggerWrap = me.triggerWrap,
+ totalTriggerWidth = 0;
+ if (triggerWrap && !me.hideTrigger && !me.readOnly) {
+ me.triggerEl.each(function(trigger) {
+ totalTriggerWidth += trigger.getWidth();
+ });
+ totalTriggerWidth += me.triggerWrap.getFrameWidth('lr');
+ }
+ return totalTriggerWidth;
+ },
+
+ setHideTrigger: function(hideTrigger) {
+ if (hideTrigger != this.hideTrigger) {
+ this.hideTrigger = hideTrigger;
+ this.updateEditState();
+ }
+ },
- setStatus : Ext.emptyFn,
- reset : Ext.emptyFn,
- update : Ext.emptyFn,
- stop : Ext.emptyFn,
- sync: Ext.emptyFn,
+ setEditable: function(editable) {
+ if (editable != this.editable) {
+ this.editable = editable;
+ this.updateEditState();
+ }
+ },
- getEl : function(){
- return this.ghost;
+ setReadOnly: function(readOnly) {
+ if (readOnly != this.readOnly) {
+ this.readOnly = readOnly;
+ this.updateEditState();
+ }
},
- getGhost : function(){
- return this.ghost;
+ initTrigger: function() {
+ var me = this,
+ triggerWrap = me.triggerWrap,
+ triggerEl = me.triggerEl;
+
+ if (me.repeatTriggerClick) {
+ me.triggerRepeater = Ext.create('Ext.util.ClickRepeater', triggerWrap, {
+ preventDefault: true,
+ handler: function(cr, e) {
+ me.onTriggerWrapClick(e);
+ }
+ });
+ } else {
+ me.mon(me.triggerWrap, 'click', me.onTriggerWrapClick, me);
+ }
+
+ triggerEl.addClsOnOver(me.triggerBaseCls + '-over');
+ triggerEl.each(function(el, c, i) {
+ el.addClsOnOver(me['trigger' + (i + 1) + 'Cls'] + '-over');
+ });
+ triggerEl.addClsOnClick(me.triggerBaseCls + '-click');
+ triggerEl.each(function(el, c, i) {
+ el.addClsOnClick(me['trigger' + (i + 1) + 'Cls'] + '-click');
+ });
},
- getProxy : function(){
- return this.proxy;
+ onDestroy: function() {
+ var me = this;
+ Ext.destroyMembers(me, 'triggerRepeater', 'triggerWrap', 'triggerEl');
+ delete me.doc;
+ me.callParent();
},
- hide : function(){
- if(this.ghost){
- if(this.proxy){
- this.proxy.remove();
- delete this.proxy;
+ onFocus: function() {
+ var me = this;
+ this.callParent();
+ if (!me.mimicing) {
+ me.bodyEl.addCls(me.wrapFocusCls);
+ me.mimicing = true;
+ me.mon(me.doc, 'mousedown', me.mimicBlur, me, {
+ delay: 10
+ });
+ if (me.monitorTab) {
+ me.on('specialkey', me.checkTab, me);
}
- this.panel.el.dom.style.display = '';
- this.ghost.remove();
- delete this.ghost;
}
},
- show : function(){
- if(!this.ghost){
- this.ghost = this.panel.createGhost(this.panel.initialConfig.cls, undefined, Ext.getBody());
- this.ghost.setXY(this.panel.el.getXY());
- if(this.insertProxy){
- this.proxy = this.panel.el.insertSibling({cls:'x-panel-dd-spacer'});
- this.proxy.setSize(this.panel.getSize());
- }
- this.panel.el.dom.style.display = 'none';
+ checkTab: function(me, e) {
+ if (!this.ignoreMonitorTab && e.getKey() == e.TAB) {
+ this.triggerBlur();
}
},
- repair : function(xy, callback, scope){
- this.hide();
- if(typeof callback == "function"){
- callback.call(scope || this);
+ onBlur: Ext.emptyFn,
+
+
+ mimicBlur: function(e) {
+ if (!this.isDestroyed && !this.bodyEl.contains(e.target) && this.validateBlur(e)) {
+ this.triggerBlur();
}
},
- moveProxy : function(parentNode, before){
- if(this.proxy){
- parentNode.insertBefore(this.proxy.dom, before);
+ triggerBlur: function() {
+ var me = this;
+ me.mimicing = false;
+ me.mun(me.doc, 'mousedown', me.mimicBlur, me);
+ if (me.monitorTab && me.inputEl) {
+ me.un('specialkey', me.checkTab, me);
}
- }
-});
+ Ext.form.field.Trigger.superclass.onBlur.call(me);
+ if (me.bodyEl) {
+ me.bodyEl.removeCls(me.wrapFocusCls);
+ }
+ },
+ beforeBlur: Ext.emptyFn,
-Ext.Panel.DD = Ext.extend(Ext.dd.DragSource, {
- constructor : function(panel, cfg){
- this.panel = panel;
- this.dragData = {panel: panel};
- this.proxy = new Ext.dd.PanelProxy(panel, cfg);
- Ext.Panel.DD.superclass.constructor.call(this, panel.el, cfg);
- var h = panel.header,
- el = panel.body;
- if(h){
- this.setHandleElId(h.id);
- el = panel.header;
- }
- el.setStyle('cursor', 'move');
- this.scroll = false;
- },
- showFrame: Ext.emptyFn,
- startDrag: Ext.emptyFn,
- b4StartDrag: function(x, y) {
- this.proxy.show();
- },
- b4MouseDown: function(e) {
- var x = e.getPageX(),
- y = e.getPageY();
- this.autoOffset(x, y);
- },
- onInitDrag : function(x, y){
- this.onStartDrag(x, y);
+ validateBlur: function(e) {
return true;
},
- createFrame : Ext.emptyFn,
- getDragEl : function(e){
- return this.proxy.ghost.dom;
- },
- endDrag : function(e){
- this.proxy.hide();
- this.panel.saveState();
- },
- autoOffset : function(x, y) {
- x -= this.startPageX;
- y -= this.startPageY;
- this.setDelta(x, y);
- }
-});
-Ext.state.Provider = Ext.extend(Ext.util.Observable, {
- constructor : function(){
-
- this.addEvents("statechange");
- this.state = {};
- Ext.state.Provider.superclass.constructor.call(this);
- },
- get : function(name, defaultValue){
- return typeof this.state[name] == "undefined" ?
- defaultValue : this.state[name];
+ onTriggerWrapClick: function(e) {
+ var me = this,
+ t = e && e.getTarget('.' + Ext.baseCSSPrefix + 'form-trigger', null),
+ match = t && t.className.match(me.triggerIndexRe),
+ idx,
+ triggerClickMethod;
+
+ if (match && !me.readOnly) {
+ idx = parseInt(match[1], 10);
+ triggerClickMethod = me['onTrigger' + (idx + 1) + 'Click'] || me.onTriggerClick;
+ if (triggerClickMethod) {
+ triggerClickMethod.call(me, e);
+ }
+ }
},
- clear : function(name){
- delete this.state[name];
- this.fireEvent("statechange", this, name, null);
- },
+ onTriggerClick: Ext.emptyFn
- set : function(name, value){
- this.state[name] = value;
- this.fireEvent("statechange", this, name, value);
- },
+
+
+});
+
+
+Ext.define('Ext.form.field.Picker', {
+ extend: 'Ext.form.field.Trigger',
+ alias: 'widget.pickerfield',
+ alternateClassName: 'Ext.form.Picker',
+ requires: ['Ext.util.KeyNav'],
- decodeValue : function(cookie){
-
- var re = /^(a|n|d|b|s|o|e)\:(.*)$/,
- matches = re.exec(unescape(cookie)),
- all,
- type,
- v,
- kv;
- if(!matches || !matches[1]){
- return;
- }
- type = matches[1];
- v = matches[2];
- switch(type){
- case 'e':
- return null;
- case 'n':
- return parseFloat(v);
- case 'd':
- return new Date(Date.parse(v));
- case 'b':
- return (v == '1');
- case 'a':
- all = [];
- if(v != ''){
- Ext.each(v.split('^'), function(val){
- all.push(this.decodeValue(val));
- }, this);
- }
- return all;
- case 'o':
- all = {};
- if(v != ''){
- Ext.each(v.split('^'), function(val){
- kv = val.split('=');
- all[kv[0]] = this.decodeValue(kv[1]);
- }, this);
- }
- return all;
- default:
- return v;
- }
- },
+ matchFieldWidth: true,
- encodeValue : function(v){
- var enc,
- flat = '',
- i = 0,
- len,
- key;
- if(v == null){
- return 'e:1';
- }else if(typeof v == 'number'){
- enc = 'n:' + v;
- }else if(typeof v == 'boolean'){
- enc = 'b:' + (v ? '1' : '0');
- }else if(Ext.isDate(v)){
- enc = 'd:' + v.toGMTString();
- }else if(Ext.isArray(v)){
- for(len = v.length; i < len; i++){
- flat += this.encodeValue(v[i]);
- if(i != len - 1){
- flat += '^';
- }
- }
- enc = 'a:' + flat;
- }else if(typeof v == 'object'){
- for(key in v){
- if(typeof v[key] != 'function' && v[key] !== undefined){
- flat += key + '=' + this.encodeValue(v[key]) + '^';
- }
- }
- enc = 'o:' + flat.substring(0, flat.length-1);
- }else{
- enc = 's:' + v;
- }
- return escape(enc);
- }
-});
+ pickerAlign: 'tl-bl?',
-Ext.state.Manager = function(){
- var provider = new Ext.state.Provider();
+
- return {
-
- setProvider : function(stateProvider){
- provider = stateProvider;
- },
+
+ openCls: Ext.baseCSSPrefix + 'pickerfield-open',
+
+
+
+
+ editable: true,
+
+
+ initComponent: function() {
+ this.callParent();
- get : function(key, defaultValue){
- return provider.get(key, defaultValue);
- },
+ this.addEvents(
+
+ 'expand',
+
+ 'collapse',
+
+ 'select'
+ );
+ },
+
+
+ initEvents: function() {
+ var me = this;
+ me.callParent();
- set : function(key, value){
- provider.set(key, value);
- },
+ me.keyNav = Ext.create('Ext.util.KeyNav', me.inputEl, {
+ down: function() {
+ if (!me.isExpanded) {
+
+
+ me.onTriggerClick();
+ }
+ },
+ esc: me.collapse,
+ scope: me,
+ forceKeyDown: true
+ });
- clear : function(key){
- provider.clear(key);
- },
+ if (!me.editable) {
+ me.mon(me.inputEl, 'click', me.onTriggerClick, me);
+ }
- getProvider : function(){
- return provider;
+ if (Ext.isGecko) {
+ me.inputEl.dom.setAttribute('autocomplete', 'off');
}
- };
-}();
+ },
+
-Ext.state.CookieProvider = Ext.extend(Ext.state.Provider, {
- constructor : function(config){
- Ext.state.CookieProvider.superclass.constructor.call(this);
- this.path = "/";
- this.expires = new Date(new Date().getTime()+(1000*60*60*24*7));
- this.domain = null;
- this.secure = false;
- Ext.apply(this, config);
- this.state = this.readCookies();
+ expand: function() {
+ var me = this,
+ bodyEl, picker, collapseIf;
+
+ if (me.rendered && !me.isExpanded && !me.isDestroyed) {
+ bodyEl = me.bodyEl;
+ picker = me.getPicker();
+ collapseIf = me.collapseIf;
+
+
+ picker.show();
+ me.isExpanded = true;
+ me.alignPicker();
+ bodyEl.addCls(me.openCls);
+
+
+ me.mon(Ext.getDoc(), {
+ mousewheel: collapseIf,
+ mousedown: collapseIf,
+ scope: me
+ });
+
+ me.fireEvent('expand', me);
+ me.onExpand();
+ }
},
+
+ onExpand: Ext.emptyFn,
+
+ alignPicker: function() {
+ var me = this,
+ picker, isAbove,
+ aboveSfx = '-above';
+
+ if (this.isExpanded) {
+ picker = me.getPicker();
+ if (me.matchFieldWidth) {
+
+ picker.setSize(me.bodyEl.getWidth(), picker.store && picker.store.getCount() ? null : 0);
+ }
+ if (picker.isFloating()) {
+ picker.alignTo(me.inputEl, me.pickerAlign, me.pickerOffset);
+
+
+
+ isAbove = picker.el.getY() < me.inputEl.getY();
+ me.bodyEl[isAbove ? 'addCls' : 'removeCls'](me.openCls + aboveSfx);
+ picker.el[isAbove ? 'addCls' : 'removeCls'](picker.baseCls + aboveSfx);
+ }
+ }
+ },
+
- set : function(name, value){
- if(typeof value == "undefined" || value === null){
- this.clear(name);
- return;
+ collapse: function() {
+ if (this.isExpanded && !this.isDestroyed) {
+ var me = this,
+ openCls = me.openCls,
+ picker = me.picker,
+ doc = Ext.getDoc(),
+ collapseIf = me.collapseIf,
+ aboveSfx = '-above';
+
+
+ picker.hide();
+ me.isExpanded = false;
+
+
+ me.bodyEl.removeCls([openCls, openCls + aboveSfx]);
+ picker.el.removeCls(picker.baseCls + aboveSfx);
+
+
+ doc.un('mousewheel', collapseIf, me);
+ doc.un('mousedown', collapseIf, me);
+
+ me.fireEvent('collapse', me);
+ me.onCollapse();
}
- this.setCookie(name, value);
- Ext.state.CookieProvider.superclass.set.call(this, name, value);
},
+ onCollapse: Ext.emptyFn,
+
+
- clear : function(name){
- this.clearCookie(name);
- Ext.state.CookieProvider.superclass.clear.call(this, name);
+ collapseIf: function(e) {
+ var me = this;
+ if (!me.isDestroyed && !e.within(me.bodyEl, false, true) && !e.within(me.picker.el, false, true)) {
+ me.collapse();
+ }
},
- readCookies : function(){
- var cookies = {},
- c = document.cookie + ";",
- re = /\s?(.*?)=(.*?);/g,
- matches,
- name,
- value;
- while((matches = re.exec(c)) != null){
- name = matches[1];
- value = matches[2];
- if(name && name.substring(0,3) == "ys-"){
- cookies[name.substr(3)] = this.decodeValue(value);
+ getPicker: function() {
+ var me = this;
+ return me.picker || (me.picker = me.createPicker());
+ },
+
+
+ createPicker: Ext.emptyFn,
+
+
+ onTriggerClick: function() {
+ var me = this;
+ if (!me.readOnly && !me.disabled) {
+ if (me.isExpanded) {
+ me.collapse();
+ } else {
+ me.expand();
}
+ me.inputEl.focus();
}
- return cookies;
},
-
- setCookie : function(name, value){
- document.cookie = "ys-"+ name + "=" + this.encodeValue(value) +
- ((this.expires == null) ? "" : ("; expires=" + this.expires.toGMTString())) +
- ((this.path == null) ? "" : ("; path=" + this.path)) +
- ((this.domain == null) ? "" : ("; domain=" + this.domain)) +
- ((this.secure == true) ? "; secure" : "");
+ mimicBlur: function(e) {
+ var me = this,
+ picker = me.picker;
+
+ if (!picker || !e.within(picker.el, false, true)) {
+ me.callParent(arguments);
+ }
},
-
- clearCookie : function(name){
- document.cookie = "ys-" + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" +
- ((this.path == null) ? "" : ("; path=" + this.path)) +
- ((this.domain == null) ? "" : ("; domain=" + this.domain)) +
- ((this.secure == true) ? "; secure" : "");
+ onDestroy : function(){
+ var me = this;
+ Ext.destroy(me.picker, me.keyNav);
+ me.callParent();
}
+
});
-Ext.DataView = Ext.extend(Ext.BoxComponent, {
-
-
-
-
-
-
-
-
-
- selectedClass : "x-view-selected",
+
+
+
+Ext.define('Ext.form.field.Spinner', {
+ extend: 'Ext.form.field.Trigger',
+ alias: 'widget.spinnerfield',
+ alternateClassName: 'Ext.form.Spinner',
+ requires: ['Ext.util.KeyNav'],
+
+ trigger1Cls: Ext.baseCSSPrefix + 'form-spinner-up',
+ trigger2Cls: Ext.baseCSSPrefix + 'form-spinner-down',
+
- emptyText : "",
+ spinUpEnabled: true,
- deferEmptyText: true,
+ spinDownEnabled: true,
+
- trackOver: false,
+ keyNavEnabled: true,
+
+ mouseWheelEnabled: true,
+
- blockRefresh: false,
+ repeatTriggerClick: true,
- last: false,
+ onSpinUp: Ext.emptyFn,
- initComponent : function(){
- Ext.DataView.superclass.initComponent.call(this);
- if(Ext.isString(this.tpl) || Ext.isArray(this.tpl)){
- this.tpl = new Ext.XTemplate(this.tpl);
- }
+ onSpinDown: Ext.emptyFn,
+
+ initComponent: function() {
+ this.callParent();
this.addEvents(
- "beforeclick",
-
- "click",
-
- "mouseenter",
-
- "mouseleave",
-
- "containerclick",
-
- "dblclick",
-
- "contextmenu",
-
- "containercontextmenu",
+ 'spin',
+
- "selectionchange",
+ 'spinup',
- "beforeselect"
+ 'spindown'
);
-
- 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);
+ onRender: function() {
+ var me = this,
+ triggers;
- this.mon(this.getTemplateTarget(), {
- "click": this.onClick,
- "dblclick": this.onDblClick,
- "contextmenu": this.onContextMenu,
- scope:this
- });
+ me.callParent(arguments);
+ triggers = me.triggerEl;
+
+
+ me.spinUpEl = triggers.item(0);
+
+ me.spinDownEl = triggers.item(1);
+
+
+ me.setSpinUpEnabled(me.spinUpEnabled);
+ me.setSpinDownEnabled(me.spinDownEnabled);
- if(this.overClass || this.trackOver){
- this.mon(this.getTemplateTarget(), {
- "mouseover": this.onMouseOver,
- "mouseout": this.onMouseOut,
- scope:this
+
+ if (me.keyNavEnabled) {
+ me.spinnerKeyNav = Ext.create('Ext.util.KeyNav', me.inputEl, {
+ scope: me,
+ up: me.spinUp,
+ down: me.spinDown
});
}
- if(this.store){
- this.bindStore(this.store, true);
+
+ if (me.mouseWheelEnabled) {
+ me.mon(me.bodyEl, 'mousewheel', me.onMouseWheel, me);
}
},
- 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;
+ getTriggerWidth: function() {
+ return this.hideTrigger || this.readOnly ? 0 : this.spinUpEl.getWidth() + this.triggerWrap.getFrameWidth('lr');
},
- getTemplateTarget: function(){
- return this.el;
+
+ onTrigger1Click: function() {
+ this.spinUp();
},
- prepareData : function(data){
- return data;
+ onTrigger2Click: function() {
+ this.spinDown();
},
- 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]);
+ spinUp: function() {
+ var me = this;
+ if (me.spinUpEnabled && !me.disabled) {
+ me.fireEvent('spin', me, 'up');
+ me.fireEvent('spinup', me);
+ me.onSpinUp();
}
- return r;
},
- bufferRender : function(records, index){
- var div = document.createElement('div');
- this.tpl.overwrite(div, this.collectData(records, index));
- return Ext.query(this.itemSelector, div);
+ spinDown: function() {
+ var me = this;
+ if (me.spinDownEnabled && !me.disabled) {
+ me.fireEvent('spin', me, 'down');
+ me.fireEvent('spindown', me);
+ me.onSpinDown();
+ }
},
- onUpdate : function(ds, record){
- var index = this.store.indexOf(record);
- if(index > -1){
- var sel = this.isSelected(index),
- original = this.all.elements[index],
- node = this.bufferRender([record], index)[0];
-
- this.all.replaceElement(index, node, true);
- if(sel){
- this.selected.replaceElement(original, node);
- this.all.item(index).addClass(this.selectedClass);
- }
- this.updateIndexes(index, index);
+ setSpinUpEnabled: function(enabled) {
+ var me = this,
+ wasEnabled = me.spinUpEnabled;
+ me.spinUpEnabled = enabled;
+ if (wasEnabled !== enabled && me.rendered) {
+ me.spinUpEl[enabled ? 'removeCls' : 'addCls'](me.trigger1Cls + '-disabled');
}
},
- onAdd : function(ds, records, index){
- if(this.all.getCount() === 0){
- this.refresh();
- return;
- }
- var nodes = this.bufferRender(records, index), n, a = this.all.elements;
- if(index < this.all.getCount()){
- n = this.all.item(index).insertSibling(nodes, 'before', true);
- a.splice.apply(a, [index, 0].concat(nodes));
- }else{
- n = this.all.last().insertSibling(nodes, 'after', true);
- a.push.apply(a, nodes);
+ setSpinDownEnabled: function(enabled) {
+ var me = this,
+ wasEnabled = me.spinDownEnabled;
+ me.spinDownEnabled = enabled;
+ if (wasEnabled !== enabled && me.rendered) {
+ me.spinDownEl[enabled ? 'removeCls' : 'addCls'](me.trigger2Cls + '-disabled');
}
- this.updateIndexes(index);
},
- onRemove : function(ds, record, index){
- this.deselect(index);
- this.all.removeElement(index, true);
- this.updateIndexes(index);
- if (this.store.getCount() === 0){
- this.refresh();
+ onMouseWheel: function(e) {
+ var me = this,
+ delta;
+ if (me.hasFocus) {
+ delta = e.getWheelDelta();
+ if (delta > 0) {
+ me.spinUp();
+ }
+ else if (delta < 0) {
+ me.spinDown();
+ }
+ e.stopEvent();
}
},
-
- refreshNode : function(index){
- this.onUpdate(this.store, this.store.getAt(index));
- },
+ onDestroy: function() {
+ Ext.destroyMembers(this, 'spinnerKeyNav', 'spinUpEl', 'spinDownEl');
+ this.callParent();
+ }
+
+});
+
+Ext.define('Ext.form.field.Number', {
+ extend:'Ext.form.field.Spinner',
+ alias: 'widget.numberfield',
+ alternateClassName: ['Ext.form.NumberField', 'Ext.form.Number'],
- updateIndexes : function(startIndex, endIndex){
- var ns = this.all.elements;
- startIndex = startIndex || 0;
- endIndex = endIndex || ((endIndex === 0) ? 0 : (ns.length - 1));
- for(var i = startIndex; i <= endIndex; i++){
- ns[i].viewIndex = i;
- }
- },
+
- getStore : function(){
- return this.store;
- },
+ allowDecimals : true,
- bindStore : function(store, initial){
- if(!initial && this.store){
- if(store !== this.store && this.store.autoDestroy){
- this.store.destroy();
- }else{
- this.store.un("beforeload", this.onBeforeLoad, this);
- this.store.un("datachanged", this.onDataChanged, this);
- 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();
- }
- },
+ decimalSeparator : '.',
+
+ decimalPrecision : 2,
+
- onDataChanged: function() {
- if (this.blockRefresh !== true) {
- this.refresh.apply(this, arguments);
- }
- },
+ minValue: Number.NEGATIVE_INFINITY,
- findItemFromChild : function(node){
- return Ext.fly(node).findParent(this.itemSelector, this.getTemplateTarget());
- },
+ maxValue: Number.MAX_VALUE,
- 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);
- }
- }
- },
+ step: 1,
- onContainerClick : function(e){
- this.clearSelections();
- },
+
+ minText : 'The minimum value for this field is {0}',
- 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);
- }
- },
+ maxText : 'The maximum value for this field is {0}',
- onDblClick : function(e){
- var item = e.getTarget(this.itemSelector, this.getTemplateTarget());
- if(item){
- this.fireEvent("dblclick", this, this.indexOf(item), item, e);
- }
- },
+ nanText : '{0} is not a valid number',
- 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);
- }
- },
+ negativeText : 'The value cannot be negative',
- 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;
- }
- }
- },
+ baseChars : '0123456789',
- onItemClick : function(item, index, e){
- if(this.fireEvent("beforeclick", this, index, item, e) === false){
- return false;
+ autoStripChars: false,
+
+ initComponent: function() {
+ var me = this,
+ allowed;
+
+ this.callParent();
+
+ me.setMinValue(me.minValue);
+ me.setMaxValue(me.maxValue);
+
+
+ allowed = me.baseChars + '';
+ if (me.allowDecimals) {
+ allowed += me.decimalSeparator;
}
- if(this.multiSelect){
- this.doMultiSelection(item, index, e);
- e.preventDefault();
- }else if(this.singleSelect){
- this.doSingleSelection(item, index, e);
- e.preventDefault();
+ if (me.minValue < 0) {
+ allowed += '-';
+ }
+ allowed = Ext.String.escapeRegex(allowed);
+ me.maskRe = new RegExp('[' + allowed + ']');
+ if (me.autoStripChars) {
+ me.stripCharsRe = new RegExp('[^' + allowed + ']', 'gi');
}
- return true;
},
- doSingleSelection : function(item, index, e){
- if(e.ctrlKey && this.isSelected(index)){
- this.deselect(index);
- }else{
- this.select(index, false);
+ getErrors: function(value) {
+ var me = this,
+ errors = me.callParent(arguments),
+ format = Ext.String.format,
+ num;
+
+ value = Ext.isDefined(value) ? value : this.processRawValue(this.getRawValue());
+
+ if (value.length < 1) {
+ return errors;
}
- },
-
- doMultiSelection : function(item, index, e){
- if(e.shiftKey && this.last !== false){
- var last = this.last;
- this.selectRange(last, index, e.ctrlKey);
- this.last = last;
- }else{
- if((e.ctrlKey||this.simpleSelect) && this.isSelected(index)){
- this.deselect(index);
- }else{
- this.select(index, e.ctrlKey || e.shiftKey || this.simpleSelect);
- }
+ value = String(value).replace(me.decimalSeparator, '.');
+
+ if(isNaN(value)){
+ errors.push(format(me.nanText, value));
}
- },
-
- getSelectionCount : function(){
- return this.selected.getCount();
- },
+ num = me.parseValue(value);
-
- getSelectedNodes : function(){
- return this.selected.elements;
- },
+ if (me.minValue === 0 && num < 0) {
+ errors.push(this.negativeText);
+ }
+ else if (num < me.minValue) {
+ errors.push(format(me.minText, me.minValue));
+ }
-
- getSelectedIndexes : function(){
- var indexes = [],
- selected = this.selected.elements,
- i = 0,
- len = selected.length;
-
- for(; i < len; i++){
- indexes.push(selected[i].viewIndex);
+ if (num > me.maxValue) {
+ errors.push(format(me.maxText, me.maxValue));
}
- return indexes;
- },
-
- getSelectedRecords : function(){
- return this.getRecords(this.selected.elements);
- },
-
- getRecords : function(nodes){
- var records = [],
- i = 0,
- len = nodes.length;
-
- for(; i < len; i++){
- records[records.length] = this.store.getAt(nodes[i].viewIndex);
- }
- return records;
+ return errors;
},
-
- getRecord : function(node){
- return this.store.getAt(node.viewIndex);
+ rawToValue: function(rawValue) {
+ return this.fixPrecision(this.parseValue(rawValue)) || rawValue || null;
},
-
- clearSelections : function(suppressEvent, skipUpdate){
- if((this.multiSelect || this.singleSelect) && this.selected.getCount() > 0){
- if(!skipUpdate){
- this.selected.removeClass(this.selectedClass);
- }
- this.selected.clear();
- this.last = false;
- if(!suppressEvent){
- this.fireEvent("selectionchange", this, this.selected.elements);
- }
- }
+ valueToRaw: function(value) {
+ var me = this,
+ decimalSeparator = me.decimalSeparator;
+ value = me.parseValue(value);
+ value = me.fixPrecision(value);
+ value = Ext.isNumber(value) ? value : parseFloat(String(value).replace(decimalSeparator, '.'));
+ value = isNaN(value) ? '' : String(value).replace('.', decimalSeparator);
+ return value;
},
-
- isSelected : function(node){
- return this.selected.contains(this.getNode(node));
- },
+ onChange: function() {
+ var me = this,
+ value = me.getValue(),
+ valueIsNull = value === null;
-
- deselect : function(node){
- if(this.isSelected(node)){
- node = this.getNode(node);
- this.selected.removeElement(node);
- if(this.last == node.viewIndex){
- this.last = false;
- }
- Ext.fly(node).removeClass(this.selectedClass);
- this.fireEvent("selectionchange", this, this.selected.elements);
- }
+ me.callParent(arguments);
+
+
+ me.setSpinUpEnabled(valueIsNull || value < me.maxValue);
+ me.setSpinDownEnabled(valueIsNull || value > me.minValue);
},
- select : function(nodeInfo, keepExisting, suppressEvent){
- if(Ext.isArray(nodeInfo)){
- if(!keepExisting){
- this.clearSelections(true);
- }
- for(var i = 0, len = nodeInfo.length; i < len; i++){
- this.select(nodeInfo[i], true, true);
- }
- if(!suppressEvent){
- this.fireEvent("selectionchange", this, this.selected.elements);
- }
- } else{
- var node = this.getNode(nodeInfo);
- if(!keepExisting){
- this.clearSelections(true);
- }
- if(node && !this.isSelected(node)){
- if(this.fireEvent("beforeselect", this, node, this.selected.elements) !== false){
- Ext.fly(node).addClass(this.selectedClass);
- this.selected.add(node);
- this.last = node.viewIndex;
- if(!suppressEvent){
- this.fireEvent("selectionchange", this, this.selected.elements);
- }
- }
- }
- }
+ setMinValue : function(value) {
+ this.minValue = Ext.Number.from(value, Number.NEGATIVE_INFINITY);
},
- selectRange : function(start, end, keepExisting){
- if(!keepExisting){
- this.clearSelections(true);
- }
- this.select(this.getNodes(start, end), true);
+ setMaxValue: function(value) {
+ this.maxValue = Ext.Number.from(value, Number.MAX_VALUE);
},
- getNode : function(nodeInfo){
- if(Ext.isString(nodeInfo)){
- return document.getElementById(nodeInfo);
- }else if(Ext.isNumber(nodeInfo)){
- return this.all.elements[nodeInfo];
- }else if(nodeInfo instanceof Ext.data.Record){
- var idx = this.store.indexOf(nodeInfo);
- return this.all.elements[idx];
- }
- return nodeInfo;
+ parseValue : function(value) {
+ value = parseFloat(String(value).replace(this.decimalSeparator, '.'));
+ return isNaN(value) ? null : value;
},
- getNodes : function(start, end){
- var ns = this.all.elements,
- nodes = [],
- i;
-
- start = start || 0;
- end = !Ext.isDefined(end) ? Math.max(ns.length - 1, 0) : end;
- if(start <= end){
- for(i = start; i <= end && ns[i]; i++){
- nodes.push(ns[i]);
- }
- } else{
- for(i = start; i >= end && ns[i]; i--){
- nodes.push(ns[i]);
- }
+ fixPrecision : function(value) {
+ var me = this,
+ nan = isNaN(value),
+ precision = me.decimalPrecision;
+
+ if (nan || !value) {
+ return nan ? '' : value;
+ } else if (!me.allowDecimals || precision <= 0) {
+ precision = 0;
}
- return nodes;
+
+ return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
},
-
- indexOf : function(node){
- node = this.getNode(node);
- if(Ext.isNumber(node.viewIndex)){
- return node.viewIndex;
+ beforeBlur : function() {
+ var me = this,
+ v = me.parseValue(me.getRawValue());
+
+ if (!Ext.isEmpty(v)) {
+ me.setValue(v);
}
- return this.all.indexOf(node);
},
-
- onBeforeLoad : function(){
- if(this.loadingText){
- this.clearSelections(false, true);
- this.getTemplateTarget().update('',
- ''
- );
+ var me = this,
+ pagingItems = me.getPagingItems(),
+ userItems = me.items || me.buttons || [];
+
+ if (me.prependButtons) {
+ me.items = userItems.concat(pagingItems);
+ } else {
+ me.items = pagingItems.concat(userItems);
}
- if(!this.tpl){
- this.tpl = new Ext.XTemplate(
- '',
- ' ',
- '',
- '',
- ''
- );
- };
-
- var cs = this.columns,
- allocatedWidth = 0,
- colsWithWidth = 0,
- len = cs.length,
- columns = [];
-
- for(var i = 0; i < len; i++){
- var c = cs[i];
- if(!c.isColumn) {
- c.xtype = c.xtype ? (/^lv/.test(c.xtype) ? c.xtype : 'lv' + c.xtype) : 'lvcolumn';
- c = Ext.create(c);
- }
- if(c.width) {
- allocatedWidth += c.width*100;
- if(allocatedWidth > this.maxColumnWidth){
- c.width -= (allocatedWidth - this.maxColumnWidth) / 100;
- }
- colsWithWidth++;
- }
- columns.push(c);
+ delete me.buttons;
+
+ if (me.displayInfo) {
+ me.items.push('->');
+ me.items.push({xtype: 'tbtext', itemId: 'displayItem'});
}
-
- cs = this.columns = columns;
-
- if(colsWithWidth < len){
- var remaining = len - colsWithWidth;
- if(allocatedWidth < this.maxColumnWidth){
- var perCol = ((this.maxColumnWidth-allocatedWidth) / remaining)/100;
- for(var j = 0; j < len; j++){
- var c = cs[j];
- if(!c.width){
- c.width = perCol;
- }
- }
+ me.callParent();
+
+ me.addEvents(
+
+ 'change',
+
+ 'beforechange'
+ );
+ me.on('afterlayout', me.onLoad, me, {single: true});
+
+ me.bindStore(me.store, true);
+ },
+
+ updateInfo : function(){
+ var me = this,
+ displayItem = me.child('#displayItem'),
+ store = me.store,
+ pageData = me.getPageData(),
+ count, msg;
+
+ if (displayItem) {
+ count = store.getCount();
+ if (count === 0) {
+ msg = me.emptyMsg;
+ } else {
+ msg = Ext.String.format(
+ me.displayMsg,
+ pageData.fromRecord,
+ pageData.toRecord,
+ pageData.total
+ );
}
+ displayItem.setText(msg);
+ me.doComponentLayout();
}
- Ext.list.ListView.superclass.initComponent.call(this);
},
- onRender : function(){
- this.autoEl = {
- cls: 'x-list-wrap'
- };
- Ext.list.ListView.superclass.onRender.apply(this, arguments);
-
- this.internalTpl.overwrite(this.el, {columns: this.columns});
-
- this.innerBody = Ext.get(this.el.dom.childNodes[1].firstChild);
- this.innerHd = Ext.get(this.el.dom.firstChild.firstChild);
-
- if(this.hideHeaders){
- this.el.dom.firstChild.style.display = 'none';
+
+ onLoad : function(){
+ var me = this,
+ pageData,
+ currPage,
+ pageCount,
+ afterText;
+
+ if (!me.rendered) {
+ return;
}
- },
- getTemplateTarget : function(){
- return this.innerBody;
+ pageData = me.getPageData();
+ currPage = pageData.currentPage;
+ pageCount = pageData.pageCount;
+ afterText = Ext.String.format(me.afterPageText, isNaN(pageCount) ? 1 : pageCount);
+
+ me.child('#afterTextItem').setText(afterText);
+ me.child('#inputItem').setValue(currPage);
+ me.child('#first').setDisabled(currPage === 1);
+ me.child('#prev').setDisabled(currPage === 1);
+ me.child('#next').setDisabled(currPage === pageCount);
+ me.child('#last').setDisabled(currPage === pageCount);
+ me.child('#refresh').enable();
+ me.updateInfo();
+ me.fireEvent('change', me, pageData);
},
- collectData : function(){
- var rs = Ext.list.ListView.superclass.collectData.apply(this, arguments);
+ getPageData : function(){
+ var store = this.store,
+ totalCount = store.getTotalCount();
+
return {
- columns: this.columns,
- rows: rs
+ total : totalCount,
+ currentPage : store.currentPage,
+ pageCount: Math.ceil(totalCount / store.pageSize),
+
+ fromRecord: ((store.currentPage - 1) * store.pageSize) + 1,
+ toRecord: Math.min(store.currentPage * store.pageSize, totalCount)
+
};
},
- verifyInternalSize : function(){
- if(this.lastSize){
- this.onResize(this.lastSize.width, this.lastSize.height);
+
+ onLoadError : function(){
+ if (!this.rendered) {
+ return;
}
+ this.child('#refresh').enable();
},
- onResize : function(w, h){
- var body = this.innerBody.dom,
- header = this.innerHd.dom,
- scrollWidth = w - Ext.num(this.scrollOffset, Ext.getScrollBarWidth()) + 'px',
- parentNode;
+ readPageFromInput : function(pageData){
+ var v = this.child('#inputItem').getValue(),
+ pageNum = parseInt(v, 10);
- if(!body){
- return;
- }
- parentNode = body.parentNode;
- if(Ext.isNumber(w)){
- if(this.reserveScrollOffset || ((parentNode.offsetWidth - parentNode.clientWidth) > 10)){
- body.style.width = scrollWidth;
- header.style.width = scrollWidth;
- }else{
- body.style.width = w + 'px';
- header.style.width = w + 'px';
- setTimeout(function(){
- if((parentNode.offsetWidth - parentNode.clientWidth) > 10){
- body.style.width = scrollWidth;
- header.style.width = scrollWidth;
- }
- }, 10);
- }
- }
- if(Ext.isNumber(h)){
- parentNode.style.height = Math.max(0, h - header.parentNode.offsetHeight) + 'px';
+ if (!v || isNaN(pageNum)) {
+ this.child('#inputItem').setValue(pageData.currentPage);
+ return false;
}
+ return pageNum;
},
- updateIndexes : function(){
- Ext.list.ListView.superclass.updateIndexes.apply(this, arguments);
- this.verifyInternalSize();
+ onPagingFocus : function(){
+ this.child('#inputItem').select();
},
- findHeaderIndex : function(header){
- header = header.dom || header;
- var parentNode = header.parentNode,
- children = parentNode.parentNode.childNodes,
- i = 0,
- c;
- for(; c = children[i]; i++){
- if(c == parentNode){
- return i;
+
+ onPagingBlur : function(e){
+ var curPage = this.getPageData().currentPage;
+ this.child('#inputItem').setValue(curPage);
+ },
+
+
+ onPagingKeyDown : function(field, e){
+ var k = e.getKey(),
+ pageData = this.getPageData(),
+ increment = e.shiftKey ? 10 : 1,
+ pageNum,
+ me = this;
+
+ if (k == e.RETURN) {
+ e.stopEvent();
+ pageNum = me.readPageFromInput(pageData);
+ if (pageNum !== false) {
+ pageNum = Math.min(Math.max(1, pageNum), pageData.total);
+ if(me.fireEvent('beforechange', me, pageNum) !== false){
+ me.store.loadPage(pageNum);
+ }
+ }
+ } else if (k == e.HOME || k == e.END) {
+ e.stopEvent();
+ pageNum = k == e.HOME ? 1 : pageData.pageCount;
+ field.setValue(pageNum);
+ } else if (k == e.UP || k == e.PAGEUP || k == e.DOWN || k == e.PAGEDOWN) {
+ e.stopEvent();
+ pageNum = me.readPageFromInput(pageData);
+ if (pageNum) {
+ if (k == e.DOWN || k == e.PAGEDOWN) {
+ increment *= -1;
+ }
+ pageNum += increment;
+ if (pageNum >= 1 && pageNum <= pageData.pages) {
+ field.setValue(pageNum);
+ }
}
}
- return -1;
},
- setHdWidths : function(){
- var els = this.innerHd.dom.getElementsByTagName('div'),
- i = 0,
- columns = this.columns,
- len = columns.length;
-
- for(; i < len; i++){
- els[i].style.width = (columns[i].width*100) + '%';
+
+ beforeLoad : function(){
+ if(this.rendered && this.refresh){
+ this.refresh.disable();
}
- }
-});
-
-Ext.reg('listview', Ext.list.ListView);
-
+ },
-Ext.ListView = Ext.list.ListView;
-Ext.list.Column = Ext.extend(Object, {
- isColumn: true,
+ doLoad : function(start){
+ if(this.fireEvent('beforechange', this, o) !== false){
+ this.store.load();
+ }
+ },
+
-
- align: 'left',
-
- header: '',
+ moveFirst : function(){
+ var me = this;
+ if(me.fireEvent('beforechange', me, 1) !== false){
+ me.store.loadPage(1);
+ }
+ },
+
+ movePrevious : function(){
+ var me = this,
+ prev = me.store.currentPage - 1;
- width: null,
+ if(me.fireEvent('beforechange', me, prev) !== false){
+ me.store.previousPage();
+ }
+ },
- cls: '',
-
+ moveNext : function(){
+ var me = this;
+ if(me.fireEvent('beforechange', me, me.store.currentPage + 1) !== false){
+ me.store.nextPage();
+ }
+ },
+
+ moveLast : function(){
+ var me = this,
+ last = this.getPageData().pageCount;
+
+ if(me.fireEvent('beforechange', me, last) !== false){
+ me.store.loadPage(last);
+ }
+ },
+ doRefresh : function(){
+ var me = this,
+ current = me.store.currentPage;
+
+ if(me.fireEvent('beforechange', me, current) !== false){
+ me.store.loadPage(current);
+ }
+ },
+
- constructor : function(c){
- if(!c.tpl){
- c.tpl = new Ext.XTemplate('{' + c.dataIndex + '}');
+ bindStore : function(store, initial){
+ var me = this;
+
+ if (!initial && me.store) {
+ if(store !== me.store && me.store.autoDestroy){
+ me.store.destroy();
+ }else{
+ me.store.un('beforeload', me.beforeLoad, me);
+ me.store.un('load', me.onLoad, me);
+ me.store.un('exception', me.onLoadError, me);
+ }
+ if(!store){
+ me.store = null;
+ }
}
- else if(Ext.isString(c.tpl)){
- c.tpl = new Ext.XTemplate(c.tpl);
+ if (store) {
+ store = Ext.data.StoreManager.lookup(store);
+ store.on({
+ scope: me,
+ beforeload: me.beforeLoad,
+ load: me.onLoad,
+ exception: me.onLoadError
+ });
}
-
- Ext.apply(this, c);
- }
-});
+ me.store = store;
+ },
-Ext.reg('lvcolumn', Ext.list.Column);
+
+ unbind : function(store){
+ this.bindStore(null);
+ },
+
+ bind : function(store){
+ this.bindStore(store);
+ },
-Ext.list.NumberColumn = Ext.extend(Ext.list.Column, {
-
- format: '0,000.00',
- constructor : function(c) {
- c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':number("' + (c.format || this.format) + '")}');
- Ext.list.NumberColumn.superclass.constructor.call(this, c);
+ onDestroy : function(){
+ this.bindStore(null);
+ this.callParent();
}
});
-Ext.reg('lvnumbercolumn', Ext.list.NumberColumn);
-
-
-Ext.list.DateColumn = Ext.extend(Ext.list.Column, {
- format: 'm/d/Y',
- constructor : function(c) {
- c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':date("' + (c.format || this.format) + '")}');
- Ext.list.DateColumn.superclass.constructor.call(this, c);
- }
-});
-Ext.reg('lvdatecolumn', Ext.list.DateColumn);
+Ext.define('Ext.view.BoundList', {
+ extend: 'Ext.view.View',
+ alias: 'widget.boundlist',
+ alternateClassName: 'Ext.BoundList',
+ requires: ['Ext.layout.component.BoundList', 'Ext.toolbar.Paging'],
-Ext.list.BooleanColumn = Ext.extend(Ext.list.Column, {
-
- trueText: 'true',
-
- falseText: 'false',
- undefinedText: ' ',
+ pageSize: 0,
+
- constructor : function(c) {
- c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':this.format}');
-
- var t = this.trueText, f = this.falseText, u = this.undefinedText;
- c.tpl.format = function(v){
- if(v === undefined){
- return u;
- }
- if(!v || v === 'false'){
- return f;
- }
- return t;
- };
-
- Ext.list.DateColumn.superclass.constructor.call(this, c);
- }
-});
-Ext.reg('lvbooleancolumn', Ext.list.BooleanColumn);
-Ext.list.ColumnResizer = Ext.extend(Ext.util.Observable, {
- minPct: .05,
+ autoScroll: true,
+ baseCls: Ext.baseCSSPrefix + 'boundlist',
+ listItemCls: '',
+ shadow: false,
+ trackOver: true,
+ refreshed: 0,
- constructor: function(config){
- Ext.apply(this, config);
- Ext.list.ColumnResizer.superclass.constructor.call(this);
- },
- init : function(listView){
- this.view = listView;
- listView.on('render', this.initEvents, this);
- },
+ ariaRole: 'listbox',
- initEvents : function(view){
- view.mon(view.innerHd, 'mousemove', this.handleHdMove, this);
- this.tracker = new Ext.dd.DragTracker({
- onBeforeStart: this.onBeforeStart.createDelegate(this),
- onStart: this.onStart.createDelegate(this),
- onDrag: this.onDrag.createDelegate(this),
- onEnd: this.onEnd.createDelegate(this),
- tolerance: 3,
- autoStart: 300
- });
- this.tracker.initEl(view.innerHd);
- view.on('beforedestroy', this.tracker.destroy, this.tracker);
- },
-
- handleHdMove : function(e, t){
- var handleWidth = 5,
- x = e.getPageX(),
- header = e.getTarget('em', 3, true);
- if(header){
- var region = header.getRegion(),
- style = header.dom.style,
- parentNode = header.dom.parentNode;
-
- if(x - region.left <= handleWidth && parentNode != parentNode.parentNode.firstChild){
- this.activeHd = Ext.get(parentNode.previousSibling.firstChild);
- style.cursor = Ext.isWebKit ? 'e-resize' : 'col-resize';
- } else if(region.right - x <= handleWidth && parentNode != parentNode.parentNode.lastChild.previousSibling){
- this.activeHd = header;
- style.cursor = Ext.isWebKit ? 'w-resize' : 'col-resize';
- } else{
- delete this.activeHd;
- style.cursor = '';
- }
- }
- },
+ componentLayout: 'boundlist',
- onBeforeStart : function(e){
- this.dragHd = this.activeHd;
- return !!this.dragHd;
- },
+ renderTpl: [''],
- onStart: function(e){
-
+ initComponent: function() {
var me = this,
- view = me.view,
- dragHeader = me.dragHd,
- x = me.tracker.getXY()[0];
-
- me.proxy = view.el.createChild({cls:'x-list-resizer'});
- me.dragX = dragHeader.getX();
- me.headerIndex = view.findHeaderIndex(dragHeader);
-
- me.headersDisabled = view.disableHeaders;
- view.disableHeaders = true;
-
- me.proxy.setHeight(view.el.getHeight());
- me.proxy.setX(me.dragX);
- me.proxy.setWidth(x - me.dragX);
+ baseCls = me.baseCls,
+ itemCls = baseCls + '-item';
+ me.itemCls = itemCls;
+ me.selectedItemCls = baseCls + '-selected';
+ me.overItemCls = baseCls + '-item-over';
+ me.itemSelector = "." + itemCls;
+
+ if (me.floating) {
+ me.addCls(baseCls + '-floating');
+ }
+
- this.setBoundaries();
- },
-
-
- setBoundaries: function(relativeX){
- var view = this.view,
- headerIndex = this.headerIndex,
- width = view.innerHd.getWidth(),
- relativeX = view.innerHd.getX(),
- minWidth = Math.ceil(width * this.minPct),
- maxWidth = width - minWidth,
- numColumns = view.columns.length,
- headers = view.innerHd.select('em', true),
- minX = minWidth + relativeX,
- maxX = maxWidth + relativeX,
- header;
-
- if (numColumns == 2) {
- this.minX = minX;
- this.maxX = maxX;
- }else{
- header = headers.item(headerIndex + 2);
- this.minX = headers.item(headerIndex).getX() + minWidth;
- this.maxX = header ? header.getX() - minWidth : maxX;
- if (headerIndex == 0) {
-
- this.minX = minX;
- } else if (headerIndex == numColumns - 2) {
-
- this.maxX = maxX;
- }
+ me.tpl = Ext.create('Ext.XTemplate',
+ '' +
+ '{[typeof values === "string" ? values : values.' + me.displayField + ']}' +
+ '' + me.delimiter + ' ' +
+ ' '
+ );
+ } else if (Ext.isString(me.displayTpl)) {
+ me.displayTpl = Ext.create('Ext.XTemplate', me.displayTpl);
+ }
-
- 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'});
+ me.callParent();
- this.body.addClass('x-tab-panel-body-'+this.tabPosition);
+ me.doQueryTask = Ext.create('Ext.util.DelayedTask', me.doRawQuery, me);
- if(!this.itemTpl){
- var tt = new Ext.Template(
- '',
- '',
- '{text}',
- ' '
- );
- tt.disableFormats = true;
- tt.compile();
- Ext.TabPanel.prototype.itemTpl = tt;
+ if (me.store.getCount() > 0) {
+ me.setValue(me.value);
}
- this.items.each(this.initTab, this);
+
+ if (transformSelect) {
+ me.render(transformSelect.parentNode, transformSelect);
+ Ext.removeNode(transformSelect);
+ delete me.renderTo;
+ }
},
-
- 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);
+ beforeBlur: function() {
+ var me = this;
+ me.doQueryTask.cancel();
+ if (me.forceSelection) {
+ me.assertValue();
+ } else {
+ me.collapse();
}
},
- 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);
+ assertValue: function() {
+ var me = this,
+ value = me.getRawValue(),
+ rec;
+
+ if (me.multiSelect) {
+
+
+ if (value !== me.getDisplayValue()) {
+ me.setValue(me.lastSelection);
+ }
+ } else {
+
+
+ rec = me.findRecordByDisplay(value);
+ if (rec) {
+ me.select(rec);
+ } else {
+ me.setValue(me.lastSelection);
+ }
}
+ me.collapse();
},
-
- findTargets : function(e){
- var item = null,
- itemEl = e.getTarget('li:not(.x-tab-edge)', this.strip);
+ onTypeAhead: function() {
+ var me = this,
+ displayField = me.displayField,
+ record = me.store.findRecord(displayField, me.getRawValue()),
+ boundList = me.getPicker(),
+ newValue, len, selStart;
- if(itemEl){
- item = this.getComponent(itemEl.id.split(this.idDelimiter)[1]);
- if(item.disabled){
- return {
- close : null,
- item : null,
- el : null
- };
+ if (record) {
+ newValue = record.get(displayField);
+ len = newValue.length;
+ selStart = me.getRawValue().length;
+
+ boundList.highlightItem(boundList.getNode(record));
+
+ if (selStart !== 0 && selStart !== len) {
+ me.setRawValue(newValue);
+ me.selectText(selStart, newValue.length);
}
}
- 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);
+
+ resetToDefault: function() {
+
+ },
+
+ bindStore: function(store, initial) {
+ var me = this,
+ oldStore = me.store;
+
+
+
+ if (oldStore && !initial) {
+ if (oldStore !== store && oldStore.autoDestroy) {
+ oldStore.destroy();
+ } else {
+ oldStore.un({
+ scope: me,
+ load: me.onLoad,
+ exception: me.collapse
+ });
+ }
+ if (!store) {
+ me.store = null;
+ if (me.picker) {
+ me.picker.bindStore(null);
+ }
}
- return;
}
- if(t.item && t.item != this.activeTab){
- this.setActiveTab(t.item);
+ if (store) {
+ if (!initial) {
+ me.resetToDefault();
+ }
+
+ me.store = Ext.data.StoreManager.lookup(store);
+ me.store.on({
+ scope: me,
+ load: me.onLoad,
+ exception: me.collapse
+ });
+
+ if (me.picker) {
+ me.picker.bindStore(store);
+ }
}
},
-
- onStripContextMenu : function(e){
- e.preventDefault();
- var t = this.findTargets(e);
- if(t.item){
- this.fireEvent('contextmenu', this, t.item, e);
+ onLoad: function() {
+ var me = this,
+ value = me.value;
+
+ me.syncSelection();
+ if (me.picker && !me.picker.getSelectionModel().hasSelection()) {
+ me.doAutoSelect();
}
},
- 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
- });
- }
+ doRawQuery: function() {
+ this.doQuery(this.getRawValue());
},
- 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);
+ doQuery: function(queryString, forceAll) {
+ queryString = queryString || '';
- tabEl.hover(function(){
- if(!item.disabled){
- tabEl.addClass(cls);
- }
- }, function(){
- tabEl.removeClass(cls);
- });
+
+
+ var me = this,
+ qe = {
+ query: queryString,
+ forceAll: forceAll,
+ combo: me,
+ cancel: false
+ },
+ store = me.store,
+ isLocalMode = me.queryMode === 'local';
- if(item.tabTip){
- tabEl.child('span.x-tab-strip-text', true).qtip = item.tabTip;
+ if (me.fireEvent('beforequery', qe) === false || qe.cancel) {
+ return false;
}
- item.tabEl = el;
- tabEl.select('a').on('click', function(e){
- if(!e.getPageX()){
- this.onStripMouseDown(e);
- }
- }, this, {preventDefault: true});
+ queryString = qe.query;
+ forceAll = qe.forceAll;
- item.on({
- scope: this,
- disable: this.onItemDisabled,
- enable: this.onItemEnabled,
- titlechange: this.onItemTitleChanged,
- iconchange: this.onItemIconChanged,
- beforeshow: this.onBeforeShowItem
- });
- },
+
+ if (forceAll || (queryString.length >= me.minChars)) {
+
+ me.expand();
+
+ if (!me.queryCaching || me.lastQuery !== queryString) {
+ me.lastQuery = queryString;
+ store.clearFilter(!forceAll);
+ if (isLocalMode) {
+ if (!forceAll) {
+ store.filter(me.displayField, queryString);
+ }
+ } else {
+ store.load({
+ params: me.getParams(queryString)
+ });
+ }
+ }
+
+ if (me.getRawValue() !== me.getDisplayValue()) {
+ me.ignoreSelection++;
+ me.picker.getSelectionModel().deselectAll();
+ me.ignoreSelection--;
+ }
-
- getTemplateArgs : function(item) {
- var cls = item.closable ? 'x-tab-strip-closable' : '';
- if(item.disabled){
- cls += ' x-item-disabled';
- }
- if(item.iconCls){
- cls += ' x-tab-with-icon';
- }
- if(item.tabCls){
- cls += ' ' + item.tabCls;
+ if (isLocalMode) {
+ me.doAutoSelect();
+ }
+ if (me.typeAhead) {
+ me.doTypeAhead();
+ }
}
-
- return {
- id: this.id + this.idDelimiter + item.getItemId(),
- text: item.title,
- cls: cls,
- iconCls: item.iconCls || ''
- };
+ return true;
},
- onAdd : function(c){
- Ext.TabPanel.superclass.onAdd.call(this, c);
- if(this.rendered){
- var items = this.items;
- this.initTab(c, items.indexOf(c));
- this.delegateUpdates();
+ getParams: function(queryString) {
+ var p = {},
+ pageSize = this.pageSize;
+ p[this.queryParam] = queryString;
+ if (pageSize) {
+ p.start = 0;
+ p.limit = pageSize;
}
+ return p;
},
- onBeforeAdd : function(item){
- var existing = item.events ? (this.items.containsKey(item.getItemId()) ? item : null) : this.items.get(item);
- if(existing){
- this.setActiveTab(item);
- return false;
- }
- Ext.TabPanel.superclass.onBeforeAdd.apply(this, arguments);
- var es = item.elements;
- item.elements = es ? es.replace(',header', '') : es;
- item.border = (item.border === true);
- },
-
-
- onRemove : function(c){
- var te = Ext.get(c.tabEl);
-
- if(te){
- te.select('a').removeAllListeners();
- Ext.destroy(te);
- }
- Ext.TabPanel.superclass.onRemove.call(this, c);
- this.stack.remove(c);
- delete c.tabEl;
- c.un('disable', this.onItemDisabled, this);
- c.un('enable', this.onItemEnabled, this);
- c.un('titlechange', this.onItemTitleChanged, this);
- c.un('iconchange', this.onItemIconChanged, this);
- c.un('beforeshow', this.onBeforeShowItem, this);
- if(c == this.activeTab){
- var next = this.stack.next();
- if(next){
- this.setActiveTab(next);
- }else if(this.items.getCount() > 0){
- this.setActiveTab(0);
- }else{
- this.setActiveTab(null);
+ doAutoSelect: function() {
+ var me = this,
+ picker = me.picker,
+ lastSelected, itemNode;
+ if (picker && me.autoSelect && me.store.getCount() > 0) {
+
+ lastSelected = picker.getSelectionModel().lastSelected;
+ itemNode = picker.getNode(lastSelected || 0);
+ if (itemNode) {
+ picker.highlightItem(itemNode);
+ picker.listEl.scrollChildIntoView(itemNode, false);
}
}
- if(!this.destroying){
- this.delegateUpdates();
- }
},
-
- onBeforeShowItem : function(item){
- if(item != this.activeTab){
- this.setActiveTab(item);
- return false;
+ doTypeAhead: function() {
+ if (!this.typeAheadTask) {
+ this.typeAheadTask = Ext.create('Ext.util.DelayedTask', this.onTypeAhead, this);
+ }
+ if (this.lastKey != Ext.EventObject.BACKSPACE && this.lastKey != Ext.EventObject.DELETE) {
+ this.typeAheadTask.delay(this.typeAheadDelay);
}
},
-
- onItemDisabled : function(item){
- var el = this.getTabEl(item);
- if(el){
- Ext.fly(el).addClass('x-item-disabled');
+ onTriggerClick: function() {
+ var me = this;
+ if (!me.readOnly && !me.disabled) {
+ if (me.isExpanded) {
+ me.collapse();
+ } else {
+ me.onFocus({});
+ if (me.triggerAction === 'all') {
+ me.doQuery(me.allQuery, true);
+ } else {
+ me.doQuery(me.getRawValue());
+ }
+ }
+ me.inputEl.focus();
}
- this.stack.remove(item);
},
+
- onItemEnabled : function(item){
- var el = this.getTabEl(item);
- if(el){
- Ext.fly(el).removeClass('x-item-disabled');
+ onKeyUp: function(e, t) {
+ var me = this,
+ key = e.getKey();
+
+ if (!me.readOnly && !me.disabled && me.editable) {
+ me.lastKey = key;
+
+
+
+
+ if (!e.isSpecialKey() || key == e.BACKSPACE || key == e.DELETE) {
+ me.doQueryTask.delay(me.queryDelay);
+ }
}
},
-
- onItemTitleChanged : function(item){
- var el = this.getTabEl(item);
- if(el){
- Ext.fly(el).child('span.x-tab-strip-text', true).innerHTML = item.title;
- }
+ initEvents: function() {
+ var me = this;
+ me.callParent();
+
+
+ me.mon(me.inputEl, 'keyup', me.onKeyUp, me);
+ },
+
+ createPicker: function() {
+ var me = this,
+ picker,
+ menuCls = Ext.baseCSSPrefix + 'menu',
+ opts = Ext.apply({
+ selModel: {
+ mode: me.multiSelect ? 'SIMPLE' : 'SINGLE'
+ },
+ floating: true,
+ hidden: true,
+ ownerCt: me.ownerCt,
+ cls: me.el.up('.' + menuCls) ? menuCls : '',
+ store: me.store,
+ displayField: me.displayField,
+ focusOnToFront: false,
+ pageSize: me.pageSize
+ }, me.listConfig, me.defaultListConfig);
+
+ picker = me.picker = Ext.create('Ext.view.BoundList', opts);
+
+ me.mon(picker, {
+ itemclick: me.onItemClick,
+ refresh: me.onListRefresh,
+ scope: me
+ });
+
+ me.mon(picker.getSelectionModel(), {
+ selectionChange: me.onListSelectionChange,
+ scope: me
+ });
+
+ return picker;
},
+ onListRefresh: function() {
+ this.alignPicker();
+ this.syncSelection();
+ },
- onItemIconChanged : function(item, iconCls, oldCls){
- var el = this.getTabEl(item);
- if(el){
- el = Ext.get(el);
- el.child('span.x-tab-strip-text').replaceClass(oldCls, iconCls);
- el[Ext.isEmpty(iconCls) ? 'removeClass' : 'addClass']('x-tab-with-icon');
+ onItemClick: function(picker, record){
+
+ var me = this,
+ lastSelection = me.lastSelection,
+ valueField = me.valueField,
+ selected;
+
+ if (!me.multiSelect && lastSelection) {
+ selected = lastSelection[0];
+ if (record.get(valueField) === selected.get(valueField)) {
+ me.collapse();
+ }
+ }
+ },
+
+ onListSelectionChange: function(list, selectedRecords) {
+ var me = this;
+
+
+ if (!me.ignoreSelection && me.isExpanded) {
+ if (!me.multiSelect) {
+ Ext.defer(me.collapse, 1, me);
+ }
+ me.setValue(selectedRecords, false);
+ if (selectedRecords.length > 0) {
+ me.fireEvent('select', me, selectedRecords);
+ }
+ me.inputEl.focus();
}
},
- getTabEl : function(item){
- var c = this.getComponent(item);
- return c ? c.tabEl : null;
+ onExpand: function() {
+ var me = this,
+ keyNav = me.listKeyNav,
+ selectOnTab = me.selectOnTab,
+ picker = me.getPicker();
+
+
+ if (keyNav) {
+ keyNav.enable();
+ } else {
+ keyNav = me.listKeyNav = Ext.create('Ext.view.BoundListKeyNav', this.inputEl, {
+ boundList: picker,
+ forceKeyDown: true,
+ tab: function(e) {
+ if (selectOnTab) {
+ this.selectHighlighted(e);
+ me.triggerBlur();
+ }
+
+ return true;
+ }
+ });
+ }
+
+
+ if (selectOnTab) {
+ me.ignoreMonitorTab = true;
+ }
+
+ Ext.defer(keyNav.enable, 1, keyNav);
+ me.inputEl.focus();
},
- onResize : function(){
- Ext.TabPanel.superclass.onResize.apply(this, arguments);
- this.delegateUpdates();
+ onCollapse: function() {
+ var me = this,
+ keyNav = me.listKeyNav;
+ if (keyNav) {
+ keyNav.disable();
+ me.ignoreMonitorTab = false;
+ }
},
- beginUpdate : function(){
- this.suspendUpdates = true;
+ select: function(r) {
+ this.setValue(r, true);
},
- endUpdate : function(){
- this.suspendUpdates = false;
- this.delegateUpdates();
+ findRecord: function(field, value) {
+ var ds = this.store,
+ idx = ds.findExact(field, value);
+ return idx !== -1 ? ds.getAt(idx) : false;
+ },
+ findRecordByValue: function(value) {
+ return this.findRecord(this.valueField, value);
+ },
+ findRecordByDisplay: function(value) {
+ return this.findRecord(this.displayField, value);
},
- hideTabStripItem : function(item){
- item = this.getComponent(item);
- var el = this.getTabEl(item);
- if(el){
- el.style.display = 'none';
- this.delegateUpdates();
+ setValue: function(value, doSelect) {
+ var me = this,
+ valueNotFoundText = me.valueNotFoundText,
+ inputEl = me.inputEl,
+ i, len, record,
+ models = [],
+ displayTplData = [],
+ processedValue = [];
+
+ if (me.store.loading) {
+
+ me.value = value;
+ return me;
}
- this.stack.remove(item);
- },
-
- unhideTabStripItem : function(item){
- item = this.getComponent(item);
- var el = this.getTabEl(item);
- if(el){
- el.style.display = '';
- this.delegateUpdates();
+
+ value = Ext.Array.from(value);
+
+
+ for (i = 0, len = value.length; i < len; i++) {
+ record = value[i];
+ if (!record || !record.isModel) {
+ record = me.findRecordByValue(record);
+ }
+
+ if (record) {
+ models.push(record);
+ displayTplData.push(record.data);
+ processedValue.push(record.get(me.valueField));
+ }
+
+
+ else {
+
+ if (Ext.isDefined(valueNotFoundText)) {
+ displayTplData.push(valueNotFoundText);
+ }
+ processedValue.push(value[i]);
+ }
}
- },
-
- delegateUpdates : function(){
- var rendered = this.rendered;
- if(this.suspendUpdates){
- return;
+
+ me.value = me.multiSelect ? processedValue : processedValue[0];
+ if (!Ext.isDefined(me.value)) {
+ me.value = null;
}
- if(this.resizeTabs && rendered){
- this.autoSizeTabs();
+ me.displayTplData = displayTplData;
+ me.lastSelection = me.valueModels = models;
+
+ if (inputEl && me.emptyText && !Ext.isEmpty(value)) {
+ inputEl.removeCls(me.emptyCls);
}
- if(this.enableTabScroll && rendered){
- this.autoScrollTabs();
+
+
+ me.setRawValue(me.getDisplayValue());
+ me.checkChange();
+
+ if (doSelect !== false) {
+ me.syncSelection();
}
+ me.applyEmptyText();
+
+ return me;
},
- autoSizeTabs : function(){
- var count = this.items.length,
- ce = this.tabPosition != 'bottom' ? 'header' : 'footer',
- ow = this[ce].dom.offsetWidth,
- aw = this[ce].dom.clientWidth;
+ getDisplayValue: function() {
+ return this.displayTpl.apply(this.displayTplData);
+ },
- if(!this.resizeTabs || count < 1 || !aw){
- return;
- }
+ getValue: function() {
+
+
+
+ var me = this,
+ picker = me.picker,
+ rawValue = me.getRawValue(),
+ value = me.value;
- var each = Math.max(Math.min(Math.floor((aw-4) / count) - this.tabMargin, this.tabWidth), this.minTabWidth);
- this.lastTabWidth = each;
- var lis = this.strip.query('li:not(.x-tab-edge)');
- for(var i = 0, len = lis.length; i < len; i++) {
- var li = lis[i],
- inner = Ext.fly(li).child('.x-tab-strip-inner', true),
- tw = li.offsetWidth,
- iw = inner.offsetWidth;
- inner.style.width = (each - (tw-iw)) + 'px';
+ if (me.getDisplayValue() !== rawValue) {
+ value = rawValue;
+ me.value = me.displayTplData = me.valueModels = null;
+ if (picker) {
+ me.ignoreSelection++;
+ picker.getSelectionModel().deselectAll();
+ me.ignoreSelection--;
+ }
}
+
+ return value;
},
-
- adjustBodyWidth : function(w){
- if(this.header){
- this.header.setWidth(w);
- }
- if(this.footer){
- this.footer.setWidth(w);
- }
- return w;
+ getSubmitValue: function() {
+ return this.getValue();
},
-
- setActiveTab : function(item){
- item = this.getComponent(item);
- if(this.fireEvent('beforetabchange', this, item, this.activeTab) === false){
- return;
- }
- if(!this.rendered){
- this.activeTab = item;
- return;
+ isEqual: function(v1, v2) {
+ var fromArray = Ext.Array.from,
+ i, len;
+
+ v1 = fromArray(v1);
+ v2 = fromArray(v2);
+ len = v1.length;
+
+ if (len !== v2.length) {
+ return false;
}
- if(this.activeTab != item){
- if(this.activeTab){
- var oldEl = this.getTabEl(this.activeTab);
- if(oldEl){
- Ext.fly(oldEl).removeClass('x-tab-strip-active');
- }
- }
- this.activeTab = item;
- if(item){
- var el = this.getTabEl(item);
- Ext.fly(el).addClass('x-tab-strip-active');
- this.stack.add(item);
- this.layout.setActiveItem(item);
-
- this.delegateUpdates();
- if(this.scrolling){
- this.scrollToTab(item, this.animScroll);
- }
+ for(i = 0; i < len; i++) {
+ if (v2[i] !== v1[i]) {
+ return false;
}
- this.fireEvent('tabchange', this, item);
}
- },
-
- getActiveTab : function(){
- return this.activeTab || null;
+ return true;
},
- getItem : function(item){
- return this.getComponent(item);
+ clearValue: function() {
+ this.setValue([]);
},
- autoScrollTabs : function(){
- this.pos = this.tabPosition=='bottom' ? this.footer : this.header;
- var count = this.items.length,
- ow = this.pos.dom.offsetWidth,
- tw = this.pos.dom.clientWidth,
- wrap = this.stripWrap,
- wd = wrap.dom,
- cw = wd.offsetWidth,
- pos = this.getScrollPos(),
- l = this.edge.getOffsetsTo(this.stripWrap)[0] + pos;
+ syncSelection: function() {
+ var me = this,
+ ExtArray = Ext.Array,
+ picker = me.picker,
+ selection, selModel;
+ if (picker) {
+
+ selection = [];
+ ExtArray.forEach(me.valueModels || [], function(value) {
+ if (value && value.isModel && me.store.indexOf(value) >= 0) {
+ selection.push(value);
+ }
+ });
- if(!this.enableTabScroll || cw < 20){
- return;
- }
- if(count == 0 || l <= tw){
- wd.scrollLeft = 0;
- wrap.setWidth(tw);
- if(this.scrolling){
- this.scrolling = false;
- this.pos.removeClass('x-tab-scrolling');
- this.scrollLeft.hide();
- this.scrollRight.hide();
-
- if(Ext.isAir || Ext.isWebKit){
- wd.style.marginLeft = '';
- wd.style.marginRight = '';
- }
- }
- }else{
- if(!this.scrolling){
- this.pos.addClass('x-tab-scrolling');
-
- if(Ext.isAir || Ext.isWebKit){
- wd.style.marginLeft = '18px';
- wd.style.marginRight = '18px';
- }
- }
- tw -= wrap.getMargins('lr');
- wrap.setWidth(tw > 20 ? tw : 20);
- if(!this.scrolling){
- if(!this.scrollLeft){
- this.createScrollers();
- }else{
- this.scrollLeft.show();
- this.scrollRight.show();
- }
- }
- this.scrolling = true;
- if(pos > (l-tw)){
- wd.scrollLeft = l-tw;
- }else{
- this.scrollToTab(this.activeTab, false);
+ me.ignoreSelection++;
+ selModel = picker.getSelectionModel();
+ selModel.deselectAll();
+ if (selection.length) {
+ selModel.select(selection);
}
- this.updateScrollButtons();
+ me.ignoreSelection--;
}
+ }
+});
+
+
+Ext.define('Ext.picker.Month', {
+ extend: 'Ext.Component',
+ requires: ['Ext.XTemplate', 'Ext.util.ClickRepeater', 'Ext.Date', 'Ext.button.Button'],
+ alias: 'widget.monthpicker',
+ alternateClassName: 'Ext.MonthPicker',
+
+ renderTpl: [
+ '',
+ '',
+ '',
+ '',
+ ' '
+ ],
+
+
+ okText: 'OK',
+
+
+ cancelText: 'Cancel',
+
+
+ baseCls: Ext.baseCSSPrefix + 'monthpicker',
+
+
+ showButtons: true,
+
+
+
+
+
+ width: 175,
+
+ height: 195,
+
+
+
+ totalYears: 10,
+ yearOffset: 5,
+ monthOffset: 6,
+
+
+ initComponent: function(){
+ var me = this;
+
+ me.selectedCls = me.baseCls + '-selected';
+ me.addEvents(
+
+ 'cancelclick',
+
+
+ 'monthclick',
+
+
+ 'monthdblclick',
+
+
+ 'okclick',
+
+
+ 'select',
+
+
+ 'yearclick',
+
+
+ 'yeardblclick'
+ );
+
+ me.setValue(me.value);
+ me.activeYear = me.getYear(new Date().getFullYear() - 4, -4);
+ this.callParent();
},
- createScrollers : function(){
- this.pos.addClass('x-tab-scrolling-' + this.tabPosition);
- var h = this.stripWrap.dom.offsetHeight;
+ onRender: function(ct, position){
+ var me = this,
+ i = 0,
+ months = [],
+ shortName = Ext.Date.getShortMonthName,
+ monthLen = me.monthOffset;
-
- var sl = this.pos.insertFirst({
- cls:'x-tab-scroller-left'
+ for (; i < monthLen; ++i) {
+ months.push(shortName(i), shortName(i + monthLen));
+ }
+
+ Ext.apply(me.renderData, {
+ months: months,
+ years: me.getYears(),
+ showButtons: me.showButtons
});
- sl.setHeight(h);
- sl.addClassOnOver('x-tab-scroller-left-over');
- this.leftRepeater = new Ext.util.ClickRepeater(sl, {
- interval : this.scrollRepeatInterval,
- handler: this.onScrollLeft,
- scope: this
+
+ Ext.apply(me.renderSelectors, {
+ bodyEl: '.' + me.baseCls + '-body',
+ prevEl: '.' + me.baseCls + '-yearnav-prev',
+ nextEl: '.' + me.baseCls + '-yearnav-next',
+ buttonsEl: '.' + me.baseCls + '-buttons'
});
- this.scrollLeft = sl;
+ this.callParent([ct, position]);
+ },
+
+
+ afterRender: function(){
+ var me = this,
+ body = me.bodyEl,
+ buttonsEl = me.buttonsEl;
+
+ me.callParent();
+
+ me.mon(body, 'click', me.onBodyClick, me);
+ me.mon(body, 'dblclick', me.onBodyClick, me);
- var sr = this.pos.insertFirst({
- cls:'x-tab-scroller-right'
+ me.years = body.select('.' + me.baseCls + '-year a');
+ me.months = body.select('.' + me.baseCls + '-month a');
+
+ if (me.showButtons) {
+ me.okBtn = Ext.create('Ext.button.Button', {
+ text: me.okText,
+ renderTo: buttonsEl,
+ handler: me.onOkClick,
+ scope: me
+ });
+ me.cancelBtn = Ext.create('Ext.button.Button', {
+ text: me.cancelText,
+ renderTo: buttonsEl,
+ handler: me.onCancelClick,
+ scope: me
+ });
+ }
+
+ me.backRepeater = Ext.create('Ext.util.ClickRepeater', me.prevEl, {
+ handler: Ext.Function.bind(me.adjustYear, me, [-me.totalYears])
});
- sr.setHeight(h);
- sr.addClassOnOver('x-tab-scroller-right-over');
- this.rightRepeater = new Ext.util.ClickRepeater(sr, {
- interval : this.scrollRepeatInterval,
- handler: this.onScrollRight,
- scope: this
+
+ me.prevEl.addClsOnOver(me.baseCls + '-yearnav-prev-over');
+ me.nextRepeater = Ext.create('Ext.util.ClickRepeater', me.nextEl, {
+ handler: Ext.Function.bind(me.adjustYear, me, [me.totalYears])
});
- this.scrollRight = sr;
+ me.nextEl.addClsOnOver(me.baseCls + '-yearnav-next-over');
+ me.updateBody();
},
- getScrollWidth : function(){
- return this.edge.getOffsetsTo(this.stripWrap)[0] + this.getScrollPos();
- },
+ setValue: function(value){
+ var me = this,
+ active = me.activeYear,
+ offset = me.monthOffset,
+ year,
+ index;
-
- getScrollPos : function(){
- return parseInt(this.stripWrap.dom.scrollLeft, 10) || 0;
- },
+ if (!value) {
+ me.value = [null, null];
+ } else if (Ext.isDate(value)) {
+ me.value = [value.getMonth(), value.getFullYear()];
+ } else {
+ me.value = [value[0], value[1]];
+ }
-
- getScrollArea : function(){
- return parseInt(this.stripWrap.dom.clientWidth, 10) || 0;
+ if (me.rendered) {
+ year = me.value[1];
+ if (year !== null) {
+ if ((year < active || year > active + me.yearOffset)) {
+ me.activeYear = year - me.yearOffset + 1;
+ }
+ }
+ me.updateBody();
+ }
+
+ return me;
},
- getScrollAnim : function(){
- return {duration:this.scrollDuration, callback: this.updateScrollButtons, scope: this};
+ getValue: function(){
+ return this.value;
},
- getScrollIncrement : function(){
- return this.scrollIncrement || (this.resizeTabs ? this.lastTabWidth+2 : 100);
+ hasSelection: function(){
+ var value = this.value;
+ return value[0] !== null && value[1] !== null;
},
+ getYears: function(){
+ var me = this,
+ offset = me.yearOffset,
+ start = me.activeYear,
+ end = start + offset,
+ i = start,
+ years = [];
- scrollToTab : function(item, animate){
- if(!item){
- return;
- }
- var el = this.getTabEl(item),
- pos = this.getScrollPos(),
- area = this.getScrollArea(),
- left = Ext.fly(el).getOffsetsTo(this.stripWrap)[0] + pos,
- right = left + el.offsetWidth;
- if(left < pos){
- this.scrollTo(left, animate);
- }else if(right > (pos + area)){
- this.scrollTo(right - area, animate);
+ for (; i < end; ++i) {
+ years.push(i, i + offset);
}
+
+ return years;
},
- scrollTo : function(pos, animate){
- this.stripWrap.scrollTo('left', pos, animate ? this.getScrollAnim() : false);
- if(!animate){
- this.updateScrollButtons();
+ updateBody: function(){
+ var me = this,
+ years = me.years,
+ months = me.months,
+ yearNumbers = me.getYears(),
+ cls = me.selectedCls,
+ value = me.getYear(null),
+ month = me.value[0],
+ monthOffset = me.monthOffset,
+ year;
+
+ if (me.rendered) {
+ years.removeCls(cls);
+ months.removeCls(cls);
+ years.each(function(el, all, index){
+ year = yearNumbers[index];
+ el.dom.innerHTML = year;
+ if (year == value) {
+ el.dom.className = cls;
+ }
+ });
+ if (month !== null) {
+ if (month < monthOffset) {
+ month = month * 2;
+ } else {
+ month = (month - monthOffset) * 2 + 1;
+ }
+ months.item(month).addCls(cls);
+ }
}
},
- onWheel : function(e){
- var d = e.getWheelDelta()*this.wheelIncrement*-1;
- e.stopEvent();
+
+ getYear: function(defaultValue, offset) {
+ var year = this.value[1];
+ offset = offset || 0;
+ return year === null ? defaultValue : year + offset;
+ },
- var pos = this.getScrollPos(),
- newpos = pos + d,
- sw = this.getScrollWidth()-this.getScrollArea();
+
+ onBodyClick: function(e, t) {
+ var me = this,
+ isDouble = e.type == 'dblclick';
- var s = Math.max(0, Math.min(sw, newpos));
- if(s != pos){
- this.scrollTo(s, false);
+ if (e.getTarget('.' + me.baseCls + '-month')) {
+ e.stopEvent();
+ me.onMonthClick(t, isDouble);
+ } else if (e.getTarget('.' + me.baseCls + '-year')) {
+ e.stopEvent();
+ me.onYearClick(t, isDouble);
}
},
- onScrollRight : function(){
- var sw = this.getScrollWidth()-this.getScrollArea(),
- pos = this.getScrollPos(),
- s = Math.min(sw, pos + this.getScrollIncrement());
- if(s != pos){
- this.scrollTo(s, this.animScroll);
+ adjustYear: function(offset){
+ if (typeof offset != 'number') {
+ offset = this.totalYears;
}
+ this.activeYear += offset;
+ this.updateBody();
},
- onScrollLeft : function(){
- var pos = this.getScrollPos(),
- s = Math.max(0, pos - this.getScrollIncrement());
- if(s != pos){
- this.scrollTo(s, this.animScroll);
- }
+ onOkClick: function(){
+ this.fireEvent('okclick', this, this.value);
},
- updateScrollButtons : function(){
- var pos = this.getScrollPos();
- this.scrollLeft[pos === 0 ? 'addClass' : 'removeClass']('x-tab-scroller-left-disabled');
- this.scrollRight[pos >= (this.getScrollWidth()-this.getScrollArea()) ? 'addClass' : 'removeClass']('x-tab-scroller-right-disabled');
+ onCancelClick: function(){
+ this.fireEvent('cancelclick', this);
},
- beforeDestroy : function() {
- Ext.destroy(this.leftRepeater, this.rightRepeater);
- this.deleteMembers('strip', 'edge', 'scrollLeft', 'scrollRight', 'stripWrap');
- this.activeTab = null;
- Ext.TabPanel.superclass.beforeDestroy.apply(this);
- }
+ onMonthClick: function(target, isDouble){
+ var me = this;
+ me.value[0] = me.resolveOffset(me.months.indexOf(target), me.monthOffset);
+ me.updateBody();
+ me.fireEvent('month' + (isDouble ? 'dbl' : '') + 'click', me, me.value);
+ me.fireEvent('select', me, me.value);
+ },
+ onYearClick: function(target, isDouble){
+ var me = this;
+ me.value[1] = me.activeYear + me.resolveOffset(me.years.indexOf(target), me.yearOffset);
+ me.updateBody();
+ me.fireEvent('year' + (isDouble ? 'dbl' : '') + 'click', me, me.value);
+ me.fireEvent('select', me, me.value);
+
+ },
+
+ resolveOffset: function(index, offset){
+ if (index % 2 === 0) {
+ return (index / 2);
+ } else {
+ return offset + Math.floor(index / 2);
+ }
+ },
+
+ beforeDestroy: function(){
+ var me = this;
+ me.years = me.months = null;
+ Ext.destroyMembers('backRepeater', 'nextRepeater', 'okBtn', 'cancelBtn');
+ this.callParent();
+ }
+});
+
+
+Ext.define('Ext.picker.Date', {
+ extend: 'Ext.Component',
+ requires: [
+ 'Ext.XTemplate',
+ 'Ext.button.Button',
+ 'Ext.button.Split',
+ 'Ext.util.ClickRepeater',
+ 'Ext.util.KeyNav',
+ 'Ext.EventObject',
+ 'Ext.fx.Manager',
+ 'Ext.picker.Month'
+ ],
+ alias: 'widget.datepicker',
+ alternateClassName: 'Ext.DatePicker',
+
+ renderTpl: [
+ '' : '';
+ },
+ longDay: function(value){
+ return Ext.Date.format(value, this.longDayFormat);
+ }
+ }
+ ],
+
+ ariaTitle: 'Date Picker',
+ todayText : 'Today',
+ todayTip : '{0} (Spacebar)',
+ minText : 'This date is before the minimum date',
+ maxText : 'This date is after the maximum date',
+ disabledDaysText : 'Disabled',
-});
-Ext.reg('tabpanel', Ext.TabPanel);
-
-
-Ext.TabPanel.prototype.activate = Ext.TabPanel.prototype.setActiveTab;
-
-
-Ext.TabPanel.AccessStack = function(){
- var items = [];
- return {
- add : function(item){
- items.push(item);
- if(items.length > 10){
- items.shift();
- }
- },
-
- remove : function(item){
- var s = [];
- for(var i = 0, len = items.length; i < len; i++) {
- if(items[i] != item){
- s.push(items[i]);
- }
- }
- items = s;
- },
-
- next : function(){
- return items.pop();
- }
- };
-};
-
-Ext.Button = Ext.extend(Ext.BoxComponent, {
+ disabledDatesText : 'Disabled',
- hidden : false,
- disabled : false,
- pressed : false,
-
+ nextText : 'Next Month (Control+Right)',
-
+ prevText : 'Previous Month (Control+Left)',
-
+ monthYearText : 'Choose a month (Control+Up/Down to move years)',
- enableToggle : false,
+ startDay : 0,
+ showToday : true,
- menuAlign : 'tl-bl?',
-
- type : 'button',
- menuClassTarget : 'tr:nth(2)',
+ disableAnim: true,
- clickEvent : 'click',
+ baseCls: Ext.baseCSSPrefix + 'datepicker',
- handleMouseEvents : true,
- tooltipType : 'qtip',
- buttonSelector : 'button:first-child',
+ longDayFormat: 'F d, Y',
- scale : 'small',
+ focusOnShow: false,
- iconAlign : 'left',
-
- arrowAlign : 'right',
+ focusOnSelect: true,
+
+ width: 178,
+ initHour: 12,
+
+ numDays: 42,
+
-
+ initComponent : function() {
+ var me = this,
+ clearTime = Ext.Date.clearTime;
- initComponent : function(){
- if(this.menu){
- this.menu = Ext.menu.MenuMgr.get(this.menu);
- this.menu.ownerCt = this;
- }
-
- Ext.Button.superclass.initComponent.call(this);
+ me.selectedCls = me.baseCls + '-selected';
+ me.disabledCellCls = me.baseCls + '-disabled';
+ me.prevCls = me.baseCls + '-prevday';
+ me.activeCls = me.baseCls + '-active';
+ me.nextCls = me.baseCls + '-prevday';
+ me.todayCls = me.baseCls + '-today';
+ me.dayNames = me.dayNames.slice(me.startDay).concat(me.dayNames.slice(0, me.startDay));
+ this.callParent();
- this.addEvents(
-
- 'click',
-
- 'toggle',
-
- 'mouseover',
-
- 'mouseout',
-
- 'menushow',
-
- 'menuhide',
-
- 'menutriggerover',
+ me.value = me.value ?
+ clearTime(me.value, true) : clearTime(new Date());
+
+ me.addEvents(
- 'menutriggerout'
+ 'select'
);
-
- 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];
+ me.initDisabledDays();
},
- 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]);
- }
- },
+ onRender : function(container, position){
+
-
- getMenuClass : function(){
- return this.menu ? (this.arrowAlign != 'bottom' ? 'x-btn-arrow' : 'x-btn-arrow-bottom') : '';
- },
+ var me = this,
+ days = new Array(me.numDays),
+ today = Ext.Date.format(new Date(), me.format);
-
- onRender : function(ct, position){
- if(!this.template){
- if(!Ext.Button.buttonTemplate){
-
- Ext.Button.buttonTemplate = new Ext.Template(
- '',
- '
');
- Ext.Button.buttonTemplate.compile();
- }
- this.template = Ext.Button.buttonTemplate;
- }
+ Ext.applyIf(me, {
+ renderData: {},
+ renderSelectors: {}
+ });
- var btn, targs = this.getTemplateArgs();
+ Ext.apply(me.renderData, {
+ dayNames: me.dayNames,
+ ariaTitle: me.ariaTitle,
+ value: me.value,
+ showToday: me.showToday,
+ prevText: me.prevText,
+ nextText: me.nextText,
+ days: days
+ });
+ me.getTpl('renderTpl').longDayFormat = me.longDayFormat;
+
+ Ext.apply(me.renderSelectors, {
+ eventEl: 'table.' + me.baseCls + '-inner',
+ prevEl: '.' + me.baseCls + '-prev a',
+ nextEl: '.' + me.baseCls + '-next a',
+ middleBtnEl: '.' + me.baseCls + '-month',
+ footerEl: '.' + me.baseCls + '-footer'
+ });
- 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.callParent(arguments);
+ me.el.unselectable();
+
+ me.cells = me.eventEl.select('tbody td');
+ me.textNodes = me.eventEl.query('tbody td span');
+
+ me.monthBtn = Ext.create('Ext.button.Split', {
+ text: '',
+ tooltip: me.monthYearText,
+ renderTo: me.middleBtnEl
});
+
- this.initButtonEl(btn, this.btnEl);
- Ext.ButtonToggleMgr.register(this);
+ me.todayBtn = Ext.create('Ext.button.Button', {
+ renderTo: me.footerEl,
+ text: Ext.String.format(me.todayText, today),
+ tooltip: Ext.String.format(me.todayTip, today),
+ handler: me.selectToday,
+ scope: me
+ });
},
- 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);
- }
+ initEvents: function(){
+ var me = this,
+ eDate = Ext.Date,
+ day = eDate.DAY;
- if(this.handleMouseEvents){
- this.mon(btn, {
- scope: this,
- mouseover: this.onMouseOver,
- mousedown: this.onMouseDown
- });
+ this.callParent();
-
-
- }
+ me.prevRepeater = Ext.create('Ext.util.ClickRepeater', me.prevEl, {
+ handler: me.showPrevMonth,
+ scope: me,
+ preventDefault: true,
+ stopDefault: true
+ });
- if(this.menu){
- this.mon(this.menu, {
- scope: this,
- show: this.onMenuShow,
- hide: this.onMenuHide
- });
- }
+ me.nextRepeater = Ext.create('Ext.util.ClickRepeater', me.nextEl, {
+ handler: me.showNextMonth,
+ scope: me,
+ preventDefault:true,
+ stopDefault:true
+ });
- 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);
- }
- },
+ me.keyNav = Ext.create('Ext.util.KeyNav', me.eventEl, Ext.apply({
+ scope: me,
+ 'left' : function(e){
+ if(e.ctrlKey){
+ me.showPrevMonth();
+ }else{
+ me.update(eDate.add(me.activeDate, day, -1));
+ }
+ },
-
- afterRender : function(){
- Ext.Button.superclass.afterRender.call(this);
- this.useSetClass = true;
- this.setButtonClass();
- this.doc = Ext.getDoc();
- this.doAutoWidth();
- },
+ 'right' : function(e){
+ if(e.ctrlKey){
+ me.showNextMonth();
+ }else{
+ me.update(eDate.add(me.activeDate, day, 1));
+ }
+ },
-
- setIconClass : function(cls){
- this.iconCls = cls;
- if(this.el){
- this.btnEl.dom.className = '';
- this.btnEl.addClass(['x-btn-text', cls || '']);
- this.setButtonClass();
- }
- return this;
- },
+ 'up' : function(e){
+ if(e.ctrlKey){
+ me.showNextYear();
+ }else{
+ me.update(eDate.add(me.activeDate, day, -7));
+ }
+ },
-
- 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;
+ 'down' : function(e){
+ if(e.ctrlKey){
+ me.showPrevYear();
+ }else{
+ me.update(eDate.add(me.activeDate, day, 7));
+ }
+ },
+ 'pageUp' : me.showNextMonth,
+ 'pageDown' : me.showPrevMonth,
+ 'enter' : function(e){
+ e.stopPropagation();
+ return true;
}
- }else{
- this.tooltip = tooltip;
+ }, me.keyNavConfig));
+
+ if(me.showToday){
+ me.todayKeyListener = me.eventEl.addKeyListener(Ext.EventObject.SPACE, me.selectToday, me);
}
- return this;
+ me.mon(me.eventEl, 'mousewheel', me.handleMouseWheel, me);
+ me.mon(me.eventEl, 'click', me.handleDateClick, me, {delegate: 'a.' + me.baseCls + '-date'});
+ me.mon(me.monthBtn, 'click', me.showMonthPicker, me);
+ me.mon(me.monthBtn, 'arrowclick', me.showMonthPicker, me);
+ me.update(me.value);
},
- clearTip : function(){
- if(Ext.isObject(this.tooltip)){
- Ext.QuickTips.unregister(this.btnEl);
+ initDisabledDays : function(){
+ var me = this,
+ dd = me.disabledDates,
+ re = '(?:',
+ len;
+
+ if(!me.disabledDatesRE && dd){
+ len = dd.length - 1;
+
+ Ext.each(dd, function(d, i){
+ re += Ext.isDate(d) ? '^' + Ext.String.escapeRegex(Ext.Date.dateFormat(d, me.format)) + '$' : dd[i];
+ if(i != len){
+ re += '|';
+ }
+ }, me);
+ me.disabledDatesRE = new RegExp(re + ')');
}
},
- beforeDestroy : function(){
- if(this.rendered){
- this.clearTip();
- }
- if(this.menu && this.destroyMenu !== false) {
- Ext.destroy(this.btnEl, this.menu);
+ setDisabledDates : function(dd){
+ var me = this;
+
+ if(Ext.isArray(dd)){
+ me.disabledDates = dd;
+ me.disabledDatesRE = null;
+ }else{
+ me.disabledDatesRE = dd;
}
- Ext.destroy(this.repeater);
+ me.initDisabledDays();
+ me.update(me.value, true);
+ return me;
},
- 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);
+ setDisabledDays : function(dd){
+ this.disabledDays = dd;
+ return this.update(this.value, true);
},
- 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);
- }
- }
- }
+ setMinDate : function(dt){
+ this.minDate = dt;
+ return this.update(this.value, true);
},
- setHandler : function(handler, scope){
- this.handler = handler;
- this.scope = scope;
- return this;
+ setMaxDate : function(dt){
+ this.maxDate = dt;
+ return this.update(this.value, true);
},
- setText : function(text){
- this.text = text;
- if(this.el){
- this.btnEl.update(text || ' ');
- this.setButtonClass();
- }
- this.doAutoWidth();
- return this;
+ setValue : function(value){
+ this.value = Ext.Date.clearTime(value, true);
+ return this.update(this.value);
},
- setIcon : function(icon){
- this.icon = icon;
- if(this.el){
- this.btnEl.setStyle('background-image', icon ? 'url(' + icon + ')' : '');
- this.setButtonClass();
- }
- return this;
+ getValue : function(){
+ return this.value;
},
- getText : function(){
- return this.text;
+ focus : function(){
+ this.update(this.activeDate);
},
- 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;
+ onEnable: function(){
+ this.callParent();
+ this.setDisabledStatus(false);
+ this.update(this.activeDate);
+
},
onDisable : function(){
- this.onDisableChange(true);
+ this.callParent();
+ this.setDisabledStatus(true);
},
- onEnable : function(){
- this.onDisableChange(false);
- },
+ setDisabledStatus : function(disabled){
+ var me = this;
- onDisableChange : function(disabled){
- if(this.el){
- if(!Ext.isIE6 || !this.text){
- this.el[disabled ? 'addClass' : 'removeClass'](this.disabledClass);
- }
- this.el.dom.disabled = disabled;
+ me.keyNav.setDisabled(disabled);
+ me.prevRepeater.setDisabled(disabled);
+ me.nextRepeater.setDisabled(disabled);
+ if (me.showToday) {
+ me.todayKeyListener.setDisabled(disabled);
+ me.todayBtn.setDisabled(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;
+ getActive: function(){
+ return this.activeDate || me.value;
},
- hideMenu : function(){
- if(this.hasVisibleMenu()){
- this.menu.hide();
+ runAnimation: function(isHide){
+ var options = {
+ target: this.monthPicker,
+ duration: 200
+ };
+
+ Ext.fx.Manager.run();
+ if (isHide) {
+
+ } else {
+
}
- return this;
+ Ext.create('Ext.fx.Anim', options);
},
- hasVisibleMenu : function(){
- return this.menu && this.menu.ownerCt == this && this.menu.isVisible();
- },
-
-
- onRepeatClick : function(repeat, e){
- this.onClick(e);
- },
+ hideMonthPicker : function(){
+ var me = this,
+ picker = me.monthPicker;
-
- 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);
+ if (picker) {
+ if (me.disableAnim) {
+ picker.hide();
+ } else {
+ this.runAnimation(true);
}
}
- },
-
-
- doToggle: function(){
- if (this.enableToggle && (this.allowDepress !== false || !this.pressed)) {
- this.toggle();
- }
+ return me;
},
- isMenuTriggerOver : function(e, internal){
- return this.menu && !internal;
- },
+ showMonthPicker : function(){
-
- isMenuTriggerOut : function(e, internal){
- return this.menu && !internal;
- },
+ var me = this,
+ picker,
+ size,
+ top,
+ left;
-
- 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;
+ if (me.rendered && !me.disabled) {
+ size = me.getSize();
+ picker = me.createMonthPicker();
+ picker.show();
+ picker.setSize(size);
+ picker.setValue(me.getActive());
+
+ if (me.disableAnim) {
+ picker.setPosition(-1, -1);
+ } else {
+ me.runAnimation(false);
}
- this.onMouseOut(e);
}
+ return me;
},
- 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);
- }
- },
+ createMonthPicker: function(){
+ var me = this,
+ picker = me.monthPicker;
- focus : function() {
- this.btnEl.focus();
- },
+ if (!picker) {
+ me.monthPicker = picker = Ext.create('Ext.picker.Month', {
+ renderTo: me.el,
+ floating: true,
+ shadow: false,
+ listeners: {
+ scope: me,
+ cancelclick: me.onCancelClick,
+ okclick: me.onOkClick,
+ yeardblclick: me.onOkClick,
+ monthdblclick: me.onOkClick
+ }
+ });
- blur : function() {
- this.btnEl.blur();
+ me.on('beforehide', me.hideMonthPicker, me);
+ }
+ return picker;
},
- onFocus : function(e){
- if(!this.disabled){
- this.el.addClass('x-btn-focus');
+ onOkClick: function(picker, value){
+ var me = this,
+ month = value[0],
+ year = value[1],
+ date = new Date(year, month, me.getActive().getDate());
+
+ if (date.getMonth() !== month) {
+
+ date = new Date(year, month, 1).getLastDateOfMonth();
}
+ me.update(date);
+ me.hideMonthPicker();
},
+
- onBlur : function(e){
- this.el.removeClass('x-btn-focus');
+ onCancelClick: function(){
+ this.hideMonthPicker();
},
- getClickEl : function(e, isUp){
- return this.el;
+ showPrevMonth : function(e){
+ return this.update(Ext.Date.add(this.activeDate, Ext.Date.MONTH, -1));
},
- onMouseDown : function(e){
- if(!this.disabled && e.button === 0){
- this.getClickEl(e).addClass('x-btn-click');
- this.doc.on('mouseup', this.onMouseUp, this);
- }
+ showNextMonth : function(e){
+ return this.update(Ext.Date.add(this.activeDate, Ext.Date.MONTH, 1));
},
+
- onMouseUp : function(e){
- if(e.button === 0){
- this.getClickEl(e, true).removeClass('x-btn-click');
- this.doc.un('mouseup', this.onMouseUp, this);
- }
+ showPrevYear : function(){
+ this.update(Ext.Date.add(this.activeDate, Ext.Date.YEAR, -1));
},
+
- 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);
- }
+ showNextYear : function(){
+ this.update(Ext.Date.add(this.activeDate, Ext.Date.YEAR, 1));
},
+
- 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;
+ handleMouseWheel : function(e){
+ e.stopEvent();
+ if(!this.disabled){
+ var delta = e.getWheelDelta();
+ if(delta > 0){
+ this.showPrevMonth();
+ } else if(delta < 0){
+ this.showNextMonth();
+ }
}
},
- 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");
- },
+ handleDateClick : function(e, t){
+ var me = this,
+ handler = me.handler;
-
- onRender : function(){
- Ext.SplitButton.superclass.onRender.apply(this, arguments);
- if(this.arrowTooltip){
- this.el.child(this.arrowSelector).dom[this.tooltipType] = this.arrowTooltip;
+ e.stopEvent();
+ if(!me.disabled && t.dateValue && !Ext.fly(t.parentNode).hasCls(me.disabledCellCls)){
+ me.cancelFocus = me.focusOnSelect === false;
+ me.setValue(new Date(t.dateValue));
+ delete me.cancelFocus;
+ me.fireEvent('select', me, me.value);
+ if (handler) {
+ handler.call(me.scope || me, me, me.value);
+ }
+
+
+
+
+ me.onSelect();
}
},
- setArrowHandler : function(handler, scope){
- this.arrowHandler = handler;
- this.scope = scope;
+ onSelect: function() {
+ if (this.hideOnSelect) {
+ this.hide();
+ }
},
- getMenuClass : function(){
- return 'x-btn-split' + (this.arrowAlign == 'bottom' ? '-bottom' : '');
- },
+
+ selectToday : function(){
+ var me = this,
+ btn = me.todayBtn,
+ handler = me.handler;
- 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;
- }
+ if(btn && !btn.disabled){
+ me.setValue(Ext.Date.clearTime(new Date()));
+ me.fireEvent('select', me, me.value);
+ if (handler) {
+ handler.call(me.scope || me, me, me.value);
+ }
+ me.onSelect();
+ }
+ return me;
},
- 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);
+ selectedUpdate: function(date, active){
+ var me = this,
+ t = date.getTime(),
+ cells = me.cells,
+ cls = me.selectedCls;
+
+ cells.removeCls(cls);
+ cells.each(function(c){
+ if (c.dom.firstChild.dateValue == t) {
+ me.el.dom.setAttribute('aria-activedescendent', c.dom.id);
+ c.addCls(cls);
+ if(me.isVisible() && !me.cancelFocus){
+ Ext.fly(c.dom.firstChild).focus(50);
}
+ return false;
}
- }
+ }, this);
},
- isMenuTriggerOver : function(e){
- return this.menu && e.target.tagName == this.arrowSelector;
- },
+ fullUpdate: function(date, active){
+ var me = this,
+ cells = me.cells.elements,
+ textNodes = me.textNodes,
+ disabledCls = me.disabledCellCls,
+ eDate = Ext.Date,
+ i = 0,
+ extraDays = 0,
+ visible = me.isVisible(),
+ sel = +eDate.clearTime(date, true),
+ today = +eDate.clearTime(new Date()),
+ min = me.minDate ? eDate.clearTime(me.minDate, true) : Number.NEGATIVE_INFINITY,
+ max = me.maxDate ? eDate.clearTime(me.maxDate, true) : Number.POSITIVE_INFINITY,
+ ddMatch = me.disabledDatesRE,
+ ddText = me.disabledDatesText,
+ ddays = me.disabledDays ? me.disabledDays.join('') : false,
+ ddaysText = me.disabledDaysText,
+ format = me.format,
+ days = eDate.getDaysInMonth(date),
+ firstOfMonth = eDate.getFirstDateOfMonth(date),
+ startingPos = firstOfMonth.getDay() - me.startDay,
+ previousMonth = eDate.add(date, eDate.MONTH, -1),
+ longDayFormat = me.longDayFormat,
+ prevStart,
+ current,
+ disableToday,
+ tempDate,
+ setCellClass,
+ html,
+ cls,
+ formatValue,
+ value;
-
- isMenuTriggerOut : function(e, internal){
- return this.menu && e.target.tagName != this.arrowSelector;
- }
-});
+ if (startingPos < 0) {
+ startingPos += 7;
+ }
-Ext.reg('splitbutton', Ext.SplitButton);
-Ext.CycleButton = Ext.extend(Ext.SplitButton, {
-
-
-
-
-
-
+ days += startingPos;
+ prevStart = eDate.getDaysInMonth(previousMonth) - startingPos;
+ current = new Date(previousMonth.getFullYear(), previousMonth.getMonth(), prevStart, me.initHour);
-
- getItemText : function(item){
- if(item && this.showText === true){
- var text = '';
- if(this.prependText){
- text += this.prependText;
+ if (me.showToday) {
+ tempDate = eDate.clearTime(new Date());
+ disableToday = (tempDate < min || tempDate > max ||
+ (ddMatch && format && ddMatch.test(eDate.dateFormat(tempDate, format))) ||
+ (ddays && ddays.indexOf(tempDate.getDay()) != -1));
+
+ if (!me.disabled) {
+ me.todayBtn.setDisabled(disableToday);
+ me.todayKeyListener.setDisabled(disableToday);
}
- 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);
+ setCellClass = function(cell){
+ value = +eDate.clearTime(current, true);
+ cell.title = eDate.format(current, longDayFormat);
+
+ cell.firstChild.dateValue = value;
+ if(value == today){
+ cell.className += ' ' + me.todayCls;
+ cell.title = me.todayText;
+ }
+ if(value == sel){
+ cell.className += ' ' + me.selectedCls;
+ me.el.dom.setAttribute('aria-activedescendant', cell.id);
+ if (visible && me.floating) {
+ Ext.fly(cell.firstChild).focus(50);
}
- this.setIconClass(item.iconCls);
}
- this.activeItem = item;
- if(!item.checked){
- item.setChecked(true, false);
+
+ if(value < min) {
+ cell.className = disabledCls;
+ cell.title = me.minText;
+ return;
+ }
+ if(value > max) {
+ cell.className = disabledCls;
+ cell.title = me.maxText;
+ return;
+ }
+ if(ddays){
+ if(ddays.indexOf(current.getDay()) != -1){
+ cell.title = ddaysText;
+ cell.className = disabledCls;
+ }
}
- if(this.forceIcon){
- this.setIconClass(this.forceIcon);
+ if(ddMatch && format){
+ formatValue = eDate.dateFormat(current, format);
+ if(ddMatch.test(formatValue)){
+ cell.title = ddText.replace('%0', formatValue);
+ cell.className = disabledCls;
+ }
}
- if(!suppressEvent){
- this.fireEvent('change', this, item);
+ };
+
+ for(; i < me.numDays; ++i) {
+ if (i < startingPos) {
+ html = (++prevStart);
+ cls = me.prevCls;
+ } else if (i >= days) {
+ html = (++extraDays);
+ cls = me.nextCls;
+ } else {
+ html = i - startingPos + 1;
+ cls = me.activeCls;
}
+ textNodes[i].innerHTML = html;
+ cells[i].className = cls;
+ current.setDate(current.getDate() + 1);
+ setCellClass(cells[i]);
}
- },
-
- getActiveItem : function(){
- return this.activeItem;
+ me.monthBtn.setText(me.monthNames[date.getMonth()] + ' ' + date.getFullYear());
},
- initComponent : function(){
- this.addEvents(
-
- "change"
- );
-
- if(this.changeHandler){
- this.on('change', this.changeHandler, this.scope||this);
- delete this.changeHandler;
- }
-
- this.itemCount = this.items.length;
+ update : function(date, forceRefresh){
+ var me = this,
+ active = me.activeDate;
- this.menu = {cls:'x-cycle-menu', items:[]};
- var checked = 0;
- Ext.each(this.items, function(item, i){
- Ext.apply(item, {
- group: item.group || this.id,
- itemIndex: i,
- checkHandler: this.checkHandler,
- scope: this,
- checked: item.checked || false
- });
- this.menu.items.push(item);
- if(item.checked){
- checked = i;
+ if (me.rendered) {
+ me.activeDate = date;
+ if(!forceRefresh && active && me.el && active.getMonth() == date.getMonth() && active.getFullYear() == date.getFullYear()){
+ me.selectedUpdate(date, active);
+ } else {
+ me.fullUpdate(date, active);
}
- }, this);
- Ext.CycleButton.superclass.initComponent.call(this);
- this.on('click', this.toggleSelected, this);
- this.setActiveItem(checked, true);
+ }
+ return me;
},
- checkHandler : function(item, pressed){
- if(pressed){
- this.setActiveItem(item);
+ beforeDestroy : function() {
+ var me = this;
+
+ if (me.rendered) {
+ Ext.destroy(
+ me.todayKeyListener,
+ me.keyNav,
+ me.monthPicker,
+ me.monthBtn,
+ me.nextRepeater,
+ me.prevRepeater,
+ me.todayBtn
+ );
+ delete me.textNodes;
+ delete me.cells.elements;
}
},
- 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;
+ onShow: function() {
+ this.callParent(arguments);
+ if (this.focusOnShow) {
+ this.focus();
}
}
- Ext.Toolbar.superclass.constructor.call(this, config);
-};
+},
-(function(){
-var T = Ext.Toolbar;
+function() {
+ var proto = this.prototype;
+
+ proto.monthNames = Ext.Date.monthNames;
-Ext.extend(T, Ext.Container, {
+ proto.dayNames = Ext.Date.dayNames;
- defaultType: 'button',
+ proto.format = Ext.Date.defaultFormat;
+});
-
- enableOverflow : false,
+Ext.define('Ext.form.field.Date', {
+ extend:'Ext.form.field.Picker',
+ alias: 'widget.datefield',
+ requires: ['Ext.picker.Date'],
+ alternateClassName: ['Ext.form.DateField', 'Ext.form.Date'],
+
+
+ format : "m/d/Y",
+
+ altFormats : "m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d|n-j|n/j",
+
+ disabledDaysText : "Disabled",
+
+ disabledDatesText : "Disabled",
+
+ minText : "The date in this field must be equal to or after {0}",
+
+ maxText : "The date in this field must be equal to or before {0}",
+
+ invalidText : "{0} is not a valid date - it must be in the format {1}",
+
+ triggerCls : Ext.baseCSSPrefix + 'form-date-trigger',
+
+ showToday : true,
+
+
+
+
+
+
+ initTime: '12',
- trackMenus : true,
- internalDefaults: {removeMode: 'container', hideParent: true},
- toolbarCls: 'x-toolbar',
+ initTimeFormat: 'H',
+ matchFieldWidth: false,
+
+ startDay: 0,
+
initComponent : function(){
- T.superclass.initComponent.call(this);
+ var me = this,
+ isString = Ext.isString,
+ min, max;
-
- this.addEvents('overflowchange');
+ min = me.minValue;
+ max = me.maxValue;
+ if(isString(min)){
+ me.minValue = me.parseDate(min);
+ }
+ if(isString(max)){
+ me.maxValue = me.parseDate(max);
+ }
+ me.disabledDatesRE = null;
+ me.initDisabledDays();
+
+ me.callParent();
},
-
- 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);
+ initValue: function() {
+ var me = this,
+ value = me.value;
+
+
+ if (Ext.isString(value)) {
+ me.value = me.rawToValue(value);
}
+
+ me.callParent();
},
+ initDisabledDays : function(){
+ if(this.disabledDates){
+ var dd = this.disabledDates,
+ len = dd.length - 1,
+ re = "(?:";
-
- 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);
- }
+ Ext.each(dd, function(d, i){
+ re += Ext.isDate(d) ? '^' + Ext.String.escapeRegex(d.dateFormat(this.format)) + '$' : dd[i];
+ if (i !== len) {
+ re += '|';
+ }
+ }, this);
+ this.disabledDatesRE = new RegExp(re + ')');
}
- 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);
- }else{
- Ext.applyIf(c, d);
- }
+ setDisabledDates : function(dd){
+ var me = this,
+ picker = me.picker;
+
+ me.disabledDates = dd;
+ me.initDisabledDays();
+ if (picker) {
+ picker.setDisabledDates(me.disabledDatesRE);
}
- return c;
},
- addSeparator : function(){
- return this.add(new T.Separator());
+ setDisabledDays : function(dd){
+ var picker = this.picker;
+
+ this.disabledDays = dd;
+ if (picker) {
+ picker.setDisabledDays(dd);
+ }
},
- addSpacer : function(){
- return this.add(new T.Spacer());
+ setMinValue : function(dt){
+ var me = this,
+ picker = me.picker,
+ minValue = (Ext.isString(dt) ? me.parseDate(dt) : dt);
+
+ me.minValue = minValue;
+ if (picker) {
+ picker.minText = Ext.String.format(me.minText, me.formatDate(me.minValue));
+ picker.setMinDate(minValue);
+ }
},
- addFill : function(){
- this.add(new T.Fill());
+ setMaxValue : function(dt){
+ var me = this,
+ picker = me.picker,
+ maxValue = (Ext.isString(dt) ? me.parseDate(dt) : dt);
+
+ me.maxValue = maxValue;
+ if (picker) {
+ picker.maxText = Ext.String.format(me.maxText, me.formatDate(me.maxValue));
+ picker.setMaxDate(maxValue);
+ }
},
- addElement : function(el){
- return this.addItem(new T.Item({el:el}));
- },
+ getErrors: function(value) {
+ var me = this,
+ format = Ext.String.format,
+ clearTime = Ext.Date.clearTime,
+ errors = me.callParent(arguments),
+ disabledDays = me.disabledDays,
+ disabledDatesRE = me.disabledDatesRE,
+ minValue = me.minValue,
+ maxValue = me.maxValue,
+ len = disabledDays ? disabledDays.length : 0,
+ i = 0,
+ svalue,
+ fvalue,
+ day,
+ time;
-
- addItem : function(item){
- return this.add.apply(this, arguments);
- },
+ value = me.formatDate(value || me.processRawValue(me.getRawValue()));
-
- 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]));
+ if (value === null || value.length < 1) {
+ return errors;
+ }
+
+ svalue = value;
+ value = me.parseDate(value);
+ if (!value) {
+ errors.push(format(me.invalidText, svalue, me.format));
+ return errors;
+ }
+
+ time = value.getTime();
+ if (minValue && time < clearTime(minValue).getTime()) {
+ errors.push(format(me.minText, me.formatDate(minValue)));
+ }
+
+ if (maxValue && time > clearTime(maxValue).getTime()) {
+ errors.push(format(me.maxText, me.formatDate(maxValue)));
+ }
+
+ if (disabledDays) {
+ day = value.getDay();
+
+ for(; i < len; i++) {
+ if (day === disabledDays[i]) {
+ errors.push(me.disabledDaysText);
+ break;
+ }
}
- return buttons;
}
- return this.add(this.constructButton(config));
+
+ fvalue = me.formatDate(value);
+ if (disabledDatesRE && disabledDatesRE.test(fvalue)) {
+ errors.push(format(me.disabledDatesText, fvalue));
+ }
+
+ return errors;
},
-
- addText : function(text){
- return this.addItem(new T.TextItem(text));
+ rawToValue: function(rawValue) {
+ return this.parseDate(rawValue) || rawValue || null;
},
-
- addDom : function(config){
- return this.add(new T.Item({autoEl: config}));
+ valueToRaw: function(value) {
+ return this.formatDate(this.parseDate(value));
},
- 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]));
+ safeParse : function(value, format) {
+ var me = this,
+ utilDate = Ext.Date,
+ parsedDate,
+ result = null;
+
+ if (utilDate.formatContainsHourInfo(format)) {
+
+ result = utilDate.parse(value, format);
+ } else {
+
+ parsedDate = utilDate.parse(value + ' ' + me.initTime, format + ' ' + me.initTimeFormat);
+ if (parsedDate) {
+ result = utilDate.clearTime(parsedDate);
}
- return buttons;
}
- return Ext.Toolbar.superclass.insert.call(this, index, item);
+ return result;
},
-
- 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;
+ getSubmitValue: function() {
+ var me = this,
+ format = me.submitFormat || me.format,
+ value = me.getValue();
+
+ return value ? Ext.Date.format(value, format) : null;
},
- onAdd : function(c){
- Ext.Toolbar.superclass.onAdd.call(this);
- this.trackMenu(c);
- if(this.disabled){
- c.disable();
+ parseDate : function(value) {
+ if(!value || Ext.isDate(value)){
+ return value;
}
- },
-
- onRemove : function(c){
- Ext.Toolbar.superclass.onRemove.call(this);
- if (c == this.activeMenuBtn) {
- delete this.activeMenuBtn;
+ var me = this,
+ val = me.safeParse(value, me.format),
+ altFormats = me.altFormats,
+ altFormatsArray = me.altFormatsArray,
+ i = 0,
+ len;
+
+ if (!val && altFormats) {
+ altFormatsArray = altFormatsArray || altFormats.split('|');
+ len = altFormatsArray.length;
+ for (; i < len && !val; ++i) {
+ val = me.safeParse(value, altFormatsArray[i]);
+ }
}
- this.trackMenu(c, true);
+ return val;
},
- onDisable : function(){
- this.items.each(function(item){
- if(item.disable){
- item.disable();
- }
- });
+ formatDate : function(date){
+ return Ext.isDate(date) ? Ext.Date.dateFormat(date, this.format) : date;
},
-
- onEnable : function(){
- this.items.each(function(item){
- if(item.enable){
- item.enable();
- }
+ createPicker: function() {
+ var me = this,
+ format = Ext.String.format;
+
+ return Ext.create('Ext.picker.Date', {
+ ownerCt: this.ownerCt,
+ renderTo: document.body,
+ floating: true,
+ hidden: true,
+ focusOnShow: true,
+ minDate: me.minValue,
+ maxDate: me.maxValue,
+ disabledDatesRE: me.disabledDatesRE,
+ disabledDatesText: me.disabledDatesText,
+ disabledDays: me.disabledDays,
+ disabledDaysText: me.disabledDaysText,
+ format: me.format,
+ showToday: me.showToday,
+ startDay: me.startDay,
+ minText: format(me.minText, me.formatDate(me.minValue)),
+ maxText: format(me.maxText, me.formatDate(me.maxValue)),
+ listeners: {
+ scope: me,
+ select: me.onSelect
+ },
+ keyNavConfig: {
+ esc: function() {
+ me.collapse();
+ }
+ }
});
},
-
- onButtonTriggerOver : function(btn){
- if(this.activeMenuBtn && this.activeMenuBtn != btn){
- this.activeMenuBtn.hideMenu();
- btn.showMenu();
- this.activeMenuBtn = btn;
- }
+ onSelect: function(m, d) {
+ this.setValue(d);
+ this.fireEvent('select', this, d);
+ this.collapse();
},
- onButtonMenuShow : function(btn){
- this.activeMenuBtn = btn;
+ onExpand: function() {
+ var me = this,
+ value = me.getValue();
+ me.picker.setValue(value instanceof Date ? value : new Date());
},
- onButtonMenuHide : function(btn){
- delete this.activeMenuBtn;
- }
-});
-Ext.reg('toolbar', Ext.Toolbar);
-
+ onCollapse: function() {
+ this.focus(false, 60);
+ },
-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);
+ beforeBlur : function(){
+ var v = this.parseDate(this.getRawValue());
+ if(v){
+ this.setValue(v);
+ }
}
-});
-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);
- },
+Ext.define('Ext.form.field.Display', {
+ extend:'Ext.form.field.Base',
+ alias: 'widget.displayfield',
+ requires: ['Ext.util.Format', 'Ext.XTemplate'],
+ alternateClassName: ['Ext.form.DisplayField', 'Ext.form.Display'],
+ fieldSubTpl: [
+ '',
+ {
+ compiled: true,
+ disableFormats: true
+ }
+ ],
- onRender : function(ct, position) {
- this.autoEl = {cls: 'xtb-text', html: this.text || ''};
- T.TextItem.superclass.onRender.call(this, ct, position);
- },
+ fieldCls: Ext.baseCSSPrefix + 'form-display-field',
- setText : function(t) {
- if(this.rendered){
- this.el.update(t);
- }else{
- this.text = t;
- }
- }
-});
-Ext.reg('tbtext', T.TextItem);
+ htmlEncode: false,
+ validateOnChange: false,
-T.Button = Ext.extend(Ext.Button, {});
-T.SplitButton = Ext.extend(Ext.SplitButton, {});
-Ext.reg('tbbutton', T.Button);
-Ext.reg('tbsplit', T.SplitButton);
+ initEvents: Ext.emptyFn,
-})();
+ submitValue: false,
-Ext.ButtonGroup = Ext.extend(Ext.Panel, {
-
-
- baseCls: 'x-btn-group',
-
- layout:'table',
- defaultType: 'button',
-
- frame: true,
- internalDefaults: {removeMode: 'container', hideParent: true},
+ isValid: function() {
+ return true;
+ },
- initComponent : function(){
- this.layoutConfig = this.layoutConfig || {};
- Ext.applyIf(this.layoutConfig, {
- columns : this.columns
- });
- if(!this.title){
- this.addClass('x-btn-group-notitle');
- }
- this.on('afterlayout', this.onAfterLayout, this);
- Ext.ButtonGroup.superclass.initComponent.call(this);
+ validate: function() {
+ return true;
},
- applyDefaults : function(c){
- c = Ext.ButtonGroup.superclass.applyDefaults.call(this, c);
- var d = this.internalDefaults;
- if(c.events){
- Ext.applyIf(c.initialConfig, d);
- Ext.apply(c, d);
- }else{
- Ext.applyIf(c, d);
+ getRawValue: function() {
+ return this.rawValue;
+ },
+
+ setRawValue: function(value) {
+ var me = this;
+ value = Ext.value(value, '');
+ me.rawValue = value;
+ if (me.rendered) {
+ me.inputEl.dom.innerHTML = me.htmlEncode ? Ext.util.Format.htmlEncode(value) : value;
}
- return c;
+ return value;
},
- onAfterLayout : function(){
- var bodyWidth = this.body.getFrameWidth('lr') + this.body.dom.firstChild.offsetWidth;
- this.body.setWidth(bodyWidth);
- this.el.setWidth(bodyWidth + this.getFrameWidth());
- }
-});
-
-Ext.reg('buttongroup', Ext.ButtonGroup);
-
-(function() {
-
-var T = Ext.Toolbar;
+ getContentTarget: function() {
+ return this.inputEl;
+ }
-Ext.PagingToolbar = Ext.extend(Ext.Toolbar, {
-
-
-
- pageSize : 20,
-
- displayMsg : 'Displaying {0} - {1} of {2}',
-
- emptyMsg : 'No data to display',
-
- beforePageText : 'Page',
-
- afterPageText : 'of {0}',
- firstText : 'First Page',
- prevText : 'Previous Page',
- nextText : 'Next Page',
- lastText : 'Last Page',
- refreshText : 'Refresh',
+});
-
-
+Ext.define("Ext.form.field.File", {
+ extend: 'Ext.form.field.Text',
+ alias: ['widget.filefield', 'widget.fileuploadfield'],
+ alternateClassName: ['Ext.form.FileUploadField', 'Ext.ux.form.FileUploadField', 'Ext.form.File'],
+ uses: ['Ext.button.Button', 'Ext.layout.component.field.File'],
-
- initComponent : function(){
- var pagingItems = [this.first = new T.Button({
- tooltip: this.firstText,
- overflowText: this.firstText,
- iconCls: 'x-tbar-page-first',
- disabled: true,
- handler: this.moveFirst,
- scope: this
- }), this.prev = new T.Button({
- tooltip: this.prevText,
- overflowText: this.prevText,
- iconCls: 'x-tbar-page-prev',
- disabled: true,
- handler: this.movePrevious,
- scope: this
- }), '-', this.beforePageText,
- this.inputItem = new Ext.form.NumberField({
- cls: 'x-tbar-page-number',
- allowDecimals: false,
- allowNegative: false,
- enableKeyEvents: true,
- selectOnFocus: true,
- submitValue: false,
- listeners: {
- scope: this,
- keydown: this.onPagingKeyDown,
- blur: this.onPagingBlur
- }
- }), this.afterTextItem = new T.TextItem({
- text: String.format(this.afterPageText, 1)
- }), '-', this.next = new T.Button({
- tooltip: this.nextText,
- overflowText: this.nextText,
- iconCls: 'x-tbar-page-next',
- disabled: true,
- handler: this.moveNext,
- scope: this
- }), this.last = new T.Button({
- tooltip: this.lastText,
- overflowText: this.lastText,
- iconCls: 'x-tbar-page-last',
- disabled: true,
- handler: this.moveLast,
- scope: this
- }), '-', this.refresh = new T.Button({
- tooltip: this.refreshText,
- overflowText: this.refreshText,
- iconCls: 'x-tbar-loading',
- handler: this.doRefresh,
- scope: this
- })];
-
-
- var userItems = this.items || this.buttons || [];
- if (this.prependButtons) {
- this.items = userItems.concat(pagingItems);
- }else{
- this.items = pagingItems.concat(userItems);
- }
- delete this.buttons;
- if(this.displayInfo){
- this.items.push('->');
- this.items.push(this.displayItem = new T.TextItem({}));
- }
- Ext.PagingToolbar.superclass.initComponent.call(this);
- this.addEvents(
-
- 'change',
-
- 'beforechange'
- );
- this.on('afterlayout', this.onFirstLayout, this, {single: true});
- this.cursor = 0;
- this.bindStore(this.store, true);
- },
+ buttonText: 'Browse...',
- onFirstLayout : function(){
- if(this.dsLoaded){
- this.onLoad.apply(this, this.dsLoaded);
- }
- },
+ buttonOnly: false,
- updateInfo : function(){
- if(this.displayItem){
- var count = this.store.getCount();
- var msg = count == 0 ?
- this.emptyMsg :
- String.format(
- this.displayMsg,
- this.cursor+1, this.cursor+count, this.store.getTotalCount()
- );
- this.displayItem.setText(msg);
- }
- },
+ buttonMargin: 3,
- onLoad : function(store, r, o){
- if(!this.rendered){
- this.dsLoaded = [store, r, o];
- return;
- }
- var p = this.getParams();
- this.cursor = (o.params && o.params[p.start]) ? o.params[p.start] : 0;
- var d = this.getPageData(), ap = d.activePage, ps = d.pages;
-
- this.afterTextItem.setText(String.format(this.afterPageText, d.pages));
- this.inputItem.setValue(ap);
- this.first.setDisabled(ap == 1);
- this.prev.setDisabled(ap == 1);
- this.next.setDisabled(ap == ps);
- this.last.setDisabled(ap == ps);
- this.refresh.enable();
- this.updateInfo();
- this.fireEvent('change', this, d);
- },
- getPageData : function(){
- var total = this.store.getTotalCount();
- return {
- total : total,
- activePage : Math.ceil((this.cursor+this.pageSize)/this.pageSize),
- pages : total < this.pageSize ? 1 : Math.ceil(total/this.pageSize)
- };
- },
- changePage : function(page){
- this.doLoad(((page-1) * this.pageSize).constrain(0, this.store.getTotalCount()));
- },
- onLoadError : function(){
- if(!this.rendered){
- return;
- }
- this.refresh.enable();
- },
- readPage : function(d){
- var v = this.inputItem.getValue(), pageNum;
- if (!v || isNaN(pageNum = parseInt(v, 10))) {
- this.inputItem.setValue(d.activePage);
- return false;
- }
- return pageNum;
- },
+ fieldBodyCls: Ext.baseCSSPrefix + 'form-file-wrap',
- onPagingFocus : function(){
- this.inputItem.select();
- },
- onPagingBlur : function(e){
- this.inputItem.setValue(this.getPageData().activePage);
- },
+ readOnly: true,
+ componentLayout: 'filefield',
- onPagingKeyDown : function(field, e){
- var k = e.getKey(), d = this.getPageData(), pageNum;
- if (k == e.RETURN) {
- e.stopEvent();
- pageNum = this.readPage(d);
- if(pageNum !== false){
- pageNum = Math.min(Math.max(1, pageNum), d.pages) - 1;
- this.doLoad(pageNum * this.pageSize);
- }
- }else if (k == e.HOME || k == e.END){
- e.stopEvent();
- pageNum = k == e.HOME ? 1 : d.pages;
- field.setValue(pageNum);
- }else if (k == e.UP || k == e.PAGEUP || k == e.DOWN || k == e.PAGEDOWN){
- e.stopEvent();
- if((pageNum = this.readPage(d))){
- var increment = e.shiftKey ? 10 : 1;
- if(k == e.DOWN || k == e.PAGEDOWN){
- increment *= -1;
- }
- pageNum += increment;
- if(pageNum >= 1 & pageNum <= d.pages){
- field.setValue(pageNum);
- }
- }
- }
- },
+ onRender: function() {
+ var me = this,
+ inputEl;
-
- getParams : function(){
-
- return this.paramNames || this.store.paramNames;
- },
+ me.callParent(arguments);
-
- beforeLoad : function(){
- if(this.rendered && this.refresh){
- this.refresh.disable();
+ me.createButton();
+ me.createFileInput();
+
+
+
+ if (me.disabled) {
+ me.disableItems();
}
- },
-
- doLoad : function(start){
- var o = {}, pn = this.getParams();
- o[pn.start] = start;
- o[pn.limit] = this.pageSize;
- if(this.fireEvent('beforechange', this, o) !== false){
- this.store.load({params:o});
+ inputEl = me.inputEl;
+ inputEl.dom.removeAttribute('name');
+ if (me.buttonOnly) {
+ inputEl.setDisplayed(false);
}
},
- moveFirst : function(){
- this.doLoad(0);
+ createButton: function() {
+ var me = this;
+ me.button = Ext.widget('button', Ext.apply({
+ renderTo: me.bodyEl,
+ text: me.buttonText,
+ cls: Ext.baseCSSPrefix + 'form-file-btn',
+ preventDefault: false,
+ ownerCt: me,
+ style: me.buttonOnly ? '' : 'margin-left:' + me.buttonMargin + 'px'
+ }, me.buttonConfig));
},
- movePrevious : function(){
- this.doLoad(Math.max(0, this.cursor-this.pageSize));
+ createFileInput : function() {
+ var me = this;
+ me.fileInputEl = me.button.el.createChild({
+ name: me.getName(),
+ cls: Ext.baseCSSPrefix + 'form-file-input',
+ tag: 'input',
+ type: 'file',
+ size: 1
+ }).on('change', me.onFileChange, me);
},
- moveNext : function(){
- this.doLoad(this.cursor+this.pageSize);
+ onFileChange: function() {
+ this.lastValue = null;
+ Ext.form.field.File.superclass.setValue.call(this, this.fileInputEl.dom.value);
},
- moveLast : function(){
- var total = this.store.getTotalCount(),
- extra = total % this.pageSize;
+ setValue: Ext.emptyFn,
- this.doLoad(extra ? (total - extra) : total - this.pageSize);
+ reset : function(){
+ this.fileInputEl.remove();
+ this.createFileInput();
+ this.callParent();
},
-
- doRefresh : function(){
- this.doLoad(this.cursor);
+ onDisable: function(){
+ this.callParent();
+ this.disableItems();
},
-
- bindStore : function(store, initial){
- var doLoad;
- if(!initial && this.store){
- if(store !== this.store && this.store.autoDestroy){
- this.store.destroy();
- }else{
- this.store.un('beforeload', this.beforeLoad, this);
- this.store.un('load', this.onLoad, this);
- this.store.un('exception', this.onLoadError, this);
- }
- if(!store){
- this.store = null;
- }
- }
- if(store){
- store = Ext.StoreMgr.lookup(store);
- store.on({
- scope: this,
- beforeload: this.beforeLoad,
- load: this.onLoad,
- exception: this.onLoadError
- });
- doLoad = true;
- }
- this.store = store;
- if(doLoad){
- this.onLoad(store, null, {});
+ disableItems: function(){
+ var file = this.fileInputEl,
+ button = this.button;
+
+ if (file) {
+ file.dom.disabled = true;
}
+ if (button) {
+ button.disable();
+ }
},
-
- unbind : function(store){
- this.bindStore(null);
+ onEnable: function(){
+ var me = this;
+ me.callParent();
+ me.fileInputEl.dom.disabled = false;
+ me.button.enable();
},
-
- bind : function(store){
- this.bindStore(store);
+ isFileUpload: function() {
+ return true;
},
-
- onDestroy : function(){
- this.bindStore(null);
- Ext.PagingToolbar.superclass.onDestroy.call(this);
- }
-});
-
-})();
-Ext.reg('paging', Ext.PagingToolbar);
-Ext.History = (function () {
- var iframe, hiddenField;
- var ready = false;
- var currentToken;
-
- function getHash() {
- var href = location.href, i = href.indexOf("#");
- return i >= 0 ? href.substr(i + 1) : null;
- }
-
- function doSave() {
- hiddenField.value = currentToken;
- }
-
- function handleStateChange(token) {
- currentToken = token;
- Ext.History.fireEvent('change', token);
- }
+ extractFileInput: function() {
+ var fileInput = this.fileInputEl.dom;
+ this.reset();
+ return fileInput;
+ },
- function updateIFrame (token) {
- var html = [' ');
+ this.callParent(arguments);
+ },
- shadow : "sides",
- defaultAlign : "tl-bl?",
- autoRender: true,
- quickShowInterval : 250,
+ initComponent : function(){
+ var me = this;
+
+ this.callParent(arguments);
+ me.addEvents(
+
+ 'select'
+ );
-
- frame:true,
- hidden:true,
- baseCls: 'x-tip',
- floating:{shadow:true,shim:true,useDisplay:true,constrain:false},
- autoHeight:true,
+ if (me.handler) {
+ me.on('select', me.handler, me.scope, true);
+ }
+ },
- closeAction: 'hide',
- initComponent : function(){
- Ext.Tip.superclass.initComponent.call(this);
- if(this.closable && !this.title){
- this.elements += ',header';
+ onRender : function(container, position){
+ var me = this,
+ clickEvent = me.clickEvent;
+
+ Ext.apply(me.renderData, {
+ itemCls: me.itemCls,
+ colors: me.colors
+ });
+ this.callParent(arguments);
+
+ me.mon(me.el, clickEvent, me.handleClick, me, {delegate: 'a'});
+
+ if(clickEvent != 'click'){
+ me.mon(me.el, 'click', Ext.emptyFn, me, {delegate: 'a', stopEvent: true});
}
},
afterRender : function(){
- Ext.Tip.superclass.afterRender.call(this);
- if(this.closable){
- this.addTool({
- id: 'close',
- handler: this[this.closeAction],
- scope: this
- });
+ var me = this,
+ value;
+
+ this.callParent(arguments);
+ if (me.value) {
+ value = me.value;
+ me.value = null;
+ me.select(value, true);
}
},
- showAt : function(xy){
- Ext.Tip.superclass.show.call(this);
- if(this.measureWidth !== false && (!this.initialConfig || typeof this.initialConfig.width != 'number')){
- this.doAutoWidth();
- }
- if(this.constrainPosition){
- xy = this.el.adjustForConstraints(xy);
+ handleClick : function(event, target){
+ var me = this,
+ color;
+
+ event.stopEvent();
+ if (!me.disabled) {
+ color = target.className.match(me.colorRe)[1];
+ me.select(color.toUpperCase());
}
- this.setPagePosition(xy[0], xy[1]);
},
- doAutoWidth : function(adjust){
- adjust = adjust || 0;
- var bw = this.body.getTextWidth();
- if(this.title){
- bw = Math.max(bw, this.header.child('span').getTextWidth(this.title));
+ select : function(color, suppressEvent){
+
+ var me = this,
+ selectedCls = me.selectedCls,
+ value = me.value,
+ el;
+
+ color = color.replace('#', '');
+ if (!me.rendered) {
+ me.value = color;
+ return;
}
- bw += this.getFrameWidth() + (this.closable ? 20 : 0) + this.body.getPadding("lr") + adjust;
- this.setWidth(bw.constrain(this.minWidth, this.maxWidth));
- if(Ext.isIE7 && !this.repainted){
- this.el.repaint();
- this.repainted = true;
- }
- },
+ if (color != value || me.allowReselect) {
+ el = me.el;
-
- showBy : function(el, pos){
- if(!this.rendered){
- this.render(Ext.getBody());
+ if (me.value) {
+ el.down('a.color-' + value).removeCls(selectedCls);
+ }
+ el.down('a.color-' + color).addCls(selectedCls);
+ me.value = color;
+ if (suppressEvent !== true) {
+ me.fireEvent('select', me, color);
+ }
}
- this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign));
},
-
- initDraggable : function(){
- this.dd = new Ext.Tip.DD(this, typeof this.draggable == 'boolean' ? null : this.draggable);
- this.header.addClass('x-tip-draggable');
+
+
+ getValue: function(){
+ return this.value || null;
}
});
-Ext.reg('tip', Ext.Tip);
-Ext.Tip.DD = function(tip, config){
- Ext.apply(this, config);
- this.tip = tip;
- Ext.Tip.DD.superclass.constructor.call(this, tip.el.id, 'WindowDD-'+tip.id);
- this.setHandleElId(tip.header.id);
- this.scroll = false;
-};
+Ext.define('Ext.layout.component.field.HtmlEditor', {
+ extend: 'Ext.layout.component.field.Field',
+ alias: ['layout.htmleditor'],
-Ext.extend(Ext.Tip.DD, Ext.dd.DD, {
- moveOnly:true,
- scroll:false,
- headerOffsets:[100, 25],
- startDrag : function(){
- this.tip.el.disableShadow();
- },
- endDrag : function(e){
- this.tip.el.enableShadow(true);
+ type: 'htmleditor',
+
+ sizeBodyContents: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ bodyEl = owner.bodyEl,
+ toolbar = owner.getToolbar(),
+ textarea = owner.textareaEl,
+ iframe = owner.iframeEl,
+ editorHeight;
+
+ if (Ext.isNumber(width)) {
+ width -= bodyEl.getFrameWidth('lr');
+ }
+ toolbar.setWidth(width);
+ textarea.setWidth(width);
+ iframe.setWidth(width);
+
+
+ if (Ext.isNumber(height)) {
+ editorHeight = height - toolbar.getHeight() - bodyEl.getFrameWidth('tb');
+ textarea.setHeight(editorHeight);
+ iframe.setHeight(editorHeight);
+ }
}
});
-Ext.ToolTip = Ext.extend(Ext.Tip, {
+
+Ext.define('Ext.form.field.HtmlEditor', {
+ extend:'Ext.Component',
+ mixins: {
+ labelable: 'Ext.form.Labelable',
+ field: 'Ext.form.field.Field'
+ },
+ alias: 'widget.htmleditor',
+ alternateClassName: 'Ext.form.HtmlEditor',
+ requires: [
+ 'Ext.tip.QuickTipManager',
+ 'Ext.picker.Color',
+ 'Ext.toolbar.Item',
+ 'Ext.toolbar.Toolbar',
+ 'Ext.util.Format',
+ 'Ext.layout.component.field.HtmlEditor'
+ ],
+
+ fieldSubTpl: [
+ '',
+ '',
+ '',
+ {
+ compiled: true,
+ disableFormats: true
+ }
+ ],
+
+ enableFormat : true,
+
+ enableFontSize : true,
+ enableColors : true,
+ enableAlignments : true,
- showDelay : 500,
+ enableLists : true,
- hideDelay : 200,
+ enableSourceEdit : true,
- dismissDelay : 5000,
+ enableLinks : true,
+ enableFont : true,
- trackMouse : false,
+ createLinkText : 'Please enter the URL for the link:',
- anchorToTarget : true,
+ defaultLinkValue : 'http:/'+'/',
- anchorOffset : 0,
+ fontFamilies : [
+ 'Arial',
+ 'Courier New',
+ 'Tahoma',
+ 'Times New Roman',
+ 'Verdana'
+ ],
+ defaultFont: 'tahoma',
+ defaultValue: (Ext.isOpera || Ext.isIE6) ? ' ' : '',
-
- targetCounter : 0,
+ fieldBodyCls: Ext.baseCSSPrefix + 'html-editor-wrap',
- constrainPosition : false,
+ componentLayout: 'htmleditor',
- initComponent : function(){
- Ext.ToolTip.superclass.initComponent.call(this);
- this.lastActive = new Date();
- this.initTarget(this.target);
- this.origAnchor = this.anchor;
- },
+ initialized : false,
+ activated : false,
+ sourceEditMode : false,
+ iframePad:3,
+ hideMode:'offsets',
+ maskOnDisable: true,
- onRender : function(ct, position){
- Ext.ToolTip.superclass.onRender.call(this, ct, position);
- this.anchorCls = 'x-tip-anchor-' + this.getAnchorPosition();
- this.anchorEl = this.el.createChild({
- cls: 'x-tip-anchor ' + this.anchorCls
- });
- },
-
- afterRender : function(){
- Ext.ToolTip.superclass.afterRender.call(this);
- this.anchorEl.setStyle('z-index', this.el.getZIndex() + 1).setVisibilityMode(Ext.Element.DISPLAY);
- },
+ initComponent : function(){
+ var me = this;
-
- initTarget : function(target){
- var t;
- if((t = Ext.get(target))){
- if(this.target){
- var tg = Ext.get(this.target);
- this.mun(tg, 'mouseover', this.onTargetOver, this);
- this.mun(tg, 'mouseout', this.onTargetOut, this);
- this.mun(tg, 'mousemove', this.onMouseMove, this);
- }
- this.mon(t, {
- mouseover: this.onTargetOver,
- mouseout: this.onTargetOut,
- mousemove: this.onMouseMove,
- scope: this
- });
- this.target = t;
- }
- if(this.anchor){
- this.anchorTarget = this.target;
- }
+ me.addEvents(
+
+ 'initialize',
+
+ 'activate',
+
+ 'beforesync',
+
+ 'beforepush',
+
+ 'sync',
+
+ 'push',
+
+ 'editmodechange'
+ );
+
+ me.callParent(arguments);
+
+
+ me.initLabelable();
+ me.initField();
},
- onMouseMove : function(e){
- var t = this.delegate ? e.getTarget(this.delegate) : this.triggerElement = true;
- if (t) {
- this.targetXY = e.getXY();
- if (t === this.triggerElement) {
- if(!this.hidden && this.trackMouse){
- this.setPagePosition(this.getTargetXY());
- }
- } else {
- this.hide();
- this.lastActive = new Date(0);
- this.onTargetOver(e);
- }
- } else if (!this.closable && this.isVisible()) {
- this.hide();
+ createToolbar : function(editor){
+ var me = this,
+ items = [],
+ tipsEnabled = Ext.tip.QuickTipManager && Ext.tip.QuickTipManager.isEnabled(),
+ baseCSSPrefix = Ext.baseCSSPrefix,
+ fontSelectItem, toolbar, undef;
+
+ function btn(id, toggle, handler){
+ return {
+ itemId : id,
+ cls : baseCSSPrefix + 'btn-icon',
+ iconCls: baseCSSPrefix + 'edit-'+id,
+ enableToggle:toggle !== false,
+ scope: editor,
+ handler:handler||editor.relayBtnCmd,
+ clickEvent:'mousedown',
+ tooltip: tipsEnabled ? editor.buttonTips[id] || undef : undef,
+ overflowText: editor.buttonTips[id].title || undef,
+ tabIndex:-1
+ };
}
- },
-
- getTargetXY : function(){
- if(this.delegate){
- this.anchorTarget = this.triggerElement;
- }
- if(this.anchor){
- this.targetCounter++;
- var offsets = this.getOffsets(),
- xy = (this.anchorToTarget && !this.trackMouse) ? this.el.getAlignToXY(this.anchorTarget, this.getAnchorAlign()) : this.targetXY,
- dw = Ext.lib.Dom.getViewWidth() - 5,
- dh = Ext.lib.Dom.getViewHeight() - 5,
- de = document.documentElement,
- bd = document.body,
- scrollX = (de.scrollLeft || bd.scrollLeft || 0) + 5,
- scrollY = (de.scrollTop || bd.scrollTop || 0) + 5,
- axy = [xy[0] + offsets[0], xy[1] + offsets[1]],
- sz = this.getSize();
-
- this.anchorEl.removeClass(this.anchorCls);
- if(this.targetCounter < 2){
- if(axy[0] < scrollX){
- if(this.anchorToTarget){
- this.defaultAlign = 'l-r';
- if(this.mouseOffset){this.mouseOffset[0] *= -1;}
- }
- this.anchor = 'left';
- return this.getTargetXY();
- }
- if(axy[0]+sz.width > dw){
- if(this.anchorToTarget){
- this.defaultAlign = 'r-l';
- if(this.mouseOffset){this.mouseOffset[0] *= -1;}
- }
- this.anchor = 'right';
- return this.getTargetXY();
- }
- if(axy[1] < scrollY){
- if(this.anchorToTarget){
- this.defaultAlign = 't-b';
- if(this.mouseOffset){this.mouseOffset[1] *= -1;}
+ if (me.enableFont && !Ext.isSafari2) {
+ fontSelectItem = Ext.widget('component', {
+ renderTpl: [
+ ''
+ ],
+ renderData: {
+ cls: baseCSSPrefix + 'font-select',
+ fonts: me.fontFamilies,
+ defaultFont: me.defaultFont
+ },
+ renderSelectors: {
+ selectEl: 'select'
+ },
+ onDisable: function() {
+ var selectEl = this.selectEl;
+ if (selectEl) {
+ selectEl.dom.disabled = true;
}
- this.anchor = 'top';
- return this.getTargetXY();
- }
- if(axy[1]+sz.height > dh){
- if(this.anchorToTarget){
- this.defaultAlign = 'b-t';
- if(this.mouseOffset){this.mouseOffset[1] *= -1;}
+ Ext.Component.superclass.onDisable.apply(this, arguments);
+ },
+ onEnable: function() {
+ var selectEl = this.selectEl;
+ if (selectEl) {
+ selectEl.dom.disabled = false;
}
- this.anchor = 'bottom';
- return this.getTargetXY();
+ Ext.Component.superclass.onEnable.apply(this, arguments);
}
- }
+ });
- this.anchorCls = 'x-tip-anchor-'+this.getAnchorPosition();
- this.anchorEl.addClass(this.anchorCls);
- this.targetCounter = 0;
- return axy;
- }else{
- var mouseOffset = this.getMouseOffset();
- return [this.targetXY[0]+mouseOffset[0], this.targetXY[1]+mouseOffset[1]];
+ items.push(
+ fontSelectItem,
+ '-'
+ );
}
- },
- getMouseOffset : function(){
- var offset = this.anchor ? [0,0] : [15,18];
- if(this.mouseOffset){
- offset[0] += this.mouseOffset[0];
- offset[1] += this.mouseOffset[1];
+ if (me.enableFormat) {
+ items.push(
+ btn('bold'),
+ btn('italic'),
+ btn('underline')
+ );
}
- return offset;
- },
-
- getAnchorPosition : function(){
- if(this.anchor){
- this.tipAnchor = this.anchor.charAt(0);
- }else{
- var m = this.defaultAlign.match(/^([a-z]+)-([a-z]+)(\?)?$/);
- if(!m){
- throw 'AnchorTip.defaultAlign is invalid';
- }
- this.tipAnchor = m[1].charAt(0);
+ if (me.enableFontSize) {
+ items.push(
+ '-',
+ btn('increasefontsize', false, me.adjustFont),
+ btn('decreasefontsize', false, me.adjustFont)
+ );
}
- switch(this.tipAnchor){
- case 't': return 'top';
- case 'b': return 'bottom';
- case 'r': return 'right';
+ if (me.enableColors) {
+ items.push(
+ '-', {
+ itemId: 'forecolor',
+ cls: baseCSSPrefix + 'btn-icon',
+ iconCls: baseCSSPrefix + 'edit-forecolor',
+ overflowText: editor.buttonTips.forecolor.title,
+ tooltip: tipsEnabled ? editor.buttonTips.forecolor || undef : undef,
+ tabIndex:-1,
+ menu : Ext.widget('menu', {
+ plain: true,
+ items: [{
+ xtype: 'colorpicker',
+ allowReselect: true,
+ focus: Ext.emptyFn,
+ value: '000000',
+ plain: true,
+ clickEvent: 'mousedown',
+ handler: function(cp, color) {
+ me.execCmd('forecolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
+ me.deferFocus();
+ this.up('menu').hide();
+ }
+ }]
+ })
+ }, {
+ itemId: 'backcolor',
+ cls: baseCSSPrefix + 'btn-icon',
+ iconCls: baseCSSPrefix + 'edit-backcolor',
+ overflowText: editor.buttonTips.backcolor.title,
+ tooltip: tipsEnabled ? editor.buttonTips.backcolor || undef : undef,
+ tabIndex:-1,
+ menu : Ext.widget('menu', {
+ plain: true,
+ items: [{
+ xtype: 'colorpicker',
+ focus: Ext.emptyFn,
+ value: 'FFFFFF',
+ plain: true,
+ allowReselect: true,
+ clickEvent: 'mousedown',
+ handler: function(cp, color) {
+ if (Ext.isGecko) {
+ me.execCmd('useCSS', false);
+ me.execCmd('hilitecolor', color);
+ me.execCmd('useCSS', true);
+ me.deferFocus();
+ } else {
+ me.execCmd(Ext.isOpera ? 'hilitecolor' : 'backcolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
+ me.deferFocus();
+ }
+ this.up('menu').hide();
+ }
+ }]
+ })
+ }
+ );
}
- return 'left';
- },
-
- getAnchorAlign : function(){
- switch(this.anchor){
- case 'top' : return 'tl-bl';
- case 'left' : return 'tl-tr';
- case 'right': return 'tr-tl';
- default : return 'bl-tl';
+ if (me.enableAlignments) {
+ items.push(
+ '-',
+ btn('justifyleft'),
+ btn('justifycenter'),
+ btn('justifyright')
+ );
}
- },
-
- getOffsets : function(){
- var offsets,
- ap = this.getAnchorPosition().charAt(0);
- if(this.anchorToTarget && !this.trackMouse){
- switch(ap){
- case 't':
- offsets = [0, 9];
- break;
- case 'b':
- offsets = [0, -13];
- break;
- case 'r':
- offsets = [-13, 0];
- break;
- default:
- offsets = [9, 0];
- break;
+ if (!Ext.isSafari2) {
+ if (me.enableLinks) {
+ items.push(
+ '-',
+ btn('createlink', false, me.createLink)
+ );
}
- }else{
- switch(ap){
- case 't':
- offsets = [-15-this.anchorOffset, 30];
- break;
- case 'b':
- offsets = [-19-this.anchorOffset, -13-this.el.dom.offsetHeight];
- break;
- case 'r':
- offsets = [-15-this.el.dom.offsetWidth, -13-this.anchorOffset];
- break;
- default:
- offsets = [25, -13-this.anchorOffset];
- break;
+
+ if (me.enableLists) {
+ items.push(
+ '-',
+ btn('insertorderedlist'),
+ btn('insertunorderedlist')
+ );
+ }
+ if (me.enableSourceEdit) {
+ items.push(
+ '-',
+ btn('sourceedit', true, function(btn){
+ me.toggleSourceEdit(!me.sourceEditMode);
+ })
+ );
}
}
- var mouseOffset = this.getMouseOffset();
- offsets[0] += mouseOffset[0];
- offsets[1] += mouseOffset[1];
- return offsets;
- },
+
+ toolbar = Ext.widget('toolbar', {
+ renderTo: me.toolbarWrap,
+ enableOverflow: true,
+ items: items
+ });
-
- onTargetOver : function(e){
- if(this.disabled || e.within(this.target.dom, true)){
- return;
- }
- var t = e.getTarget(this.delegate);
- if (t) {
- this.triggerElement = t;
- this.clearTimer('hide');
- this.targetXY = e.getXY();
- this.delayShow();
- }
- },
+ if (fontSelectItem) {
+ me.fontSelect = fontSelectItem.selectEl;
-
- delayShow : function(){
- if(this.hidden && !this.showTimer){
- if(this.lastActive.getElapsed() < this.quickShowInterval){
- this.show();
- }else{
- this.showTimer = this.show.defer(this.showDelay, this);
- }
- }else if(!this.hidden && this.autoHide !== false){
- this.show();
+ me.mon(me.fontSelect, 'change', function(){
+ me.relayCmd('fontname', me.fontSelect.dom.value);
+ me.deferFocus();
+ });
}
- },
-
- onTargetOut : function(e){
- if(this.disabled || e.within(this.target.dom, true)){
- return;
- }
- this.clearTimer('show');
- if(this.autoHide !== false){
- this.delayHide();
- }
+
+ me.mon(toolbar.el, 'click', function(e){
+ e.preventDefault();
+ });
+
+ me.toolbar = toolbar;
},
-
- delayHide : function(){
- if(!this.hidden && !this.hideTimer){
- this.hideTimer = this.hide.defer(this.hideDelay, this);
- }
+ onDisable: function() {
+ this.bodyEl.mask();
+ this.callParent(arguments);
},
-
- hide: function(){
- this.clearTimer('dismiss');
- this.lastActive = new Date();
- if(this.anchorEl){
- this.anchorEl.hide();
- }
- Ext.ToolTip.superclass.hide.call(this);
- delete this.triggerElement;
+ onEnable: function() {
+ this.bodyEl.unmask();
+ this.callParent(arguments);
},
- show : function(){
- if(this.anchor){
-
-
- this.showAt([-1000,-1000]);
- this.origConstrainPosition = this.constrainPosition;
- this.constrainPosition = false;
- this.anchor = this.origAnchor;
- }
- this.showAt(this.getTargetXY());
+ setReadOnly: function(readOnly) {
+ var me = this,
+ textareaEl = me.textareaEl,
+ iframeEl = me.iframeEl,
+ body;
- if(this.anchor){
- this.anchorEl.show();
- this.syncAnchor();
- this.constrainPosition = this.origConstrainPosition;
- }else{
- this.anchorEl.hide();
- }
- },
+ me.readOnly = readOnly;
-
- showAt : function(xy){
- this.lastActive = new Date();
- this.clearTimers();
- Ext.ToolTip.superclass.showAt.call(this, xy);
- if(this.dismissDelay && this.autoHide !== false){
- this.dismissTimer = this.hide.defer(this.dismissDelay, this);
- }
- if(this.anchor && !this.anchorEl.isVisible()){
- this.syncAnchor();
- this.anchorEl.show();
- }else{
- this.anchorEl.hide();
+ if (textareaEl) {
+ textareaEl.dom.readOnly = readOnly;
}
- },
-
- syncAnchor : function(){
- var anchorPos, targetPos, offset;
- switch(this.tipAnchor.charAt(0)){
- case 't':
- anchorPos = 'b';
- targetPos = 'tl';
- offset = [20+this.anchorOffset, 2];
- break;
- case 'r':
- anchorPos = 'l';
- targetPos = 'tr';
- offset = [-2, 11+this.anchorOffset];
- break;
- case 'b':
- anchorPos = 't';
- targetPos = 'bl';
- offset = [20+this.anchorOffset, -2];
- break;
- default:
- anchorPos = 'r';
- targetPos = 'tl';
- offset = [2, 11+this.anchorOffset];
- break;
+ if (me.initialized) {
+ body = me.getEditorBody();
+ if (Ext.isIE) {
+
+ iframeEl.setDisplayed(false);
+ body.contentEditable = !readOnly;
+ iframeEl.setDisplayed(true);
+ } else {
+ me.setDesignMode(!readOnly);
+ }
+ if (body) {
+ body.style.cursor = readOnly ? 'default' : 'text';
+ }
+ me.disableItems(readOnly);
}
- this.anchorEl.alignTo(this.el, anchorPos+'-'+targetPos, offset);
},
- setPagePosition : function(x, y){
- Ext.ToolTip.superclass.setPagePosition.call(this, x, y);
- if(this.anchor){
- this.syncAnchor();
- }
+ getDocMarkup: function() {
+ var me = this,
+ h = me.iframeEl.getHeight() - me.iframePad * 2;
+ return Ext.String.format('', me.iframePad, h);
},
- clearTimer : function(name){
- name = name + 'Timer';
- clearTimeout(this[name]);
- delete this[name];
+ getEditorBody: function() {
+ var doc = this.getDoc();
+ return doc.body || doc.documentElement;
},
- clearTimers : function(){
- this.clearTimer('show');
- this.clearTimer('dismiss');
- this.clearTimer('hide');
+ getDoc: function() {
+ return (!Ext.isIE && this.iframeEl.dom.contentDocument) || this.getWin().document;
},
- onShow : function(){
- Ext.ToolTip.superclass.onShow.call(this);
- Ext.getDoc().on('mousedown', this.onDocMouseDown, this);
+ getWin: function() {
+ return Ext.isIE ? this.iframeEl.dom.contentWindow : window.frames[this.iframeEl.dom.name];
},
- onHide : function(){
- Ext.ToolTip.superclass.onHide.call(this);
- Ext.getDoc().un('mousedown', this.onDocMouseDown, this);
+ onRender: function() {
+ var me = this,
+ renderSelectors = me.renderSelectors;
+
+ Ext.applyIf(renderSelectors, me.getLabelableSelectors());
+
+ Ext.applyIf(renderSelectors, {
+ toolbarWrap: 'div.' + Ext.baseCSSPrefix + 'html-editor-tb',
+ iframeEl: 'iframe',
+ textareaEl: 'textarea'
+ });
+
+ me.callParent(arguments);
+
+ me.textareaEl.dom.value = me.value || '';
+
+
+ me.monitorTask = Ext.TaskManager.start({
+ run: me.checkDesignMode,
+ scope: me,
+ interval:100
+ });
+
+ me.createToolbar(me);
+ me.disableItems(true);
},
-
- onDocMouseDown : function(e){
- if(this.autoHide !== true && !this.closable && !e.within(this.el.dom)){
- this.disable();
- this.doEnable.defer(100, this);
+ initRenderTpl: function() {
+ var me = this;
+ if (!me.hasOwnProperty('renderTpl')) {
+ me.renderTpl = me.getTpl('labelableRenderTpl');
}
+ return me.callParent();
},
-
-
- doEnable : function(){
- if(!this.isDestroyed){
- this.enable();
- }
+
+ initRenderData: function() {
+ return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
},
-
- onDisable : function(){
- this.clearTimers();
- this.hide();
+ getSubTplData: function() {
+ var cssPrefix = Ext.baseCSSPrefix;
+ return {
+ toolbarWrapCls: cssPrefix + 'html-editor-tb',
+ textareaCls: cssPrefix + 'hidden',
+ iframeName: Ext.id(),
+ iframeSrc: Ext.SSL_SECURE_URL,
+ size: 'height:100px;'
+ };
},
-
- adjustPosition : function(x, y){
- if(this.contstrainPosition){
- var ay = this.targetXY[1], h = this.getSize().height;
- if(y <= ay && (y+h) >= ay){
- y = ay-h-5;
- }
- }
- return {x : x, y: y};
+ getSubTplMarkup: function() {
+ return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
},
-
- beforeDestroy : function(){
- this.clearTimers();
- Ext.destroy(this.anchorEl);
- delete this.anchorEl;
- delete this.target;
- delete this.anchorTarget;
- delete this.triggerElement;
- Ext.ToolTip.superclass.beforeDestroy.call(this);
+
+ getBodyNaturalWidth: function() {
+ return 565;
},
-
- onDestroy : function(){
- Ext.getDoc().un('mousedown', this.onDocMouseDown, this);
- Ext.ToolTip.superclass.onDestroy.call(this);
- }
-});
+ initFrameDoc: function() {
+ var me = this,
+ doc, task;
-Ext.reg('tooltip', Ext.ToolTip);
-Ext.QuickTip = Ext.extend(Ext.ToolTip, {
-
-
- interceptTitles : false,
+ Ext.TaskManager.stop(me.monitorTask);
-
- tagConfig : {
- namespace : "ext",
- attribute : "qtip",
- width : "qwidth",
- target : "target",
- title : "qtitle",
- hide : "hide",
- cls : "qclass",
- align : "qalign",
- anchor : "anchor"
+ doc = me.getDoc();
+ me.win = me.getWin();
+
+ doc.open();
+ doc.write(me.getDocMarkup());
+ doc.close();
+
+ task = {
+ run: function() {
+ var doc = me.getDoc();
+ if (doc.body || doc.readyState === 'complete') {
+ Ext.TaskManager.stop(task);
+ me.setDesignMode(true);
+ Ext.defer(me.initEditor, 10, me);
+ }
+ },
+ interval : 10,
+ duration:10000,
+ scope: me
+ };
+ Ext.TaskManager.start(task);
},
-
- initComponent : function(){
- this.target = this.target || Ext.getDoc();
- this.targets = this.targets || {};
- Ext.QuickTip.superclass.initComponent.call(this);
+ checkDesignMode: function() {
+ var me = this,
+ doc = me.getDoc();
+ if (doc && (!doc.editorInitialized || me.getDesignMode() !== 'on')) {
+ me.initFrameDoc();
+ }
},
- register : function(config){
- var cs = Ext.isArray(config) ? config : arguments;
- for(var i = 0, len = cs.length; i < len; i++){
- var c = cs[i];
- var target = c.target;
- if(target){
- if(Ext.isArray(target)){
- for(var j = 0, jlen = target.length; j < jlen; j++){
- this.targets[Ext.id(target[j])] = c;
- }
- } else{
- this.targets[Ext.id(target)] = c;
- }
+ setDesignMode: function(mode) {
+ var me = this,
+ doc = me.getDoc();
+ if (doc) {
+ if (me.readOnly) {
+ mode = false;
}
+ doc.designMode = (/on|true/i).test(String(mode).toLowerCase()) ?'on':'off';
}
},
- unregister : function(el){
- delete this.targets[Ext.id(el)];
+ getDesignMode: function() {
+ var doc = this.getDoc();
+ return !doc ? '' : String(doc.designMode).toLowerCase();
},
-
-
- cancelShow: function(el){
- var at = this.activeTarget;
- el = Ext.get(el).dom;
- if(this.isVisible()){
- if(at && at.el == el){
- this.hide();
+
+ disableItems: function(disabled) {
+ this.getToolbar().items.each(function(item){
+ if(item.getItemId() !== 'sourceedit'){
+ item.setDisabled(disabled);
}
- }else if(at && at.el == el){
- this.clearTimer('show');
- }
- },
-
- getTipCfg: function(e) {
- var t = e.getTarget(),
- ttp,
- cfg;
- if(this.interceptTitles && t.title && Ext.isString(t.title)){
- ttp = t.title;
- t.qtip = ttp;
- t.removeAttribute("title");
- e.preventDefault();
- }else{
- cfg = this.tagConfig;
- ttp = t.qtip || Ext.fly(t).getAttribute(cfg.attribute, cfg.namespace);
- }
- return ttp;
+ });
},
- onTargetOver : function(e){
- if(this.disabled){
- return;
- }
- this.targetXY = e.getXY();
- var t = e.getTarget();
- if(!t || t.nodeType !== 1 || t == document || t == document.body){
- return;
+ toggleSourceEdit: function(sourceEditMode) {
+ var me = this,
+ iframe = me.iframeEl,
+ textarea = me.textareaEl,
+ hiddenCls = Ext.baseCSSPrefix + 'hidden',
+ btn = me.getToolbar().getComponent('sourceedit');
+
+ if (!Ext.isBoolean(sourceEditMode)) {
+ sourceEditMode = !me.sourceEditMode;
}
- if(this.activeTarget && ((t == this.activeTarget.el) || Ext.fly(this.activeTarget.el).contains(t))){
- this.clearTimer('hide');
- this.show();
- return;
+ me.sourceEditMode = sourceEditMode;
+
+ if (btn.pressed !== sourceEditMode) {
+ btn.toggle(sourceEditMode);
}
- if(t && this.targets[t.id]){
- this.activeTarget = this.targets[t.id];
- this.activeTarget.el = t;
- this.anchor = this.activeTarget.anchor;
- if(this.anchor){
- this.anchorTarget = t;
- }
- this.delayShow();
- return;
+ if (sourceEditMode) {
+ me.disableItems(true);
+ me.syncValue();
+ iframe.addCls(hiddenCls);
+ textarea.removeCls(hiddenCls);
+ textarea.dom.removeAttribute('tabIndex');
+ textarea.focus();
}
- var ttp, et = Ext.fly(t), cfg = this.tagConfig, ns = cfg.namespace;
- if(ttp = this.getTipCfg(e)){
- var autoHide = et.getAttribute(cfg.hide, ns);
- this.activeTarget = {
- el: t,
- text: ttp,
- width: et.getAttribute(cfg.width, ns),
- autoHide: autoHide != "user" && autoHide !== 'false',
- title: et.getAttribute(cfg.title, ns),
- cls: et.getAttribute(cfg.cls, ns),
- align: et.getAttribute(cfg.align, ns)
-
- };
- this.anchor = et.getAttribute(cfg.anchor, ns);
- if(this.anchor){
- this.anchorTarget = t;
+ else {
+ if (me.initialized) {
+ me.disableItems(me.readOnly);
}
- this.delayShow();
+ me.pushValue();
+ iframe.removeCls(hiddenCls);
+ textarea.addCls(hiddenCls);
+ textarea.dom.setAttribute('tabIndex', -1);
+ me.deferFocus();
}
+ me.fireEvent('editmodechange', me, sourceEditMode);
+ me.doComponentLayout();
},
- onTargetOut : function(e){
-
-
- if (this.activeTarget && e.within(this.activeTarget.el) && !this.getTipCfg(e)) {
- return;
+ createLink : function() {
+ var url = prompt(this.createLinkText, this.defaultLinkValue);
+ if (url && url !== 'http:/'+'/') {
+ this.relayCmd('createlink', url);
}
+ },
+
+ clearInvalid: Ext.emptyFn,
- this.clearTimer('show');
- if(this.autoHide !== false){
- this.delayHide();
+
+ setValue: function(value) {
+ var me = this,
+ textarea = me.textareaEl;
+ me.mixins.field.setValue.call(me, value);
+ if (value === null || value === undefined) {
+ value = '';
}
+ if (textarea) {
+ textarea.dom.value = value;
+ }
+ me.pushValue();
+ return this;
},
- showAt : function(xy){
- var t = this.activeTarget;
- if(t){
- if(!this.rendered){
- this.render(Ext.getBody());
- this.activeTarget = t;
- }
- if(t.width){
- this.setWidth(t.width);
- this.body.setWidth(this.adjustBodyWidth(t.width - this.getFrameWidth()));
- this.measureWidth = false;
- } else{
- this.measureWidth = true;
- }
- this.setTitle(t.title || '');
- this.body.update(t.text);
- this.autoHide = t.autoHide;
- this.dismissDelay = t.dismissDelay || this.dismissDelay;
- if(this.lastCls){
- this.el.removeClass(this.lastCls);
- delete this.lastCls;
- }
- if(t.cls){
- this.el.addClass(t.cls);
- this.lastCls = t.cls;
- }
- if(this.anchor){
- this.constrainPosition = false;
- }else if(t.align){
- xy = this.el.getAlignToXY(t.el, t.align);
- this.constrainPosition = false;
- }else{
- this.constrainPosition = true;
- }
+ cleanHtml: function(html) {
+ html = String(html);
+ if (Ext.isWebKit) {
+ html = html.replace(/\sclass="(?:Apple-style-span|khtml-block-placeholder)"/gi, '');
}
- Ext.QuickTip.superclass.showAt.call(this, xy);
+
+
+ if (html.charCodeAt(0) === this.defaultValue.replace(/\D/g, '')) {
+ html = html.substring(1);
+ }
+ return html;
},
- hide: function(){
- delete this.activeTarget;
- Ext.QuickTip.superclass.hide.call(this);
- }
-});
-Ext.reg('quicktip', Ext.QuickTip);
-Ext.QuickTips = function(){
- var tip,
- disabled = false;
-
- return {
-
- init : function(autoRender){
- if(!tip){
- if(!Ext.isReady){
- Ext.onReady(function(){
- Ext.QuickTips.init(autoRender);
- });
- return;
- }
- tip = new Ext.QuickTip({
- elements:'header,body',
- disabled: disabled
- });
- if(autoRender !== false){
- tip.render(Ext.getBody());
+ syncValue : function(){
+ var me = this,
+ body, html, bodyStyle, match;
+ if (me.initialized) {
+ body = me.getEditorBody();
+ html = body.innerHTML;
+ if (Ext.isWebKit) {
+ bodyStyle = body.getAttribute('style');
+ match = bodyStyle.match(/text-align:(.*?);/i);
+ if (match && match[1]) {
+ html = '
'); + range.collapse(false); + range.select(); + } } } }; - this.expandPath(keys.join(this.pathSeparator), attr, f); - }else{ - this.root.select(); - if(callback){ - callback(true, this.root); - } } - }, - - - getTreeEl : function(){ - return this.body; - }, - - - onRender : function(ct, position){ - Ext.tree.TreePanel.superclass.onRender.call(this, ct, position); - this.el.addClass('x-tree'); - this.innerCt = this.body.createChild({tag:'ul', - cls:'x-tree-root-ct ' + - (this.useArrows ? 'x-tree-arrows' : this.lines ? 'x-tree-lines' : 'x-tree-no-lines')}); - }, - - initEvents : function(){ - Ext.tree.TreePanel.superclass.initEvents.call(this); - - if(this.containerScroll){ - Ext.dd.ScrollManager.register(this.body); - } - if((this.enableDD || this.enableDrop) && !this.dropZone){ - - this.dropZone = new Ext.tree.TreeDropZone(this, this.dropConfig || { - ddGroup: this.ddGroup || 'TreeDD', appendOnly: this.ddAppendOnly === true - }); + if (Ext.isOpera) { + return function(e){ + var me = this; + if (e.getKey() === e.TAB) { + e.stopEvent(); + me.win.focus(); + me.execCmd('InsertHTML',' '); + me.deferFocus(); + } + }; } - if((this.enableDD || this.enableDrag) && !this.dragZone){ - - this.dragZone = new Ext.tree.TreeDragZone(this, this.dragConfig || { - ddGroup: this.ddGroup || 'TreeDD', - scroll: this.ddScroll - }); + + if (Ext.isWebKit) { + return function(e){ + var me = this, + k = e.getKey(); + if (k === e.TAB) { + e.stopEvent(); + me.execCmd('InsertText','\t'); + me.deferFocus(); + } + else if (k === e.ENTER) { + e.stopEvent(); + me.execCmd('InsertHtml','
'); + me.deferFocus(); + } + }; } - this.getSelectionModel().init(this); - }, + + return null; + }(), - afterRender : function(){ - Ext.tree.TreePanel.superclass.afterRender.call(this); - this.renderRoot(); + getToolbar : function(){ + return this.toolbar; }, - beforeDestroy : function(){ - if(this.rendered){ - Ext.dd.ScrollManager.unregister(this.body); - Ext.destroy(this.dropZone, this.dragZone); - } - this.destroyRoot(); - Ext.destroy(this.loader); - this.nodeHash = this.root = this.loader = null; - Ext.tree.TreePanel.superclass.beforeDestroy.call(this); - }, - - destroyRoot : function(){ - if(this.root && this.root.destroy){ - this.root.destroy(true); + buttonTips : { + bold : { + title: 'Bold (Ctrl+B)', + text: 'Make the selected text bold.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + italic : { + title: 'Italic (Ctrl+I)', + text: 'Make the selected text italic.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + underline : { + title: 'Underline (Ctrl+U)', + text: 'Underline the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + increasefontsize : { + title: 'Grow Text', + text: 'Increase the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + decreasefontsize : { + title: 'Shrink Text', + text: 'Decrease the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + backcolor : { + title: 'Text Highlight Color', + text: 'Change the background color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + forecolor : { + title: 'Font Color', + text: 'Change the color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyleft : { + title: 'Align Text Left', + text: 'Align text to the left.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifycenter : { + title: 'Center Text', + text: 'Center text in the editor.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyright : { + title: 'Align Text Right', + text: 'Align text to the right.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertunorderedlist : { + title: 'Bullet List', + text: 'Start a bulleted list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertorderedlist : { + title: 'Numbered List', + text: 'Start a numbered list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + createlink : { + title: 'Hyperlink', + text: 'Make the selected text a hyperlink.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + sourceedit : { + title: 'Source Edit', + text: 'Switch to source editing mode.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' } } @@ -33546,5722 +71601,5378 @@ Ext.tree.TreePanel = Ext.extend(Ext.Panel, { - - - - - - - - - - - - - - +}); +Ext.define('Ext.form.field.Radio', { + extend:'Ext.form.field.Checkbox', + alias: ['widget.radiofield', 'widget.radio'], + alternateClassName: 'Ext.form.Radio', + requires: ['Ext.form.RadioManager'], - - - - - - - - - - - - - - - - -}); + isRadio: true, -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); -}; + + inputType: 'radio', + ariaRole: 'radio', -Ext.tree.TreeEventModel.prototype = { - initEvents : function(){ - var t = this.tree; + + getGroupValue: function() { + var selected = this.getManager().getChecked(this.name); + return selected ? selected.inputValue : null; + }, - if(t.trackMouseOver !== false){ - t.mon(t.innerCt, { - scope: this, - mouseover: this.delegateOver, - mouseout: this.delegateOut - }); + + onBoxClick: function(e) { + var me = this; + if (!me.disabled && !me.readOnly) { + this.setValue(true); } - 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); + + setValue: function(v) { + var me = this, + active; + + if (Ext.isBoolean(v)) { + me.callParent(arguments); + } else { + active = me.getManager().getWithValue(me.name, v).getAt(0); + if (active) { + active.setValue(true); } } - return null; + return me; }, - getNodeTarget : function(e){ - var t = e.getTarget('.x-tree-node-icon', 1); - if(!t){ - t = e.getTarget('.x-tree-node-el', 6); - } - return t; + + getSubmitValue: function() { + return this.checked ? this.inputValue : null; }, - 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)); + + onChange: function(newVal, oldVal) { + var me = this; + me.callParent(arguments); + + if (newVal) { + this.getManager().getByName(me.name).each(function(item){ + if (item !== me) { + item.setValue(false); + } + }, me); } }, - 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)); - } + + beforeDestroy: function(){ + this.callParent(); + this.getManager().removeAtKey(this.id); }, - 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; - } + + getManager: function() { + return Ext.form.RadioManager; + } +}); - }, - 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'); - } - }, +Ext.define('Ext.picker.Time', { + extend: 'Ext.view.BoundList', + alias: 'widget.timepicker', + requires: ['Ext.data.Store', 'Ext.Date'], - 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); - }, + + increment: 15, - onNodeClick : function(e, node){ - node.ui.onClick(e); - }, + + format : "g:i A", - onNodeOver : function(e, node){ - this.lastOverNode = node; - node.ui.onOver(e); - }, + + displayField: 'disp', - onNodeOut : function(e, node){ - node.ui.onOut(e); - }, + + initDate: [2008,1,1], - onIconOver : function(e, node){ - node.ui.addClass('x-tree-ec-over'); - }, + componentCls: Ext.baseCSSPrefix + 'timepicker', - onIconOut : function(e, node){ - node.ui.removeClass('x-tree-ec-over'); - }, + + loadingText: '', - onIconClick : function(e, node){ - node.ui.ecClick(e); - }, + initComponent: function() { + var me = this, + dateUtil = Ext.Date, + clearTime = dateUtil.clearTime, + initDate = me.initDate.join('/'); - onCheckboxClick : function(e, node){ - node.ui.onCheckChange(e); + + me.absMin = clearTime(new Date(initDate)); + me.absMax = dateUtil.add(clearTime(new Date(initDate)), 'mi', (24 * 60) - 1); + + me.store = me.createStore(); + me.updateList(); + + this.callParent(); }, - onNodeDblClick : function(e, node){ - node.ui.onDblClick(e); + + setMinValue: function(value) { + this.minValue = value; + this.updateList(); }, - onNodeContextMenu : function(e, node){ - node.ui.onContextMenu(e); + + setMaxValue: function(value) { + this.maxValue = value; + this.updateList(); }, - beforeEvent : function(e){ - var node = this.getNode(e); - if(this.disabled || !node || !node.ui){ - e.stopEvent(); - return false; - } - return true; + + normalizeDate: function(date) { + var initDate = this.initDate; + date.setFullYear(initDate[0], initDate[1] - 1, initDate[2]); + return date; }, - disable: function(){ - this.disabled = true; + + updateList: function() { + var me = this, + min = me.normalizeDate(me.minValue || me.absMin), + max = me.normalizeDate(me.maxValue || me.absMax); + + me.store.filterBy(function(record) { + var date = record.get('date'); + return date >= min && date <= max; + }); }, - enable: function(){ - this.disabled = false; - } -}; -Ext.tree.DefaultSelectionModel = Ext.extend(Ext.util.Observable, { - constructor : function(config){ - this.selNode = null; - - this.addEvents( - - 'selectionchange', + createStore: function() { + var me = this, + utilDate = Ext.Date, + times = [], + min = me.absMin, + max = me.absMax; - - 'beforeselect' - ); + while(min <= max){ + times.push({ + disp: utilDate.dateFormat(min, me.format), + date: min + }); + min = utilDate.add(min, 'mi', me.increment); + } + + return Ext.create('Ext.data.Store', { + fields: ['disp', 'date'], + data: times + }); + } + +}); + + +Ext.define('Ext.form.field.Time', { + extend:'Ext.form.field.Picker', + alias: 'widget.timefield', + requires: ['Ext.form.field.Date', 'Ext.picker.Time', 'Ext.view.BoundListKeyNav', 'Ext.Date'], + alternateClassName: ['Ext.form.TimeField', 'Ext.form.Time'], - 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); - }, + triggerCls: Ext.baseCSSPrefix + 'form-time-trigger', + - 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; - node.ui.onSelectedChange(true); - this.fireEvent('selectionchange', this, node, last); - } - return node; - }, + minText : "The time in this field must be equal to or after {0}", + + maxText : "The time in this field must be equal to or before {0}", + - unselect : function(node, silent){ - if(this.selNode == node){ - this.clearSelections(silent); - } - }, + invalidText : "{0} is not a valid time", + + format : "g:i A", + - clearSelections : function(silent){ - var n = this.selNode; - if(n){ - n.ui.onSelectedChange(false); - this.selNode = null; - if(silent !== true){ - this.fireEvent('selectionchange', this, null); - } - } - return n; - }, + + altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A", + - getSelectedNode : function(){ - return this.selNode; - }, + increment: 15, + + pickerMaxHeight: 300, + - isSelected : function(node){ - return this.selNode == node; - }, + selectOnTab: true, - selectPrevious : function( s){ - if(!(s = s || this.selNode || this.lastSelNode)){ - return null; + initDate: '1/1/2008', + initDateFormat: 'j/n/Y', + + + initComponent: function() { + var me = this, + min = me.minValue, + max = me.maxValue; + if (min) { + me.setMinValue(min); } - - var ps = s.previousSibling; - if(ps){ - if(!ps.isExpanded() || ps.childNodes.length < 1){ - return this.select(ps, this.selectPrevious); - } else{ - var lc = ps.lastChild; - while(lc && lc.isExpanded() && Ext.fly(lc.ui.wrap).isVisible() && lc.childNodes.length > 0){ - lc = lc.lastChild; - } - return this.select(lc, this.selectPrevious); - } - } else if(s.parentNode && (this.tree.rootVisible || !s.parentNode.isRoot)){ - return this.select(s.parentNode, this.selectPrevious); + if (max) { + me.setMaxValue(max); } - return null; + this.callParent(); }, - - selectNext : function( s){ - if(!(s = s || this.selNode || this.lastSelNode)){ - return null; - } - - if(s.firstChild && s.isExpanded() && Ext.fly(s.ui.wrap).isVisible()){ - return this.select(s.firstChild, this.selectNext); - }else if(s.nextSibling){ - return this.select(s.nextSibling, this.selectNext); - }else if(s.parentNode){ - var newS = null; - s.parentNode.bubble(function(){ - if(this.nextSibling){ - newS = this.getOwnerTree().selModel.select(this.nextSibling, this.selectNext); - return false; - } - }); - return newS; - } - return null; - }, + initValue: function() { + var me = this, + value = me.value; - onKeyDown : function(e){ - var s = this.selNode || this.lastSelNode; - var sm = this; - if(!s){ - return; + if (Ext.isString(value)) { + me.value = me.rawToValue(value); } - var k = e.getKey(); - switch(k){ - case e.DOWN: - e.stopEvent(); - this.selectNext(); - break; - case e.UP: - e.stopEvent(); - this.selectPrevious(); - break; - case e.RIGHT: - e.preventDefault(); - if(s.hasChildNodes()){ - if(!s.isExpanded()){ - s.expand(); - }else if(s.firstChild){ - this.select(s.firstChild, e); - } - } - break; - case e.LEFT: - e.preventDefault(); - if(s.hasChildNodes() && s.isExpanded()){ - s.collapse(); - }else if(s.parentNode && (this.tree.rootVisible || s.parentNode != this.tree.getRootNode())){ - this.select(s.parentNode, e); - } - break; - }; - } -}); - -Ext.tree.MultiSelectionModel = Ext.extend(Ext.util.Observable, { - - constructor : function(config){ - this.selNodes = []; - this.selMap = {}; - this.addEvents( - - 'selectionchange' - ); - Ext.apply(this, config); - Ext.tree.MultiSelectionModel.superclass.constructor.call(this); + me.callParent(); }, + - init : function(tree){ - this.tree = tree; - tree.mon(tree.getTreeEl(), 'keydown', this.onKeyDown, this); - tree.on('click', this.onNodeClick, this); + setMinValue: function(value) { + var me = this, + picker = me.picker; + me.setLimit(value, true); + if (picker) { + picker.setMinValue(me.minValue); + } }, + - onNodeClick : function(node, e){ - if(e.ctrlKey && this.isSelected(node)){ - this.unselect(node); - }else{ - this.select(node, e, e.ctrlKey); + setMaxValue: function(value) { + var me = this, + picker = me.picker; + me.setLimit(value, false); + if (picker) { + picker.setMaxValue(me.maxValue); } }, + - - select : function(node, e, keepExisting){ - if(keepExisting !== true){ - this.clearSelections(true); + setLimit: function(value, isMin) { + var me = this, + d, val; + if (Ext.isString(value)) { + d = me.parseDate(value); } - if(this.isSelected(node)){ - this.lastSelNode = node; - return node; + else if (Ext.isDate(value)) { + d = value; } - this.selNodes.push(node); - this.selMap[node.id] = node; - this.lastSelNode = node; - node.ui.onSelectedChange(true); - this.fireEvent('selectionchange', this, this.selNodes); - return node; - }, - - - unselect : function(node){ - if(this.selMap[node.id]){ - node.ui.onSelectedChange(false); - var sn = this.selNodes; - var index = sn.indexOf(node); - if(index != -1){ - this.selNodes.splice(index, 1); - } - delete this.selMap[node.id]; - this.fireEvent('selectionchange', this, this.selNodes); + if (d) { + val = Ext.Date.clearTime(new Date(me.initDate)); + val.setHours(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()); + me[isMin ? 'minValue' : 'maxValue'] = val; } }, - - - clearSelections : function(suppressEvent){ - var sn = this.selNodes; - if(sn.length > 0){ - for(var i = 0, len = sn.length; i < len; i++){ - sn[i].ui.onSelectedChange(false); - } - this.selNodes = []; - this.selMap = {}; - if(suppressEvent !== true){ - this.fireEvent('selectionchange', this, this.selNodes); - } - } + + rawToValue: function(rawValue) { + return this.parseDate(rawValue) || rawValue || null; }, - - - isSelected : function(node){ - return this.selMap[node.id] ? true : false; + + valueToRaw: function(value) { + return this.formatDate(this.parseDate(value)); }, + - - getSelectedNodes : function(){ - return this.selNodes.concat([]); - }, + getErrors: function(value) { + var me = this, + format = Ext.String.format, + errors = me.callParent(arguments), + minValue = me.minValue, + maxValue = me.maxValue, + date; - onKeyDown : Ext.tree.DefaultSelectionModel.prototype.onKeyDown, + value = me.formatDate(value || me.processRawValue(me.getRawValue())); - selectNext : Ext.tree.DefaultSelectionModel.prototype.selectNext, + if (value === null || value.length < 1) { + return errors; + } + + date = me.parseDate(value); + if (!date) { + errors.push(format(me.invalidText, value, me.format)); + return errors; + } + + if (minValue && date < minValue) { + errors.push(format(me.minText, me.formatDate(minValue))); + } + + if (maxValue && date > maxValue) { + errors.push(format(me.maxText, me.formatDate(maxValue))); + } + + return errors; + }, + + formatDate: function() { + return Ext.form.field.Date.prototype.formatDate.apply(this, arguments); + }, - selectPrevious : Ext.tree.DefaultSelectionModel.prototype.selectPrevious -}); -Ext.data.Tree = Ext.extend(Ext.util.Observable, { - constructor: function(root){ - this.nodeHash = {}; - - this.root = null; - if(root){ - this.setRootNode(root); + parseDate: function(value) { + if (!value || Ext.isDate(value)) { + return value; } - this.addEvents( - - "append", - - "remove", - - "move", - - "insert", - - "beforeappend", - - "beforeremove", + + var me = this, + val = me.safeParse(value, me.format), + altFormats = me.altFormats, + altFormatsArray = me.altFormatsArray, + i = 0, + len; + + if (!val && altFormats) { + altFormatsArray = altFormatsArray || altFormats.split('|'); + len = altFormatsArray.length; + for (; i < len && !val; ++i) { + val = me.safeParse(value, altFormatsArray[i]); + } + } + return val; + }, + + safeParse: function(value, format){ + var me = this, + utilDate = Ext.Date, + parsedDate, + result = null; + + if (utilDate.formatContainsDateInfo(format)) { - "beforemove", + result = utilDate.parse(value, format); + } else { - "beforeinsert" - ); - Ext.data.Tree.superclass.constructor.call(this); + parsedDate = utilDate.parse(me.initDate + ' ' + value, me.initDateFormat + ' ' + format); + if (parsedDate) { + result = parsedDate; + } + } + return result; }, - - - pathSeparator: "/", - proxyNodeEvent : function(){ - return this.fireEvent.apply(this, arguments); + getSubmitValue: function() { + var me = this, + format = me.submitFormat || me.format, + value = me.getValue(); + + return value ? Ext.Date.format(value, format) : null; }, - getRootNode : function(){ - return this.root; + createPicker: function() { + var me = this, + picker = Ext.create('Ext.picker.Time', { + selModel: { + mode: 'SINGLE' + }, + floating: true, + hidden: true, + minValue: me.minValue, + maxValue: me.maxValue, + increment: me.increment, + format: me.format, + ownerCt: this.ownerCt, + renderTo: document.body, + maxHeight: me.pickerMaxHeight, + focusOnToFront: false + }); + + me.mon(picker.getSelectionModel(), { + selectionchange: me.onListSelect, + scope: me + }); + + return picker; }, - setRootNode : function(node){ - this.root = node; - node.ownerTree = this; - node.isRoot = true; - this.registerNode(node); - return node; - }, + onExpand: function() { + var me = this, + keyNav = me.pickerKeyNav, + selectOnTab = me.selectOnTab, + picker = me.getPicker(), + lastSelected = picker.getSelectionModel().lastSelected, + itemNode; + + if (!keyNav) { + keyNav = me.pickerKeyNav = Ext.create('Ext.view.BoundListKeyNav', this.inputEl, { + boundList: picker, + forceKeyDown: true, + tab: function(e) { + if (selectOnTab) { + this.selectHighlighted(e); + me.triggerBlur(); + } + + return true; + } + }); + + if (selectOnTab) { + me.ignoreMonitorTab = true; + } + } + Ext.defer(keyNav.enable, 1, keyNav); - - getNodeById : function(id){ - return this.nodeHash[id]; + + if (lastSelected) { + itemNode = picker.getNode(lastSelected); + if (itemNode) { + picker.highlightItem(itemNode); + picker.el.scrollChildIntoView(itemNode, false); + } + } }, - registerNode : function(node){ - this.nodeHash[node.id] = node; + onCollapse: function() { + var me = this, + keyNav = me.pickerKeyNav; + if (keyNav) { + keyNav.disable(); + me.ignoreMonitorTab = false; + } }, - unregisterNode : function(node){ - delete this.nodeHash[node.id]; - }, - - toString : function(){ - return "[Tree"+(this.id?" "+this.id:"")+"]"; + onListSelect: function(list, recordArray) { + var me = this, + record = recordArray[0], + val = record ? record.get('date') : null; + me.setValue(val); + me.fireEvent('select', me, val); + me.picker.clearHighlight(); + me.collapse(); + me.inputEl.focus(); } }); -Ext.data.Node = Ext.extend(Ext.util.Observable, { - - constructor: function(attributes){ - - this.attributes = attributes || {}; - this.leaf = this.attributes.leaf; - - this.id = this.attributes.id; - if(!this.id){ - this.id = Ext.id(null, "xnode-"); - this.attributes.id = this.id; - } - - this.childNodes = []; - - this.parentNode = null; - - this.firstChild = null; - - this.lastChild = null; - - this.previousSibling = null; - - this.nextSibling = null; - this.addEvents({ - - "append" : true, - - "remove" : true, - - "move" : true, - - "insert" : true, - - "beforeappend" : true, - - "beforeremove" : true, - - "beforemove" : true, - - "beforeinsert" : true - }); - this.listeners = this.attributes.listeners; - Ext.data.Node.superclass.constructor.call(this); +Ext.define('Ext.grid.CellEditor', { + extend: 'Ext.Editor', + constructor: function(config) { + if (config.field) { + config.field.monitorTab = false; + } + config.autoSize = { + width: 'boundEl' + }; + this.callParent(arguments); }, - fireEvent : function(evtName){ - - if(Ext.data.Node.superclass.fireEvent.apply(this, arguments) === false){ - return false; + onShow: function() { + var first = this.boundEl.first(); + if (first) { + first.hide(); } - - var ot = this.getOwnerTree(); - if(ot){ - if(ot.proxyNodeEvent.apply(ot, arguments) === false){ - return false; - } + this.callParent(arguments); + }, + + + onHide: function() { + var first = this.boundEl.first(); + if (first) { + first.show(); } - return true; + this.callParent(arguments); }, - - isLeaf : function(){ - return this.leaf === true; + + afterRender: function() { + this.callParent(arguments); + var field = this.field; + if (field.isXType('checkboxfield')) { + field.mon(field.inputEl, 'mousedown', this.onCheckBoxMouseDown, this); + field.mon(field.inputEl, 'click', this.onCheckBoxClick, this); + } }, - - setFirstChild : function(node){ - this.firstChild = node; + + onCheckBoxMouseDown: function() { + this.completeEdit = Ext.emptyFn; }, - - setLastChild : function(node){ - this.lastChild = node; + + onCheckBoxClick: function() { + delete this.completeEdit; + this.field.focus(false, 10); }, + + alignment: "tl-tl", + hideEl : false, + cls: Ext.baseCSSPrefix + "small-editor " + Ext.baseCSSPrefix + "grid-editor", + shim: false, + shadow: false +}); +Ext.define('Ext.grid.ColumnLayout', { + extend: 'Ext.layout.container.HBox', + alias: 'layout.gridcolumn', + type : 'column', - isLast : function(){ - return (!this.parentNode ? true : this.parentNode.lastChild == this); - }, + clearInnerCtOnLayout: false, - - isFirst : function(){ - return (!this.parentNode ? true : this.parentNode.firstChild == this); + constructor: function() { + var me = this; + me.callParent(arguments); + if (!Ext.isDefined(me.availableSpaceOffset)) { + me.availableSpaceOffset = (Ext.getScrollBarWidth() - 2); + } }, - - hasChildNodes : function(){ - return !this.isLeaf() && this.childNodes.length > 0; - }, + beforeLayout: function() { + var me = this, + i = 0, + items = me.getLayoutItems(), + len = items.length, + item, returnValue; - - isExpandable : function(){ - return this.attributes.expandable || this.hasChildNodes(); - }, + returnValue = me.callParent(arguments); - - appendChild : function(node){ - var multi = false; - if(Ext.isArray(node)){ - multi = node; - }else if(arguments.length > 1){ - multi = arguments; - } - if(multi){ - for(var i = 0, len = multi.length; i < len; i++) { - this.appendChild(multi[i]); - } - }else{ - if(this.fireEvent("beforeappend", this.ownerTree, this, node) === false){ - return false; - } - var index = this.childNodes.length; - var oldParent = node.parentNode; - - if(oldParent){ - if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index) === false){ - return false; + me.innerCt.setHeight(23); + + + if (me.align == 'stretchmax') { + for (; i < len; i++) { + item = items[i]; + item.el.setStyle({ + height: 'auto' + }); + item.titleContainer.setStyle({ + height: 'auto', + paddingTop: '0' + }); + if (item.componentLayout && item.componentLayout.lastComponentSize) { + item.componentLayout.lastComponentSize.height = item.el.dom.offsetHeight; } - oldParent.removeChild(node); - } - index = this.childNodes.length; - if(index === 0){ - this.setFirstChild(node); - } - this.childNodes.push(node); - node.parentNode = this; - var ps = this.childNodes[index-1]; - if(ps){ - node.previousSibling = ps; - ps.nextSibling = node; - }else{ - node.previousSibling = null; } - node.nextSibling = null; - this.setLastChild(node); - node.setOwnerTree(this.getOwnerTree()); - this.fireEvent("append", this.ownerTree, this, node, index); - if(oldParent){ - node.fireEvent("move", this.ownerTree, node, oldParent, this, index); - } - return node; } + return returnValue; }, - removeChild : function(node, destroy){ - var index = this.childNodes.indexOf(node); - if(index == -1){ - return false; - } - if(this.fireEvent("beforeremove", this.ownerTree, this, node) === false){ - return false; - } + calculateChildBoxes: function(visibleItems, targetSize) { + var me = this, + calculations = me.callParent(arguments), + boxes = calculations.boxes, + metaData = calculations.meta, + len = boxes.length, i = 0, box, item; - - this.childNodes.splice(index, 1); + if (targetSize.width && !me.isColumn) { + + if (me.owner.forceFit) { - - if(node.previousSibling){ - node.previousSibling.nextSibling = node.nextSibling; - } - if(node.nextSibling){ - node.nextSibling.previousSibling = node.previousSibling; - } + for (; i < len; i++) { + box = boxes[i]; + item = box.component; - - if(this.firstChild == node){ - this.setFirstChild(node.nextSibling); - } - if(this.lastChild == node){ - this.setLastChild(node.previousSibling); - } + + item.minWidth = Ext.grid.plugin.HeaderResizer.prototype.minColWidth; - this.fireEvent("remove", this.ownerTree, this, node); - if(destroy){ - node.destroy(true); - }else{ - node.clear(); - } - return node; - }, + + + item.flex = box.width; + } - - clear : function(destroy){ - - this.setOwnerTree(null, destroy); - this.parentNode = this.previousSibling = this.nextSibling = null; - if(destroy){ - this.firstChild = this.lastChild = null; + + calculations = me.callParent(arguments); + } + else if (metaData.tooNarrow) { + targetSize.width = metaData.desiredSize; + } } - }, - - destroy : function( silent){ - - if(silent === true){ - this.purgeListeners(); - this.clear(true); - Ext.each(this.childNodes, function(n){ - n.destroy(true); - }); - this.childNodes = null; - }else{ - this.remove(true); - } + return calculations; }, - - insertBefore : function(node, refNode){ - if(!refNode){ - return this.appendChild(node); - } - - if(node == refNode){ - return false; - } - - if(this.fireEvent("beforeinsert", this.ownerTree, this, node, refNode) === false){ - return false; - } - var index = this.childNodes.indexOf(refNode); - var oldParent = node.parentNode; - var refIndex = index; + afterLayout: function() { + var me = this, + i = 0, + items = me.getLayoutItems(), + len = items.length; - - if(oldParent == this && this.childNodes.indexOf(node) < index){ - refIndex--; - } + me.callParent(arguments); - if(oldParent){ - if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index, refNode) === false){ - return false; + if (me.align == 'stretchmax') { + for (; i < len; i++) { + items[i].setPadding(); } - oldParent.removeChild(node); - } - if(refIndex === 0){ - this.setFirstChild(node); - } - this.childNodes.splice(refIndex, 0, node); - node.parentNode = this; - var ps = this.childNodes[refIndex-1]; - if(ps){ - node.previousSibling = ps; - ps.nextSibling = node; - }else{ - node.previousSibling = null; } - node.nextSibling = refNode; - refNode.previousSibling = node; - node.setOwnerTree(this.getOwnerTree()); - this.fireEvent("insert", this.ownerTree, this, node, refNode); - if(oldParent){ - node.fireEvent("move", this.ownerTree, node, oldParent, this, refIndex, refNode); - } - return node; }, - remove : function(destroy){ - if (this.parentNode) { - this.parentNode.removeChild(this, destroy); - } - return this; - }, - - removeAll : function(destroy){ - var cn = this.childNodes, - n; - while((n = cn[0])){ - this.removeChild(n, destroy); + updateInnerCtSize: function(tSize, calcs) { + var me = this, + extra = 0; + + + if (!me.isColumn && calcs.meta.tooNarrow) { + if ( + Ext.isWebKit || + Ext.isGecko || + (Ext.isIEQuirks && (Ext.isIE6 || Ext.isIE7 || Ext.isIE8)) + ) { + extra = 1; + + } else if (Ext.isIE6 || Ext.isIE7 || Ext.isIE8) { + extra = 2; + } + + + extra++; + tSize.width = calcs.meta.desiredSize + (me.reserveOffset ? me.availableSpaceOffset : 0) + extra; } - return this; + return me.callParent(arguments); }, - - item : function(index){ - return this.childNodes[index]; - }, + doOwnerCtLayouts: function() { + var ownerCt = this.owner.ownerCt; + if (!ownerCt.componentLayout.layoutBusy) { + ownerCt.doComponentLayout(); + } + } +}); +Ext.define('Ext.grid.LockingView', { - replaceChild : function(newChild, oldChild){ - var s = oldChild ? oldChild.nextSibling : null; - this.removeChild(oldChild); - this.insertBefore(newChild, s); - return oldChild; + mixins: { + observable: 'Ext.util.Observable' }, - - indexOf : function(child){ - return this.childNodes.indexOf(child); - }, - + eventRelayRe: /^(beforeitem|beforecontainer|item|container|cell)/, - getOwnerTree : function(){ + constructor: function(config){ + var me = this, + eventNames = [], + eventRe = me.eventRelayRe, + locked = config.locked.getView(), + normal = config.normal.getView(), + events, + event; + + Ext.apply(me, { + lockedView: locked, + normalView: normal, + lockedGrid: config.locked, + normalGrid: config.normal, + panel: config.panel + }); + me.mixins.observable.constructor.call(me, config); - if(!this.ownerTree){ - var p = this; - while(p){ - if(p.ownerTree){ - this.ownerTree = p.ownerTree; - break; - } - p = p.parentNode; + + events = locked.events; + for (event in events) { + if (events.hasOwnProperty(event) && eventRe.test(event)) { + eventNames.push(event); } } - return this.ownerTree; + me.relayEvents(locked, eventNames); + me.relayEvents(normal, eventNames); + + normal.on({ + scope: me, + itemmouseleave: me.onItemMouseLeave, + itemmouseenter: me.onItemMouseEnter + }); + + locked.on({ + scope: me, + itemmouseleave: me.onItemMouseLeave, + itemmouseenter: me.onItemMouseEnter + }); }, - - getDepth : function(){ - var depth = 0; - var p = this; - while(p.parentNode){ - ++depth; - p = p.parentNode; - } - return depth; + getGridColumns: function() { + var cols = this.lockedGrid.headerCt.getGridColumns(); + return cols.concat(this.normalGrid.headerCt.getGridColumns()); }, - - setOwnerTree : function(tree, destroy){ - - if(tree != this.ownerTree){ - if(this.ownerTree){ - this.ownerTree.unregisterNode(this); - } - this.ownerTree = tree; + onItemMouseEnter: function(view, record){ + var me = this, + locked = me.lockedView, + other = me.normalView, + item; - if(destroy !== true){ - Ext.each(this.childNodes, function(n){ - n.setOwnerTree(tree); - }); - } - if(tree){ - tree.registerNode(this); + if (view.trackOver) { + if (view !== locked) { + other = locked; } + item = other.getNode(record); + other.highlightItem(item); } }, - - setId: function(id){ - if(id !== this.id){ - var t = this.ownerTree; - if(t){ - t.unregisterNode(this); - } - this.id = this.attributes.id = id; - if(t){ - t.registerNode(this); + onItemMouseLeave: function(view, record){ + var me = this, + locked = me.lockedView, + other = me.normalView; + + if (view.trackOver) { + if (view !== locked) { + other = locked; } - this.onIdChange(id); + other.clearHighlight(); } }, - - onIdChange: Ext.emptyFn, - + relayFn: function(name, args){ + args = args || []; + + var view = this.lockedView; + view[name].apply(view, args || []); + view = this.normalView; + view[name].apply(view, args || []); + }, - getPath : function(attr){ - attr = attr || "id"; - var p = this.parentNode; - var b = [this.attributes[attr]]; - while(p){ - b.unshift(p.attributes[attr]); - p = p.parentNode; - } - var sep = this.getOwnerTree().pathSeparator; - return sep + b.join(sep); + getSelectionModel: function(){ + return this.panel.getSelectionModel(); }, - - bubble : function(fn, scope, args){ - var p = this; - while(p){ - if(fn.apply(scope || p, args || [p]) === false){ - break; - } - p = p.parentNode; - } + getStore: function(){ + return this.panel.store; }, - - cascade : function(fn, scope, args){ - if(fn.apply(scope || this, args || [this]) !== false){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].cascade(fn, scope, args); - } + getNode: function(nodeInfo){ + + return this.normalView.getNode(nodeInfo); + }, + + getCell: function(record, column){ + var view = this.lockedView, + row; + + + if (view.getHeaderAtIndex(column) === -1) { + view = this.normalView; } + + row = view.getNode(record); + return Ext.fly(row).down(column.getCellSelector()); }, - - eachChild : function(fn, scope, args){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - if(fn.apply(scope || cs[i], args || [cs[i]]) === false){ - break; - } + getRecord: function(node){ + var result = this.lockedView.getRecord(node); + if (!node) { + result = this.normalView.getRecord(node); } + return result; }, - - findChild : function(attribute, value, deep){ - return this.findChildBy(function(){ - return this.attributes[attribute] == value; - }, null, deep); + refreshNode: function(){ + this.relayFn('refreshNode', arguments); }, - - findChildBy : function(fn, scope, deep){ - var cs = this.childNodes, - len = cs.length, - i = 0, - n, - res; - for(; i < len; i++){ - n = cs[i]; - if(fn.call(scope || n, n) === true){ - return n; - }else if (deep){ - res = n.findChildBy(fn, scope, deep); - if(res != null){ - return res; - } - } - - } - return null; + refresh: function(){ + this.relayFn('refresh', arguments); }, - - sort : function(fn, scope){ - var cs = this.childNodes; - var len = cs.length; - if(len > 0){ - var sortFn = scope ? function(){fn.apply(scope, arguments);} : fn; - cs.sort(sortFn); - for(var i = 0; i < len; i++){ - var n = cs[i]; - n.previousSibling = cs[i-1]; - n.nextSibling = cs[i+1]; - if(i === 0){ - this.setFirstChild(n); - } - if(i == len-1){ - this.setLastChild(n); - } - } - } + bindStore: function(){ + this.relayFn('bindStore', arguments); }, - - contains : function(node){ - return node.isAncestor(this); + addRowCls: function(){ + this.relayFn('addRowCls', arguments); }, + + removeRowCls: function(){ + this.relayFn('removeRowCls', arguments); + } + +}); +Ext.define('Ext.grid.Lockable', { - isAncestor : function(node){ - var p = this.parentNode; - while(p){ - if(p == node){ - return true; + requires: ['Ext.grid.LockingView'], + + + syncRowHeight: true, + + + + + + + + + spacerHidden: true, + + + unlockText: 'Unlock', + lockText: 'Lock', + + determineXTypeToCreate: function() { + var me = this, + typeToCreate; + + if (me.subGridXType) { + typeToCreate = me.subGridXType; + } else { + var xtypes = this.getXTypes().split('/'), + xtypesLn = xtypes.length, + xtype = xtypes[xtypesLn - 1], + superxtype = xtypes[xtypesLn - 2]; + + if (superxtype !== 'tablepanel') { + typeToCreate = superxtype; + } else { + typeToCreate = xtype; } - p = p.parentNode; } - return false; + + return typeToCreate; }, - - toString : function(){ - return "[Node"+(this.id?" "+this.id:"")+"]"; - } -}); -Ext.tree.TreeNode = Ext.extend(Ext.data.Node, { - constructor : function(attributes){ - attributes = attributes || {}; - if(Ext.isString(attributes)){ - attributes = {text: attributes}; - } - this.childrenRendered = false; - this.rendered = false; - Ext.tree.TreeNode.superclass.constructor.call(this, attributes); - this.expanded = attributes.expanded === true; - this.isTarget = attributes.isTarget !== false; - this.draggable = attributes.draggable !== false && attributes.allowDrag !== false; - this.allowChildren = attributes.allowChildren !== false && attributes.allowDrop !== false; - + + + injectLockable: function() { - this.text = attributes.text; + this.lockable = true; - this.disabled = attributes.disabled === true; - this.hidden = attributes.hidden === true; - - this.addEvents( - - 'textchange', - - 'beforeexpand', - - 'beforecollapse', - - 'expand', - - 'disabledchange', + this.hasView = true; + + var me = this, - 'collapse', - 'beforeclick', - 'click', + xtype = me.determineXTypeToCreate(), - 'checkchange', + selModel = me.getSelectionModel(), + lockedGrid = { + xtype: xtype, + + enableAnimations: false, + scroll: false, + scrollerOwner: false, + selModel: selModel, + border: false, + cls: Ext.baseCSSPrefix + 'grid-inner-locked' + }, + normalGrid = { + xtype: xtype, + enableAnimations: false, + scrollerOwner: false, + selModel: selModel, + border: false + }, + i = 0, + columns, + lockedHeaderCt, + normalHeaderCt; + + me.addCls(Ext.baseCSSPrefix + 'grid-locked'); + + + + + Ext.copyTo(normalGrid, me, me.normalCfgCopy); + Ext.copyTo(lockedGrid, me, me.lockedCfgCopy); + for (; i < me.normalCfgCopy.length; i++) { + delete me[me.normalCfgCopy[i]]; + } + for (i = 0; i < me.lockedCfgCopy.length; i++) { + delete me[me.lockedCfgCopy[i]]; + } + + me.lockedHeights = []; + me.normalHeights = []; + + columns = me.processColumns(me.columns); + + lockedGrid.width = columns.lockedWidth; + lockedGrid.columns = columns.locked; + normalGrid.columns = columns.normal; + + me.store = Ext.StoreManager.lookup(me.store); + lockedGrid.store = me.store; + normalGrid.store = me.store; + + + normalGrid.flex = 1; + lockedGrid.viewConfig = me.lockedViewConfig || {}; + lockedGrid.viewConfig.loadingUseMsg = false; + normalGrid.viewConfig = me.normalViewConfig || {}; + + Ext.applyIf(lockedGrid.viewConfig, me.viewConfig); + Ext.applyIf(normalGrid.viewConfig, me.viewConfig); + + me.normalGrid = Ext.ComponentManager.create(normalGrid); + me.lockedGrid = Ext.ComponentManager.create(lockedGrid); + + me.view = Ext.create('Ext.grid.LockingView', { + locked: me.lockedGrid, + normal: me.normalGrid, + panel: me + }); + + if (me.syncRowHeight) { + me.lockedGrid.getView().on({ + refresh: me.onLockedGridAfterRefresh, + itemupdate: me.onLockedGridAfterUpdate, + scope: me + }); - 'beforedblclick', + me.normalGrid.getView().on({ + refresh: me.onNormalGridAfterRefresh, + itemupdate: me.onNormalGridAfterUpdate, + scope: me + }); + } + + lockedHeaderCt = me.lockedGrid.headerCt; + normalHeaderCt = me.normalGrid.headerCt; + + lockedHeaderCt.lockedCt = true; + lockedHeaderCt.lockableInjected = true; + normalHeaderCt.lockableInjected = true; + + lockedHeaderCt.on({ + columnshow: me.onLockedHeaderShow, + columnhide: me.onLockedHeaderHide, + columnmove: me.onLockedHeaderMove, + sortchange: me.onLockedHeaderSortChange, + columnresize: me.onLockedHeaderResize, + scope: me + }); + + normalHeaderCt.on({ + columnmove: me.onNormalHeaderMove, + sortchange: me.onNormalHeaderSortChange, + scope: me + }); + + me.normalGrid.on({ + scrollershow: me.onScrollerShow, + scrollerhide: me.onScrollerHide, + scope: me + }); + + me.lockedGrid.on('afterlayout', me.onLockedGridAfterLayout, me, {single: true}); + + me.modifyHeaderCt(); + me.items = [me.lockedGrid, me.normalGrid]; + + me.layout = { + type: 'hbox', + align: 'stretch' + }; + }, + + processColumns: function(columns){ + + var i = 0, + len = columns.length, + lockedWidth = 0, + lockedHeaders = [], + normalHeaders = [], + column; - 'dblclick', + for (; i < len; ++i) { + column = columns[i]; - 'contextmenu', - 'beforechildrenrendered' - ); + column.processed = true; + if (column.locked) { + if (column.flex) { + Ext.Error.raise("Columns which are locked do NOT support a flex width. You must set a width on the " + columns[i].text + "column."); + } + lockedWidth += column.width; + lockedHeaders.push(column); + } else { + normalHeaders.push(column); + } + } + return { + lockedWidth: lockedWidth, + locked: lockedHeaders, + normal: normalHeaders + }; + }, - var uiClass = this.attributes.uiProvider || this.defaultUI || Ext.tree.TreeNodeUI; - - this.ui = new uiClass(this); + onLockedGridAfterLayout: function() { + var me = this, + lockedView = me.lockedGrid.getView(); + lockedView.on({ + refresh: me.createSpacer, + beforerefresh: me.destroySpacer, + scope: me + }); }, - preventHScroll : true, - isExpanded : function(){ - return this.expanded; + onLockedHeaderMove: function() { + if (this.syncRowHeight) { + this.onNormalGridAfterRefresh(); + } }, - - - getUI : function(){ - return this.ui; + + + onNormalHeaderMove: function() { + if (this.syncRowHeight) { + this.onLockedGridAfterRefresh(); + } }, + + + + createSpacer: function() { + var me = this, + + + w = Ext.getScrollBarWidth() + (Ext.isIE ? 2 : 0), + view = me.lockedGrid.getView(), + el = view.el; - getLoader : function(){ - var owner; - return this.loader || ((owner = this.getOwnerTree()) && owner.loader ? owner.loader : (this.loader = new Ext.tree.TreeLoader())); + me.spacerEl = Ext.core.DomHelper.append(el, { + cls: me.spacerHidden ? (Ext.baseCSSPrefix + 'hidden') : '', + style: 'height: ' + w + 'px;' + }, true); }, - - setFirstChild : function(node){ - var of = this.firstChild; - Ext.tree.TreeNode.superclass.setFirstChild.call(this, node); - if(this.childrenRendered && of && node != of){ - of.renderIndent(true, true); - } - if(this.rendered){ - this.renderIndent(true, true); + destroySpacer: function() { + var me = this; + if (me.spacerEl) { + me.spacerEl.destroy(); + delete me.spacerEl; } }, - - setLastChild : function(node){ - var ol = this.lastChild; - Ext.tree.TreeNode.superclass.setLastChild.call(this, node); - if(this.childrenRendered && ol && node != ol){ - ol.renderIndent(true, true); - } - if(this.rendered){ - this.renderIndent(true, true); + + onLockedGridAfterRefresh: function() { + var me = this, + view = me.lockedGrid.getView(), + el = view.el, + rowEls = el.query(view.getItemSelector()), + ln = rowEls.length, + i = 0; + + + me.lockedHeights = []; + + for (; i < ln; i++) { + me.lockedHeights[i] = rowEls[i].clientHeight; } + me.syncRowHeights(); }, - - appendChild : function(n){ - if(!n.render && !Ext.isArray(n)){ - n = this.getLoader().createNode(n); - } - var node = Ext.tree.TreeNode.superclass.appendChild.call(this, n); - if(node && this.childrenRendered){ - node.render(); + onNormalGridAfterRefresh: function() { + var me = this, + view = me.normalGrid.getView(), + el = view.el, + rowEls = el.query(view.getItemSelector()), + ln = rowEls.length, + i = 0; + + + me.normalHeights = []; + + for (; i < ln; i++) { + me.normalHeights[i] = rowEls[i].clientHeight; } - this.ui.updateExpandIcon(); - return node; + me.syncRowHeights(); + }, + + + onLockedGridAfterUpdate: function(record, index, node) { + this.lockedHeights[index] = node.clientHeight; + this.syncRowHeights(); + }, + + + onNormalGridAfterUpdate: function(record, index, node) { + this.normalHeights[index] = node.clientHeight; + this.syncRowHeights(); }, - - removeChild : function(node, destroy){ - this.ownerTree.getSelectionModel().unselect(node); - Ext.tree.TreeNode.superclass.removeChild.apply(this, arguments); + + + syncRowHeights: function() { + var me = this, + lockedHeights = me.lockedHeights, + normalHeights = me.normalHeights, + calcHeights = [], + ln = lockedHeights.length, + i = 0, + lockedView, normalView, + lockedRowEls, normalRowEls, + vertScroller = me.getVerticalScroller(), + scrollTop; + - if(!destroy){ - var rendered = node.ui.rendered; + + if (lockedHeights.length && normalHeights.length) { + lockedView = me.lockedGrid.getView(); + normalView = me.normalGrid.getView(); + lockedRowEls = lockedView.el.query(lockedView.getItemSelector()); + normalRowEls = normalView.el.query(normalView.getItemSelector()); + - if(rendered){ - node.ui.remove(); - } - if(rendered && this.childNodes.length < 1){ - this.collapse(false, false); - }else{ - this.ui.updateExpandIcon(); + for (; i < ln; i++) { + + if (!isNaN(lockedHeights[i]) && !isNaN(normalHeights[i])) { + if (lockedHeights[i] > normalHeights[i]) { + Ext.fly(normalRowEls[i]).setHeight(lockedHeights[i]); + } else if (lockedHeights[i] < normalHeights[i]) { + Ext.fly(lockedRowEls[i]).setHeight(normalHeights[i]); + } + } } - if(!this.firstChild && !this.isHiddenRoot()){ - this.childrenRendered = false; + + + me.normalGrid.invalidateScroller(); + + + + if (vertScroller && vertScroller.setViewScrollTop) { + vertScroller.setViewScrollTop(me.virtualScrollTop); + } else { + + + + scrollTop = normalView.el.dom.scrollTop; + normalView.el.dom.scrollTop = scrollTop; + lockedView.el.dom.scrollTop = scrollTop; } + + + me.lockedHeights = []; + me.normalHeights = []; } - return node; }, - - insertBefore : function(node, refNode){ - if(!node.render){ - node = this.getLoader().createNode(node); - } - var newNode = Ext.tree.TreeNode.superclass.insertBefore.call(this, node, refNode); - if(newNode && refNode && this.childrenRendered){ - node.render(); - } - this.ui.updateExpandIcon(); - return newNode; - }, - - setText : function(text){ - var oldText = this.text; - this.text = this.attributes.text = text; - if(this.rendered){ - this.ui.onTextChange(this, text, oldText); + onScrollerShow: function(scroller, direction) { + if (direction === 'horizontal') { + this.spacerHidden = false; + this.spacerEl.removeCls(Ext.baseCSSPrefix + 'hidden'); } - this.fireEvent('textchange', this, text, oldText); }, - setIconCls : function(cls){ - var old = this.attributes.iconCls; - this.attributes.iconCls = cls; - if(this.rendered){ - this.ui.onIconClsChange(this, cls, old); + onScrollerHide: function(scroller, direction) { + if (direction === 'horizontal') { + this.spacerHidden = true; + this.spacerEl.addCls(Ext.baseCSSPrefix + 'hidden'); } }, + - setTooltip : function(tip, title){ - this.attributes.qtip = tip; - this.attributes.qtipTitle = title; - if(this.rendered){ - this.ui.onTipChange(this, tip, title); - } + modifyHeaderCt: function() { + var me = this; + me.lockedGrid.headerCt.getMenuItems = me.getMenuItems(true); + me.normalGrid.headerCt.getMenuItems = me.getMenuItems(false); }, - - setIcon : function(icon){ - this.attributes.icon = icon; - if(this.rendered){ - this.ui.onIconChange(this, icon); - } + onUnlockMenuClick: function() { + this.unlock(); }, + onLockMenuClick: function() { + this.lock(); + }, - setHref : function(href, target){ - this.attributes.href = href; - this.attributes.hrefTarget = target; - if(this.rendered){ - this.ui.onHrefChange(this, href, target); - } + getMenuItems: function(locked) { + var me = this, + unlockText = me.unlockText, + lockText = me.lockText, + + unlockCls = 'xg-hmenu-unlock', + lockCls = 'xg-hmenu-lock', + unlockHandler = Ext.Function.bind(me.onUnlockMenuClick, me), + lockHandler = Ext.Function.bind(me.onLockMenuClick, me); + + + return function() { + var o = Ext.grid.header.Container.prototype.getMenuItems.call(this); + o.push('-',{ + cls: unlockCls, + text: unlockText, + handler: unlockHandler, + disabled: !locked + }); + o.push({ + cls: lockCls, + text: lockText, + handler: lockHandler, + disabled: locked + }); + return o; + }; }, - setCls : function(cls){ - var old = this.attributes.cls; - this.attributes.cls = cls; - if(this.rendered){ - this.ui.onClsChange(this, cls, old); - } - }, - - select : function(){ - var t = this.getOwnerTree(); - if(t){ - t.getSelectionModel().select(this); + lock: function(activeHd, toIdx) { + var me = this, + normalGrid = me.normalGrid, + lockedGrid = me.lockedGrid, + normalHCt = normalGrid.headerCt, + lockedHCt = lockedGrid.headerCt; + + activeHd = activeHd || normalHCt.getMenu().activeHeader; + + + + if (activeHd.flex) { + activeHd.width = activeHd.getWidth(); + delete activeHd.flex; + } + + normalHCt.remove(activeHd, false); + lockedHCt.suspendLayout = true; + if (Ext.isDefined(toIdx)) { + lockedHCt.insert(toIdx, activeHd); + } else { + lockedHCt.add(activeHd); } + lockedHCt.suspendLayout = false; + me.syncLockedSection(); }, - - unselect : function(silent){ - var t = this.getOwnerTree(); - if(t){ - t.getSelectionModel().unselect(this, silent); - } + syncLockedSection: function() { + var me = this; + me.syncLockedWidth(); + me.lockedGrid.getView().refresh(); + me.normalGrid.getView().refresh(); }, - - isSelected : function(){ - var t = this.getOwnerTree(); - return t ? t.getSelectionModel().isSelected(this) : false; + + + syncLockedWidth: function() { + var me = this, + width = me.lockedGrid.headerCt.getFullWidth(true); + me.lockedGrid.setWidth(width); }, - - expand : function(deep, anim, callback, scope){ - if(!this.expanded){ - if(this.fireEvent('beforeexpand', this, deep, anim) === false){ - return; - } - if(!this.childrenRendered){ - this.renderChildren(); - } - this.expanded = true; - if(!this.isHiddenRoot() && (this.getOwnerTree().animate && anim !== false) || anim){ - this.ui.animExpand(function(){ - this.fireEvent('expand', this); - this.runCallback(callback, scope || this, [this]); - if(deep === true){ - this.expandChildNodes(true, true); - } - }.createDelegate(this)); - return; - }else{ - this.ui.expand(); - this.fireEvent('expand', this); - this.runCallback(callback, scope || this, [this]); - } - }else{ - this.runCallback(callback, scope || this, [this]); - } - if(deep === true){ - this.expandChildNodes(true); - } + onLockedHeaderResize: function() { + this.syncLockedWidth(); }, - - runCallback : function(cb, scope, args){ - if(Ext.isFunction(cb)){ - cb.apply(scope, args); - } + + onLockedHeaderHide: function() { + this.syncLockedWidth(); }, - - isHiddenRoot : function(){ - return this.isRoot && !this.getOwnerTree().rootVisible; + + onLockedHeaderShow: function() { + this.syncLockedWidth(); }, - - collapse : function(deep, anim, callback, scope){ - if(this.expanded && !this.isHiddenRoot()){ - if(this.fireEvent('beforecollapse', this, deep, anim) === false){ - return; - } - this.expanded = false; - if((this.getOwnerTree().animate && anim !== false) || anim){ - this.ui.animCollapse(function(){ - this.fireEvent('collapse', this); - this.runCallback(callback, scope || this, [this]); - if(deep === true){ - this.collapseChildNodes(true); - } - }.createDelegate(this)); - return; - }else{ - this.ui.collapse(); - this.fireEvent('collapse', this); - this.runCallback(callback, scope || this, [this]); - } - }else if(!this.expanded){ - this.runCallback(callback, scope || this, [this]); - } - if(deep === true){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].collapse(true, false); - } + onLockedHeaderSortChange: function(headerCt, header, sortState) { + if (sortState) { + + + this.normalGrid.headerCt.clearOtherSortStates(null, true); } }, - - delayedExpand : function(delay){ - if(!this.expandProcId){ - this.expandProcId = this.expand.defer(delay, this); + onNormalHeaderSortChange: function(headerCt, header, sortState) { + if (sortState) { + + + this.lockedGrid.headerCt.clearOtherSortStates(null, true); } }, - - cancelExpand : function(){ - if(this.expandProcId){ - clearTimeout(this.expandProcId); + + + unlock: function(activeHd, toIdx) { + var me = this, + normalGrid = me.normalGrid, + lockedGrid = me.lockedGrid, + normalHCt = normalGrid.headerCt, + lockedHCt = lockedGrid.headerCt; + + if (!Ext.isDefined(toIdx)) { + toIdx = 0; } - this.expandProcId = false; + activeHd = activeHd || lockedHCt.getMenu().activeHeader; + + lockedHCt.remove(activeHd, false); + me.syncLockedWidth(); + me.lockedGrid.getView().refresh(); + normalHCt.insert(toIdx, activeHd); + me.normalGrid.getView().refresh(); }, - - toggle : function(){ - if(this.expanded){ - this.collapse(); - }else{ - this.expand(); + + reconfigureLockable: function(store, columns) { + var me = this, + lockedGrid = me.lockedGrid, + normalGrid = me.normalGrid; + + if (columns) { + lockedGrid.headerCt.removeAll(); + normalGrid.headerCt.removeAll(); + + columns = me.processColumns(columns); + lockedGrid.setWidth(columns.lockedWidth); + lockedGrid.headerCt.add(columns.locked); + normalGrid.headerCt.add(columns.normal); } - }, + + if (store) { + store = Ext.data.StoreManager.lookup(store); + me.store = store; + lockedGrid.bindStore(store); + normalGrid.bindStore(store); + } else { + lockedGrid.getView().refresh(); + normalGrid.getView().refresh(); + } + } +}); - - ensureVisible : function(callback, scope){ - var tree = this.getOwnerTree(); - tree.expandPath(this.parentNode ? this.parentNode.getPath() : this.getPath(), false, function(){ - var node = tree.getNodeById(this.id); - tree.getTreeEl().scrollChildIntoView(node.ui.anchor); - this.runCallback(callback, scope || this, [this]); - }.createDelegate(this)); - }, +Ext.define('Ext.grid.Scroller', { + extend: 'Ext.Component', + alias: 'widget.gridscroller', + weight: 110, + cls: Ext.baseCSSPrefix + 'scroller', + focusable: false, - expandChildNodes : function(deep, anim) { - var cs = this.childNodes, - i, - len = cs.length; - for (i = 0; i < len; i++) { - cs[i].expand(deep, anim); + renderTpl: [''], + + initComponent: function() { + var me = this, + dock = me.dock, + cls = Ext.baseCSSPrefix + 'scroller-vertical', + sizeProp = 'width', + + + + + + scrollbarWidth = Ext.getScrollBarWidth() + (Ext.isIE ? 1 : -1); + + me.offsets = {bottom: 0}; + + if (dock === 'top' || dock === 'bottom') { + cls = Ext.baseCSSPrefix + 'scroller-horizontal'; + sizeProp = 'height'; } + me[sizeProp] = scrollbarWidth; + + me.cls += (' ' + cls); + + Ext.applyIf(me.renderSelectors, { + stretchEl: '.' + Ext.baseCSSPrefix + 'stretcher' + }); + me.callParent(); }, - - collapseChildNodes : function(deep){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].collapse(deep); - } + + afterRender: function() { + var me = this; + me.callParent(); + me.ownerCt.on('afterlayout', me.onOwnerAfterLayout, me); + me.mon(me.el, 'scroll', me.onElScroll, me); + Ext.cache[me.el.id].skipGarbageCollection = true; }, - - disable : function(){ - this.disabled = true; - this.unselect(); - if(this.rendered && this.ui.onDisableChange){ - this.ui.onDisableChange(this, true); + getSizeCalculation: function() { + var owner = this.getPanel(), + dock = this.dock, + elDom = this.el.dom, + width = 1, + height = 1, + view, tbl; + + if (dock === 'top' || dock === 'bottom') { + + + var items = owner.query('tableview'), + center = items[1] || items[0]; + + if (!center) { + return false; + } + + + + width = center.headerCt.getFullWidth(); + + if (Ext.isIEQuirks) { + width--; + } + + width--; + } else { + view = owner.down('tableview:not([lockableInjected])'); + if (!view) { + return false; + } + tbl = view.el; + if (!tbl) { + return false; + } + + + + height = tbl.dom.scrollHeight; } - this.fireEvent('disabledchange', this, true); - }, - - - enable : function(){ - this.disabled = false; - if(this.rendered && this.ui.onDisableChange){ - this.ui.onDisableChange(this, false); + if (isNaN(width)) { + width = 1; } - this.fireEvent('disabledchange', this, false); + if (isNaN(height)) { + height = 1; + } + return { + width: width, + height: height + }; }, - - renderChildren : function(suppressEvent){ - if(suppressEvent !== false){ - this.fireEvent('beforechildrenrendered', this); + invalidate: function(firstPass) { + if (!this.stretchEl || !this.ownerCt) { + return; } - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].render(true); + var size = this.getSizeCalculation(), + elDom = this.el.dom; + if (size) { + this.stretchEl.setSize(size); + + + + elDom.scrollTop = elDom.scrollTop; } - this.childrenRendered = true; }, - - sort : function(fn, scope){ - Ext.tree.TreeNode.superclass.sort.apply(this, arguments); - if(this.childrenRendered){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].render(true); - } - } + onOwnerAfterLayout: function(owner, layout) { + this.invalidate(); }, - render : function(bulkRender){ - this.ui.render(bulkRender); - if(!this.rendered){ - - this.getOwnerTree().registerNode(this); - this.rendered = true; - if(this.expanded){ - this.expanded = false; - this.expand(false, false); - } + setScrollTop: function(scrollTop) { + if (this.el) { + var elDom = this.el.dom; + return elDom.scrollTop = Ext.Number.constrain(scrollTop, 0, elDom.scrollHeight - elDom.clientHeight); } }, - renderIndent : function(deep, refresh){ - if(refresh){ - this.ui.childIndent = null; - } - this.ui.renderIndent(); - if(deep === true && this.childrenRendered){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].renderIndent(true, refresh); - } - } - }, - - beginUpdate : function(){ - this.childrenRendered = false; - }, - - endUpdate : function(){ - if(this.expanded && this.rendered){ - this.renderChildren(); + setScrollLeft: function(scrollLeft) { + if (this.el) { + var elDom = this.el.dom; + return elDom.scrollLeft = Ext.Number.constrain(scrollLeft, 0, elDom.scrollWidth - elDom.clientWidth); } }, - destroy : function(silent){ - if(silent === true){ - this.unselect(true); + scrollByDeltaY: function(delta) { + if (this.el) { + var elDom = this.el.dom; + return this.setScrollTop(elDom.scrollTop + delta); } - Ext.tree.TreeNode.superclass.destroy.call(this, silent); - Ext.destroy(this.ui, this.loader); - this.ui = this.loader = null; }, - onIdChange : function(id){ - this.ui.onIdChange(id); - } -}); - -Ext.tree.TreePanel.nodeTypes.node = Ext.tree.TreeNode; - Ext.tree.AsyncTreeNode = function(config){ - this.loaded = config && config.loaded === true; - this.loading = false; - Ext.tree.AsyncTreeNode.superclass.constructor.apply(this, arguments); - - this.addEvents('beforeload', 'load'); - - -}; -Ext.extend(Ext.tree.AsyncTreeNode, Ext.tree.TreeNode, { - expand : function(deep, anim, callback, scope){ - if(this.loading){ - var timer; - var f = function(){ - if(!this.loading){ - clearInterval(timer); - this.expand(deep, anim, callback, scope); - } - }.createDelegate(this); - timer = setInterval(f, 200); - return; - } - if(!this.loaded){ - if(this.fireEvent("beforeload", this) === false){ - return; - } - this.loading = true; - this.ui.beforeLoad(this); - var loader = this.loader || this.attributes.loader || this.getOwnerTree().getLoader(); - if(loader){ - loader.load(this, this.loadComplete.createDelegate(this, [deep, anim, callback, scope]), this); - return; - } + scrollByDeltaX: function(delta) { + if (this.el) { + var elDom = this.el.dom; + return this.setScrollLeft(elDom.scrollLeft + delta); } - Ext.tree.AsyncTreeNode.superclass.expand.call(this, deep, anim, callback, scope); }, - isLoading : function(){ - return this.loading; - }, - loadComplete : function(deep, anim, callback, scope){ - this.loading = false; - this.loaded = true; - this.ui.afterLoad(this); - this.fireEvent("load", this); - this.expand(deep, anim, callback, scope); + scrollToTop : function(){ + this.setScrollTop(0); }, - isLoaded : function(){ - return this.loaded; - }, - - hasChildNodes : function(){ - if(!this.isLeaf() && !this.loaded){ - return true; - }else{ - return Ext.tree.AsyncTreeNode.superclass.hasChildNodes.call(this); - } + onElScroll: function(event, target) { + this.fireEvent('bodyscroll', event, target); }, - - reload : function(callback, scope){ - this.collapse(false, false); - while(this.firstChild){ - this.removeChild(this.firstChild).destroy(); - } - this.childrenRendered = false; - this.loaded = false; - if(this.isHiddenRoot()){ - this.expanded = false; + getPanel: function() { + var me = this; + if (!me.panel) { + me.panel = this.up('[scrollerOwner]'); } - this.expand(false, false, callback, scope); + return me.panel; } }); -Ext.tree.TreePanel.nodeTypes.async = Ext.tree.AsyncTreeNode; -Ext.tree.TreeNodeUI = Ext.extend(Object, { - - constructor : function(node){ - Ext.apply(this, { - node: node, - rendered: false, - animating: false, - wasLeaf: true, - ecc: 'x-tree-ec-icon x-tree-elbow', - emptyIcon: Ext.BLANK_IMAGE_URL - }); - }, - - - removeChild : function(node){ - if(this.rendered){ - this.ctNode.removeChild(node.ui.getEl()); - } - }, - - beforeLoad : function(){ - this.addClass("x-tree-node-loading"); - }, +Ext.define('Ext.grid.PagingScroller', { + extend: 'Ext.grid.Scroller', + alias: 'widget.paginggridscroller', - afterLoad : function(){ - this.removeClass("x-tree-node-loading"); - }, - - onTextChange : function(node, text, oldText){ - if(this.rendered){ - this.textNode.innerHTML = text; - } - }, - onIconClsChange : function(node, cls, oldCls){ - if(this.rendered){ - Ext.fly(this.iconNode).replaceClass(oldCls, cls); - } - }, - onIconChange : function(node, icon){ - if(this.rendered){ - - var empty = Ext.isEmpty(icon); - this.iconNode.src = empty ? this.emptyIcon : icon; - Ext.fly(this.iconNode)[empty ? 'removeClass' : 'addClass']('x-tree-node-inline-icon'); - } - }, + percentageFromEdge: 0.35, - onTipChange : function(node, tip, title){ - if(this.rendered){ - var hasTitle = Ext.isDefined(title); - if(this.textNode.setAttributeNS){ - this.textNode.setAttributeNS("ext", "qtip", tip); - if(hasTitle){ - this.textNode.setAttributeNS("ext", "qtitle", title); - } - }else{ - this.textNode.setAttribute("ext:qtip", tip); - if(hasTitle){ - this.textNode.setAttribute("ext:qtitle", title); - } - } - } - }, + scrollToLoadBuffer: 200, - onHrefChange : function(node, href, target){ - if(this.rendered){ - this.anchor.href = this.getHref(href); - if(Ext.isDefined(target)){ - this.anchor.target = target; - } - } - }, + activePrefetch: true, + chunkSize: 50, + snapIncrement: 25, - onClsChange : function(node, cls, oldCls){ - if(this.rendered){ - Ext.fly(this.elNode).replaceClass(oldCls, cls); - } - }, + syncScroll: true, + + initComponent: function() { + var me = this, + ds = me.store; + ds.on('guaranteedrange', this.onGuaranteedRange, this); + this.callParent(arguments); + }, + - onDisableChange : function(node, state){ - this.disabled = state; - if (this.checkbox) { - this.checkbox.disabled = state; + onGuaranteedRange: function(range, start, end) { + var me = this, + ds = me.store, + rs; + + if (range.length && me.visibleStart < range[0].index) { + return; } - this[state ? 'addClass' : 'removeClass']('x-tree-node-disabled'); - }, + + ds.loadRecords(range); - - onSelectedChange : function(state){ - if(state){ - this.focus(); - this.addClass("x-tree-selected"); - }else{ + if (!me.firstLoad) { + if (me.rendered) { + me.invalidate(); + } else { + me.on('afterrender', this.invalidate, this, {single: true}); + } + me.firstLoad = true; + } else { - this.removeClass("x-tree-selected"); + me.syncTo(); } }, - - onMove : function(tree, node, oldParent, newParent, index, refNode){ - this.childIndent = null; - if(this.rendered){ - var targetNode = newParent.ui.getContainer(); - if(!targetNode){ - this.holder = document.createElement("div"); - this.holder.appendChild(this.wrap); - return; - } - var insertBefore = refNode ? refNode.ui.getEl() : null; - if(insertBefore){ - targetNode.insertBefore(this.wrap, insertBefore); - }else{ - targetNode.appendChild(this.wrap); - } - this.node.renderIndent(true, oldParent != newParent); + syncTo: function() { + var me = this, + pnl = me.getPanel(), + store = pnl.store, + scrollerElDom = this.el.dom, + rowOffset = me.visibleStart - store.guaranteedStart, + scrollBy = rowOffset * me.rowHeight, + scrollHeight = scrollerElDom.scrollHeight, + clientHeight = scrollerElDom.clientHeight, + scrollTop = scrollerElDom.scrollTop, + useMaximum; + + + + if (Ext.isIE9 && Ext.isStrict) { + clientHeight = scrollerElDom.offsetHeight + 2; } - }, - - addClass : function(cls){ - if(this.elNode){ - Ext.fly(this.elNode).addClass(cls); - } + + + useMaximum = (scrollHeight - clientHeight - scrollTop <= 0); + this.setViewScrollTop(scrollBy, useMaximum); }, - - - removeClass : function(cls){ - if(this.elNode){ - Ext.fly(this.elNode).removeClass(cls); - } + + getPageData : function(){ + var panel = this.getPanel(), + store = panel.store, + totalCount = store.getTotalCount(); + + return { + total : totalCount, + currentPage : store.currentPage, + pageCount: Math.ceil(totalCount / store.pageSize), + fromRecord: ((store.currentPage - 1) * store.pageSize) + 1, + toRecord: Math.min(store.currentPage * store.pageSize, totalCount) + }; }, - - remove : function(){ - if(this.rendered){ - this.holder = document.createElement("div"); - this.holder.appendChild(this.wrap); + onElScroll: function(e, t) { + var me = this, + panel = me.getPanel(), + store = panel.store, + pageSize = store.pageSize, + guaranteedStart = store.guaranteedStart, + guaranteedEnd = store.guaranteedEnd, + totalCount = store.getTotalCount(), + numFromEdge = Math.ceil(me.percentageFromEdge * store.pageSize), + position = t.scrollTop, + visibleStart = Math.floor(position / me.rowHeight), + view = panel.down('tableview'), + viewEl = view.el, + visibleHeight = viewEl.getHeight(), + visibleAhead = Math.ceil(visibleHeight / me.rowHeight), + visibleEnd = visibleStart + visibleAhead, + prevPage = Math.floor(visibleStart / store.pageSize), + nextPage = Math.floor(visibleEnd / store.pageSize) + 2, + lastPage = Math.ceil(totalCount / store.pageSize), + + requestStart = Math.floor(visibleStart / me.snapIncrement) * me.snapIncrement, + requestEnd = requestStart + pageSize - 1, + activePrefetch = me.activePrefetch; + + me.visibleStart = visibleStart; + me.visibleEnd = visibleEnd; + + + me.syncScroll = true; + if (totalCount >= pageSize) { + + if (requestEnd > totalCount - 1) { + this.cancelLoad(); + if (store.rangeSatisfied(totalCount - pageSize, totalCount - 1)) { + me.syncScroll = true; + } + store.guaranteeRange(totalCount - pageSize, totalCount - 1); + + } else if (visibleStart < guaranteedStart || visibleEnd > guaranteedEnd) { + if (store.rangeSatisfied(requestStart, requestEnd)) { + this.cancelLoad(); + store.guaranteeRange(requestStart, requestEnd); + } else { + store.mask(); + me.attemptLoad(requestStart, requestEnd); + } + + me.syncScroll = false; + } else if (activePrefetch && visibleStart < (guaranteedStart + numFromEdge) && prevPage > 0) { + me.syncScroll = true; + store.prefetchPage(prevPage); + } else if (activePrefetch && visibleEnd > (guaranteedEnd - numFromEdge) && nextPage < lastPage) { + me.syncScroll = true; + store.prefetchPage(nextPage); + } } - }, - - 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 - }); + if (me.syncScroll) { + me.syncTo(); } }, - - getDDHandles : function(){ - return [this.iconNode, this.textNode, this.elNode]; - }, - - - hide : function(){ - this.node.hidden = true; - if(this.wrap){ - this.wrap.style.display = "none"; + getSizeCalculation: function() { + + + var owner = this.ownerCt, + view = owner.getView(), + store = this.store, + dock = this.dock, + elDom = this.el.dom, + width = 1, + height = 1; + + if (!this.rowHeight) { + this.rowHeight = view.el.down(view.getItemSelector()).getHeight(false, true); } - }, + height = store.getTotalCount() * this.rowHeight; - show : function(){ - this.node.hidden = false; - if(this.wrap){ - this.wrap.style.display = ""; + if (isNaN(width)) { + width = 1; } + if (isNaN(height)) { + height = 1; + } + return { + width: width, + height: height + }; }, - - onContextMenu : function(e){ - if (this.node.hasListener("contextmenu") || this.node.getOwnerTree().hasListener("contextmenu")) { - e.preventDefault(); - this.focus(); - this.fireEvent("contextmenu", this.node, e); + attemptLoad: function(start, end) { + var me = this; + if (!me.loadTask) { + me.loadTask = Ext.create('Ext.util.DelayedTask', me.doAttemptLoad, me, []); } + me.loadTask.delay(me.scrollToLoadBuffer, me.doAttemptLoad, me, [start, end]); }, - - 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(); + cancelLoad: function() { + if (this.loadTask) { + this.loadTask.cancel(); } }, - - onDblClick : function(e){ - e.preventDefault(); - if(this.disabled){ + doAttemptLoad: function(start, end) { + var store = this.getPanel().store; + store.guaranteeRange(start, end); + }, + + setViewScrollTop: function(scrollTop, useMax) { + var owner = this.getPanel(), + items = owner.query('tableview'), + i = 0, + len = items.length, + center, + centerEl, + calcScrollTop, + maxScrollTop, + scrollerElDom = this.el.dom; + + owner.virtualScrollTop = scrollTop; + + center = items[1] || items[0]; + centerEl = center.el.dom; + + maxScrollTop = ((owner.store.pageSize * this.rowHeight) - centerEl.clientHeight); + calcScrollTop = (scrollTop % ((owner.store.pageSize * this.rowHeight) + 1)); + if (useMax) { + calcScrollTop = maxScrollTop; + } + if (calcScrollTop > maxScrollTop) { + 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); + for (; i < len; i++) { + items[i].el.dom.scrollTop = calcScrollTop; } - }, + } +}); - onOver : function(e){ - this.addClass('x-tree-node-over'); - }, - onOut : function(e){ - this.removeClass('x-tree-node-over'); - }, - - onCheckChange : function(){ - var checked = this.checkbox.checked; - - this.checkbox.defaultChecked = checked; - this.node.attributes.checked = checked; - this.fireEvent('checkchange', this.node, checked); - }, +Ext.define('Ext.panel.Table', { + extend: 'Ext.panel.Panel', - - ecClick : function(e){ - if(!this.animating && this.node.isExpandable()){ - this.node.toggle(); - } - }, + alias: 'widget.tablepanel', - - startDrop : function(){ - this.dropping = true; - }, + uses: [ + 'Ext.selection.RowModel', + 'Ext.grid.Scroller', + 'Ext.grid.header.Container', + 'Ext.grid.Lockable' + ], - - endDrop : function(){ - setTimeout(function(){ - this.dropping = false; - }.createDelegate(this), 50); - }, + cls: Ext.baseCSSPrefix + 'grid', + extraBodyCls: Ext.baseCSSPrefix + 'grid-body', + layout: 'fit', - expand : function(){ - this.updateExpandIcon(); - this.ctNode.style.display = ""; - }, + hasView: false, - focus : function(){ - if(!this.node.preventHScroll){ - try{this.anchor.focus(); - }catch(e){} - }else{ - try{ - var noscroll = this.node.getOwnerTree().getTreeEl().dom; - var l = noscroll.scrollLeft; - this.anchor.focus(); - noscroll.scrollLeft = l; - }catch(e){} - } - }, - - - toggleCheck : function(value){ - var cb = this.checkbox; - if(cb){ - cb.checked = (value === undefined ? !cb.checked : value); - this.onCheckChange(); - } - }, + viewType: null, + selType: 'rowmodel', - blur : function(){ - try{ - this.anchor.blur(); - }catch(e){} - }, + scrollDelta: 40, - animExpand : function(callback){ - var ct = Ext.get(this.ctNode); - ct.stopFx(); - if(!this.node.isExpandable()){ - this.updateExpandIcon(); - this.ctNode.style.display = ""; - Ext.callback(callback); - return; - } - this.animating = true; - this.updateExpandIcon(); - - ct.slideIn('t', { - callback : function(){ - this.animating = false; - Ext.callback(callback); - }, - scope: this, - duration: this.node.ownerTree.duration || .25 - }); - }, + scroll: true, - highlight : function(){ - var tree = this.node.getOwnerTree(); - Ext.fly(this.wrap).highlight( - tree.hlColor || "C3DAF9", - {endColor: tree.hlBaseColor} - ); - }, - collapse : function(){ - this.updateExpandIcon(); - this.ctNode.style.display = "none"; - }, - animCollapse : function(callback){ - var ct = Ext.get(this.ctNode); - ct.enableDisplayMode('block'); - ct.stopFx(); - - this.animating = true; - this.updateExpandIcon(); - - ct.slideOut('t', { - callback : function(){ - this.animating = false; - Ext.callback(callback); - }, - scope: this, - duration: this.node.ownerTree.duration || .25 - }); - }, - getContainer : function(){ - return this.ctNode; - }, + sortableColumns: true, + verticalScrollDock: 'right', + verticalScrollerType: 'gridscroller', - getEl : function(){ - return this.wrap; - }, + horizontalScrollerPresentCls: Ext.baseCSSPrefix + 'horizontal-scroller-present', + verticalScrollerPresentCls: Ext.baseCSSPrefix + 'vertical-scroller-present', - appendDDGhost : function(ghostNode){ - ghostNode.appendChild(this.elNode.cloneNode(true)); - }, - - getDDRepairXY : function(){ - return Ext.lib.Dom.getXY(this.iconNode); - }, + scrollerOwner: true, + invalidateScrollerOnRefresh: true, - onRender : function(){ - this.render(); - }, + enableColumnMove: true, + enableColumnResize: true, - - render : function(bulkRender){ - var n = this.node, a = n.attributes; - var targetNode = n.parentNode ? - n.parentNode.ui.getContainer() : n.ownerTree.innerCt.dom; - if(!this.rendered){ - this.rendered = true; + initComponent: function() { + if (!this.viewType) { + Ext.Error.raise("You must specify a viewType config."); + } + if (!this.store) { + Ext.Error.raise("You must specify a store config"); + } + if (this.headers) { + Ext.Error.raise("The headers config is not supported. Please specify columns instead."); + } - this.renderElements(n, a, targetNode, bulkRender); + var me = this, + scroll = me.scroll, + vertical = false, + horizontal = false, + headerCtCfg = me.columns || me.colModel, + i = 0, + view, + border = me.border; - if(a.qtip){ - this.onTipChange(n, a.qtip, a.qtipTitle); - }else if(a.qtipCfg){ - a.qtipCfg.target = Ext.id(this.textNode); - Ext.QuickTips.register(a.qtipCfg); - } - this.initEvents(); - if(!this.node.expanded){ - this.updateExpandIcon(true); - } - }else{ - if(bulkRender === true) { - targetNode.appendChild(this.wrap); - } + + me.determineScrollbars = Ext.Function.createBuffered(me.determineScrollbars, 30); + me.injectView = Ext.Function.createBuffered(me.injectView, 30); + + if (me.hideHeaders) { + border = false; } - }, - - renderElements : function(n, a, targetNode, bulkRender){ - this.indentMarkup = n.parentNode ? n.parentNode.ui.getChildIndent() : ''; - - var cb = Ext.isBoolean(a.checked), - nel, - href = this.getHref(a.href), - buf = ['",
- '',
- " "].join('');
+
+ if (headerCtCfg instanceof Ext.grid.header.Container) {
+ me.headerCt = headerCtCfg;
+ me.headerCt.border = border;
+ me.columns = me.headerCt.items.items;
+ } else {
+ if (Ext.isArray(headerCtCfg)) {
+ headerCtCfg = {
+ items: headerCtCfg,
+ border: border
+ };
+ }
+ Ext.apply(headerCtCfg, {
+ forceFit: me.forceFit,
+ sortable: me.sortableColumns,
+ enableColumnMove: me.enableColumnMove,
+ enableColumnResize: me.enableColumnResize,
+ border: border
+ });
+ me.columns = headerCtCfg.items;
- if(bulkRender !== true && n.nextSibling && (nel = n.nextSibling.ui.getEl())){
- this.wrap = Ext.DomHelper.insertHtml("beforeBegin", nel, buf);
- }else{
- this.wrap = Ext.DomHelper.insertHtml("beforeEnd", targetNode, buf);
+
+
+ if (Ext.ComponentQuery.query('{locked !== undefined}{processed != true}', me.columns).length) {
+ me.self.mixin('lockable', Ext.grid.Lockable);
+ me.injectLockable();
+ }
}
- this.elNode = this.wrap.childNodes[0];
- this.ctNode = this.wrap.childNodes[1];
- var cs = this.elNode.childNodes;
- this.indentNode = cs[0];
- this.ecNode = cs[1];
- this.iconNode = cs[2];
- var index = 3;
- if(cb){
- this.checkbox = cs[3];
+ me.store = Ext.data.StoreManager.lookup(me.store);
+ me.addEvents(
- this.checkbox.defaultChecked = this.checkbox.checked;
- index++;
- }
- this.anchor = cs[index];
- this.textNode = cs[index].firstChild;
- },
-
-
- getHref : function(href){
- return Ext.isEmpty(href) ? (Ext.isGecko ? '' : '#') : href;
- },
-
-
- getAnchor : function(){
- return this.anchor;
- },
-
-
- getTextEl : function(){
- return this.textNode;
- },
-
+ 'scrollerhide',
+
+ 'scrollershow'
+ );
- getIconEl : function(){
- return this.iconNode;
- },
+ me.bodyCls = me.bodyCls || '';
+ me.bodyCls += (' ' + me.extraBodyCls);
+
+ delete me.autoScroll;
- isChecked : function(){
- return this.checkbox ? this.checkbox.checked : false;
- },
+
+
+ if (!me.hasView) {
-
- updateExpandIcon : function(){
- if(this.rendered){
- var n = this.node,
- c1,
- c2,
- cls = n.isLast() ? "x-tree-elbow-end" : "x-tree-elbow",
- hasChild = n.hasChildNodes();
- if(hasChild || n.attributes.expandable){
- if(n.expanded){
- cls += "-minus";
- c1 = "x-tree-node-collapsed";
- c2 = "x-tree-node-expanded";
- }else{
- cls += "-plus";
- c1 = "x-tree-node-expanded";
- c2 = "x-tree-node-collapsed";
- }
- if(this.wasLeaf){
- this.removeClass("x-tree-node-leaf");
- this.wasLeaf = false;
- }
- if(this.c1 != c1 || this.c2 != c2){
- Ext.fly(this.elNode).replaceClass(c1, c2);
- this.c1 = c1; this.c2 = c2;
- }
- }else{
- if(!this.wasLeaf){
- Ext.fly(this.elNode).replaceClass("x-tree-node-expanded", "x-tree-node-collapsed");
- delete this.c1;
- delete this.c2;
- this.wasLeaf = true;
- }
- }
- var ecc = "x-tree-ec-icon "+cls;
- if(this.ecc != ecc){
- this.ecNode.className = ecc;
- this.ecc = ecc;
+
+
+ if (!me.headerCt) {
+ me.headerCt = Ext.create('Ext.grid.header.Container', headerCtCfg);
}
- }
- },
-
- onIdChange: function(id){
- if(this.rendered){
- this.elNode.setAttribute('ext:tree-node-id', id);
- }
- },
+
+ me.columns = me.headerCt.items.items;
-
- getChildIndent : function(){
- if(!this.childIndent){
- var buf = [],
- p = this.node;
- while(p){
- if(!p.isRoot || (p.isRoot && p.ownerTree.rootVisible)){
- if(!p.isLast()) {
- buf.unshift('
');
- } else {
- buf.unshift('');
- }
+ if (me.hideHeaders) {
+ me.headerCt.height = 0;
+ me.headerCt.border = false;
+ me.headerCt.addCls(Ext.baseCSSPrefix + 'grid-header-ct-hidden');
+ me.addCls(Ext.baseCSSPrefix + 'grid-header-hidden');
+
+
+ if (Ext.isIEQuirks) {
+ me.headerCt.style = {
+ display: 'none'
+ };
}
- p = p.parentNode;
}
- this.childIndent = buf.join("");
- }
- return this.childIndent;
- },
-
- renderIndent : function(){
- if(this.rendered){
- var indent = "",
- p = this.node.parentNode;
- if(p){
- indent = p.ui.getChildIndent();
- }
- if(this.indentMarkup != indent){
- this.indentNode.innerHTML = indent;
- this.indentMarkup = indent;
+
+ if (scroll === true || scroll === 'both') {
+ vertical = horizontal = true;
+ } else if (scroll === 'horizontal') {
+ horizontal = true;
+ } else if (scroll === 'vertical') {
+ vertical = true;
+
+ } else {
+ me.headerCt.availableSpaceOffset = 0;
}
- this.updateExpandIcon();
- }
- },
- destroy : function(){
- if(this.elNode){
- Ext.dd.Registry.unregister(this.elNode.id);
- }
-
- Ext.each(['textnode', 'anchor', 'checkbox', 'indentNode', 'ecNode', 'iconNode', 'elNode', 'ctNode', 'wrap', 'holder'], function(el){
- if(this[el]){
- Ext.fly(this[el]).remove();
- delete this[el];
+ if (vertical) {
+ me.verticalScroller = me.verticalScroller || {};
+ Ext.applyIf(me.verticalScroller, {
+ dock: me.verticalScrollDock,
+ xtype: me.verticalScrollerType,
+ store: me.store
+ });
+ me.verticalScroller = Ext.ComponentManager.create(me.verticalScroller);
+ me.mon(me.verticalScroller, {
+ bodyscroll: me.onVerticalScroll,
+ scope: me
+ });
}
- }, this);
- delete this.node;
- }
-});
-
-
-Ext.tree.RootTreeNodeUI = Ext.extend(Ext.tree.TreeNodeUI, {
-
- render : function(){
- if(!this.rendered){
- var targetNode = this.node.ownerTree.innerCt.dom;
- this.node.expanded = true;
- targetNode.innerHTML = '';
- this.wrap = this.ctNode = targetNode.firstChild;
- }
- },
- collapse : Ext.emptyFn,
- expand : Ext.emptyFn
-});
-Ext.tree.TreeLoader = function(config){
- this.baseParams = {};
- Ext.apply(this, config);
-
- this.addEvents(
-
- "beforeload",
-
- "load",
-
- "loadexception"
- );
- Ext.tree.TreeLoader.superclass.constructor.call(this);
- if(Ext.isString(this.paramOrder)){
- this.paramOrder = this.paramOrder.split(/[\s,|]/);
- }
-};
-Ext.extend(Ext.tree.TreeLoader, Ext.util.Observable, {
-
-
-
-
-
-
-
- uiProviders : {},
-
-
- clearOnLoad : true,
-
-
- paramOrder: undefined,
+ if (horizontal) {
+ me.horizontalScroller = Ext.ComponentManager.create({
+ xtype: 'gridscroller',
+ section: me,
+ dock: 'bottom',
+ store: me.store
+ });
+ me.mon(me.horizontalScroller, {
+ bodyscroll: me.onHorizontalScroll,
+ scope: me
+ });
+ }
-
- paramsAsHash: false,
+ me.headerCt.on('columnresize', me.onHeaderResize, me);
+ me.relayEvents(me.headerCt, ['columnresize', 'columnmove', 'columnhide', 'columnshow', 'sortchange']);
+ me.features = me.features || [];
+ me.dockedItems = me.dockedItems || [];
+ me.dockedItems.unshift(me.headerCt);
+ me.viewConfig = me.viewConfig || {};
+ me.viewConfig.invalidateScrollerOnRefresh = me.invalidateScrollerOnRefresh;
-
- nodeParameter: 'node',
+
+
+ view = me.getView();
-
- directFn : undefined,
+ if (view) {
+ me.mon(view.store, {
+ load: me.onStoreLoad,
+ scope: me
+ });
+ me.mon(view, {
+ refresh: {
+ fn: this.onViewRefresh,
+ scope: me,
+ buffer: 50
+ },
+ itemupdate: me.onViewItemUpdate,
+ scope: me
+ });
+ this.relayEvents(view, [
+
+ 'beforeitemmousedown',
+
+ 'beforeitemmouseup',
+
+ 'beforeitemmouseenter',
+
+ 'beforeitemmouseleave',
+
+ 'beforeitemclick',
+
+ 'beforeitemdblclick',
+
+ 'beforeitemcontextmenu',
+
+ 'itemmousedown',
+
+ 'itemmouseup',
+
+ 'itemmouseenter',
+
+ 'itemmouseleave',
+
+ 'itemclick',
+
+ 'itemdblclick',
+
+ 'itemcontextmenu',
+
+ 'beforecontainermousedown',
+
+ 'beforecontainermouseup',
+
+ 'beforecontainermouseover',
+
+ 'beforecontainermouseout',
+
+ 'beforecontainerclick',
+
+ 'beforecontainerdblclick',
+
+ 'beforecontainercontextmenu',
+
+ 'containermouseup',
+
+ 'containermouseover',
+
+ 'containermouseout',
+
+ 'containerclick',
+
+ 'containerdblclick',
+
+ 'containercontextmenu',
-
- load : function(node, callback, scope){
- if(this.clearOnLoad){
- while(node.firstChild){
- node.removeChild(node.firstChild);
+
+ 'selectionchange',
+
+ 'beforeselect'
+ ]);
}
}
- if(this.doPreload(node)){
- this.runCallback(callback, scope || node, [node]);
- }else if(this.directFn || this.dataUrl || this.url){
- this.requestData(node, callback, scope || node);
- }
+ me.callParent(arguments);
},
- doPreload : function(node){
- if(node.attributes.children){
- if(node.childNodes.length < 1){
- var cs = node.attributes.children;
- node.beginUpdate();
- for(var i = 0, len = cs.length; i < len; i++){
- var cn = node.appendChild(this.createNode(cs[i]));
- if(this.preloadChildren){
- this.doPreload(cn);
- }
- }
- node.endUpdate();
+
+ initStateEvents: function(){
+ var events = this.stateEvents;
+
+ Ext.each(['columnresize', 'columnmove', 'columnhide', 'columnshow', 'sortchange'], function(event){
+ if (Ext.Array.indexOf(events, event)) {
+ events.push(event);
}
- return true;
- }
- return false;
+ });
+ this.callParent();
},
- getParams: function(node){
- var bp = Ext.apply({}, this.baseParams),
- np = this.nodeParameter,
- po = this.paramOrder;
+ getState: function(){
+ var state = {
+ columns: []
+ },
+ sorter = this.store.sorters.first();
+
+ this.headerCt.items.each(function(header){
+ state.columns.push({
+ id: header.headerId,
+ width: header.flex ? undefined : header.width,
+ hidden: header.hidden,
+ sortable: header.sortable
+ });
+ });
- np && (bp[ np ] = node.id);
+ if (sorter) {
+ state.sort = {
+ property: sorter.property,
+ direction: sorter.direction
+ };
+ }
+ return state;
+ },
- if(this.directFn){
- var buf = [node.id];
- if(po){
-
- if(np && po.indexOf(np) > -1){
- buf = [];
- }
+ applyState: function(state) {
+ var headers = state.columns,
+ length = headers ? headers.length : 0,
+ headerCt = this.headerCt,
+ items = headerCt.items,
+ sorter = state.sort,
+ store = this.store,
+ i = 0,
+ index,
+ headerState,
+ header;
- for(var i = 0, len = po.length; i < len; i++){
- buf.push(bp[ po[i] ]);
+ for (; i < length; ++i) {
+ headerState = headers[i];
+ header = headerCt.down('gridcolumn[headerId=' + headerState.id + ']');
+ index = items.indexOf(header);
+ if (i !== index) {
+ headerCt.moveHeader(index, i);
+ }
+ header.sortable = headerState.sortable;
+ if (Ext.isDefined(headerState.width)) {
+ delete header.flex;
+ if (header.rendered) {
+ header.setWidth(headerState.width);
+ } else {
+ header.minWidth = header.width = headerState.width;
}
- }else if(this.paramsAsHash){
- buf = [bp];
}
- return buf;
- }else{
- return bp;
+ header.hidden = headerState.hidden;
}
- },
- requestData : function(node, callback, scope){
- if(this.fireEvent("beforeload", this, node, callback) !== false){
- if(this.directFn){
- var args = this.getParams(node);
- args.push(this.processDirectResponse.createDelegate(this, [{callback: callback, node: node, scope: scope}], true));
- this.directFn.apply(window, args);
- }else{
- this.transId = Ext.Ajax.request({
- method:this.requestMethod,
- url: this.dataUrl||this.url,
- success: this.handleResponse,
- failure: this.handleFailure,
- scope: this,
- argument: {callback: callback, node: node, scope: scope},
- params: this.getParams(node)
- });
+ if (sorter) {
+ if (store.remoteSort) {
+ store.sorters.add(Ext.create('Ext.util.Sorter', {
+ property: sorter.property,
+ direction: sorter.direction
+ }));
+ }
+ else {
+ store.sort(sorter.property, sorter.direction);
}
- }else{
-
-
- this.runCallback(callback, scope || node, []);
}
},
- processDirectResponse: function(result, response, args){
- if(response.status){
- this.handleResponse({
- responseData: Ext.isArray(result) ? result : null,
- responseText: result,
- argument: args
- });
- }else{
- this.handleFailure({
- argument: args
- });
- }
+
+ getStore: function(){
+ return this.store;
},
- runCallback: function(cb, scope, args){
- if(Ext.isFunction(cb)){
- cb.apply(scope, args);
+ getView: function() {
+ var me = this,
+ sm;
+
+ if (!me.view) {
+ sm = me.getSelectionModel();
+ me.view = me.createComponent(Ext.apply({}, me.viewConfig, {
+ xtype: me.viewType,
+ store: me.store,
+ headerCt: me.headerCt,
+ selModel: sm,
+ features: me.features,
+ panel: me
+ }));
+ me.mon(me.view, {
+ uievent: me.processEvent,
+ scope: me
+ });
+ sm.view = me.view;
+ me.headerCt.view = me.view;
+ me.relayEvents(me.view, ['cellclick', 'celldblclick']);
}
+ return me.view;
},
- isLoading : function(){
- return !!this.transId;
- },
-
- abort : function(){
- if(this.isLoading()){
- Ext.Ajax.abort(this.transId);
- }
- },
+
+ setAutoScroll: Ext.emptyFn,
- createNode : function(attr){
-
- if(this.baseAttrs){
- Ext.applyIf(attr, this.baseAttrs);
- }
- if(this.applyLoader !== false && !attr.loader){
- attr.loader = this;
- }
- if(Ext.isString(attr.uiProvider)){
- attr.uiProvider = this.uiProviders[attr.uiProvider] || eval(attr.uiProvider);
- }
- if(attr.nodeType){
- return new Ext.tree.TreePanel.nodeTypes[attr.nodeType](attr);
- }else{
- return attr.leaf ?
- new Ext.tree.TreeNode(attr) :
- new Ext.tree.AsyncTreeNode(attr);
- }
- },
+
+
+ elScroll: function(direction, distance, animate) {
+ var me = this,
+ scroller;
- processResponse : function(response, node, callback, scope){
- var json = response.responseText;
- try {
- var o = response.responseData || Ext.decode(json);
- node.beginUpdate();
- for(var i = 0, len = o.length; i < len; i++){
- var n = this.createNode(o[i]);
- if(n){
- node.appendChild(n);
- }
- }
- node.endUpdate();
- this.runCallback(callback, scope || node, [node]);
- }catch(e){
- this.handleFailure(response);
+ if (direction === "up" || direction === "left") {
+ distance = -distance;
}
- },
- handleResponse : function(response){
- this.transId = false;
- var a = response.argument;
- this.processResponse(response, a.node, a.callback, a.scope);
- this.fireEvent("load", this, a.node, response);
+ if (direction === "down" || direction === "up") {
+ scroller = me.getVerticalScroller();
+ scroller.scrollByDeltaY(distance);
+ } else {
+ scroller = me.getHorizontalScroller();
+ scroller.scrollByDeltaX(distance);
+ }
},
-
- handleFailure : function(response){
- this.transId = false;
- var a = response.argument;
- this.fireEvent("loadexception", this, a.node, response);
- this.runCallback(a.callback, a.scope || a.node, [a.node]);
+
+ afterLayout: function() {
+ this.callParent(arguments);
+ this.injectView();
},
+
- destroy : function(){
- this.abort();
- this.purgeListeners();
- }
-});
-Ext.tree.TreeFilter = function(tree, config){
- this.tree = tree;
- this.filtered = {};
- Ext.apply(this, config);
-};
+
+ injectView: function() {
+ if (!this.hasView && !this.collapsed) {
+ var me = this,
+ view = me.getView();
-Ext.tree.TreeFilter.prototype = {
- clearBlank:false,
- reverse:false,
- autoClear:false,
- remove:false,
+ me.hasView = true;
+ me.add(view);
-
- filter : function(value, attr, startNode){
- attr = attr || "text";
- var f;
- if(typeof value == "string"){
- var vlen = value.length;
-
- if(vlen == 0 && this.clearBlank){
- this.clear();
- return;
- }
- value = value.toLowerCase();
- f = function(n){
- return n.attributes[attr].substr(0, vlen).toLowerCase() == value;
- };
- }else if(value.exec){
- f = function(n){
- return value.test(n.attributes[attr]);
- };
- }else{
- throw 'Illegal filter type, must be string or regex';
+
+ view.el.scroll = Ext.Function.bind(me.elScroll, me);
+
+
+ me.mon(view.el, {
+ mousewheel: me.onMouseWheel,
+ scope: me
+ });
}
- this.filterBy(f, null, startNode);
- },
+ },
-
- filterBy : function(fn, scope, startNode){
- startNode = startNode || this.tree.root;
- if(this.autoClear){
- this.clear();
- }
- var af = this.filtered, rv = this.reverse;
- var f = function(n){
- if(n == startNode){
- return true;
- }
- if(af[n.id]){
- return false;
- }
- var m = fn.call(scope || n, n);
- if(!m || rv){
- af[n.id] = n;
- n.ui.hide();
- return false;
- }
- return true;
- };
- startNode.cascade(f);
- if(this.remove){
- for(var id in af){
- if(typeof id != "function"){
- var n = af[id];
- if(n && n.parentNode){
- n.parentNode.removeChild(n);
- }
- }
- }
+ afterExpand: function() {
+ this.callParent(arguments);
+ if (!this.hasView) {
+ this.injectView();
}
},
- clear : function(){
- var t = this.tree;
- var af = this.filtered;
- for(var id in af){
- if(typeof id != "function"){
- var n = af[id];
- if(n){
- n.ui.show();
- }
- }
+ processEvent: function(type, view, cell, recordIndex, cellIndex, e) {
+ var me = this,
+ header;
+
+ if (cellIndex !== -1) {
+ header = me.headerCt.getGridColumns()[cellIndex];
+ return header.processEvent.apply(header, arguments);
}
- this.filtered = {};
- }
-};
+ },
-Ext.tree.TreeSorter = Ext.extend(Object, {
-
- constructor: function(tree, config){
-
-
-
-
-
+ determineScrollbars: function() {
+ var me = this,
+ viewElDom,
+ centerScrollWidth,
+ centerClientWidth,
+ scrollHeight,
+ clientHeight;
- Ext.apply(this, config);
- tree.on({
- scope: this,
- beforechildrenrendered: this.doSort,
- append: this.updateSort,
- insert: this.updateSort,
- textchange: this.updateSortParent
- });
+ if (!me.collapsed && me.view && me.view.el) {
+ viewElDom = me.view.el.dom;
+
+ centerScrollWidth = me.headerCt.getFullWidth();
+
+ centerClientWidth = viewElDom.offsetWidth;
+ if (me.verticalScroller && me.verticalScroller.el) {
+ scrollHeight = me.verticalScroller.getSizeCalculation().height;
+ } else {
+ scrollHeight = viewElDom.scrollHeight;
+ }
- var desc = this.dir && this.dir.toLowerCase() == 'desc',
- prop = this.property || 'text';
- sortType = this.sortType;
- folderSort = this.folderSort;
- caseSensitive = this.caseSensitive === true;
- leafAttr = this.leafAttr || 'leaf';
+ clientHeight = viewElDom.clientHeight;
- if(Ext.isString(sortType)){
- sortType = Ext.data.SortTypes[sortType];
- }
- this.sortFn = function(n1, n2){
- var attr1 = n1.attributes,
- attr2 = n2.attributes;
-
- if(folderSort){
- if(attr1[leafAttr] && !attr2[leafAttr]){
- return 1;
+ if (!me.collapsed && scrollHeight > clientHeight) {
+ me.showVerticalScroller();
+ } else {
+ me.hideVerticalScroller();
}
- if(!attr1[leafAttr] && attr2[leafAttr]){
- return -1;
+
+ if (!me.collapsed && centerScrollWidth > (centerClientWidth + Ext.getScrollBarWidth() - 2)) {
+ me.showHorizontalScroller();
+ } else {
+ me.hideHorizontalScroller();
}
}
- var prop1 = attr1[prop],
- prop2 = attr2[prop],
- v1 = sortType ? sortType(prop1) : (caseSensitive ? prop1 : prop1.toUpperCase());
- v2 = sortType ? sortType(prop2) : (caseSensitive ? prop2 : prop2.toUpperCase());
-
- if(v1 < v2){
- return desc ? 1 : -1;
- }else if(v1 > v2){
- return desc ? -1 : 1;
- }
- return 0;
- };
- },
-
- doSort : function(node){
- node.sort(this.sortFn);
},
- updateSort : function(tree, node){
- if(node.childrenRendered){
- this.doSort.defer(1, this, [node]);
+ onHeaderResize: function() {
+ if (this.view && this.view.rendered) {
+ this.determineScrollbars();
+ this.invalidateScroller();
}
},
- updateSortParent : function(node){
- var p = node.parentNode;
- if(p && p.childrenRendered){
- this.doSort.defer(1, this, [p]);
- }
- }
-});
-if(Ext.dd.DropZone){
-
-Ext.tree.TreeDropZone = function(tree, config){
-
- this.allowParentInsert = config.allowParentInsert || false;
- this.allowContainerDrop = config.allowContainerDrop || false;
-
- this.appendOnly = config.appendOnly || false;
+ hideHorizontalScroller: function() {
+ var me = this;
- Ext.tree.TreeDropZone.superclass.constructor.call(this, tree.getTreeEl(), config);
-
- this.tree = tree;
-
- this.dragOverData = {};
-
- this.lastInsertClass = "x-tree-no-status";
-};
+ if (me.horizontalScroller && me.horizontalScroller.ownerCt === me) {
+ me.verticalScroller.offsets.bottom = 0;
+ me.removeDocked(me.horizontalScroller, false);
+ me.removeCls(me.horizontalScrollerPresentCls);
+ me.fireEvent('scrollerhide', me.horizontalScroller, 'horizontal');
+ }
-Ext.extend(Ext.tree.TreeDropZone, Ext.dd.DropZone, {
-
- ddGroup : "TreeDD",
+ },
- expandDelay : 1000,
+ showHorizontalScroller: function() {
+ var me = this;
-
- expandNode : function(node){
- if(node.hasChildNodes() && !node.isExpanded()){
- node.expand(false, null, this.triggerCacheRefresh.createDelegate(this));
+ if (me.verticalScroller) {
+ me.verticalScroller.offsets.bottom = Ext.getScrollBarWidth() - 2;
+ }
+ if (me.horizontalScroller && me.horizontalScroller.ownerCt !== me) {
+ me.addDocked(me.horizontalScroller);
+ me.addCls(me.horizontalScrollerPresentCls);
+ me.fireEvent('scrollershow', me.horizontalScroller, 'horizontal');
}
},
- queueExpand : function(node){
- this.expandProcId = this.expandNode.defer(this.expandDelay, this, [node]);
- },
+ hideVerticalScroller: function() {
+ var me = this,
+ headerCt = me.headerCt;
-
- cancelExpand : function(){
- if(this.expandProcId){
- clearTimeout(this.expandProcId);
- this.expandProcId = false;
+
+ if (headerCt && headerCt.layout.reserveOffset) {
+ headerCt.layout.reserveOffset = false;
+ headerCt.doLayout();
+ }
+ if (me.verticalScroller && me.verticalScroller.ownerCt === me) {
+ me.removeDocked(me.verticalScroller, false);
+ me.removeCls(me.verticalScrollerPresentCls);
+ me.fireEvent('scrollerhide', me.verticalScroller, 'vertical');
}
},
- isValidDropPoint : function(n, pt, dd, e, data){
- if(!n || !data){ return false; }
- var targetNode = n.node;
- var dropNode = data.node;
+ showVerticalScroller: function() {
+ var me = this,
+ headerCt = me.headerCt;
+
- if(!(targetNode && targetNode.isTarget && pt)){
- return false;
+ if (headerCt && !headerCt.layout.reserveOffset) {
+ headerCt.layout.reserveOffset = true;
+ headerCt.doLayout();
}
- if(pt == "append" && targetNode.allowChildren === false){
- return false;
- }
- if((pt == "above" || pt == "below") && (targetNode.parentNode && targetNode.parentNode.allowChildren === false)){
- return false;
+ if (me.verticalScroller && me.verticalScroller.ownerCt !== me) {
+ me.addDocked(me.verticalScroller);
+ me.addCls(me.verticalScrollerPresentCls);
+ me.fireEvent('scrollershow', me.verticalScroller, 'vertical');
}
- if(dropNode && (targetNode == dropNode || dropNode.contains(targetNode))){
- return false;
+ },
+
+
+ invalidateScroller: function() {
+ var me = this,
+ vScroll = me.verticalScroller,
+ hScroll = me.horizontalScroller;
+
+ if (vScroll) {
+ vScroll.invalidate();
}
-
- var overEvent = this.dragOverData;
- overEvent.tree = this.tree;
- overEvent.target = targetNode;
- overEvent.data = data;
- overEvent.point = pt;
- overEvent.source = dd;
- overEvent.rawEvent = e;
- overEvent.dropNode = dropNode;
- overEvent.cancel = false;
- var result = this.tree.fireEvent("nodedragover", overEvent);
- return overEvent.cancel === false && result !== false;
- },
-
-
- getDropPoint : function(e, n, dd){
- var tn = n.node;
- if(tn.isRoot){
- return tn.allowChildren !== false ? "append" : false;
- }
- var dragEl = n.ddel;
- var t = Ext.lib.Dom.getY(dragEl), b = t + dragEl.offsetHeight;
- var y = Ext.lib.Event.getPageY(e);
- var noAppend = tn.allowChildren === false || tn.isLeaf();
- if(this.appendOnly || tn.parentNode.allowChildren === false){
- return noAppend ? false : "append";
- }
- var noBelow = false;
- if(!this.allowParentInsert){
- noBelow = tn.hasChildNodes() && tn.isExpanded();
- }
- var q = (b - t) / (noAppend ? 2 : 3);
- if(y >= t && y < (t + q)){
- return "above";
- }else if(!noBelow && (noAppend || y >= b-q && y <= b)){
- return "below";
- }else{
- return "append";
+ if (hScroll) {
+ hScroll.invalidate();
}
},
- onNodeEnter : function(n, dd, e, data){
- this.cancelExpand();
+ onHeaderMove: function(headerCt, header, fromIdx, toIdx) {
+ this.view.refresh();
},
+
- onContainerOver : function(dd, e, data) {
- if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) {
- return this.dropAllowed;
- }
- return this.dropNotAllowed;
+ onHeaderHide: function(headerCt, header) {
+ this.invalidateScroller();
},
-
- onNodeOver : function(n, dd, e, data){
- var pt = this.getDropPoint(e, n, dd);
- var node = n.node;
-
-
- if(!this.expandProcId && pt == "append" && node.hasChildNodes() && !n.node.isExpanded()){
- this.queueExpand(node);
- }else if(pt != "append"){
- this.cancelExpand();
- }
-
-
- var returnCls = this.dropNotAllowed;
- if(this.isValidDropPoint(n, pt, dd, e, data)){
- if(pt){
- var el = n.ddel;
- var cls;
- if(pt == "above"){
- returnCls = n.node.isFirst() ? "x-tree-drop-ok-above" : "x-tree-drop-ok-between";
- cls = "x-tree-drag-insert-above";
- }else if(pt == "below"){
- returnCls = n.node.isLast() ? "x-tree-drop-ok-below" : "x-tree-drop-ok-between";
- cls = "x-tree-drag-insert-below";
- }else{
- returnCls = "x-tree-drop-ok-append";
- cls = "x-tree-drag-append";
- }
- if(this.lastInsertClass != cls){
- Ext.fly(el).replaceClass(this.lastInsertClass, cls);
- this.lastInsertClass = cls;
- }
- }
- }
- return returnCls;
+ onHeaderShow: function(headerCt, header) {
+ this.invalidateScroller();
},
-
- onNodeOut : function(n, dd, e, data){
- this.cancelExpand();
- this.removeDropIndicators(n);
+ getVerticalScroller: function() {
+ return this.getScrollerOwner().down('gridscroller[dock=' + this.verticalScrollDock + ']');
},
-
- onNodeDrop : function(n, dd, e, data){
- var point = this.getDropPoint(e, n, dd);
- var targetNode = n.node;
- targetNode.ui.startDrop();
- if(!this.isValidDropPoint(n, point, dd, e, data)){
- targetNode.ui.endDrop();
- return false;
+ getHorizontalScroller: function() {
+ return this.getScrollerOwner().down('gridscroller[dock=bottom]');
+ },
+
+ onMouseWheel: function(e) {
+ var me = this,
+ browserEvent = e.browserEvent,
+ vertScroller = me.getVerticalScroller(),
+ horizScroller = me.getHorizontalScroller(),
+ scrollDelta = me.scrollDelta,
+ deltaY, deltaX,
+ vertScrollerEl, horizScrollerEl,
+ origScrollLeft, origScrollTop,
+ newScrollLeft, newScrollTop;
+
+
+
+ if (horizScroller) {
+ horizScrollerEl = horizScroller.el;
+ if (horizScrollerEl) {
+ origScrollLeft = horizScrollerEl.dom.scrollLeft;
+ }
+ }
+ if (vertScroller) {
+ vertScrollerEl = vertScroller.el;
+ if (vertScrollerEl) {
+ origScrollTop = vertScrollerEl.dom.scrollTop;
+ }
+ }
+
+
+ if (browserEvent.wheelDeltaX || browserEvent.wheelDeltaY) {
+ deltaX = -browserEvent.wheelDeltaX / 120 * scrollDelta / 3;
+ deltaY = -browserEvent.wheelDeltaY / 120 * scrollDelta / 3;
+ if (horizScroller) {
+ newScrollLeft = horizScroller.scrollByDeltaX(deltaX);
+ }
+ if (vertScroller) {
+ newScrollTop = vertScroller.scrollByDeltaY(deltaY);
+ }
+ } else {
+
+ if (browserEvent.axis && browserEvent.axis === 1) {
+ if (horizScroller) {
+ deltaX = -(scrollDelta * e.getWheelDelta()) / 3;
+ newScrollLeft = horizScroller.scrollByDeltaX(deltaX);
+ }
+ } else {
+ if (vertScroller) {
+
+ deltaY = -(scrollDelta * e.getWheelDelta() / 3);
+ newScrollTop = vertScroller.scrollByDeltaY(deltaY);
+ }
+ }
}
+
+
- var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, point, e) : null);
- return this.processDrop(targetNode, data, point, dd, e, dropNode);
+ if ((deltaX !== 0 && newScrollLeft !== origScrollLeft) ||
+ (deltaY !== 0 && newScrollTop !== origScrollTop)) {
+ e.stopEvent();
+ }
},
+
- onContainerDrop : function(dd, e, data){
- if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) {
- var targetNode = this.tree.getRootNode();
- targetNode.ui.startDrop();
- var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, 'append', e) : null);
- return this.processDrop(targetNode, data, 'append', dd, e, dropNode);
+ onViewRefresh: function() {
+ if (Ext.isIE) {
+ this.syncCellHeight();
+ }
+ this.determineScrollbars();
+ if (this.invalidateScrollerOnRefresh) {
+ this.invalidateScroller();
+ }
+ },
+
+ onViewItemUpdate: function(record, index, tr) {
+ if (Ext.isIE) {
+ this.syncCellHeight([tr]);
}
- return false;
},
+
- processDrop: function(target, data, point, dd, e, dropNode){
- var dropEvent = {
- tree : this.tree,
- target: target,
- data: data,
- point: point,
- source: dd,
- rawEvent: e,
- dropNode: dropNode,
- cancel: !dropNode,
- dropStatus: false
- };
- var retval = this.tree.fireEvent("beforenodedrop", dropEvent);
- if(retval === false || dropEvent.cancel === true || !dropEvent.dropNode){
- target.ui.endDrop();
- return dropEvent.dropStatus;
- }
- target = dropEvent.target;
- if(point == 'append' && !target.isExpanded()){
- target.expand(false, null, function(){
- this.completeDrop(dropEvent);
- }.createDelegate(this));
- }else{
- this.completeDrop(dropEvent);
+ syncCellHeight: function(trs) {
+ var me = this,
+ i = 0,
+ tds,
+ j, tdsLn,
+ tr, td,
+ trsLn,
+ rowHeights = [],
+ cellHeights,
+ cellClsSelector = ('.' + Ext.baseCSSPrefix + 'grid-cell');
+
+ trs = trs || me.view.getNodes();
+
+ trsLn = trs.length;
+
+ for (; i < trsLn; i++) {
+ tr = trs[i];
+ tds = Ext.fly(tr).query(cellClsSelector);
+ tdsLn = tds.length;
+ cellHeights = [];
+ for (j = 0; j < tdsLn; j++) {
+ td = tds[j];
+ cellHeights.push(td.clientHeight);
+ }
+ rowHeights.push(Ext.Array.max(cellHeights));
+ }
+
+
+ for (i = 0; i < trsLn; i++) {
+ tr = trs[i];
+ tdsLn = tr.childNodes.length;
+ for (j = 0; j < tdsLn; j++) {
+ td = Ext.fly(tr.childNodes[j]);
+ if (rowHeights[i]) {
+ if (td.is(cellClsSelector)) {
+ td.setHeight(rowHeights[i]);
+ } else {
+ td.down(cellClsSelector).setHeight(rowHeights[i]);
+ }
+ }
+
+ }
}
- return true;
},
- completeDrop : function(de){
- var ns = de.dropNode, p = de.point, t = de.target;
- if(!Ext.isArray(ns)){
- ns = [ns];
- }
- var n;
- for(var i = 0, len = ns.length; i < len; i++){
- n = ns[i];
- if(p == "above"){
- t.parentNode.insertBefore(n, t);
- }else if(p == "below"){
- t.parentNode.insertBefore(n, t.nextSibling);
- }else{
- t.appendChild(n);
- }
+ setScrollTop: function(top) {
+ var me = this,
+ rootCmp = me.getScrollerOwner(),
+ verticalScroller = me.getVerticalScroller();
+
+ rootCmp.virtualScrollTop = top;
+ if (verticalScroller) {
+ verticalScroller.setScrollTop(top);
}
- n.ui.focus();
- if(Ext.enableFx && this.tree.hlDrop){
- n.ui.highlight();
+
+ },
+
+ getScrollerOwner: function() {
+ var rootCmp = this;
+ if (!this.scrollerOwner) {
+ rootCmp = this.up('[scrollerOwner]');
}
- t.ui.endDrop();
- this.tree.fireEvent("nodedrop", de);
+ return rootCmp;
},
- afterNodeMoved : function(dd, data, e, targetNode, dropNode){
- if(Ext.enableFx && this.tree.hlDrop){
- dropNode.ui.focus();
- dropNode.ui.highlight();
+ scrollByDeltaY: function(deltaY) {
+ var rootCmp = this.getScrollerOwner(),
+ scrollerRight;
+ scrollerRight = rootCmp.down('gridscroller[dock=' + this.verticalScrollDock + ']');
+ if (scrollerRight) {
+ scrollerRight.scrollByDeltaY(deltaY);
}
- this.tree.fireEvent("nodedrop", this.tree, targetNode, data, dd, e);
},
+
- getTree : function(){
- return this.tree;
+ scrollByDeltaX: function(deltaX) {
+ this.horizontalScroller.scrollByDeltaX(deltaX);
},
- removeDropIndicators : function(n){
- if(n && n.ddel){
- var el = n.ddel;
- Ext.fly(el).removeClass([
- "x-tree-drag-insert-above",
- "x-tree-drag-insert-below",
- "x-tree-drag-append"]);
- this.lastInsertClass = "_noclass";
+ getLhsMarker: function() {
+ var me = this;
+
+ if (!me.lhsMarker) {
+ me.lhsMarker = Ext.core.DomHelper.append(me.el, {
+ cls: Ext.baseCSSPrefix + 'grid-resize-marker'
+ }, true);
}
+ return me.lhsMarker;
},
- beforeDragDrop : function(target, e, id){
- this.cancelExpand();
- return true;
+ getRhsMarker: function() {
+ var me = this;
+
+ if (!me.rhsMarker) {
+ me.rhsMarker = Ext.core.DomHelper.append(me.el, {
+ cls: Ext.baseCSSPrefix + 'grid-resize-marker'
+ }, true);
+ }
+ return me.rhsMarker;
},
- afterRepair : function(data){
- if(data && Ext.enableFx){
- data.node.ui.highlight();
+ getSelectionModel: function(){
+ if (!this.selModel) {
+ this.selModel = {};
}
- this.hideProxy();
- }
-});
-}
-if(Ext.dd.DragZone){
-Ext.tree.TreeDragZone = function(tree, config){
- Ext.tree.TreeDragZone.superclass.constructor.call(this, tree.innerCt, config);
-
- this.tree = tree;
-};
+ var mode = 'SINGLE',
+ type;
+ if (this.simpleSelect) {
+ mode = 'SIMPLE';
+ } else if (this.multiSelect) {
+ mode = 'MULTI';
+ }
-Ext.extend(Ext.tree.TreeDragZone, Ext.dd.DragZone, {
-
- ddGroup : "TreeDD",
+ Ext.applyIf(this.selModel, {
+ allowDeselect: this.allowDeselect,
+ mode: mode
+ });
-
- onBeforeDrag : function(data, e){
- var n = data.node;
- return n && n.draggable && !n.disabled;
- },
+ if (!this.selModel.events) {
+ type = this.selModel.selType || this.selType;
+ this.selModel = Ext.create('selection.' + type, this.selModel);
+ }
-
- onInitDrag : function(e){
- var data = this.dragData;
- this.tree.getSelectionModel().select(data.node);
- this.tree.eventModel.disable();
- this.proxy.update("");
- data.node.ui.appendDDGhost(this.proxy.ghost.dom);
- this.tree.fireEvent("startdrag", this.tree, data.node, e);
+ if (!this.selModel.hasRelaySetup) {
+ this.relayEvents(this.selModel, ['selectionchange', 'select', 'deselect']);
+ this.selModel.hasRelaySetup = true;
+ }
+
+
+
+ if (this.disableSelection) {
+ this.selModel.locked = true;
+ }
+ return this.selModel;
},
-
- getRepairXY : function(e, data){
- return data.node.ui.getDDRepairXY();
+ onVerticalScroll: function(event, target) {
+ var owner = this.getScrollerOwner(),
+ items = owner.query('tableview'),
+ i = 0,
+ len = items.length;
+
+ for (; i < len; i++) {
+ items[i].el.dom.scrollTop = target.scrollTop;
+ }
},
-
- onEndDrag : function(data, e){
- this.tree.eventModel.enable.defer(100, this.tree.eventModel);
- this.tree.fireEvent("enddrag", this.tree, data.node, e);
+ onHorizontalScroll: function(event, target) {
+ var owner = this.getScrollerOwner(),
+ items = owner.query('tableview'),
+ i = 0,
+ len = items.length,
+ center,
+ centerEl,
+ centerScrollWidth,
+ centerClientWidth,
+ width;
+
+ center = items[1] || items[0];
+ centerEl = center.el.dom;
+ centerScrollWidth = centerEl.scrollWidth;
+ centerClientWidth = centerEl.offsetWidth;
+ width = this.horizontalScroller.getWidth();
+
+ centerEl.scrollLeft = target.scrollLeft;
+ this.headerCt.el.dom.scrollLeft = target.scrollLeft;
},
- onValidDrop : function(dd, e, id){
- this.tree.fireEvent("dragdrop", this.tree, this.dragData.node, dd, e);
- this.hideProxy();
+ onStoreLoad: Ext.emptyFn,
+
+ getEditorParent: function() {
+ return this.body;
},
-
- beforeInvalidDrop : function(e, id){
-
- var sm = this.tree.getSelectionModel();
- sm.clearSelections();
- sm.select(this.dragData.node);
+ bindStore: function(store) {
+ var me = this;
+ me.store = store;
+ me.getView().bindStore(store);
},
-
-
- afterRepair : function(){
- if (Ext.enableFx && this.tree.hlDrop) {
- Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9");
+
+ reconfigure: function(store, columns) {
+ var me = this;
+
+ if (me.lockable) {
+ me.reconfigureLockable(store, columns);
+ return;
}
- this.dragging = false;
+
+ if (columns) {
+ me.headerCt.removeAll();
+ me.headerCt.add(columns);
+ }
+ if (store) {
+ store = Ext.StoreManager.lookup(store);
+ me.bindStore(store);
+ } else {
+ me.getView().refresh();
+ }
+ },
+
+ afterComponentLayout: function() {
+ this.callParent(arguments);
+ this.determineScrollbars();
+ this.invalidateScroller();
}
});
-}
-Ext.tree.TreeEditor = function(tree, fc, config){
- fc = fc || {};
- var field = fc.events ? fc : new Ext.form.TextField(fc);
-
- Ext.tree.TreeEditor.superclass.constructor.call(this, field, config);
- this.tree = tree;
+Ext.define('Ext.view.Table', {
+ extend: 'Ext.view.View',
+ alias: 'widget.tableview',
+ uses: [
+ 'Ext.view.TableChunker',
+ 'Ext.util.DelayedTask',
+ 'Ext.util.MixedCollection'
+ ],
- if(!tree.rendered){
- tree.on('render', this.initEditor, this);
- }else{
- this.initEditor(tree);
- }
-};
+ cls: Ext.baseCSSPrefix + 'grid-view',
-Ext.extend(Ext.tree.TreeEditor, Ext.Editor, {
-
- alignment: "l-l",
-
- autoSize: false,
-
- hideEl : false,
-
- cls: "x-small-editor x-tree-editor",
- shim:false,
+ itemSelector: '.' + Ext.baseCSSPrefix + 'grid-row',
- shadow:"frame",
+ cellSelector: '.' + Ext.baseCSSPrefix + 'grid-cell',
+
+ selectedItemCls: Ext.baseCSSPrefix + 'grid-row-selected',
+ selectedCellCls: Ext.baseCSSPrefix + 'grid-cell-selected',
+ focusedItemCls: Ext.baseCSSPrefix + 'grid-row-focused',
+ overItemCls: Ext.baseCSSPrefix + 'grid-row-over',
+ altRowCls: Ext.baseCSSPrefix + 'grid-row-alt',
+ rowClsRe: /(?:^|\s*)grid-row-(first|last|alt)(?:\s+|$)/g,
+ cellRe: new RegExp('x-grid-cell-([^\\s]+) ', ''),
+
- maxWidth: 250,
+ trackOver: true,
+
- editDelay : 350,
+ getRowClass: null,
- initEditor : function(tree){
- tree.on({
- scope : this,
- beforeclick: this.beforeNodeClick,
- dblclick : this.onNodeDblClick
+ initComponent: function() {
+ this.scrollState = {};
+ this.selModel.view = this;
+ this.headerCt.view = this;
+ this.initFeatures();
+ this.setNewTemplate();
+ this.callParent();
+ this.mon(this.store, {
+ load: this.onStoreLoad,
+ scope: this
});
+
+
+
+
+
+
+
+
- this.on({
- scope : this,
- complete : this.updateNode,
- beforestartedit: this.fitToTree,
- specialkey : this.onSpecialKey
- });
- this.on('startedit', this.bindScroll, this, {delay:10});
- },
-
-
- fitToTree : function(ed, el){
- var td = this.tree.getTreeEl().dom, nd = el.dom;
- if(td.scrollLeft > nd.offsetLeft){
- td.scrollLeft = nd.offsetLeft;
- }
- var w = Math.min(
- this.maxWidth,
- (td.clientWidth > 20 ? td.clientWidth : td.offsetWidth) - Math.max(0, nd.offsetLeft-td.scrollLeft) - 5);
- this.setSize(w, '');
},
- triggerEdit : function(node, defer){
- this.completeEdit();
- if(node.attributes.editable !== false){
-
- this.editNode = node;
- if(this.tree.autoScroll){
- Ext.fly(node.ui.getEl()).scrollIntoView(this.tree.body);
- }
- var value = node.text || '';
- if (!Ext.isGecko && Ext.isEmpty(node.text)){
- node.setText(' ');
+ onStoreLoad: function(){
+ if (this.invalidateScrollerOnRefresh) {
+ if (Ext.isGecko) {
+ if (!this.scrollToTopTask) {
+ this.scrollToTopTask = Ext.create('Ext.util.DelayedTask', this.scrollToTop, this);
+ }
+ this.scrollToTopTask.delay(1);
+ } else {
+ this.scrollToTop();
}
- this.autoEditTimer = this.startEdit.defer(this.editDelay, this, [node.ui.textNode, value]);
- return false;
}
},
- bindScroll : function(){
- this.tree.getTreeEl().on('scroll', this.cancelEdit, this);
- },
-
+ scrollToTop: Ext.emptyFn,
- beforeNodeClick : function(node, e){
- clearTimeout(this.autoEditTimer);
- if(this.tree.getSelectionModel().isSelected(node)){
- e.stopEvent();
- return this.triggerEdit(node);
- }
- },
-
- onNodeDblClick : function(node, e){
- clearTimeout(this.autoEditTimer);
+
+ getGridColumns: function() {
+ return this.headerCt.getGridColumns();
},
-
- updateNode : function(ed, value){
- this.tree.getTreeEl().un('scroll', this.cancelEdit, this);
- this.editNode.setText(value);
+
+ getHeaderAtIndex: function(index) {
+ return this.headerCt.getHeaderAtIndex(index);
},
-
- onHide : function(){
- Ext.tree.TreeEditor.superclass.onHide.call(this);
- if(this.editNode){
- this.editNode.ui.focus.defer(50, this.editNode.ui);
- }
+
+ getCell: function(record, column) {
+ var row = this.getNode(record);
+ return Ext.fly(row).down(column.getCellSelector());
},
- onSpecialKey : function(field, e){
- var k = e.getKey();
- if(k == e.ESC){
- e.stopEvent();
- this.cancelEdit();
- }else if(k == e.ENTER && !e.hasModifier()){
- e.stopEvent();
- this.completeEdit();
+ getFeature: function(id) {
+ var features = this.featuresMC;
+ if (features) {
+ return features.get(id);
}
},
+
- onDestroy : function(){
- clearTimeout(this.autoEditTimer);
- Ext.tree.TreeEditor.superclass.onDestroy.call(this);
- var tree = this.tree;
- tree.un('beforeclick', this.beforeNodeClick, this);
- tree.un('dblclick', this.onNodeDblClick, this);
- }
-});
-
-var swfobject = function() {
-
- var UNDEF = "undefined",
- OBJECT = "object",
- SHOCKWAVE_FLASH = "Shockwave Flash",
- SHOCKWAVE_FLASH_AX = "ShockwaveFlash.ShockwaveFlash",
- FLASH_MIME_TYPE = "application/x-shockwave-flash",
- EXPRESS_INSTALL_ID = "SWFObjectExprInst",
- ON_READY_STATE_CHANGE = "onreadystatechange",
-
- win = window,
- doc = document,
- nav = navigator,
-
- plugin = false,
- domLoadFnArr = [main],
- regObjArr = [],
- objIdArr = [],
- listenersArr = [],
- storedAltContent,
- storedAltContentId,
- storedCallbackFn,
- storedCallbackObj,
- isDomLoaded = false,
- isExpressInstallActive = false,
- dynamicStylesheet,
- dynamicStylesheetMedia,
- autoHideShow = true,
-
-
- ua = function() {
- var w3cdom = typeof doc.getElementById != UNDEF && typeof doc.getElementsByTagName != UNDEF && typeof doc.createElement != UNDEF,
- u = nav.userAgent.toLowerCase(),
- p = nav.platform.toLowerCase(),
- windows = p ? (/win/).test(p) : /win/.test(u),
- mac = p ? (/mac/).test(p) : /mac/.test(u),
- webkit = /webkit/.test(u) ? parseFloat(u.replace(/^.*webkit\/(\d+(\.\d+)?).*$/, "$1")) : false,
- ie = !+"\v1",
- playerVersion = [0,0,0],
- d = null;
- if (typeof nav.plugins != UNDEF && typeof nav.plugins[SHOCKWAVE_FLASH] == OBJECT) {
- d = nav.plugins[SHOCKWAVE_FLASH].description;
- if (d && !(typeof nav.mimeTypes != UNDEF && nav.mimeTypes[FLASH_MIME_TYPE] && !nav.mimeTypes[FLASH_MIME_TYPE].enabledPlugin)) {
- plugin = true;
- ie = false;
- d = d.replace(/^.*\s+(\S+\s+\S+$)/, "$1");
- playerVersion[0] = parseInt(d.replace(/^(.*)\..*$/, "$1"), 10);
- playerVersion[1] = parseInt(d.replace(/^.*\.(.*)\s.*$/, "$1"), 10);
- playerVersion[2] = /[a-zA-Z]/.test(d) ? parseInt(d.replace(/^.*[a-zA-Z]+(.*)$/, "$1"), 10) : 0;
- }
- }
- else if (typeof win.ActiveXObject != UNDEF) {
- try {
- var a = new ActiveXObject(SHOCKWAVE_FLASH_AX);
- if (a) {
- d = a.GetVariable("$version");
- if (d) {
- ie = true;
- d = d.split(" ")[1].split(",");
- playerVersion = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)];
- }
- }
+ initFeatures: function() {
+ this.features = this.features || [];
+ var features = this.features,
+ ln = features.length,
+ i = 0;
+
+ this.featuresMC = Ext.create('Ext.util.MixedCollection');
+ for (; i < ln; i++) {
+
+ if (!features[i].isFeature) {
+ features[i] = Ext.create('feature.'+features[i].ftype, features[i]);
}
- catch(e) {}
+
+ features[i].view = this;
+ this.featuresMC.add(features[i]);
}
- return { w3:w3cdom, pv:playerVersion, wk:webkit, ie:ie, win:windows, mac:mac };
- }(),
+ },
+
-
- onDomLoad = function() {
- if (!ua.w3) { return; }
- if ((typeof doc.readyState != UNDEF && doc.readyState == "complete") || (typeof doc.readyState == UNDEF && (doc.getElementsByTagName("body")[0] || doc.body))) {
- callDomLoadFunctions();
- }
- if (!isDomLoaded) {
- if (typeof doc.addEventListener != UNDEF) {
- doc.addEventListener("DOMContentLoaded", callDomLoadFunctions, false);
- }
- if (ua.ie && ua.win) {
- doc.attachEvent(ON_READY_STATE_CHANGE, function() {
- if (doc.readyState == "complete") {
- doc.detachEvent(ON_READY_STATE_CHANGE, arguments.callee);
- callDomLoadFunctions();
- }
- });
- if (win == top) {
- (function(){
- if (isDomLoaded) { return; }
- try {
- doc.documentElement.doScroll("left");
- }
- catch(e) {
- setTimeout(arguments.callee, 0);
- return;
- }
- callDomLoadFunctions();
- })();
- }
- }
- if (ua.wk) {
- (function(){
- if (isDomLoaded) { return; }
- if (!(/loaded|complete/).test(doc.readyState)) {
- setTimeout(arguments.callee, 0);
- return;
- }
- callDomLoadFunctions();
- })();
+ attachEventsForFeatures: function() {
+ var features = this.features,
+ ln = features.length,
+ i = 0;
+
+ for (; i < ln; i++) {
+ if (features[i].isFeature) {
+ features[i].attachEvents();
}
- addLoadEvent(callDomLoadFunctions);
- }
- }();
-
- function callDomLoadFunctions() {
- if (isDomLoaded) { return; }
- try {
- var t = doc.getElementsByTagName("body")[0].appendChild(createElement("span"));
- t.parentNode.removeChild(t);
- }
- catch (e) { return; }
- isDomLoaded = true;
- var dl = domLoadFnArr.length;
- for (var i = 0; i < dl; i++) {
- domLoadFnArr[i]();
- }
- }
-
- function addDomLoadEvent(fn) {
- if (isDomLoaded) {
- fn();
- }
- else {
- domLoadFnArr[domLoadFnArr.length] = fn;
- }
- }
-
-
- function addLoadEvent(fn) {
- if (typeof win.addEventListener != UNDEF) {
- win.addEventListener("load", fn, false);
- }
- else if (typeof doc.addEventListener != UNDEF) {
- doc.addEventListener("load", fn, false);
- }
- else if (typeof win.attachEvent != UNDEF) {
- addListener(win, "onload", fn);
- }
- else if (typeof win.onload == "function") {
- var fnOld = win.onload;
- win.onload = function() {
- fnOld();
- fn();
- };
- }
- else {
- win.onload = fn;
}
- }
+ },
+
+ afterRender: function() {
+ this.callParent();
+ this.mon(this.el, {
+ scroll: this.fireBodyScroll,
+ scope: this
+ });
+ this.attachEventsForFeatures();
+ },
+
+ fireBodyScroll: function(e, t) {
+ this.fireEvent('bodyscroll', e, t);
+ },
+
- function main() {
- if (plugin) {
- testPlayerVersion();
- }
- else {
- matchVersions();
+ prepareData: function(data, idx, record) {
+ var orig = this.headerCt.prepareData(data, idx, record, this),
+ features = this.features,
+ ln = features.length,
+ i = 0,
+ node, feature;
+
+ for (; i < ln; i++) {
+ feature = features[i];
+ if (feature.isFeature) {
+ Ext.apply(orig, feature.getAdditionalData(data, idx, record, orig, this));
+ }
}
- }
-
+
+ return orig;
+ },
+
- function testPlayerVersion() {
- var b = doc.getElementsByTagName("body")[0];
- var o = createElement(OBJECT);
- o.setAttribute("type", FLASH_MIME_TYPE);
- var t = b.appendChild(o);
- if (t) {
- var counter = 0;
- (function(){
- if (typeof t.GetVariable != UNDEF) {
- var d = t.GetVariable("$version");
- if (d) {
- d = d.split(" ")[1].split(",");
- ua.pv = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)];
- }
- }
- else if (counter < 10) {
- counter++;
- setTimeout(arguments.callee, 10);
- return;
+ collectData: function(records, startIndex) {
+ var preppedRecords = this.callParent(arguments),
+ headerCt = this.headerCt,
+ fullWidth = headerCt.getFullWidth(),
+ features = this.features,
+ ln = features.length,
+ o = {
+ rows: preppedRecords,
+ fullWidth: fullWidth
+ },
+ i = 0,
+ feature,
+ j = 0,
+ jln,
+ rowParams;
+
+ jln = preppedRecords.length;
+
+
+ if (this.getRowClass) {
+ for (; j < jln; j++) {
+ rowParams = {};
+ preppedRecords[j]['rowCls'] = this.getRowClass(records[j], j, rowParams, this.store);
+ if (rowParams.alt) {
+ Ext.Error.raise("The getRowClass alt property is no longer supported.");
}
- b.removeChild(o);
- t = null;
- matchVersions();
- })();
- }
- else {
- matchVersions();
- }
- }
-
-
- function matchVersions() {
- var rl = regObjArr.length;
- if (rl > 0) {
- for (var i = 0; i < rl; i++) {
- var id = regObjArr[i].id;
- var cb = regObjArr[i].callbackFn;
- var cbObj = {success:false, id:id};
- if (ua.pv[0] > 0) {
- var obj = getElementById(id);
- if (obj) {
- if (hasPlayerVersion(regObjArr[i].swfVersion) && !(ua.wk && ua.wk < 312)) {
- setVisibility(id, true);
- if (cb) {
- cbObj.success = true;
- cbObj.ref = getObjectById(id);
- cb(cbObj);
- }
- }
- else if (regObjArr[i].expressInstall && canExpressInstall()) {
- var att = {};
- att.data = regObjArr[i].expressInstall;
- att.width = obj.getAttribute("width") || "0";
- att.height = obj.getAttribute("height") || "0";
- if (obj.getAttribute("class")) { att.styleclass = obj.getAttribute("class"); }
- if (obj.getAttribute("align")) { att.align = obj.getAttribute("align"); }
-
- var par = {};
- var p = obj.getElementsByTagName("param");
- var pl = p.length;
- for (var j = 0; j < pl; j++) {
- if (p[j].getAttribute("name").toLowerCase() != "movie") {
- par[p[j].getAttribute("name")] = p[j].getAttribute("value");
- }
- }
- showExpressInstall(att, par, id, cb);
- }
- else {
- displayAltContent(obj);
- if (cb) { cb(cbObj); }
- }
- }
+ if (rowParams.tstyle) {
+ Ext.Error.raise("The getRowClass tstyle property is no longer supported.");
}
- else {
- setVisibility(id, true);
- if (cb) {
- var o = getObjectById(id);
- if (o && typeof o.SetVariable != UNDEF) {
- cbObj.success = true;
- cbObj.ref = o;
- }
- cb(cbObj);
- }
+ if (rowParams.cells) {
+ Ext.Error.raise("The getRowClass cells property is no longer supported.");
+ }
+ if (rowParams.body) {
+ Ext.Error.raise("The getRowClass body property is no longer supported. Use the getAdditionalData method of the rowbody feature.");
+ }
+ if (rowParams.bodyStyle) {
+ Ext.Error.raise("The getRowClass bodyStyle property is no longer supported.");
+ }
+ if (rowParams.cols) {
+ Ext.Error.raise("The getRowClass cols property is no longer supported.");
}
}
}
- }
-
- function getObjectById(objectIdStr) {
- var r = null;
- var o = getElementById(objectIdStr);
- if (o && o.nodeName == "OBJECT") {
- if (typeof o.SetVariable != UNDEF) {
- r = o;
- }
- else {
- var n = o.getElementsByTagName(OBJECT)[0];
- if (n) {
- r = n;
- }
+
+
+ for (; i < ln; i++) {
+ feature = features[i];
+ if (feature.isFeature && feature.collectData && !feature.disabled) {
+ o = feature.collectData(records, preppedRecords, startIndex, fullWidth, o);
+ break;
}
}
- return r;
- }
-
-
- function canExpressInstall() {
- return !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac) && !(ua.wk && ua.wk < 312);
- }
+ return o;
+ },
+
- function showExpressInstall(att, par, replaceElemIdStr, callbackFn) {
- isExpressInstallActive = true;
- storedCallbackFn = callbackFn || null;
- storedCallbackObj = {success:false, id:replaceElemIdStr};
- var obj = getElementById(replaceElemIdStr);
- if (obj) {
- if (obj.nodeName == "OBJECT") {
- storedAltContent = abstractAltContent(obj);
- storedAltContentId = null;
- }
- else {
- storedAltContent = obj;
- storedAltContentId = replaceElemIdStr;
- }
- att.id = EXPRESS_INSTALL_ID;
- if (typeof att.width == UNDEF || (!(/%$/).test(att.width) && parseInt(att.width, 10) < 310)) {
- att.width = "310";
- }
+ onHeaderResize: function(header, w, suppressFocus) {
+ var el = this.el;
+ if (el) {
+ this.saveScrollState();
- if (typeof att.height == UNDEF || (!(/%$/).test(att.height) && parseInt(att.height, 10) < 137)) {
- att.height = "137";
- }
- doc.title = doc.title.slice(0, 47) + " - Flash Player Installation";
- var pt = ua.ie && ua.win ? "ActiveX" : "PlugIn",
- fv = "MMredirectURL=" + win.location.toString().replace(/&/g,"%26") + "&MMplayerType=" + pt + "&MMdoctitle=" + doc.title;
- if (typeof par.flashvars != UNDEF) {
- par.flashvars += "&" + fv;
- }
- else {
- par.flashvars = fv;
- }
- if (ua.ie && ua.win && obj.readyState != 4) {
- var newObj = createElement("div");
- replaceElemIdStr += "SWFObjectNew";
- newObj.setAttribute("id", replaceElemIdStr);
- obj.parentNode.insertBefore(newObj, obj);
- obj.style.display = "none";
- (function(){
- if (obj.readyState == 4) {
- obj.parentNode.removeChild(obj);
- }
- else {
- setTimeout(arguments.callee, 10);
- }
- })();
+ el.select('.' + Ext.baseCSSPrefix + 'grid-col-resizer-'+header.id).setWidth(w);
+ el.select('.' + Ext.baseCSSPrefix + 'grid-table-resizer').setWidth(this.headerCt.getFullWidth());
+ this.restoreScrollState();
+ this.setNewTemplate();
+ if (!suppressFocus) {
+ this.el.focus();
}
- createSWF(att, par, replaceElemIdStr);
- }
- }
-
-
- function displayAltContent(obj) {
- if (ua.ie && ua.win && obj.readyState != 4) {
-
-
- var el = createElement("div");
- obj.parentNode.insertBefore(el, obj);
- el.parentNode.replaceChild(abstractAltContent(obj), el);
- obj.style.display = "none";
- (function(){
- if (obj.readyState == 4) {
- obj.parentNode.removeChild(obj);
- }
- else {
- setTimeout(arguments.callee, 10);
- }
- })();
- }
- else {
- obj.parentNode.replaceChild(abstractAltContent(obj), obj);
}
- }
+ },
- function abstractAltContent(obj) {
- var ac = createElement("div");
- if (ua.win && ua.ie) {
- ac.innerHTML = obj.innerHTML;
- }
- else {
- var nestedObj = obj.getElementsByTagName(OBJECT)[0];
- if (nestedObj) {
- var c = nestedObj.childNodes;
- if (c) {
- var cl = c.length;
- for (var i = 0; i < cl; i++) {
- if (!(c[i].nodeType == 1 && c[i].nodeName == "PARAM") && !(c[i].nodeType == 8)) {
- ac.appendChild(c[i].cloneNode(true));
- }
- }
- }
- }
- }
- return ac;
- }
-
- function createSWF(attObj, parObj, id) {
- var r, el = getElementById(id);
- if (ua.wk && ua.wk < 312) { return r; }
- if (el) {
- if (typeof attObj.id == UNDEF) {
- attObj.id = id;
- }
- if (ua.ie && ua.win) {
- var att = "";
- for (var i in attObj) {
- if (attObj[i] != Object.prototype[i]) {
- if (i.toLowerCase() == "data") {
- parObj.movie = attObj[i];
- }
- else if (i.toLowerCase() == "styleclass") {
- att += ' class="' + attObj[i] + '"';
- }
- else if (i.toLowerCase() != "classid") {
- att += ' ' + i + '="' + attObj[i] + '"';
- }
- }
- }
- var par = "";
- for (var j in parObj) {
- if (parObj[j] != Object.prototype[j]) {
- par += '';
- }
- }
- el.outerHTML = '';
- objIdArr[objIdArr.length] = attObj.id;
- r = getElementById(attObj.id);
- }
- else {
- var o = createElement(OBJECT);
- o.setAttribute("type", FLASH_MIME_TYPE);
- for (var m in attObj) {
- if (attObj[m] != Object.prototype[m]) {
- if (m.toLowerCase() == "styleclass") {
- o.setAttribute("class", attObj[m]);
- }
- else if (m.toLowerCase() != "classid") {
- o.setAttribute(m, attObj[m]);
- }
- }
- }
- for (var n in parObj) {
- if (parObj[n] != Object.prototype[n] && n.toLowerCase() != "movie") {
- createObjParam(o, n, parObj[n]);
- }
- }
- el.parentNode.replaceChild(o, el);
- r = o;
- }
+ onHeaderShow: function(headerCt, header, suppressFocus) {
+
+ if (header.oldWidth) {
+ this.onHeaderResize(header, header.oldWidth, suppressFocus);
+ delete header.oldWidth;
+
+
+
+ } else if (header.width && !header.flex) {
+ this.onHeaderResize(header, header.width, suppressFocus);
}
- return r;
- }
+ this.setNewTemplate();
+ },
+
- function createObjParam(el, pName, pValue) {
- var p = createElement("param");
- p.setAttribute("name", pName);
- p.setAttribute("value", pValue);
- el.appendChild(p);
- }
+ onHeaderHide: function(headerCt, header, suppressFocus) {
+ this.onHeaderResize(header, 0, suppressFocus);
+ },
+
+ setNewTemplate: function() {
+ var columns = this.headerCt.getColumnsForTpl(true);
+ this.tpl = this.getTableChunker().getTableTpl({
+ columns: columns,
+ features: this.features
+ });
+ },
+
- function removeSWF(id) {
- var obj = getElementById(id);
- if (obj && obj.nodeName == "OBJECT") {
- if (ua.ie && ua.win) {
- obj.style.display = "none";
- (function(){
- if (obj.readyState == 4) {
- removeObjectInIE(id);
- }
- else {
- setTimeout(arguments.callee, 10);
- }
- })();
- }
- else {
- obj.parentNode.removeChild(obj);
- }
- }
- }
+ getTableChunker: function() {
+ return this.chunker || Ext.view.TableChunker;
+ },
+
- function removeObjectInIE(id) {
- var obj = getElementById(id);
- if (obj) {
- for (var i in obj) {
- if (typeof obj[i] == "function") {
- obj[i] = null;
- }
- }
- obj.parentNode.removeChild(obj);
+ addRowCls: function(rowInfo, cls) {
+ var row = this.getNode(rowInfo);
+ if (row) {
+ Ext.fly(row).addCls(cls);
}
- }
-
+ },
+
- function getElementById(id) {
- var el = null;
- try {
- el = doc.getElementById(id);
+ removeRowCls: function(rowInfo, cls) {
+ var row = this.getNode(rowInfo);
+ if (row) {
+ Ext.fly(row).removeCls(cls);
}
- catch (e) {}
- return el;
- }
-
- function createElement(el) {
- return doc.createElement(el);
- }
-
-
- function addListener(target, eventType, fn) {
- target.attachEvent(eventType, fn);
- listenersArr[listenersArr.length] = [target, eventType, fn];
- }
+ },
+
+ onRowSelect : function(rowIdx) {
+ this.addRowCls(rowIdx, this.selectedItemCls);
+ },
+
- function hasPlayerVersion(rv) {
- var pv = ua.pv, v = rv.split(".");
- v[0] = parseInt(v[0], 10);
- v[1] = parseInt(v[1], 10) || 0;
- v[2] = parseInt(v[2], 10) || 0;
- return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false;
- }
+ onRowDeselect : function(rowIdx) {
+ this.removeRowCls(rowIdx, this.selectedItemCls);
+ this.removeRowCls(rowIdx, this.focusedItemCls);
+ },
-
- function createCSS(sel, decl, media, newStyle) {
- if (ua.ie && ua.mac) { return; }
- var h = doc.getElementsByTagName("head")[0];
- if (!h) { return; }
- var m = (media && typeof media == "string") ? media : "screen";
- if (newStyle) {
- dynamicStylesheet = null;
- dynamicStylesheetMedia = null;
+ onCellSelect: function(position) {
+ var cell = this.getCellByPosition(position);
+ if (cell) {
+ cell.addCls(this.selectedCellCls);
}
- if (!dynamicStylesheet || dynamicStylesheetMedia != m) {
-
- var s = createElement("style");
- s.setAttribute("type", "text/css");
- s.setAttribute("media", m);
- dynamicStylesheet = h.appendChild(s);
- if (ua.ie && ua.win && typeof doc.styleSheets != UNDEF && doc.styleSheets.length > 0) {
- dynamicStylesheet = doc.styleSheets[doc.styleSheets.length - 1];
- }
- dynamicStylesheetMedia = m;
+ },
+
+ onCellDeselect: function(position) {
+ var cell = this.getCellByPosition(position);
+ if (cell) {
+ cell.removeCls(this.selectedCellCls);
}
- if (ua.ie && ua.win) {
- if (dynamicStylesheet && typeof dynamicStylesheet.addRule == OBJECT) {
- dynamicStylesheet.addRule(sel, decl);
- }
- }
- else {
- if (dynamicStylesheet && typeof doc.createTextNode != UNDEF) {
- dynamicStylesheet.appendChild(doc.createTextNode(sel + " {" + decl + "}"));
- }
- }
- }
+ },
- function setVisibility(id, isVisible) {
- if (!autoHideShow) { return; }
- var v = isVisible ? "visible" : "hidden";
- if (isDomLoaded && getElementById(id)) {
- getElementById(id).style.visibility = v;
- }
- else {
- createCSS("#" + id, "visibility:" + v);
+ onCellFocus: function(position) {
+
+ this.focusCell(position);
+ },
+
+ getCellByPosition: function(position) {
+ var row = position.row,
+ column = position.column,
+ store = this.store,
+ node = this.getNode(row),
+ header = this.headerCt.getHeaderAtIndex(column),
+ cellSelector,
+ cell = false;
+
+ if (header) {
+ cellSelector = header.getCellSelector();
+ cell = Ext.fly(node).down(cellSelector);
}
- }
+ return cell;
+ },
- function urlEncodeIfNecessary(s) {
- var regex = /[\\\"<>\.;]/;
- var hasBadChars = regex.exec(s) != null;
- return hasBadChars && typeof encodeURIComponent != UNDEF ? encodeURIComponent(s) : s;
- }
-
- var cleanup = function() {
- if (ua.ie && ua.win) {
- window.attachEvent("onunload", function() {
-
- var ll = listenersArr.length;
- for (var i = 0; i < ll; i++) {
- listenersArr[i][0].detachEvent(listenersArr[i][1], listenersArr[i][2]);
- }
-
- var il = objIdArr.length;
- for (var j = 0; j < il; j++) {
- removeSWF(objIdArr[j]);
- }
-
- for (var k in ua) {
- ua[k] = null;
- }
- ua = null;
- for (var l in swfobject) {
- swfobject[l] = null;
- }
- swfobject = null;
- });
+ onRowFocus: function(rowIdx, highlight, supressFocus) {
+ var row = this.getNode(rowIdx);
+
+ if (highlight) {
+ this.addRowCls(rowIdx, this.focusedItemCls);
+ if (!supressFocus) {
+ this.focusRow(rowIdx);
+ }
+
+ } else {
+ this.removeRowCls(rowIdx, this.focusedItemCls);
}
- }();
+ },
+
- return {
-
- registerObject: function(objectIdStr, swfVersionStr, xiSwfUrlStr, callbackFn) {
- if (ua.w3 && objectIdStr && swfVersionStr) {
- var regObj = {};
- regObj.id = objectIdStr;
- regObj.swfVersion = swfVersionStr;
- regObj.expressInstall = xiSwfUrlStr;
- regObj.callbackFn = callbackFn;
- regObjArr[regObjArr.length] = regObj;
- setVisibility(objectIdStr, false);
- }
- else if (callbackFn) {
- callbackFn({success:false, id:objectIdStr});
- }
- },
-
- getObjectById: function(objectIdStr) {
- if (ua.w3) {
- return getObjectById(objectIdStr);
- }
- },
-
- embedSWF: function(swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj, callbackFn) {
- var callbackObj = {success:false, id:replaceElemIdStr};
- if (ua.w3 && !(ua.wk && ua.wk < 312) && swfUrlStr && replaceElemIdStr && widthStr && heightStr && swfVersionStr) {
- setVisibility(replaceElemIdStr, false);
- addDomLoadEvent(function() {
- widthStr += "";
- heightStr += "";
- var att = {};
- if (attObj && typeof attObj === OBJECT) {
- for (var i in attObj) {
- att[i] = attObj[i];
- }
- }
- att.data = swfUrlStr;
- att.width = widthStr;
- att.height = heightStr;
- var par = {};
- if (parObj && typeof parObj === OBJECT) {
- for (var j in parObj) {
- par[j] = parObj[j];
- }
- }
- if (flashvarsObj && typeof flashvarsObj === OBJECT) {
- for (var k in flashvarsObj) {
- if (typeof par.flashvars != UNDEF) {
- par.flashvars += "&" + k + "=" + flashvarsObj[k];
- }
- else {
- par.flashvars = k + "=" + flashvarsObj[k];
- }
- }
- }
- if (hasPlayerVersion(swfVersionStr)) {
- var obj = createSWF(att, par, replaceElemIdStr);
- if (att.id == replaceElemIdStr) {
- setVisibility(replaceElemIdStr, true);
- }
- callbackObj.success = true;
- callbackObj.ref = obj;
- }
- else if (xiSwfUrlStr && canExpressInstall()) {
- att.data = xiSwfUrlStr;
- showExpressInstall(att, par, replaceElemIdStr, callbackFn);
- return;
- }
- else {
- setVisibility(replaceElemIdStr, true);
- }
- if (callbackFn) { callbackFn(callbackObj); }
- });
- }
- else if (callbackFn) { callbackFn(callbackObj); }
- },
-
- switchOffAutoHideShow: function() {
- autoHideShow = false;
- },
-
- ua: ua,
-
- getFlashPlayerVersion: function() {
- return { major:ua.pv[0], minor:ua.pv[1], release:ua.pv[2] };
- },
-
- hasFlashPlayerVersion: hasPlayerVersion,
-
- createSWF: function(attObj, parObj, replaceElemIdStr) {
- if (ua.w3) {
- return createSWF(attObj, parObj, replaceElemIdStr);
+ focusRow: function(rowIdx) {
+ var row = this.getNode(rowIdx),
+ el = this.el,
+ adjustment = 0,
+ panel = this.ownerCt,
+ rowRegion,
+ elRegion,
+ record;
+
+ if (row && this.el) {
+ elRegion = el.getRegion();
+ rowRegion = Ext.fly(row).getRegion();
+
+ if (rowRegion.top < elRegion.top) {
+ adjustment = rowRegion.top - elRegion.top;
+
+ } else if (rowRegion.bottom > elRegion.bottom) {
+ adjustment = rowRegion.bottom - elRegion.bottom;
}
- else {
- return undefined;
+ record = this.getRecord(row);
+ rowIdx = this.store.indexOf(record);
+
+ if (adjustment) {
+
+ panel.scrollByDeltaY(adjustment);
}
- },
-
- showExpressInstall: function(att, par, replaceElemIdStr, callbackFn) {
- if (ua.w3 && canExpressInstall()) {
- showExpressInstall(att, par, replaceElemIdStr, callbackFn);
+ this.fireEvent('rowfocus', record, row, rowIdx);
+ }
+ },
+
+ focusCell: function(position) {
+ var cell = this.getCellByPosition(position),
+ el = this.el,
+ adjustmentY = 0,
+ adjustmentX = 0,
+ elRegion = el.getRegion(),
+ panel = this.ownerCt,
+ cellRegion,
+ record;
+
+ if (cell) {
+ cellRegion = cell.getRegion();
+
+ if (cellRegion.top < elRegion.top) {
+ adjustmentY = cellRegion.top - elRegion.top;
+
+ } else if (cellRegion.bottom > elRegion.bottom) {
+ adjustmentY = cellRegion.bottom - elRegion.bottom;
}
- },
-
- removeSWF: function(objElemIdStr) {
- if (ua.w3) {
- removeSWF(objElemIdStr);
+
+
+ if (cellRegion.left < elRegion.left) {
+ adjustmentX = cellRegion.left - elRegion.left;
+
+ } else if (cellRegion.right > elRegion.right) {
+ adjustmentX = cellRegion.right - elRegion.right;
}
- },
-
- createCSS: function(selStr, declStr, mediaStr, newStyleBoolean) {
- if (ua.w3) {
- createCSS(selStr, declStr, mediaStr, newStyleBoolean);
+
+ if (adjustmentY) {
+
+ panel.scrollByDeltaY(adjustmentY);
}
- },
-
- addDomLoadEvent: addDomLoadEvent,
-
- addLoadEvent: addLoadEvent,
-
- getQueryParamValue: function(param) {
- var q = doc.location.search || doc.location.hash;
- if (q) {
- if (/\?/.test(q)) { q = q.split("?")[1]; }
- if (param == null) {
- return urlEncodeIfNecessary(q);
- }
- var pairs = q.split("&");
- for (var i = 0; i < pairs.length; i++) {
- if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) {
- return urlEncodeIfNecessary(pairs[i].substring((pairs[i].indexOf("=") + 1)));
- }
- }
+ if (adjustmentX) {
+ panel.scrollByDeltaX(adjustmentX);
}
- return "";
- },
-
-
- expressInstallCallback: function() {
- if (isExpressInstallActive) {
- var obj = getElementById(EXPRESS_INSTALL_ID);
- if (obj && storedAltContent) {
- obj.parentNode.replaceChild(storedAltContent, obj);
- if (storedAltContentId) {
- setVisibility(storedAltContentId, true);
- if (ua.ie && ua.win) { storedAltContent.style.display = "block"; }
- }
- if (storedCallbackFn) { storedCallbackFn(storedCallbackObj); }
- }
- isExpressInstallActive = false;
- }
+ el.focus();
+ this.fireEvent('cellfocus', record, cell, position);
}
- };
-}();
+ },
-Ext.FlashComponent = Ext.extend(Ext.BoxComponent, {
- flashVersion : '9.0.115',
+ scrollByDelta: function(delta, dir) {
+ dir = dir || 'scrollTop';
+ var elDom = this.el.dom;
+ elDom[dir] = (elDom[dir] += delta);
+ },
-
- backgroundColor: '#ffffff',
+ onUpdate: function(ds, index) {
+ this.callParent(arguments);
+ },
- wmode: 'opaque',
+ saveScrollState: function() {
+ var dom = this.el.dom,
+ state = this.scrollState;
-
- flashVars: undefined,
+ state.left = dom.scrollLeft;
+ state.top = dom.scrollTop;
+ },
- flashParams: undefined,
+ restoreScrollState: function() {
+ var dom = this.el.dom,
+ state = this.scrollState,
+ headerEl = this.headerCt.el.dom;
-
- url: undefined,
- swfId : undefined,
- swfWidth: '100%',
- swfHeight: '100%',
+ headerEl.scrollLeft = dom.scrollLeft = state.left;
+ dom.scrollTop = state.top;
+ },
- expressInstall: false,
+ refresh: function(firstPass) {
+ var me = this,
+ table;
- initComponent : function(){
- Ext.FlashComponent.superclass.initComponent.call(this);
+
+ me.setNewTemplate();
+
+
+
+
+ if (me.rendered) {
+ table = me.el.child('table');
+ if (table) {
+ table.removeAllListeners();
+ }
+ }
+
+ me.callParent(arguments);
- this.addEvents(
+
+ if (me.rendered) {
- 'initialize'
- );
+ table = me.el.child('table');
+ if (table) {
+ table.unselectable();
+ }
+
+ if (!firstPass) {
+
+ me.el.focus();
+ }
+ }
},
- onRender : function(){
- Ext.FlashComponent.superclass.onRender.apply(this, arguments);
+ processItemEvent: function(type, record, row, rowIndex, e) {
+ var me = this,
+ cell = e.getTarget(me.cellSelector, row),
+ cellIndex = cell ? cell.cellIndex : -1,
+ map = me.statics().EventMap,
+ selModel = me.getSelectionModel(),
+ result;
- var params = Ext.apply({
- allowScriptAccess: 'always',
- bgcolor: this.backgroundColor,
- wmode: this.wmode
- }, this.flashParams), vars = Ext.apply({
- allowedDomain: document.location.hostname,
- YUISwfId: this.getId(),
- YUIBridgeCallback: 'Ext.FlashEventProxy.onEvent'
- }, this.flashVars);
+ if (type == 'keydown' && !cell && selModel.getCurrentPosition) {
+
+ cell = me.getCellByPosition(selModel.getCurrentPosition());
+ if (cell) {
+ cell = cell.dom;
+ cellIndex = cell.cellIndex;
+ }
+ }
- new swfobject.embedSWF(this.url, this.id, this.swfWidth, this.swfHeight, this.flashVersion,
- this.expressInstall ? Ext.FlashComponent.EXPRESS_INSTALL_URL : undefined, vars, params);
+ result = me.fireEvent('uievent', type, me, cell, rowIndex, cellIndex, e);
- this.swf = Ext.getDom(this.id);
- this.el = Ext.get(this.swf);
- },
+ if (result === false || me.callParent(arguments) === false) {
+ return false;
+ }
- getSwfId : function(){
- return this.swfId || (this.swfId = "extswf" + (++Ext.Component.AUTO_ID));
- },
+
+ if (type == 'mouseover' || type == 'mouseout') {
+ return true;
+ }
- getId : function(){
- return this.id || (this.id = "extflashcmp" + (++Ext.Component.AUTO_ID));
+ return !(
+
+ (me['onBeforeCell' + map[type]](cell, cellIndex, record, row, rowIndex, e) === false) ||
+ (me.fireEvent('beforecell' + type, me, cell, cellIndex, record, row, rowIndex, e) === false) ||
+ (me['onCell' + map[type]](cell, cellIndex, record, row, rowIndex, e) === false) ||
+ (me.fireEvent('cell' + type, me, cell, cellIndex, record, row, rowIndex, e) === false)
+ );
},
- onFlashEvent : function(e){
- switch(e.type){
- case "swfReady":
- this.initSwf();
- return;
- case "log":
- return;
- }
- e.component = this;
- this.fireEvent(e.type.toLowerCase().replace(/event$/, ''), e);
- },
+ processSpecialEvent: function(e) {
+ var me = this,
+ map = this.statics().EventMap,
+ features = this.features,
+ ln = features.length,
+ type = e.type,
+ i, feature, prefix, featureTarget,
+ beforeArgs, args,
+ panel = me.ownerCt;
- initSwf : function(){
- this.onSwfReady(!!this.isInitialized);
- this.isInitialized = true;
- this.fireEvent('initialize', this);
- },
+ this.callParent(arguments);
- beforeDestroy: function(){
- if(this.rendered){
- swfobject.removeSWF(this.swf.id);
+ if (type == 'mouseover' || type == 'mouseout') {
+ return;
+ }
+
+ for (i = 0; i < ln; i++) {
+ feature = features[i];
+ if (feature.hasFeatureEvent) {
+ featureTarget = e.getTarget(feature.eventSelector, me.getTargetEl());
+ if (featureTarget) {
+ prefix = feature.eventPrefix;
+
+
+ beforeArgs = feature.getFireEventArgs('before' + prefix + type, me, featureTarget);
+ args = feature.getFireEventArgs(prefix + type, me, featureTarget);
+
+ if (
+
+ (me.fireEvent.apply(me, beforeArgs) === false) ||
+
+ (panel.fireEvent.apply(panel, beforeArgs) === false) ||
+
+ (me.fireEvent.apply(me, args) === false) ||
+
+ (panel.fireEvent.apply(panel, args) === false)
+ ) {
+ return false;
+ }
+ }
+ }
}
- Ext.FlashComponent.superclass.beforeDestroy.call(this);
+ return true;
},
- onSwfReady : Ext.emptyFn
-});
+ onCellMouseDown: Ext.emptyFn,
+ onCellMouseUp: Ext.emptyFn,
+ onCellClick: Ext.emptyFn,
+ onCellDblClick: Ext.emptyFn,
+ onCellContextMenu: Ext.emptyFn,
+ onCellKeyDown: Ext.emptyFn,
+ onBeforeCellMouseDown: Ext.emptyFn,
+ onBeforeCellMouseUp: Ext.emptyFn,
+ onBeforeCellClick: Ext.emptyFn,
+ onBeforeCellDblClick: Ext.emptyFn,
+ onBeforeCellContextMenu: Ext.emptyFn,
+ onBeforeCellKeyDown: Ext.emptyFn,
+
+ expandToFit: function(header) {
+ var maxWidth = this.getMaxContentWidth(header);
+ delete header.flex;
+ header.setWidth(maxWidth);
+ },
-Ext.FlashComponent.EXPRESS_INSTALL_URL = 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf';
+
+ getMaxContentWidth: function(header) {
+ var cellSelector = header.getCellInnerSelector(),
+ cells = this.el.query(cellSelector),
+ i = 0,
+ ln = cells.length,
+ maxWidth = header.el.dom.scrollWidth,
+ scrollWidth;
-Ext.reg('flash', Ext.FlashComponent);
-Ext.FlashEventProxy = {
- onEvent : function(id, e){
- var fp = Ext.getCmp(id);
- if(fp){
- fp.onFlashEvent(e);
- }else{
- arguments.callee.defer(10, this, [id, e]);
+ for (; i < ln; i++) {
+ scrollWidth = cells[i].scrollWidth;
+ if (scrollWidth > maxWidth) {
+ maxWidth = scrollWidth;
+ }
}
- }
-};
+ return maxWidth;
+ },
- Ext.chart.Chart = Ext.extend(Ext.FlashComponent, {
- refreshBuffer: 100,
+ getPositionByEvent: function(e) {
+ var cellNode = e.getTarget(this.cellSelector),
+ rowNode = e.getTarget(this.itemSelector),
+ record = this.getRecord(rowNode),
+ header = this.getHeaderByCell(cellNode);
-
+ return this.getPosition(record, header);
+ },
-
- chartStyle: {
- padding: 10,
- animationEnabled: true,
- font: {
- name: 'Tahoma',
- color: 0x444444,
- size: 11
- },
- dataTip: {
- padding: 5,
- border: {
- color: 0x99bbe8,
- size:1
- },
- background: {
- color: 0xDAE7F6,
- alpha: .9
- },
- font: {
- name: 'Tahoma',
- color: 0x15428B,
- size: 10,
- bold: true
+ getHeaderByCell: function(cell) {
+ if (cell) {
+ var m = cell.className.match(this.cellRe);
+ if (m && m[1]) {
+ return Ext.getCmp(m[1]);
}
}
+ return false;
},
+ walkCells: function(pos, direction, e, preventWrap, verifierFn, scope) {
+ var row = pos.row,
+ column = pos.column,
+ rowCount = this.store.getCount(),
+ firstCol = this.getFirstVisibleColumnIndex(),
+ lastCol = this.getLastVisibleColumnIndex(),
+ newPos = {row: row, column: column},
+ activeHeader = this.headerCt.getHeaderAtIndex(column);
-
- extraStyle: null,
+
+ if (!activeHeader || activeHeader.hidden) {
+ return false;
+ }
-
- seriesStyles: null,
+ e = e || {};
+ direction = direction.toLowerCase();
+ switch (direction) {
+ case 'right':
+
+ if (column === lastCol) {
+
+ if (preventWrap || row === rowCount - 1) {
+ return false;
+ }
+ if (!e.ctrlKey) {
+
+ newPos.row = row + 1;
+ newPos.column = firstCol;
+ }
+
+ } else {
+ if (!e.ctrlKey) {
+ newPos.column = column + this.getRightGap(activeHeader);
+ } else {
+ newPos.column = lastCol;
+ }
+ }
+ break;
-
- disableCaching: Ext.isIE || Ext.isOpera,
- disableCacheParam: '_dc',
+ case 'left':
+
+ if (column === firstCol) {
+
+ if (preventWrap || row === 0) {
+ return false;
+ }
+ if (!e.ctrlKey) {
+
+ newPos.row = row - 1;
+ newPos.column = lastCol;
+ }
+
+ } else {
+ if (!e.ctrlKey) {
+ newPos.column = column + this.getLeftGap(activeHeader);
+ } else {
+ newPos.column = firstCol;
+ }
+ }
+ break;
- initComponent : function(){
- Ext.chart.Chart.superclass.initComponent.call(this);
- if(!this.url){
- this.url = Ext.chart.Chart.CHART_URL;
+ case 'up':
+
+ if (row === 0) {
+ return false;
+
+ } else {
+ if (!e.ctrlKey) {
+ newPos.row = row - 1;
+ } else {
+ newPos.row = 0;
+ }
+ }
+ break;
+
+ case 'down':
+
+ if (row === rowCount - 1) {
+ return false;
+
+ } else {
+ if (!e.ctrlKey) {
+ newPos.row = row + 1;
+ } else {
+ newPos.row = rowCount - 1;
+ }
+ }
+ break;
}
- if(this.disableCaching){
- this.url = Ext.urlAppend(this.url, String.format('{0}={1}', this.disableCacheParam, new Date().getTime()));
+
+ if (verifierFn && verifierFn.call(scope || window, newPos) !== true) {
+ return false;
+ } else {
+ return newPos;
}
- this.addEvents(
- 'itemmouseover',
- 'itemmouseout',
- 'itemclick',
- 'itemdoubleclick',
- 'itemdragstart',
- 'itemdrag',
- 'itemdragend',
-
- 'beforerefresh',
-
- 'refresh'
- );
- this.store = Ext.StoreMgr.lookup(this.store);
},
+ getFirstVisibleColumnIndex: function() {
+ var headerCt = this.getHeaderCt(),
+ allColumns = headerCt.getGridColumns(),
+ visHeaders = Ext.ComponentQuery.query(':not([hidden])', allColumns),
+ firstHeader = visHeaders[0];
-
- setStyle: function(name, value){
- this.swf.setStyle(name, Ext.encode(value));
- },
-
-
- setStyles: function(styles){
- this.swf.setStyles(Ext.encode(styles));
+ return headerCt.getHeaderIndex(firstHeader);
},
-
- setSeriesStyles: function(styles){
- this.seriesStyles = styles;
- var s = [];
- Ext.each(styles, function(style){
- s.push(Ext.encode(style));
- });
- this.swf.setSeriesStyles(s);
- },
+ getLastVisibleColumnIndex: function() {
+ var headerCt = this.getHeaderCt(),
+ allColumns = headerCt.getGridColumns(),
+ visHeaders = Ext.ComponentQuery.query(':not([hidden])', allColumns),
+ lastHeader = visHeaders[visHeaders.length - 1];
- setCategoryNames : function(names){
- this.swf.setCategoryNames(names);
+ return headerCt.getHeaderIndex(lastHeader);
},
- setLegendRenderer : function(fn, scope){
- var chart = this;
- scope = scope || chart;
- chart.removeFnProxy(chart.legendFnName);
- chart.legendFnName = chart.createFnProxy(function(name){
- return fn.call(scope, name);
- });
- chart.swf.setLegendLabelFunction(chart.legendFnName);
+ getHeaderCt: function() {
+ return this.headerCt;
},
- setTipRenderer : function(fn, scope){
- var chart = this;
- scope = scope || chart;
- chart.removeFnProxy(chart.tipFnName);
- chart.tipFnName = chart.createFnProxy(function(item, index, series){
- var record = chart.store.getAt(index);
- return fn.call(scope, chart, record, index, series);
- });
- chart.swf.setDataTipFunction(chart.tipFnName);
- },
+ getPosition: function(record, header) {
+ var me = this,
+ store = me.store,
+ gridCols = me.headerCt.getGridColumns();
- setSeries : function(series){
- this.series = series;
- this.refresh();
+ return {
+ row: store.indexOf(record),
+ column: Ext.Array.indexOf(gridCols, header)
+ };
},
- bindStore : function(store, initial){
- if(!initial && this.store){
- if(store !== this.store && this.store.autoDestroy){
- this.store.destroy();
- }else{
- this.store.un("datachanged", this.refresh, this);
- this.store.un("add", this.delayRefresh, this);
- this.store.un("remove", this.delayRefresh, this);
- this.store.un("update", this.delayRefresh, this);
- this.store.un("clear", this.refresh, this);
+ getRightGap: function(activeHeader) {
+ var headerCt = this.getHeaderCt(),
+ headers = headerCt.getGridColumns(),
+ activeHeaderIdx = Ext.Array.indexOf(headers, activeHeader),
+ i = activeHeaderIdx + 1,
+ nextIdx;
+
+ for (; i <= headers.length; i++) {
+ if (!headers[i].hidden) {
+ nextIdx = i;
+ break;
}
}
- if(store){
- store = Ext.StoreMgr.lookup(store);
- store.on({
- scope: this,
- datachanged: this.refresh,
- add: this.delayRefresh,
- remove: this.delayRefresh,
- update: this.delayRefresh,
- clear: this.refresh
- });
- }
- this.store = store;
- if(store && !initial){
- this.refresh();
- }
- },
- onSwfReady : function(isReset){
- Ext.chart.Chart.superclass.onSwfReady.call(this, isReset);
- var ref;
- this.swf.setType(this.type);
+ return nextIdx - activeHeaderIdx;
+ },
- if(this.chartStyle){
- this.setStyles(Ext.apply({}, this.extraStyle, this.chartStyle));
+ beforeDestroy: function() {
+ if (this.rendered) {
+ table = this.el.child('table');
+ if (table) {
+ table.removeAllListeners();
+ }
}
+ this.callParent(arguments);
+ },
- if(this.categoryNames){
- this.setCategoryNames(this.categoryNames);
- }
+
+ getLeftGap: function(activeHeader) {
+ var headerCt = this.getHeaderCt(),
+ headers = headerCt.getGridColumns(),
+ activeHeaderIdx = Ext.Array.indexOf(headers, activeHeader),
+ i = activeHeaderIdx - 1,
+ prevIdx;
- if(this.tipRenderer){
- ref = this.getFunctionRef(this.tipRenderer);
- this.setTipRenderer(ref.fn, ref.scope);
- }
- if(this.legendRenderer){
- ref = this.getFunctionRef(this.legendRenderer);
- this.setLegendRenderer(ref.fn, ref.scope);
- }
- if(!isReset){
- this.bindStore(this.store, true);
+ for (; i >= 0; i--) {
+ if (!headers[i].hidden) {
+ prevIdx = i;
+ break;
+ }
}
- this.refresh.defer(10, this);
- },
- delayRefresh : function(){
- if(!this.refreshTask){
- this.refreshTask = new Ext.util.DelayedTask(this.refresh, this);
- }
- this.refreshTask.delay(this.refreshBuffer);
- },
+ return prevIdx - activeHeaderIdx;
+ }
+});
- refresh : function(){
- if(this.fireEvent('beforerefresh', this) !== false){
- var styleChanged = false;
-
- var data = [], rs = this.store.data.items;
- for(var j = 0, len = rs.length; j < len; j++){
- data[j] = rs[j].data;
- }
-
-
- var dataProvider = [];
- var seriesCount = 0;
- var currentSeries = null;
- var i = 0;
- if(this.series){
- seriesCount = this.series.length;
- for(i = 0; i < seriesCount; i++){
- currentSeries = this.series[i];
- var clonedSeries = {};
- for(var prop in currentSeries){
- if(prop == "style" && currentSeries.style !== null){
- clonedSeries.style = Ext.encode(currentSeries.style);
- styleChanged = true;
-
-
-
-
- } else{
- clonedSeries[prop] = currentSeries[prop];
- }
- }
- dataProvider.push(clonedSeries);
- }
- }
+Ext.define('Ext.grid.View', {
+ extend: 'Ext.view.Table',
+ alias: 'widget.gridview',
- if(seriesCount > 0){
- for(i = 0; i < seriesCount; i++){
- currentSeries = dataProvider[i];
- if(!currentSeries.type){
- currentSeries.type = this.type;
- }
- currentSeries.dataProvider = data;
- }
- } else{
- dataProvider.push({type: this.type, dataProvider: data});
- }
- this.swf.setDataProvider(dataProvider);
- if(this.seriesStyles){
- this.setSeriesStyles(this.seriesStyles);
+
+ stripeRows: true,
+
+ invalidateScrollerOnRefresh: true,
+
+
+ scrollToTop : function(){
+ if (this.rendered) {
+ var section = this.ownerCt,
+ verticalScroller = section.verticalScroller;
+
+ if (verticalScroller) {
+ verticalScroller.scrollToTop();
}
- this.fireEvent('refresh', this);
}
},
- createFnProxy : function(fn){
- var fnName = 'extFnProxy' + (++Ext.chart.Chart.PROXY_FN_ID);
- Ext.chart.Chart.proxyFunction[fnName] = fn;
- return 'Ext.chart.Chart.proxyFunction.' + fnName;
+ onAdd: function(ds, records, index) {
+ this.callParent(arguments);
+ this.doStripeRows(index);
},
-
- removeFnProxy : function(fn){
- if(!Ext.isEmpty(fn)){
- fn = fn.replace('Ext.chart.Chart.proxyFunction.', '');
- delete Ext.chart.Chart.proxyFunction[fn];
- }
+
+ onRemove: function(ds, records, index) {
+ this.callParent(arguments);
+ this.doStripeRows(index);
},
-
- getFunctionRef : function(val){
- if(Ext.isFunction(val)){
- return {
- fn: val,
- scope: this
- };
- }else{
- return {
- fn: val.fn,
- scope: val.scope || this
- };
+
+ doStripeRows: function(startRow) {
+
+ if (this.stripeRows) {
+ var rows = this.getNodes(startRow),
+ rowsLn = rows.length,
+ i = 0,
+ row;
+
+ for (; i < rowsLn; i++) {
+ row = rows[i];
+
+ row.className = row.className.replace(this.rowClsRe, ' ');
+
+ if (i % 2 === 1) {
+ row.className += (' ' + this.altRowCls);
+ }
+ }
}
},
+
+ refresh: function(firstPass) {
+ this.callParent(arguments);
+ this.doStripeRows(0);
+
+ var g = this.up('gridpanel');
+ if (g && this.invalidateScrollerOnRefresh) {
+ g.invalidateScroller();
+ }
+ }
+});
+
+Ext.define('Ext.grid.Panel', {
+ extend: 'Ext.panel.Table',
+ requires: ['Ext.grid.View'],
+ alias: ['widget.gridpanel', 'widget.grid'],
+ alternateClassName: ['Ext.list.ListView', 'Ext.ListView', 'Ext.grid.GridPanel'],
+ viewType: 'gridview',
- onDestroy: function(){
- if (this.refreshTask && this.refreshTask.cancel){
- this.refreshTask.cancel();
+ lockable: false,
+
+
+
+ normalCfgCopy: ['invalidateScrollerOnRefresh', 'verticalScroller', 'verticalScrollDock', 'verticalScrollerType', 'scroll'],
+ lockedCfgCopy: ['invalidateScrollerOnRefresh'],
+
+
+
+ initComponent: function() {
+ var me = this;
+
+ if (me.columnLines) {
+ me.setColumnLines(me.columnLines);
}
- Ext.chart.Chart.superclass.onDestroy.call(this);
- this.bindStore(null);
- this.removeFnProxy(this.tipFnName);
- this.removeFnProxy(this.legendFnName);
+
+ me.callParent();
+ },
+
+ setColumnLines: function(show) {
+ var me = this,
+ method = (show) ? 'addClsWithUI' : 'removeClsWithUI';
+
+ me[method]('with-col-lines')
}
});
-Ext.reg('chart', Ext.chart.Chart);
-Ext.chart.Chart.PROXY_FN_ID = 0;
-Ext.chart.Chart.proxyFunction = {};
-Ext.chart.Chart.CHART_URL = 'http:/' + '/yui.yahooapis.com/2.8.2/build/charts/assets/charts.swf';
-Ext.chart.PieChart = Ext.extend(Ext.chart.Chart, {
- type: 'pie',
- onSwfReady : function(isReset){
- Ext.chart.PieChart.superclass.onSwfReady.call(this, isReset);
- this.setDataField(this.dataField);
- this.setCategoryField(this.categoryField);
- },
- setDataField : function(field){
- this.dataField = field;
- this.swf.setDataField(field);
- },
- setCategoryField : function(field){
- this.categoryField = field;
- this.swf.setCategoryField(field);
- }
-});
-Ext.reg('piechart', Ext.chart.PieChart);
+Ext.define('Ext.grid.RowEditor', {
+ extend: 'Ext.form.Panel',
+ requires: [
+ 'Ext.tip.ToolTip',
+ 'Ext.util.HashMap',
+ 'Ext.util.KeyNav'
+ ],
+
+ saveBtnText : 'Update',
+ cancelBtnText: 'Cancel',
+ errorsText: 'Errors',
+ dirtyText: 'You need to commit or cancel your changes',
+
+ lastScrollLeft: 0,
+ lastScrollTop: 0,
+
+ border: false,
+
+ initComponent: function() {
+ var me = this,
+ form;
+
+ me.cls = Ext.baseCSSPrefix + 'grid-row-editor';
+
+ me.layout = {
+ type: 'hbox',
+ align: 'middle'
+ };
+
+
+
+ me.columns = Ext.create('Ext.util.HashMap');
+ me.columns.getKey = function(columnHeader) {
+ var f;
+ if (columnHeader.getEditor) {
+ f = columnHeader.getEditor();
+ if (f) {
+ return f.id;
+ }
+ }
+ return columnHeader.id;
+ };
+ me.mon(me.columns, {
+ add: me.onFieldAdd,
+ remove: me.onFieldRemove,
+ replace: me.onFieldReplace,
+ scope: me
+ });
+
+ me.callParent(arguments);
-Ext.chart.CartesianChart = Ext.extend(Ext.chart.Chart, {
- onSwfReady : function(isReset){
- Ext.chart.CartesianChart.superclass.onSwfReady.call(this, isReset);
- this.labelFn = [];
- if(this.xField){
- this.setXField(this.xField);
+ if (me.fields) {
+ me.setField(me.fields);
+ delete me.fields;
}
- if(this.yField){
- this.setYField(this.yField);
+
+ form = me.getForm();
+ form.trackResetOnLoad = true;
+ },
+
+ onFieldChange: function() {
+ var me = this,
+ form = me.getForm(),
+ valid = form.isValid();
+ if (me.errorSummary && me.isVisible()) {
+ me[valid ? 'hideToolTip' : 'showToolTip']();
}
- if(this.xAxis){
- this.setXAxis(this.xAxis);
+ if (me.floatingButtons) {
+ me.floatingButtons.child('#update').setDisabled(!valid);
}
- if(this.xAxes){
- this.setXAxes(this.xAxes);
+ me.isValid = valid;
+ },
+
+ afterRender: function() {
+ var me = this,
+ plugin = me.editingPlugin;
+
+ me.callParent(arguments);
+ me.mon(me.renderTo, 'scroll', me.onCtScroll, me, { buffer: 100 });
+
+
+ me.mon(me.el, {
+ click: Ext.emptyFn,
+ stopPropagation: true
+ });
+
+ me.el.swallowEvent([
+ 'keypress',
+ 'keydown'
+ ]);
+
+ me.keyNav = Ext.create('Ext.util.KeyNav', me.el, {
+ enter: plugin.completeEdit,
+ esc: plugin.onEscKey,
+ scope: plugin
+ });
+
+ me.mon(plugin.view, {
+ beforerefresh: me.onBeforeViewRefresh,
+ refresh: me.onViewRefresh,
+ scope: me
+ });
+ },
+
+ onBeforeViewRefresh: function(view) {
+ var me = this,
+ viewDom = view.el.dom;
+
+ if (me.el.dom.parentNode === viewDom) {
+ viewDom.removeChild(me.el.dom);
}
- if(this.yAxis){
- this.setYAxis(this.yAxis);
+ },
+
+ onViewRefresh: function(view) {
+ var me = this,
+ viewDom = view.el.dom,
+ context = me.context,
+ idx;
+
+ viewDom.appendChild(me.el.dom);
+
+
+ if (context && (idx = context.store.indexOf(context.record)) >= 0) {
+ context.row = view.getNode(idx);
+ me.reposition();
+ if (me.tooltip && me.tooltip.isVisible()) {
+ me.tooltip.setTarget(context.row);
+ }
+ } else {
+ me.editingPlugin.cancelEdit();
}
- if(this.yAxes){
- this.setYAxes(this.yAxes);
+ },
+
+ onCtScroll: function(e, target) {
+ var me = this,
+ scrollTop = target.scrollTop,
+ scrollLeft = target.scrollLeft;
+
+ if (scrollTop !== me.lastScrollTop) {
+ me.lastScrollTop = scrollTop;
+ if ((me.tooltip && me.tooltip.isVisible()) || me.hiddenTip) {
+ me.repositionTip();
+ }
}
- if(Ext.isDefined(this.constrainViewport)){
- this.swf.setConstrainViewport(this.constrainViewport);
+ if (scrollLeft !== me.lastScrollLeft) {
+ me.lastScrollLeft = scrollLeft;
+ me.reposition();
}
},
- setXField : function(value){
- this.xField = value;
- this.swf.setHorizontalField(value);
+ onColumnAdd: function(column) {
+ this.setField(column);
},
- setYField : function(value){
- this.yField = value;
- this.swf.setVerticalField(value);
+ onColumnRemove: function(column) {
+ this.columns.remove(column);
},
- setXAxis : function(value){
- this.xAxis = this.createAxis('xAxis', value);
- this.swf.setHorizontalAxis(this.xAxis);
+ onColumnResize: function(column, width) {
+ column.getEditor().setWidth(width - 2);
+ if (this.isVisible()) {
+ this.reposition();
+ }
},
- setXAxes : function(value){
- var axis;
- for(var i = 0; i < value.length; i++) {
- axis = this.createAxis('xAxis' + i, value[i]);
- this.swf.setHorizontalAxis(axis);
+ onColumnHide: function(column) {
+ column.getEditor().hide();
+ if (this.isVisible()) {
+ this.reposition();
}
},
- setYAxis : function(value){
- this.yAxis = this.createAxis('yAxis', value);
- this.swf.setVerticalAxis(this.yAxis);
+ onColumnShow: function(column) {
+ var field = column.getEditor();
+ field.setWidth(column.getWidth() - 2).show();
+ if (this.isVisible()) {
+ this.reposition();
+ }
},
- setYAxes : function(value){
- var axis;
- for(var i = 0; i < value.length; i++) {
- axis = this.createAxis('yAxis' + i, value[i]);
- this.swf.setVerticalAxis(axis);
+ onColumnMove: function(column, fromIdx, toIdx) {
+ var field = column.getEditor();
+ if (this.items.indexOf(field) != toIdx) {
+ this.move(fromIdx, toIdx);
}
},
- createAxis : function(axis, value){
- var o = Ext.apply({}, value),
- ref,
- old;
+ onFieldAdd: function(hm, fieldId, column) {
+ var me = this,
+ colIdx = me.editingPlugin.grid.headerCt.getHeaderIndex(column),
+ field = column.getEditor({ xtype: 'displayfield' });
- if(this[axis]){
- old = this[axis].labelFunction;
- this.removeFnProxy(old);
- this.labelFn.remove(old);
- }
- if(o.labelRenderer){
- ref = this.getFunctionRef(o.labelRenderer);
- o.labelFunction = this.createFnProxy(function(v){
- return ref.fn.call(ref.scope, v);
+ me.insert(colIdx, field);
+ },
+
+ onFieldRemove: function(hm, fieldId, column) {
+ var me = this,
+ field = column.getEditor(),
+ fieldDom = field.el.dom;
+ me.remove(field, false);
+ fieldDom.parentNode.removeChild(fieldDom);
+ },
+
+ onFieldReplace: function(hm, fieldId, column, oldColumn) {
+ var me = this;
+ me.onFieldRemove(hm, fieldId, oldColumn);
+ },
+
+ clearFields: function() {
+ var me = this,
+ hm = me.columns;
+ hm.each(function(fieldId) {
+ hm.removeAtKey(fieldId);
+ });
+ },
+
+ getFloatingButtons: function() {
+ var me = this,
+ cssPrefix = Ext.baseCSSPrefix,
+ btnsCss = cssPrefix + 'grid-row-editor-buttons',
+ plugin = me.editingPlugin,
+ btns;
+
+ if (!me.floatingButtons) {
+ btns = me.floatingButtons = Ext.create('Ext.Container', {
+ renderTpl: [
+ '',
+ '',
+ '',
+ '',
+ ''
+ ],
+
+ renderTo: me.el,
+ baseCls: btnsCss,
+ layout: {
+ type: 'hbox',
+ align: 'middle'
+ },
+ defaults: {
+ margins: '0 1 0 1'
+ },
+ items: [{
+ itemId: 'update',
+ flex: 1,
+ xtype: 'button',
+ handler: plugin.completeEdit,
+ scope: plugin,
+ text: me.saveBtnText,
+ disabled: !me.isValid
+ }, {
+ flex: 1,
+ xtype: 'button',
+ handler: plugin.cancelEdit,
+ scope: plugin,
+ text: me.cancelBtnText
+ }]
+ });
+
+
+ me.mon(btns.el, {
+
+
+ mousedown: Ext.emptyFn,
+ click: Ext.emptyFn,
+ stopEvent: true
});
- delete o.labelRenderer;
- this.labelFn.push(o.labelFunction);
- }
- if(axis.indexOf('xAxis') > -1 && o.position == 'left'){
- o.position = 'bottom';
}
- return o;
+ return me.floatingButtons;
},
- onDestroy : function(){
- Ext.chart.CartesianChart.superclass.onDestroy.call(this);
- Ext.each(this.labelFn, function(fn){
- this.removeFnProxy(fn);
- }, this);
- }
-});
-Ext.reg('cartesianchart', Ext.chart.CartesianChart);
-
+ reposition: function(animateConfig) {
+ var me = this,
+ context = me.context,
+ row = context && Ext.get(context.row),
+ btns = me.getFloatingButtons(),
+ btnEl = btns.el,
+ grid = me.editingPlugin.grid,
+ viewEl = grid.view.el,
+ scroller = grid.verticalScroller,
-Ext.chart.LineChart = Ext.extend(Ext.chart.CartesianChart, {
- type: 'line'
-});
-Ext.reg('linechart', Ext.chart.LineChart);
+
+
+ mainBodyWidth = grid.headerCt.getFullWidth(),
+ scrollerWidth = grid.getWidth(),
+
+
+ width = Math.min(mainBodyWidth, scrollerWidth),
+ scrollLeft = grid.view.el.dom.scrollLeft,
+ btnWidth = btns.getWidth(),
+ left = (width - btnWidth) / 2 + scrollLeft,
+ y, rowH, newHeight,
-Ext.chart.ColumnChart = Ext.extend(Ext.chart.CartesianChart, {
- type: 'column'
-});
-Ext.reg('columnchart', Ext.chart.ColumnChart);
+ invalidateScroller = function() {
+ if (scroller) {
+ scroller.invalidate();
+ btnEl.scrollIntoView(viewEl, false);
+ }
+ if (animateConfig && animateConfig.callback) {
+ animateConfig.callback.call(animateConfig.scope || me);
+ }
+ };
+
+ if (row && Ext.isElement(row.dom)) {
+
+
+ row.scrollIntoView(viewEl, false);
-Ext.chart.StackedColumnChart = Ext.extend(Ext.chart.CartesianChart, {
- type: 'stackcolumn'
-});
-Ext.reg('stackedcolumnchart', Ext.chart.StackedColumnChart);
+
+
+
+ y = row.getXY()[1] - 5;
+ rowH = row.getHeight();
+ newHeight = rowH + 10;
+
+
+
+
+ if (Ext.isIE) {
+ newHeight += 2;
+ }
-Ext.chart.BarChart = Ext.extend(Ext.chart.CartesianChart, {
- type: 'bar'
-});
-Ext.reg('barchart', Ext.chart.BarChart);
+
+ if (me.getHeight() != newHeight) {
+ me.setHeight(newHeight);
+ me.el.setLeft(0);
+ }
+ if (animateConfig) {
+ var animObj = {
+ to: {
+ y: y
+ },
+ duration: animateConfig.duration || 125,
+ listeners: {
+ afteranimate: function() {
+ invalidateScroller();
+ y = row.getXY()[1] - 5;
+ me.el.setY(y);
+ }
+ }
+ };
+ me.animate(animObj);
+ } else {
+ me.el.setY(y);
+ invalidateScroller();
+ }
+ }
+ if (me.getWidth() != mainBodyWidth) {
+ me.setWidth(mainBodyWidth);
+ }
+ btnEl.setLeft(left);
+ },
-Ext.chart.StackedBarChart = Ext.extend(Ext.chart.CartesianChart, {
- type: 'stackbar'
-});
-Ext.reg('stackedbarchart', Ext.chart.StackedBarChart);
+ getEditor: function(fieldInfo) {
+ var me = this;
+ if (Ext.isNumber(fieldInfo)) {
+
+
+
+ return me.query('>[isFormField]')[fieldInfo];
+ } else if (fieldInfo instanceof Ext.grid.column.Column) {
+ return fieldInfo.getEditor();
+ }
+ },
+ removeField: function(field) {
+ var me = this;
+
+ field = me.getEditor(field);
+ me.mun(field, 'validitychange', me.onValidityChange, me);
-Ext.chart.Axis = function(config){
- Ext.apply(this, config);
-};
+
+
+ me.columns.removeKey(field.id);
+ },
-Ext.chart.Axis.prototype =
-{
-
- type: null,
+ setField: function(column) {
+ var me = this,
+ field;
-
- orientation: "horizontal",
+ if (Ext.isArray(column)) {
+ Ext.Array.forEach(column, me.setField, me);
+ return;
+ }
-
- reverse: false,
+
+ field = column.getEditor(null, { xtype: 'displayfield' });
+ field.margins = '0 0 0 2';
+ field.setWidth(column.getWidth() - 2);
+ me.mon(field, 'change', me.onFieldChange, me);
-
- labelFunction: null,
+
+
+ me.columns.add(field.id, column);
+ },
-
- hideOverlappingLabels: true,
+ loadRecord: function(record) {
+ var me = this,
+ form = me.getForm();
+ form.loadRecord(record);
+ if (form.isValid()) {
+ me.hideToolTip();
+ } else {
+ me.showToolTip();
+ }
-
- labelSpacing: 2
-};
+
+ Ext.Array.forEach(me.query('>displayfield'), function(field) {
+ me.renderColumnData(field, record);
+ }, me);
+ },
+ renderColumnData: function(field, record) {
+ var me = this,
+ grid = me.editingPlugin.grid,
+ headerCt = grid.headerCt,
+ view = grid.view,
+ store = view.store,
+ column = me.columns.get(field.id),
+ value = field.getRawValue();
+
+
+ if (column.renderer) {
+ var metaData = { tdCls: '', style: '' },
+ rowIdx = store.indexOf(record),
+ colIdx = headerCt.getHeaderIndex(column);
+
+ value = column.renderer.call(
+ column.scope || headerCt.ownerCt,
+ value,
+ metaData,
+ record,
+ rowIdx,
+ colIdx,
+ store,
+ view
+ );
+ }
-Ext.chart.NumericAxis = Ext.extend(Ext.chart.Axis, {
- type: "numeric",
+ field.setRawValue(value);
+ field.resetOriginalValue();
+ },
-
- minimum: NaN,
+ beforeEdit: function() {
+ var me = this;
-
- maximum: NaN,
+ if (me.isVisible() && !me.autoCancel && me.isDirty()) {
+ me.showToolTip();
+ return false;
+ }
+ },
- majorUnit: NaN,
+ startEdit: function(record, columnHeader) {
+ var me = this,
+ grid = me.editingPlugin.grid,
+ view = grid.getView(),
+ store = grid.store,
+ context = me.context = Ext.apply(me.editingPlugin.context, {
+ view: grid.getView(),
+ store: store
+ });
-
- minorUnit: NaN,
+
+ context.grid.getSelectionModel().select(record);
-
- snapToUnits: true,
+
+ me.loadRecord(record);
-
- alwaysShowZero: true,
+ if (!me.isVisible()) {
+ me.show();
+ me.focusContextCell();
+ } else {
+ me.reposition({
+ callback: this.focusContextCell
+ });
+ }
+ },
- scale: "linear",
+ focusContextCell: function() {
+ var field = this.getEditor(this.context.colIdx);
+ if (field && field.focus) {
+ field.focus();
+ }
+ },
-
- roundMajorUnit: true,
+ cancelEdit: function() {
+ var me = this,
+ form = me.getForm();
-
- calculateByLabelSize: true,
+ me.hide();
+ form.clearInvalid();
+ form.reset();
+ },
-
- position: 'left',
+ completeEdit: function() {
+ var me = this,
+ form = me.getForm();
-
- adjustMaximumByMajorUnit: true,
+ if (!form.isValid()) {
+ return;
+ }
-
- adjustMinimumByMajorUnit: true
+ form.updateRecord(me.context.record);
+ me.hide();
+ return true;
+ },
-});
+ onShow: function() {
+ var me = this;
+ me.callParent(arguments);
+ me.reposition();
+ },
+ onHide: function() {
+ var me = this;
+ me.callParent(arguments);
+ me.hideToolTip();
+ me.invalidateScroller();
+ if (me.context) {
+ me.context.view.focus();
+ me.context = null;
+ }
+ },
-Ext.chart.TimeAxis = Ext.extend(Ext.chart.Axis, {
- type: "time",
+ isDirty: function() {
+ var me = this,
+ form = me.getForm();
+ return form.isDirty();
+ },
-
- minimum: null,
+ getToolTip: function() {
+ var me = this,
+ tip;
+
+ if (!me.tooltip) {
+ tip = me.tooltip = Ext.createWidget('tooltip', {
+ cls: Ext.baseCSSPrefix + 'grid-row-editor-errors',
+ title: me.errorsText,
+ autoHide: false,
+ closable: true,
+ closeAction: 'disable',
+ anchor: 'left'
+ });
+ }
+ return me.tooltip;
+ },
-
- maximum: null,
+ hideToolTip: function() {
+ var me = this,
+ tip = me.getToolTip();
+ if (tip.rendered) {
+ tip.disable();
+ }
+ me.hiddenTip = false;
+ },
-
- majorUnit: NaN,
+ showToolTip: function() {
+ var me = this,
+ tip = me.getToolTip(),
+ context = me.context,
+ row = Ext.get(context.row),
+ viewEl = context.grid.view.el;
-
- majorTimeUnit: null,
+ tip.setTarget(row);
+ tip.showAt([-10000, -10000]);
+ tip.body.update(me.getErrors());
+ tip.mouseOffset = [viewEl.getWidth() - row.getWidth() + me.lastScrollLeft + 15, 0];
+ me.repositionTip();
+ tip.doLayout();
+ tip.enable();
+ },
-
- minorUnit: NaN,
+ repositionTip: function() {
+ var me = this,
+ tip = me.getToolTip(),
+ context = me.context,
+ row = Ext.get(context.row),
+ viewEl = context.grid.view.el,
+ viewHeight = viewEl.getHeight(),
+ viewTop = me.lastScrollTop,
+ viewBottom = viewTop + viewHeight,
+ rowHeight = row.getHeight(),
+ rowTop = row.dom.offsetTop,
+ rowBottom = rowTop + rowHeight;
+
+ if (rowBottom > viewTop && rowTop < viewBottom) {
+ tip.show();
+ me.hiddenTip = false;
+ } else {
+ tip.hide();
+ me.hiddenTip = true;
+ }
+ },
-
- minorTimeUnit: null,
+ getErrors: function() {
+ var me = this,
+ dirtyText = !me.autoCancel && me.isDirty() ? me.dirtyText + '
' : '', + errors = []; - - snapToUnits: true, + Ext.Array.forEach(me.query('>[isFormField]'), function(field) { + errors = errors.concat( + Ext.Array.map(field.getErrors(), function(e) { + return '' + e + ' ';
+ })
+ );
+ }, me);
-
- stackingEnabled: false,
+ return dirtyText + '',
- '',
- ''
- );
+
+ setPadding: function() {
+ var me = this,
+ headerHeight,
+ lineHeight = parseInt(me.textEl.getStyle('line-height'), 10);
+
+
+ if (!me.isGroupHeader) {
+ headerHeight = me.el.getViewSize().height;
+ if (me.titleContainer.getHeight() < headerHeight) {
+ me.titleContainer.dom.style.height = headerHeight + 'px';
+ }
+ }
+ headerHeight = me.titleContainer.getViewSize().height;
+
+
+ if (lineHeight) {
+ me.titleContainer.setStyle({
+ paddingTop: Math.max(((headerHeight - lineHeight) / 2), 0) + 'px'
+ });
}
- 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 });
+
+
+ if (Ext.isIE && me.triggerEl) {
+ me.triggerEl.setHeight(headerHeight);
}
- 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 || ''
- };
+ onDestroy: function() {
+ var me = this;
+ Ext.destroy(me.keyNav);
+ delete me.keyNav;
+ me.callParent(arguments);
},
-
- setText : function(text){
- this.text = text||' ';
- if(this.rendered){
- this.textEl.update(this.text);
- this.parentMenu.layout.doAutoSize();
- }
+ onTitleMouseOver: function() {
+ this.titleContainer.addCls(this.hoverCls);
},
-
- setIconClass : function(cls){
- var oldCls = this.iconCls;
- this.iconCls = cls;
- if(this.rendered){
- this.iconEl.replaceClass(oldCls, this.iconCls);
- }
+ onTitleMouseOut: function() {
+ this.titleContainer.removeCls(this.hoverCls);
},
-
- beforeDestroy: function(){
- if (this.menu){
- delete this.menu.ownerCt;
- this.menu.destroy();
+ onDownKey: function(e) {
+ if (this.triggerEl) {
+ this.onElClick(e, this.triggerEl.dom || this.el.dom);
}
- Ext.menu.Item.superclass.beforeDestroy.call(this);
},
-
- handleClick : function(e){
- if(!this.href){
- e.stopEvent();
- }
- Ext.menu.Item.superclass.handleClick.apply(this, arguments);
+ onEnterKey: function(e) {
+ this.onElClick(e, this.el.dom);
},
- activate : function(autoExpand){
- if(Ext.menu.Item.superclass.activate.apply(this, arguments)){
- this.focus();
- if(autoExpand){
- this.expandMenu();
- }
+ onElDblClick: function(e, t) {
+ var me = this,
+ ownerCt = me.ownerCt;
+ if (ownerCt && Ext.Array.indexOf(ownerCt.items, me) !== 0 && me.isOnLeftEdge(e) ) {
+ ownerCt.expandToFit(me.previousSibling('gridcolumn'));
}
- 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());
+ onElClick: function(e, t) {
+
+
+ var me = this,
+ ownerHeaderCt = me.getOwnerHeaderCt();
+
+ if (ownerHeaderCt && !ownerHeaderCt.ddLock) {
+
+
+ if (me.triggerEl && (e.target === me.triggerEl.dom || t === me.triggerEl.dom || e.within(me.triggerEl))) {
+ ownerHeaderCt.onHeaderTriggerClick(me, e, t);
+
+ } else if (e.getKey() || (!me.isOnLeftEdge(e) && !me.isOnRightEdge(e))) {
+ me.toggleSortState();
+ ownerHeaderCt.onHeaderClick(me, e, t);
}
- return true;
}
- return false;
},
- deactivate : function(){
- Ext.menu.Item.superclass.deactivate.apply(this, arguments);
- this.hideMenu();
+ processEvent: function(type, view, cell, recordIndex, cellIndex, e) {
+ return this.fireEvent.apply(this, arguments);
},
-
- 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);
- }
+ toggleSortState: function() {
+ var me = this,
+ idx,
+ nextIdx;
+
+ if (me.sortable) {
+ idx = Ext.Array.indexOf(me.possibleSortStates, me.sortState);
+
+ nextIdx = (idx + 1) % me.possibleSortStates.length;
+ me.setSortState(me.possibleSortStates[nextIdx]);
}
},
-
- 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);
- }
+ doSort: function(state) {
+ var ds = this.up('tablepanel').store;
+ ds.sort({
+ property: this.getSortParam(),
+ direction: state
+ });
},
- hideMenu : function(){
- clearTimeout(this.showTimer);
- delete this.showTimer;
- if(!this.hideTimer && this.menu && this.menu.isVisible()){
- this.hideTimer = this.deferHide.defer(this.hideDelay, this);
- }
+ getSortParam: function() {
+ return this.dataIndex;
},
- 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",
+ setSortState: function(state, skipClear, initial) {
+ var me = this,
+ colSortClsPrefix = Ext.baseCSSPrefix + 'column-header-sort-',
+ ascCls = colSortClsPrefix + 'ASC',
+ descCls = colSortClsPrefix + 'DESC',
+ nullCls = colSortClsPrefix + 'null',
+ ownerHeaderCt = me.getOwnerHeaderCt(),
+ oldSortState = me.sortState;
+
+ if (oldSortState !== state && me.getSortParam()) {
+ me.addCls(colSortClsPrefix + state);
+
+ if (state && !initial) {
+ me.doSort(state);
+ }
+ switch (state) {
+ case 'DESC':
+ me.removeCls([ascCls, nullCls]);
+ break;
+ case 'ASC':
+ me.removeCls([descCls, nullCls]);
+ break;
+ case null:
+ me.removeCls([ascCls, descCls]);
+ break;
+ }
+ if (ownerHeaderCt && !me.triStateSort && !skipClear) {
+ ownerHeaderCt.clearOtherSortStates(me);
+ }
+ me.sortState = state;
+ ownerHeaderCt.fireEvent('sortchange', ownerHeaderCt, me, state);
+ }
+ },
-
- checked: false,
+ hide: function() {
+ var me = this,
+ items,
+ len, i,
+ lb,
+ newWidth = 0,
+ ownerHeaderCt = me.getOwnerHeaderCt();
-
- 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);
- },
+
+ me.oldWidth = me.getWidth();
-
- 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);
+
+ if (me.isGroupHeader) {
+ items = me.items.items;
+ me.callParent(arguments);
+ ownerHeaderCt.onHeaderHide(me);
+ for (i = 0, len = items.length; i < len; i++) {
+ items[i].hidden = true;
+ ownerHeaderCt.onHeaderHide(items[i], true);
+ }
+ return;
}
- },
-
- destroy : function(){
- Ext.menu.MenuMgr.unregisterCheckable(this);
- Ext.menu.CheckItem.superclass.destroy.apply(this, arguments);
- },
+
+ lb = me.ownerCt.componentLayout.layoutBusy;
+ me.ownerCt.componentLayout.layoutBusy = true;
+ me.callParent(arguments);
+ me.ownerCt.componentLayout.layoutBusy = lb;
-
- 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");
+
+ ownerHeaderCt.onHeaderHide(me);
+
+ if (me.ownerCt.isGroupHeader) {
+
+ items = me.ownerCt.query('>:not([hidden])');
+ if (!items.length) {
+ me.ownerCt.hide();
}
- this.checked = state;
- if(!suppress){
- this.fireEvent("checkchange", this, state);
+
+ else {
+ for (i = 0, len = items.length; i < len; i++) {
+ newWidth += items[i].getWidth();
+ }
+ me.ownerCt.minWidth = newWidth;
+ me.ownerCt.setWidth(newWidth);
}
}
},
-
- 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,
-
+ show: function() {
+ var me = this,
+ ownerCt = me.getOwnerHeaderCt(),
+ lb,
+ items,
+ len, i,
+ newWidth = 0;
+
-
- hideOnClick : true,
-
-
- pickerId : null,
-
-
-
-
- cls : 'x-date-menu',
-
-
-
-
+ lb = me.ownerCt.componentLayout.layoutBusy;
+ me.ownerCt.componentLayout.layoutBusy = true;
+ me.callParent(arguments);
+ me.ownerCt.componentLayout.layoutBusy = lb;
- 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});
+
+ if (me.isSubHeader) {
+ if (!me.ownerCt.isVisible()) {
+ me.ownerCt.show();
+ }
}
- 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);
+
+
+ if (me.isGroupHeader && !me.query(':not([hidden])').length) {
+ items = me.query('>*');
+ for (i = 0, len = items.length; i < len; i++) {
+ items[i].show();
+ }
+ }
+
+
+ if (me.ownerCt.isGroupHeader) {
+ items = me.ownerCt.query('>:not([hidden])');
+ for (i = 0, len = items.length; i < len; i++) {
+ newWidth += items[i].getWidth();
+ }
+ me.ownerCt.minWidth = newWidth;
+ me.ownerCt.setWidth(newWidth);
}
- },
- menuHide : function() {
- if(this.hideOnClick){
- this.hide(true);
+
+ if (ownerCt) {
+ ownerCt.onHeaderShow(me);
}
},
- onBeforeShow : function(){
- if(this.picker){
- this.picker.hideMonthPicker(true);
+ getDesiredWidth: function() {
+ var me = this;
+ if (me.rendered && me.componentLayout && me.componentLayout.lastComponentSize) {
+
+
+
+
+
+
+ return me.componentLayout.lastComponentSize.width;
+
+
+
+ }
+ else if (me.flex) {
+
+ return me.width;
+ }
+ else {
+ return me.width;
}
},
- onShow : function(){
- var el = this.picker.getEl();
- el.setWidth(el.getWidth());
+ getCellSelector: function() {
+ return '.' + Ext.baseCSSPrefix + 'grid-cell-' + this.getItemId();
+ },
+
+ getCellInnerSelector: function() {
+ return this.getCellSelector() + ' .' + Ext.baseCSSPrefix + 'grid-cell-inner';
+ },
+
+ isOnLeftEdge: function(e) {
+ return (e.getXY()[0] - this.el.getLeft() <= this.handleWidth);
+ },
+
+ isOnRightEdge: function(e) {
+ return (this.el.getRight() - e.getXY()[0] <= this.handleWidth);
}
- });
- Ext.reg('datemenu', Ext.menu.DateMenu);
-
- Ext.menu.ColorMenu = Ext.extend(Ext.menu.Menu, {
-
- enableScrolling : false,
-
-
-
-
- hideOnClick : true,
-
- cls : 'x-color-menu',
-
-
- paletteId : null,
@@ -39269,11988 +76980,11394 @@ Ext.reg('menucheckitem', Ext.menu.CheckItem);
+});
+
+Ext.define('Ext.grid.RowNumberer', {
+ extend: 'Ext.grid.column.Column',
+ alias: 'widget.rownumberer',
+ text: " ",
+
+ width: 23,
+
- 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);
+ sortable: false,
+
+ align: 'right',
+
+ constructor : function(config){
+ this.callParent(arguments);
+ if (this.rowspan) {
+ this.renderer = Ext.Function.bind(this.renderer, this);
}
},
- menuHide : function(){
- if(this.hideOnClick){
- this.hide(true);
+
+ fixed: true,
+ hideable: false,
+ menuDisabled: true,
+ dataIndex: '',
+ cls: Ext.baseCSSPrefix + 'row-numberer',
+ rowspan: undefined,
+
+
+ renderer: function(value, metaData, record, rowIdx, colIdx, store) {
+ if (this.rowspan){
+ metaData.cellAttr = 'rowspan="'+this.rowspan+'"';
}
+
+ metaData.tdCls = Ext.baseCSSPrefix + 'grid-cell-special';
+ return store.indexOfTotal(record) + 1;
}
});
-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,
+Ext.define('Ext.view.DropZone', {
+ extend: 'Ext.dd.DropZone',
-
- isFormField : true,
+ indicatorHtml: '',
+ indicatorCls: 'x-grid-drop-indicator',
-
- msgDisplay: '',
+ constructor: function(config) {
+ var me = this;
+ Ext.apply(me, config);
-
- hasFocus : false,
+
+
+
+
+
+ if (!me.ddGroup) {
+ me.ddGroup = 'view-dd-zone-' + me.view.id;
+ }
-
- initComponent : function(){
- Ext.form.Field.superclass.initComponent.call(this);
- this.addEvents(
-
- 'focus',
-
- 'blur',
-
- 'specialkey',
-
- 'change',
-
- 'invalid',
-
- 'valid'
- );
+
+
+
+ me.callParent([me.view.el]);
},
-
- getName : function(){
- return this.rendered && this.el.dom.name ? this.el.dom.name : this.name || this.id || '';
+
+
+ fireViewEvent: function() {
+ this.lock();
+ var result = this.view.fireEvent.apply(this.view, arguments);
+ this.unlock();
+ return result;
},
-
- onRender : function(ct, position){
- if(!this.el){
- var cfg = this.getAutoCreate();
+ getTargetFromEvent : function(e) {
+ var node = e.getTarget(this.view.getItemSelector()),
+ mouseY, nodeList, testNode, i, len, box;
- if(!cfg.name){
- cfg.name = this.name || this.id;
- }
- if(this.inputType){
- cfg.type = this.inputType;
- }
- this.autoEl = cfg;
- }
- Ext.form.Field.superclass.onRender.call(this, ct, position);
- if(this.submitValue === false){
- this.el.dom.removeAttribute('name');
- }
- var type = this.el.dom.type;
- if(type){
- if(type == 'password'){
- type = 'text';
+
+
+ if (!node) {
+ mouseY = e.getPageY();
+ for (i = 0, nodeList = this.view.getNodes(), len = nodeList.length; i < len; i++) {
+ testNode = nodeList[i];
+ box = Ext.fly(testNode).getBox();
+ if (mouseY <= box.bottom) {
+ return testNode;
+ }
}
- this.el.addClass('x-form-'+type);
- }
- if(this.readOnly){
- this.setReadOnly(true);
- }
- if(this.tabIndex !== undefined){
- this.el.dom.setAttribute('tabIndex', this.tabIndex);
}
-
- this.el.addClass([this.fieldClass, this.cls]);
+ return node;
},
-
- getItemCt : function(){
- return this.itemCt;
+ getIndicator: function() {
+ var me = this;
+
+ if (!me.indicator) {
+ me.indicator = Ext.createWidget('component', {
+ html: me.indicatorHtml,
+ cls: me.indicatorCls,
+ ownerCt: me.view,
+ floating: true,
+ shadow: false
+ });
+ }
+ return me.indicator;
},
-
- initValue : function(){
- if(this.value !== undefined){
- this.setValue(this.value);
- }else if(!Ext.isEmpty(this.el.dom.value) && this.el.dom.value != this.emptyText){
- this.setValue(this.el.dom.value);
+ getPosition: function(e, node) {
+ var y = e.getXY()[1],
+ region = Ext.fly(node).getRegion(),
+ pos;
+
+ if ((region.bottom - y) >= (region.bottom - region.top) / 2) {
+ pos = "before";
+ } else {
+ pos = "after";
}
-
- this.originalValue = this.getValue();
+ return pos;
},
- isDirty : function() {
- if(this.disabled || !this.rendered) {
+ containsRecordAtOffset: function(records, record, offset) {
+ if (!record) {
return false;
}
- return String(this.getValue()) !== String(this.originalValue);
+ var view = this.view,
+ recordIndex = view.indexOf(record),
+ nodeBefore = view.getNode(recordIndex + offset),
+ recordBefore = nodeBefore ? view.getRecord(nodeBefore) : null;
+
+ return recordBefore && Ext.Array.contains(records, recordBefore);
},
-
- setReadOnly : function(readOnly){
- if(this.rendered){
- this.el.dom.readOnly = readOnly;
+ positionIndicator: function(node, data, e) {
+ var me = this,
+ view = me.view,
+ pos = me.getPosition(e, node),
+ overRecord = view.getRecord(node),
+ draggingRecords = data.records,
+ indicator, indicatorY;
+
+ if (!Ext.Array.contains(draggingRecords, overRecord) && (
+ pos == 'before' && !me.containsRecordAtOffset(draggingRecords, overRecord, -1) ||
+ pos == 'after' && !me.containsRecordAtOffset(draggingRecords, overRecord, 1)
+ )) {
+ me.valid = true;
+
+ if (me.overRecord != overRecord || me.currentPosition != pos) {
+
+ indicatorY = Ext.fly(node).getY() - view.el.getY() - 1;
+ if (pos == 'after') {
+ indicatorY += Ext.fly(node).getHeight();
+ }
+ me.getIndicator().setWidth(Ext.fly(view.el).getWidth()).showAt(0, indicatorY);
+
+
+ me.overRecord = overRecord;
+ me.currentPosition = pos;
+ }
+ } else {
+ me.invalidateDrop();
}
- this.readOnly = readOnly;
},
-
- afterRender : function(){
- Ext.form.Field.superclass.afterRender.call(this);
- this.initEvents();
- this.initValue();
+ invalidateDrop: function() {
+ if (this.valid) {
+ this.valid = false;
+ this.getIndicator().hide();
+ }
},
- fireKey : function(e){
- if(e.isSpecialKey()){
- this.fireEvent('specialkey', this, e);
+ onNodeOver: function(node, dragZone, e, data) {
+ if (!Ext.Array.contains(data.records, this.view.getRecord(node))) {
+ this.positionIndicator(node, data, e);
}
+ return this.valid ? this.dropAllowed : this.dropNotAllowed;
},
- reset : function(){
- this.setValue(this.originalValue);
- this.clearInvalid();
+
+ notifyOut: function(node, dragZone, e, data) {
+ this.callParent(arguments);
+ delete this.overRecord;
+ delete this.currentPosition;
+ if (this.indicator) {
+ this.indicator.hide();
+ }
},
- initEvents : function(){
- this.mon(this.el, Ext.EventManager.getKeyEvent(), this.fireKey, this);
- this.mon(this.el, 'focus', this.onFocus, this);
+ onContainerOver : function(dd, e, data) {
+ var v = this.view,
+ c = v.store.getCount();
+ if (c) {
+ this.positionIndicator(v.getNode(c - 1), data, e);
+ }
+
- this.mon(this.el, 'blur', this.onBlur, this, this.inEditor ? {buffer:10} : null);
+ else {
+ delete this.overRecord;
+ delete this.currentPosition;
+ this.getIndicator().setWidth(Ext.fly(v.el).getWidth()).showAt(0, 0);
+ this.valid = true;
+ }
+ return this.dropAllowed;
},
-
- preFocus: Ext.emptyFn,
+ onContainerDrop : function(dd, e, data) {
+ return this.onNodeDrop(dd, null, e, data);
+ },
-
- onFocus : function(){
- this.preFocus();
- if(this.focusClass){
- this.el.addClass(this.focusClass);
- }
- if(!this.hasFocus){
- this.hasFocus = true;
+ onNodeDrop: function(node, dragZone, e, data) {
+ var me = this,
+ dropped = false,
+
+
+
+
- this.startValue = this.getValue();
- this.fireEvent('focus', this);
+ processDrop = function () {
+ me.invalidateDrop();
+ me.handleNodeDrop(data, me.overRecord, me.currentPosition);
+ dropped = true;
+ me.fireViewEvent('drop', node, data, me.overRecord, me.currentPosition);
+ },
+ performOperation;
+
+ if (me.valid) {
+ performOperation = me.fireViewEvent('beforedrop', node, data, me.overRecord, me.currentPosition, processDrop);
+ if (performOperation === 0) {
+ return;
+ } else if (performOperation !== false) {
+
+ if (!dropped) {
+ processDrop();
+ }
+ } else {
+ return false;
+ }
+ } else {
+ return false;
}
- },
+ }
+});
-
- beforeBlur : Ext.emptyFn,
+Ext.define('Ext.grid.ViewDropZone', {
+ extend: 'Ext.view.DropZone',
-
- onBlur : function(){
- this.beforeBlur();
- if(this.focusClass){
- this.el.removeClass(this.focusClass);
- }
- this.hasFocus = false;
- if(this.validationEvent !== false && (this.validateOnBlur || this.validationEvent == 'blur')){
- this.validate();
- }
- var v = this.getValue();
- if(String(v) !== String(this.startValue)){
- this.fireEvent('change', this, v, this.startValue);
- }
- this.fireEvent('blur', this);
- this.postBlur();
- },
+ indicatorHtml: '',
+ indicatorCls: 'x-grid-drop-indicator',
-
- postBlur : Ext.emptyFn,
+ handleNodeDrop : function(data, record, position) {
+ var view = this.view,
+ store = view.getStore(),
+ index, records, i, len;
-
- isValid : function(preventMark){
- if(this.disabled){
- return true;
+
+ if (data.copy) {
+ records = data.records;
+ data.records = [];
+ for (i = 0, len = records.length; i < len; i++) {
+ data.records.push(records[i].copy(records[i].getId()));
+ }
+ } else {
+
+ data.view.store.remove(data.records, data.view === view);
}
- var restore = this.preventMark;
- this.preventMark = preventMark === true;
- var v = this.validateValue(this.processValue(this.getRawValue()));
- this.preventMark = restore;
- return v;
- },
-
- validate : function(){
- if(this.disabled || this.validateValue(this.processValue(this.getRawValue()))){
- this.clearInvalid();
- return true;
+ index = store.indexOf(record);
+ if (position == 'after') {
+ index++;
}
- return false;
- },
+ store.insert(index, data.records);
+ view.getSelectionModel().select(data.records);
+ }
+});
-
- processValue : function(value){
- return value;
- },
+Ext.define('Ext.grid.column.Action', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.actioncolumn'],
+ alternateClassName: 'Ext.grid.ActionColumn',
- validateValue : function(value) {
-
- var error = this.getErrors(value)[0];
-
- if (error == undefined) {
- return true;
- } else {
- this.markInvalid(error);
- return false;
- }
- },
- getErrors: function() {
- return [];
- },
-
- getActiveError : function(){
- return this.activeError || '';
- },
-
- markInvalid : function(msg){
-
- if (this.rendered && !this.preventMark) {
- msg = msg || this.invalidText;
+
+
+
+ header: ' ',
+
+ actionIdRe: /x-action-col-(\d+)/,
- var mt = this.getMessageHandler();
- if(mt){
- mt.mark(this, msg);
- }else if(this.msgTarget){
- this.el.addClass(this.invalidClass);
- var t = Ext.getDom(this.msgTarget);
- if(t){
- t.innerHTML = msg;
- t.style.display = this.msgDisplay;
- }
- }
- }
-
- this.setActiveError(msg);
- },
+ altText: '',
- clearInvalid : function(){
+ sortable: false,
+
+ constructor: function(config) {
+ var me = this,
+ cfg = Ext.apply({}, config),
+ items = cfg.items || [me],
+ l = items.length,
+ i,
+ item;
+
- if (this.rendered && !this.preventMark) {
- this.el.removeClass(this.invalidClass);
- var mt = this.getMessageHandler();
- if(mt){
- mt.clear(this);
- }else if(this.msgTarget){
- this.el.removeClass(this.invalidClass);
- var t = Ext.getDom(this.msgTarget);
- if(t){
- t.innerHTML = '';
- t.style.display = 'none';
- }
- }
- }
+ delete cfg.items;
+ this.callParent([cfg]);
+
- this.unsetActiveError();
- },
+ me.items = items;
-
- setActiveError: function(msg, suppressEvent) {
- this.activeError = msg;
- if (suppressEvent !== true) this.fireEvent('invalid', this, msg);
- },
-
-
- unsetActiveError: function(suppressEvent) {
- delete this.activeError;
- if (suppressEvent !== true) this.fireEvent('valid', this);
- },
-
- getMessageHandler : function(){
- return Ext.form.MessageTargets[this.msgTarget];
- },
-
- getErrorCt : function(){
- return this.el.findParent('.x-form-element', 5, true) ||
- this.el.findParent('.x-form-field-wrap', 5, true);
- },
+ me.renderer = function(v, meta) {
-
- alignErrorEl : function(){
- this.errorEl.setWidth(this.getErrorCt().getWidth(true) - 20);
- },
+ v = Ext.isFunction(cfg.renderer) ? cfg.renderer.apply(this, arguments)||'' : '';
-
- alignErrorIcon : function(){
- this.errorIcon.alignTo(this.el, 'tl-tr', [2, 0]);
+ meta.tdCls += ' ' + Ext.baseCSSPrefix + 'action-col-cell';
+ for (i = 0; i < l; i++) {
+ item = items[i];
+ v += ' +
+ ')
';
+ }
+ return v;
+ };
},
-
- getRawValue : function(){
- var v = this.rendered ? this.el.getValue() : Ext.value(this.value, '');
- if(v === this.emptyText){
- v = '';
- }
- return v;
+ destroy: function() {
+ delete this.items;
+ delete this.renderer;
+ return this.callParent(arguments);
},
- getValue : function(){
- if(!this.rendered) {
- return this.value;
- }
- var v = this.el.getValue();
- if(v === this.emptyText || v === undefined){
- v = '';
+ processEvent : function(type, view, cell, recordIndex, cellIndex, e){
+ var m = e.getTarget().className.match(this.actionIdRe),
+ item, fn;
+ if (m && (item = this.items[parseInt(m[1], 10)])) {
+ if (type == 'click') {
+ fn = item.handler;
+ if (fn || this.handler) {
+ fn.call(item.scope||this.scope||this, view, recordIndex, cellIndex, item, e);
+ }
+ } else if ((type == 'mousedown') && (item.stopSelection !== false)) {
+ return false;
+ }
}
- return v;
- },
-
-
- setRawValue : function(v){
- return this.rendered ? (this.el.dom.value = (Ext.isEmpty(v) ? '' : v)) : '';
+ return this.callParent(arguments);
},
-
- setValue : function(v){
- this.value = v;
- if(this.rendered){
- this.el.dom.value = (Ext.isEmpty(v) ? '' : v);
- this.validate();
- }
- return this;
+ cascade: function(fn, scope) {
+ fn.call(scope||this, this);
},
- append : function(v){
- this.setValue([this.getValue(), v].join(''));
+ getRefItems: function() {
+ return [];
}
+});
+
+Ext.define('Ext.grid.column.Boolean', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.booleancolumn'],
+ alternateClassName: 'Ext.grid.BooleanColumn',
+ trueText: 'true',
+
+ falseText: 'false',
-});
+ undefinedText: ' ',
+ constructor: function(cfg){
+ this.callParent(arguments);
+ var trueText = this.trueText,
+ falseText = this.falseText,
+ undefinedText = this.undefinedText;
-Ext.form.MessageTargets = {
- 'qtip' : {
- mark: function(field, msg){
- field.el.addClass(field.invalidClass);
- field.el.dom.qtip = msg;
- field.el.dom.qclass = 'x-form-invalid-tip';
- if(Ext.QuickTips){
- Ext.QuickTips.enable();
- }
- },
- clear: function(field){
- field.el.removeClass(field.invalidClass);
- field.el.dom.qtip = '';
- }
- },
- 'title' : {
- mark: function(field, msg){
- field.el.addClass(field.invalidClass);
- field.el.dom.title = msg;
- },
- clear: function(field){
- field.el.dom.title = '';
- }
- },
- 'under' : {
- mark: function(field, msg){
- field.el.addClass(field.invalidClass);
- if(!field.errorEl){
- var elp = field.getErrorCt();
- if(!elp){
- field.el.dom.title = msg;
- return;
- }
- field.errorEl = elp.createChild({cls:'x-form-invalid-msg'});
- field.on('resize', field.alignErrorEl, field);
- field.on('destroy', function(){
- Ext.destroy(this.errorEl);
- }, field);
- }
- field.alignErrorEl();
- field.errorEl.update(msg);
- Ext.form.Field.msgFx[field.msgFx].show(field.errorEl, field);
- },
- clear: function(field){
- field.el.removeClass(field.invalidClass);
- if(field.errorEl){
- Ext.form.Field.msgFx[field.msgFx].hide(field.errorEl, field);
- }else{
- field.el.dom.title = '';
+ this.renderer = function(value){
+ if(value === undefined){
+ return undefinedText;
}
- }
- },
- 'side' : {
- mark: function(field, msg){
- field.el.addClass(field.invalidClass);
- if(!field.errorIcon){
- var elp = field.getErrorCt();
-
- if(!elp){
- field.el.dom.title = msg;
- return;
- }
- field.errorIcon = elp.createChild({cls:'x-form-invalid-icon'});
- if (field.ownerCt) {
- field.ownerCt.on('afterlayout', field.alignErrorIcon, field);
- field.ownerCt.on('expand', field.alignErrorIcon, field);
- }
- field.on('resize', field.alignErrorIcon, field);
- field.on('destroy', function(){
- Ext.destroy(this.errorIcon);
- }, field);
- }
- field.alignErrorIcon();
- field.errorIcon.dom.qtip = msg;
- field.errorIcon.dom.qclass = 'x-form-invalid-tip';
- field.errorIcon.show();
- },
- clear: function(field){
- field.el.removeClass(field.invalidClass);
- if(field.errorIcon){
- field.errorIcon.dom.qtip = '';
- field.errorIcon.hide();
- }else{
- field.el.dom.title = '';
+ if(!value || value === 'false'){
+ return falseText;
}
- }
+ return trueText;
+ };
}
-};
+});
+Ext.define('Ext.grid.column.Date', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.datecolumn'],
+ requires: ['Ext.Date'],
+ alternateClassName: 'Ext.grid.DateColumn',
-Ext.form.Field.msgFx = {
- normal : {
- show: function(msgEl, f){
- msgEl.setDisplayed('block');
- },
+
+ format : Ext.Date.defaultFormat,
- hide : function(msgEl, f){
- msgEl.setDisplayed(false).update('');
- }
- },
+ constructor: function(cfg){
+ this.callParent(arguments);
+ this.renderer = Ext.util.Format.dateRenderer(this.format);
+ }
+});
- slide : {
- show: function(msgEl, f){
- msgEl.slideIn('t', {stopFx:true});
- },
+Ext.define('Ext.grid.column.Number', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.numbercolumn'],
+ requires: ['Ext.util.Format'],
+ alternateClassName: 'Ext.grid.NumberColumn',
- hide : function(msgEl, f){
- msgEl.slideOut('t', {stopFx:true,useDisplay:true});
- }
- },
+
+ format : '0,000.00',
+ constructor: function(cfg) {
+ this.callParent(arguments);
+ this.renderer = Ext.util.Format.numberRenderer(this.format);
+ }
+});
- slideRight : {
- show: function(msgEl, f){
- msgEl.fixDisplay();
- msgEl.alignTo(f.el, 'tl-tr');
- msgEl.slideIn('l', {stopFx:true});
- },
+Ext.define('Ext.grid.column.Template', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.templatecolumn'],
+ requires: ['Ext.XTemplate'],
+ alternateClassName: 'Ext.grid.TemplateColumn',
- hide : function(msgEl, f){
- msgEl.slideOut('l', {stopFx:true,useDisplay:true});
- }
+
+ constructor: function(cfg){
+ var me = this,
+ tpl;
+
+ me.callParent(arguments);
+ tpl = me.tpl = (!Ext.isPrimitive(me.tpl) && me.tpl.compile) ? me.tpl : Ext.create('Ext.XTemplate', me.tpl);
+
+ me.renderer = function(value, p, record) {
+ var data = Ext.apply({}, record.data, record.getAssociatedData());
+ return tpl.apply(data);
+ };
}
-};
-Ext.reg('field', Ext.form.Field);
+});
-Ext.form.TextField = Ext.extend(Ext.form.Field, {
-
+
+Ext.define('Ext.grid.feature.Feature', {
+ extend: 'Ext.util.Observable',
+ alias: 'feature.feature',
+ isFeature: true,
+ disabled: false,
- grow : false,
- growMin : 30,
+ hasFeatureEvent: true,
- growMax : 800,
- vtype : null,
+ eventPrefix: null,
- maskRe : null,
- disableKeyFilter : false,
+ eventSelector: null,
- allowBlank : true,
- minLength : 0,
+ view: null,
- maxLength : Number.MAX_VALUE,
- minLengthText : 'The minimum length for this field is {0}',
+ grid: null,
- maxLengthText : 'The maximum length for this field is {0}',
- selectOnFocus : false,
+ collectData: false,
+
+ getFeatureTpl: function() {
+ return '';
+ },
- blankText : 'This field is required',
- validator : null,
+ getFireEventArgs: function(eventName, view, featureTarget) {
+ return [eventName, view, featureTarget];
+ },
- regex : null,
- regexText : '',
+ attachEvents: function() {
+
+ },
- emptyText : null,
+ getFragmentTpl: function() {
+ return;
+ },
- emptyClass : 'x-form-empty-field',
-
-
- initComponent : function(){
- Ext.form.TextField.superclass.initComponent.call(this);
- this.addEvents(
-
- 'autosize',
-
-
- 'keydown',
-
- 'keyup',
-
- 'keypress'
- );
+ mutateMetaRowTpl: function(metaRowTplArray) {
+
},
-
- initEvents : function(){
- Ext.form.TextField.superclass.initEvents.call(this);
- if(this.validationEvent == 'keyup'){
- this.validationTask = new Ext.util.DelayedTask(this.validate, this);
- this.mon(this.el, 'keyup', this.filterValidation, this);
- }
- else if(this.validationEvent !== false && this.validationEvent != 'blur'){
- this.mon(this.el, this.validationEvent, this.validate, this, {buffer: this.validationDelay});
- }
- if(this.selectOnFocus || this.emptyText){
- this.mon(this.el, 'mousedown', this.onMouseDown, this);
-
- if(this.emptyText){
- this.applyEmptyText();
- }
- }
- if(this.maskRe || (this.vtype && this.disableKeyFilter !== true && (this.maskRe = Ext.form.VTypes[this.vtype+'Mask']))){
- this.mon(this.el, 'keypress', this.filterKeys, this);
- }
- if(this.grow){
- this.mon(this.el, 'keyup', this.onKeyUpBuffered, this, {buffer: 50});
- this.mon(this.el, 'click', this.autoSize, this);
- }
- if(this.enableKeyEvents){
- this.mon(this.el, {
- scope: this,
- keyup: this.onKeyUp,
- keydown: this.onKeyDown,
- keypress: this.onKeyPress
- });
- }
- },
- onMouseDown: function(e){
- if(!this.hasFocus){
- this.mon(this.el, 'mouseup', Ext.emptyFn, this, { single: true, preventDefault: true });
- }
- },
-
- processValue : function(value){
- if(this.stripCharsRe){
- var newValue = value.replace(this.stripCharsRe, '');
- if(newValue !== value){
- this.setRawValue(newValue);
- return newValue;
- }
- }
- return value;
+ getMetaRowTplFragments: function() {
+ return {};
},
- filterValidation : function(e){
- if(!e.isNavKeyPress()){
- this.validationTask.delay(this.validationDelay);
- }
+ getTableFragments: function() {
+ return {};
},
- onDisable: function(){
- Ext.form.TextField.superclass.onDisable.call(this);
- if(Ext.isIE){
- this.el.dom.unselectable = 'on';
- }
+ getAdditionalData: function(data, idx, record, orig) {
+ return {};
},
- onEnable: function(){
- Ext.form.TextField.superclass.onEnable.call(this);
- if(Ext.isIE){
- this.el.dom.unselectable = '';
- }
+ enable: function() {
+ this.disabled = false;
},
-
- onKeyUpBuffered : function(e){
- if(this.doAutoSize(e)){
- this.autoSize();
- }
- },
+ disable: function() {
+ this.disabled = true;
+ }
- doAutoSize : function(e){
- return !e.isNavKeyPress();
- },
+});
+Ext.define('Ext.grid.feature.AbstractSummary', {
- onKeyUp : function(e){
- this.fireEvent('keyup', this, e);
- },
-
- onKeyDown : function(e){
- this.fireEvent('keydown', this, e);
+
+ extend: 'Ext.grid.feature.Feature',
+
+ alias: 'feature.abstractsummary',
+
+
+
+
+ showSummaryRow: true,
+
+
+ nestedIdRe: /\{\{id\}([\w\-]*)\}/g,
+
+
+ toggleSummaryRow: function(visible){
+ this.showSummaryRow = !!visible;
},
-
- onKeyPress : function(e){
- this.fireEvent('keypress', this, e);
+
+ getSummaryFragments: function(){
+ var fragments = {};
+ if (this.showSummaryRow) {
+ Ext.apply(fragments, {
+ printSummaryRow: Ext.bind(this.printSummaryRow, this)
+ });
+ }
+ return fragments;
},
-
- reset : function(){
- Ext.form.TextField.superclass.reset.call(this);
- this.applyEmptyText();
+
+ printSummaryRow: function(index){
+ var inner = this.view.getTableChunker().metaRowTpl.join('');
+
+ inner = inner.replace('x-grid-row', 'x-grid-row-summary');
+ inner = inner.replace('{{id}}', '{gridSummaryValue}');
+ inner = inner.replace(this.nestedIdRe, '{id$1}');
+ inner = inner.replace('{[this.embedRowCls()]}', '{rowCls}');
+ inner = inner.replace('{[this.embedRowAttr()]}', '{rowAttr}');
+ inner = Ext.create('Ext.XTemplate', inner, {
+ firstOrLastCls: Ext.view.TableChunker.firstOrLastCls
+ });
+
+ return inner.applyTemplate({
+ columns: this.getPrintData(index)
+ });
},
-
- applyEmptyText : function(){
- if(this.rendered && this.emptyText && this.getRawValue().length < 1 && !this.hasFocus){
- this.setRawValue(this.emptyText);
- this.el.addClass(this.emptyClass);
+
+
+ getColumnValue: function(column, data){
+ var comp = Ext.getCmp(column.id),
+ value = data[column.dataIndex],
+ renderer = comp.summaryRenderer || comp.renderer;
+
+ if (renderer) {
+ value = renderer.call(comp.scope || this, value, data, column.dataIndex);
}
+ return value;
},
-
- preFocus : function(){
- var el = this.el,
- isEmpty;
- if(this.emptyText){
- if(el.dom.value == this.emptyText){
- this.setRawValue('');
- isEmpty = true;
+
+ getSummary: function(store, type, field, group){
+ if (type) {
+ if (Ext.isFunction(type)) {
+ return store.aggregate(type, null, group);
+ }
+
+ switch (type) {
+ case 'count':
+ return store.count(group);
+ case 'min':
+ return store.min(field, group);
+ case 'max':
+ return store.max(field, group);
+ case 'sum':
+ return store.sum(field, group);
+ case 'average':
+ return store.average(field, group);
+ default:
+ return group ? {} : '';
+
}
- el.removeClass(this.emptyClass);
- }
- if(this.selectOnFocus || isEmpty){
- el.dom.select();
}
- },
-
+ }
- postBlur : function(){
- this.applyEmptyText();
- },
+});
+
+Ext.define('Ext.grid.feature.Chunking', {
+ extend: 'Ext.grid.feature.Feature',
+ alias: 'feature.chunking',
- filterKeys : function(e){
- if(e.ctrlKey){
- return;
- }
- var k = e.getKey();
- if(Ext.isGecko && (e.isNavKeyPress() || k == e.BACKSPACE || (k == e.DELETE && e.button == -1))){
- return;
- }
- var cc = String.fromCharCode(e.getCharCode());
- if(!Ext.isGecko && e.isSpecialKey() && !cc){
- return;
- }
- if(!this.maskRe.test(cc)){
- e.stopEvent();
- }
+ chunkSize: 20,
+ rowHeight: Ext.isIE ? 27 : 26,
+ visibleChunk: 0,
+ hasFeatureEvent: false,
+ attachEvents: function() {
+ var grid = this.view.up('gridpanel'),
+ scroller = grid.down('gridscroller[dock=right]');
+ scroller.el.on('scroll', this.onBodyScroll, this, {buffer: 300});
+
},
-
- setValue : function(v){
- if(this.emptyText && this.el && !Ext.isEmpty(v)){
- this.el.removeClass(this.emptyClass);
+
+ onBodyScroll: function(e, t) {
+ var view = this.view,
+ top = t.scrollTop,
+ nextChunk = Math.floor(top / this.rowHeight / this.chunkSize);
+ if (nextChunk !== this.visibleChunk) {
+
+ this.visibleChunk = nextChunk;
+ view.refresh();
+ view.el.dom.scrollTop = top;
+
+ view.el.dom.scrollTop = top;
}
- Ext.form.TextField.superclass.setValue.apply(this, arguments);
- this.applyEmptyText();
- this.autoSize();
- return this;
},
-
- getErrors: function(value) {
- var errors = Ext.form.TextField.superclass.getErrors.apply(this, arguments);
-
- value = Ext.isDefined(value) ? value : this.processValue(this.getRawValue());
+ collectData: function(records, preppedRecords, startIndex, fullWidth, orig) {
+ var o = {
+ fullWidth: orig.fullWidth,
+ chunks: []
+ },
- if (Ext.isFunction(this.validator)) {
- var msg = this.validator(value);
- if (msg !== true) {
- errors.push(msg);
- }
- }
- if (value.length < 1 || value === this.emptyText) {
- if (this.allowBlank) {
-
- return errors;
+ recordCount = orig.rows.length,
+ start = 0,
+ i = 0,
+ visibleChunk = this.visibleChunk,
+ chunk,
+ rows,
+ chunkLength;
+
+ for (; start < recordCount; start+=this.chunkSize, i++) {
+ if (start+this.chunkSize > recordCount) {
+ chunkLength = recordCount - start;
} else {
- errors.push(this.blankText);
+ chunkLength = this.chunkSize;
}
- }
-
- if (!this.allowBlank && (value.length < 1 || value === this.emptyText)) {
- errors.push(this.blankText);
- }
-
- if (value.length < this.minLength) {
- errors.push(String.format(this.minLengthText, this.minLength));
- }
-
- if (value.length > this.maxLength) {
- errors.push(String.format(this.maxLengthText, this.maxLength));
- }
-
- if (this.vtype) {
- var vt = Ext.form.VTypes;
- if(!vt[this.vtype](value, this)){
- errors.push(this.vtypeText || vt[this.vtype +'Text']);
+
+ if (i >= visibleChunk - 1 && i <= visibleChunk + 1) {
+ rows = orig.rows.slice(start, start+this.chunkSize);
+ } else {
+ rows = [];
}
+ o.chunks.push({
+ rows: rows,
+ fullWidth: fullWidth,
+ chunkHeight: chunkLength * this.rowHeight
+ });
}
- if (this.regex && !this.regex.test(value)) {
- errors.push(this.regexText);
- }
- return errors;
+ return o;
},
-
- selectText : function(start, end){
- var v = this.getRawValue();
- var doFocus = false;
- if(v.length > 0){
- start = start === undefined ? 0 : start;
- end = end === undefined ? v.length : end;
- var d = this.el.dom;
- if(d.setSelectionRange){
- d.setSelectionRange(start, end);
- }else if(d.createTextRange){
- var range = d.createTextRange();
- range.moveStart('character', start);
- range.moveEnd('character', end-v.length);
- range.select();
+ getTableFragments: function() {
+ return {
+ openTableWrap: function() {
+ return '',
+
+ '{[this.recurse(values)]} '
+ ].join('');
},
-
- onRender : function(ct, position){
- this.doc = Ext.isIE ? Ext.getBody() : Ext.getDoc();
- Ext.form.TriggerField.superclass.onRender.call(this, ct, position);
+ getFragmentTpl: function() {
+ return {
+ indentByDepth: this.indentByDepth,
+ depthToIndent: this.depthToIndent
+ };
+ },
- this.wrap = this.el.wrap({cls: 'x-form-field-wrap x-form-field-trigger-wrap'});
- this.trigger = this.wrap.createChild(this.triggerConfig ||
- {tag: "img", src: Ext.BLANK_IMAGE_URL, alt: "", cls: "x-form-trigger " + this.triggerClass});
- this.initTrigger();
- if(!this.width){
- this.wrap.setWidth(this.el.getWidth()+this.trigger.getWidth());
- }
- this.resizeEl = this.positionEl = this.wrap;
+ indentByDepth: function(values) {
+ var depth = values.depth || 0;
+ return 'style="padding-left:'+ depth * this.depthToIndent + 'px;"';
},
- getWidth: function() {
- return(this.el.getWidth() + this.trigger.getWidth());
+
+
+ destroy: function() {
+ var me = this;
+
+ delete me.view;
+ delete me.prunedHeader;
},
- updateEditState: function(){
- if(this.rendered){
- if (this.readOnly) {
- this.el.dom.readOnly = true;
- this.el.addClass('x-trigger-noedit');
- this.mun(this.el, 'click', this.onTriggerClick, this);
- this.trigger.setDisplayed(false);
- } else {
- if (!this.editable) {
- this.el.dom.readOnly = true;
- this.el.addClass('x-trigger-noedit');
- this.mon(this.el, 'click', this.onTriggerClick, this);
- } else {
- this.el.dom.readOnly = false;
- this.el.removeClass('x-trigger-noedit');
- this.mun(this.el, 'click', this.onTriggerClick, this);
- }
- this.trigger.setDisplayed(!this.hideTrigger);
+
+ attachEvents: function() {
+ var me = this,
+ view = me.view,
+ header, headerId, menu, menuItem;
+
+ view.on({
+ scope: me,
+ groupclick: me.onGroupClick,
+ rowfocus: me.onRowFocus
+ });
+ view.store.on('groupchange', me.onGroupChange, me);
+
+ me.pruneGroupedHeader();
+
+ if (me.enableGroupingMenu) {
+ me.injectGroupingMenu();
+ }
+
+ if (me.hideGroupedHeader) {
+ header = view.headerCt.down('gridcolumn[dataIndex=' + me.getGroupField() + ']');
+ headerId = header.id;
+ menu = view.headerCt.getMenu();
+ menuItem = menu.down('menuitem[headerId='+ headerId +']');
+ if (menuItem) {
+ menuItem.setChecked(false);
}
- this.onResize(this.width || this.wrap.getWidth());
}
},
-
- setHideTrigger: function(hideTrigger){
- if(hideTrigger != this.hideTrigger){
- this.hideTrigger = hideTrigger;
- this.updateEditState();
- }
+ injectGroupingMenu: function() {
+ var me = this,
+ view = me.view,
+ headerCt = view.headerCt;
+ headerCt.showMenuBy = me.showMenuBy;
+ headerCt.getMenuItems = me.getMenuItems();
},
-
- setEditable: function(editable){
- if(editable != this.editable){
- this.editable = editable;
- this.updateEditState();
- }
+ showMenuBy: function(t, header) {
+ var menu = this.getMenu(),
+ groupMenuItem = menu.down('#groupMenuItem'),
+ groupableMth = header.groupable === false ? 'disable' : 'enable';
+
+ groupMenuItem[groupableMth]();
+ Ext.grid.header.Container.prototype.showMenuBy.apply(this, arguments);
},
-
- setReadOnly: function(readOnly){
- if(readOnly != this.readOnly){
- this.readOnly = readOnly;
- this.updateEditState();
- }
+ getMenuItems: function() {
+ var me = this,
+ groupByText = me.groupByText,
+ disabled = me.disabled,
+ showGroupsText = me.showGroupsText,
+ enableNoGroups = me.enableNoGroups,
+ groupMenuItemClick = Ext.Function.bind(me.onGroupMenuItemClick, me),
+ groupToggleMenuItemClick = Ext.Function.bind(me.onGroupToggleMenuItemClick, me)
+
+
+ return function() {
+ var o = Ext.grid.header.Container.prototype.getMenuItems.call(this);
+ o.push('-', {
+ itemId: 'groupMenuItem',
+ text: groupByText,
+ handler: groupMenuItemClick
+ });
+ if (enableNoGroups) {
+ o.push({
+ itemId: 'groupToggleMenuItem',
+ text: showGroupsText,
+ checked: !disabled,
+ checkHandler: groupToggleMenuItemClick
+ });
+ }
+ return o;
+ };
},
- afterRender : function(){
- Ext.form.TriggerField.superclass.afterRender.call(this);
- this.updateEditState();
- },
- initTrigger : function(){
- this.mon(this.trigger, 'click', this.onTriggerClick, this, {preventDefault:true});
- this.trigger.addClassOnOver('x-form-trigger-over');
- this.trigger.addClassOnClick('x-form-trigger-click');
+ onGroupMenuItemClick: function(menuItem, e) {
+ var menu = menuItem.parentMenu,
+ hdr = menu.activeHeader,
+ view = this.view;
+
+ delete this.lastGroupIndex;
+ this.enable();
+ view.store.group(hdr.dataIndex);
+ this.pruneGroupedHeader();
+
},
- onDestroy : function(){
- Ext.destroy(this.trigger, this.wrap);
- if (this.mimicing){
- this.doc.un('mousedown', this.mimicBlur, this);
- }
- delete this.doc;
- Ext.form.TriggerField.superclass.onDestroy.call(this);
+ onGroupToggleMenuItemClick: function(menuItem, checked) {
+ this[checked ? 'enable' : 'disable']();
},
- onFocus : function(){
- Ext.form.TriggerField.superclass.onFocus.call(this);
- if(!this.mimicing){
- this.wrap.addClass(this.wrapFocusClass);
- this.mimicing = true;
- this.doc.on('mousedown', this.mimicBlur, this, {delay: 10});
- if(this.monitorTab){
- this.on('specialkey', this.checkTab, this);
+ pruneGroupedHeader: function() {
+ var me = this,
+ view = me.view,
+ store = view.store,
+ groupField = me.getGroupField(),
+ headerCt = view.headerCt,
+ header = headerCt.down('header[dataIndex=' + groupField + ']');
+
+ if (header) {
+ if (me.prunedHeader) {
+ me.prunedHeader.show();
}
+ me.prunedHeader = header;
+ header.hide();
}
},
-
- checkTab : function(me, e){
- if(e.getKey() == e.TAB){
- this.triggerBlur();
+ getGroupField: function(){
+ var group = this.view.store.groupers.first();
+ if (group) {
+ return group.property;
}
+ return '';
},
- onBlur : Ext.emptyFn,
+ onRowFocus: function(rowIdx) {
+ var node = this.view.getNode(rowIdx),
+ groupBd = Ext.fly(node).up('.' + this.collapsedCls);
-
- mimicBlur : function(e){
- if(!this.isDestroyed && !this.wrap.contains(e.target) && this.validateBlur(e)){
- this.triggerBlur();
+ if (groupBd) {
+
+
+ this.expand(groupBd);
}
},
- triggerBlur : function(){
- this.mimicing = false;
- this.doc.un('mousedown', this.mimicBlur, this);
- if(this.monitorTab && this.el){
- this.un('specialkey', this.checkTab, this);
- }
- Ext.form.TriggerField.superclass.onBlur.call(this);
- if(this.wrap){
- this.wrap.removeClass(this.wrapFocusClass);
- }
- },
+ expand: function(groupBd) {
+ var me = this,
+ view = me.view,
+ grid = view.up('gridpanel'),
+ groupBdDom = Ext.getDom(groupBd);
+
+ me.collapsedState[groupBdDom.id] = false;
- beforeBlur : Ext.emptyFn,
+ groupBd.removeCls(me.collapsedCls);
+ groupBd.prev().removeCls(me.hdCollapsedCls);
-
-
- validateBlur : function(e){
- return true;
+ grid.determineScrollbars();
+ grid.invalidateScroller();
+ view.fireEvent('groupexpand');
},
- onTriggerClick : Ext.emptyFn
-
-
-
-
-});
-
-
-Ext.form.TwinTriggerField = Ext.extend(Ext.form.TriggerField, {
-
-
-
-
- initComponent : function(){
- Ext.form.TwinTriggerField.superclass.initComponent.call(this);
+ collapse: function(groupBd) {
+ var me = this,
+ view = me.view,
+ grid = view.up('gridpanel'),
+ groupBdDom = Ext.getDom(groupBd);
+
+ me.collapsedState[groupBdDom.id] = true;
- this.triggerConfig = {
- tag:'span', cls:'x-form-twin-triggers', cn:[
- {tag: "img", src: Ext.BLANK_IMAGE_URL, alt: "", cls: "x-form-trigger " + this.trigger1Class},
- {tag: "img", src: Ext.BLANK_IMAGE_URL, alt: "", cls: "x-form-trigger " + this.trigger2Class}
- ]};
- },
+ groupBd.addCls(me.collapsedCls);
+ groupBd.prev().addCls(me.hdCollapsedCls);
- getTrigger : function(index){
- return this.triggers[index];
+ grid.determineScrollbars();
+ grid.invalidateScroller();
+ view.fireEvent('groupcollapse');
},
- afterRender: function(){
- Ext.form.TwinTriggerField.superclass.afterRender.call(this);
- var triggers = this.triggers,
- i = 0,
- len = triggers.length;
-
- for(; i < len; ++i){
- if(this['hideTrigger' + (i + 1)]){
- triggers[i].hide();
- }
-
- }
+ onGroupChange: function(){
+ this.view.refresh();
},
- initTrigger : function(){
- var ts = this.trigger.select('.x-form-trigger', true),
- triggerField = this;
-
- ts.each(function(t, all, index){
- var triggerIndex = 'Trigger'+(index+1);
- t.hide = function(){
- var w = triggerField.wrap.getWidth();
- this.dom.style.display = 'none';
- triggerField.el.setWidth(w-triggerField.trigger.getWidth());
- triggerField['hidden' + triggerIndex] = true;
- };
- t.show = function(){
- var w = triggerField.wrap.getWidth();
- this.dom.style.display = '';
- triggerField.el.setWidth(w-triggerField.trigger.getWidth());
- triggerField['hidden' + triggerIndex] = false;
- };
- this.mon(t, 'click', this['on'+triggerIndex+'Click'], this, {preventDefault:true});
- t.addClassOnOver('x-form-trigger-over');
- t.addClassOnClick('x-form-trigger-click');
- }, this);
- this.triggers = ts.elements;
- },
+
+ onGroupClick: function(view, group, idx, foo, e) {
+ var me = this,
+ toggleCls = me.toggleCls,
+ groupBd = Ext.fly(group.nextSibling, '_grouping');
- getTriggerWidth: function(){
- var tw = 0;
- Ext.each(this.triggers, function(t, index){
- var triggerIndex = 'Trigger' + (index + 1),
- w = t.getWidth();
- if(w === 0 && !this['hidden' + triggerIndex]){
- tw += this.defaultTriggerWidth;
- }else{
- tw += w;
- }
- }, this);
- return tw;
+ if (groupBd.hasCls(me.collapsedCls)) {
+ me.expand(groupBd);
+ } else {
+ me.collapse(groupBd);
+ }
},
- onDestroy : function() {
- Ext.destroy(this.triggers);
- Ext.form.TwinTriggerField.superclass.onDestroy.call(this);
+ getMetaRowTplFragments: function() {
+ return {
+ isRow: this.isRow,
+ closeRow: this.closeRow
+ };
},
- onTrigger1Click : Ext.emptyFn,
- onTrigger2Click : Ext.emptyFn
-});
-Ext.reg('trigger', Ext.form.TriggerField);
+ isRow: function() {
+ return '';
+ },
-Ext.form.TextArea = Ext.extend(Ext.form.TextField, {
- growMin : 60,
- growMax: 1000,
- growAppend : ' \n ',
+ closeRow: function() {
+ return ' ';
+ },
- enterIsSpecial : false,
+
+ mutateMetaRowTpl: function(metaRowTpl) {
+ metaRowTpl.unshift('{[this.isRow()]}');
+ metaRowTpl.push('{[this.closeRow()]}');
+ },
- preventScrollbars: false,
+ getAdditionalData: function(data, idx, record, orig) {
+ var view = this.view,
+ hCt = view.headerCt,
+ col = hCt.items.getAt(0),
+ o = {},
+ tdAttrKey = col.id + '-tdAttr';
+
+
+ o[tdAttrKey] = this.indentByDepth(data) + " " + (orig[tdAttrKey] ? orig[tdAttrKey] : '');
+ o.collapsed = 'true';
+ return o;
+ },
- onRender : function(ct, position){
- if(!this.el){
- this.defaultAutoCreate = {
- tag: "textarea",
- style:"width:100px;height:60px;",
- autocomplete: "off"
- };
- }
- Ext.form.TextArea.superclass.onRender.call(this, ct, position);
- if(this.grow){
- this.textSizeEl = Ext.DomHelper.append(document.body, {
- tag: "pre", cls: "x-form-grow-sizer"
- });
- if(this.preventScrollbars){
- this.el.setStyle("overflow", "hidden");
+ getGroupRows: function(group, records, preppedRecords, fullWidth) {
+ var me = this,
+ children = group.children,
+ rows = group.rows = [],
+ view = me.view;
+ group.viewId = view.id;
+
+ Ext.Array.each(records, function(record, idx) {
+ if (Ext.Array.indexOf(children, record) != -1) {
+ rows.push(Ext.apply(preppedRecords[idx], {
+ depth: 1
+ }));
}
- this.el.setHeight(this.growMin);
+ });
+ delete group.children;
+ group.fullWidth = fullWidth;
+ if (me.collapsedState[view.id + '-gp-' + group.name]) {
+ group.collapsedCls = me.collapsedCls;
+ group.hdCollapsedCls = me.hdCollapsedCls;
}
- },
- onDestroy : function(){
- Ext.removeNode(this.textSizeEl);
- Ext.form.TextArea.superclass.onDestroy.call(this);
+ return group;
},
- fireKey : function(e){
- if(e.isSpecialKey() && (this.enterIsSpecial || (e.getKey() != e.ENTER || e.hasModifier()))){
- this.fireEvent("specialkey", this, e);
+
+ collectData: function(records, preppedRecords, startIndex, fullWidth, o) {
+ var me = this,
+ store = me.view.store,
+ groups;
+
+ if (!me.disabled && store.isGrouped()) {
+ groups = store.getGroups();
+ Ext.Array.each(groups, function(group, idx){
+ me.getGroupRows(group, records, preppedRecords, fullWidth);
+ }, me);
+ return {
+ rows: groups,
+ fullWidth: fullWidth
+ };
}
+ return o;
},
- doAutoSize : function(e){
- return !e.isNavKeyPress() || e.getKey() == e.ENTER;
- },
- filterValidation: function(e) {
- if(!e.isNavKeyPress() || (!this.enterIsSpecial && e.keyCode == e.ENTER)){
- this.validationTask.delay(this.validationDelay);
- }
- },
-
- autoSize: function(){
- if(!this.grow || !this.textSizeEl){
- return;
- }
- var el = this.el,
- v = Ext.util.Format.htmlEncode(el.dom.value),
- ts = this.textSizeEl,
- h;
-
- Ext.fly(ts).setWidth(this.el.getWidth());
- if(v.length < 1){
- v = " ";
- }else{
- v += this.growAppend;
- if(Ext.isIE){
- v = v.replace(/\n/g, '
'); - } - } - ts.innerHTML = v; - h = Math.min(this.growMax, Math.max(ts.offsetHeight, this.growMin)); - if(h != this.lastHeight){ - this.lastHeight = h; - this.el.setHeight(h); - this.fireEvent("autosize", this, h); - } + getFireEventArgs: function(type, view, featureTarget) { + var returnArray = [type, view, featureTarget], + groupBd = Ext.fly(featureTarget.nextSibling, '_grouping'), + groupBdId = Ext.getDom(groupBd).id, + prefix = view.id + '-gp-', + groupName = groupBdId.substr(prefix.length); + + returnArray.push(groupName); + + return returnArray; } }); -Ext.reg('textarea', Ext.form.TextArea); -Ext.form.NumberField = Ext.extend(Ext.form.TextField, { - - - - fieldClass: "x-form-field x-form-num-field", - - - allowDecimals : true, - - - decimalSeparator : ".", - + + +Ext.define('Ext.grid.feature.GroupingSummary', { - decimalPrecision : 2, - allowNegative : true, + extend: 'Ext.grid.feature.Grouping', + alias: 'feature.groupingsummary', - minValue : Number.NEGATIVE_INFINITY, + mixins: { + summary: 'Ext.grid.feature.AbstractSummary' + }, - maxValue : Number.MAX_VALUE, + + + + getFeatureTpl: function() { + var tpl = this.callParent(arguments); + + if (this.showSummaryRow) { + + tpl = tpl.replace('', ''); + tpl += '{[this.printSummaryRow(xindex)]}'; + } + return tpl; + }, - minText : "The minimum value for this field is {0}", + getFragmentTpl: function() { + var me = this, + fragments = me.callParent(); + + Ext.apply(fragments, me.getSummaryFragments()); + if (me.showSummaryRow) { + + me.summaryGroups = me.view.store.getGroups(); + me.summaryData = me.generateSummaryData(); + } + return fragments; + }, - maxText : "The maximum value for this field is {0}", + getPrintData: function(index){ + var me = this, + columns = me.view.headerCt.getColumnsForTpl(), + i = 0, + length = columns.length, + data = [], + name = me.summaryGroups[index - 1].name, + active = me.summaryData[name], + column; + + for (; i < length; ++i) { + column = columns[i]; + column.gridSummaryValue = this.getColumnValue(column, active); + data.push(column); + } + return data; + }, - nanText : "{0} is not a valid number", + generateSummaryData: function(){ + var me = this, + data = {}, + remoteData = {}, + store = me.view.store, + groupField = this.getGroupField(), + reader = store.proxy.reader, + groups = me.summaryGroups, + columns = me.view.headerCt.getColumnsForTpl(), + i, + length, + fieldData, + root, + key, + comp; + + for (i = 0, length = groups.length; i < length; ++i) { + data[groups[i].name] = {}; + } + + if (me.remoteRoot && reader.rawData) { + + root = reader.root; + reader.root = me.remoteRoot; + reader.buildExtractors(true); + Ext.Array.each(reader.getRoot(reader.rawData), function(value) { + data[value[groupField]] = value; + data[value[groupField]]._remote = true; + }); + + reader.root = root; + reader.buildExtractors(true); + } + + for (i = 0, length = columns.length; i < length; ++i) { + comp = Ext.getCmp(columns[i].id); + fieldData = me.getSummary(store, comp.summaryType, comp.dataIndex, true); + + for (key in fieldData) { + if (fieldData.hasOwnProperty(key)) { + if (!data[key]._remote) { + data[key][comp.dataIndex] = fieldData[key]; + } + } + } + } + return data; + } +}); + + +Ext.define('Ext.grid.feature.RowBody', { + extend: 'Ext.grid.feature.Feature', + alias: 'feature.rowbody', + rowBodyHiddenCls: Ext.baseCSSPrefix + 'grid-row-body-hidden', + rowBodyTrCls: Ext.baseCSSPrefix + 'grid-rowbody-tr', + rowBodyTdCls: Ext.baseCSSPrefix + 'grid-cell-rowbody', + rowBodyDivCls: Ext.baseCSSPrefix + 'grid-rowbody', + + eventPrefix: 'rowbody', + eventSelector: '.' + Ext.baseCSSPrefix + 'grid-rowbody-tr', - baseChars : "0123456789", + getRowBody: function(values) { + return [ + ' ',
+ '',
+ ' ',
+ ' '
+ ].join('');
+ },
- autoStripChars: false,
+ getMetaRowTplFragments: function() {
+ return {
+ getRowBody: this.getRowBody,
+ rowBodyTrCls: this.rowBodyTrCls,
+ rowBodyTdCls: this.rowBodyTdCls,
+ rowBodyDivCls: this.rowBodyDivCls
+ };
+ },
-
- initEvents : function() {
- var allowed = this.baseChars + '';
- if (this.allowDecimals) {
- allowed += this.decimalSeparator;
- }
- if (this.allowNegative) {
- allowed += '-';
- }
- allowed = Ext.escapeRe(allowed);
- this.maskRe = new RegExp('[' + allowed + ']');
- if (this.autoStripChars) {
- this.stripCharsRe = new RegExp('[^' + allowed + ']', 'gi');
- }
-
- Ext.form.NumberField.superclass.initEvents.call(this);
+ mutateMetaRowTpl: function(metaRowTpl) {
+ metaRowTpl.push('{[this.getRowBody(values)]}');
},
+
+ getAdditionalData: function(data, idx, record, orig) {
+ var headerCt = this.view.headerCt,
+ colspan = headerCt.getColumnCount();
+
+ return {
+ rowBody: "",
+ rowBodyCls: this.rowBodyCls,
+ rowBodyColspan: colspan
+ };
+ }
+});
+
+Ext.define('Ext.grid.feature.RowWrap', {
+ extend: 'Ext.grid.feature.Feature',
+ alias: 'feature.rowwrap',
+
- getErrors: function(value) {
- var errors = Ext.form.NumberField.superclass.getErrors.apply(this, arguments);
-
- value = Ext.isDefined(value) ? value : this.processValue(this.getRawValue());
+ hasFeatureEvent: false,
+
+ mutateMetaRowTpl: function(metaRowTpl) {
- if (value.length < 1) {
- return errors;
- }
- value = String(value).replace(this.decimalSeparator, ".");
+ metaRowTpl[0] = metaRowTpl[0].replace(Ext.baseCSSPrefix + 'grid-row', '');
+ metaRowTpl[0] = metaRowTpl[0].replace("{[this.embedRowCls()]}", "");
- if(isNaN(value)){
- errors.push(String.format(this.nanText, value));
- }
+ metaRowTpl.unshift('');
- var num = this.parseValue(value);
+ metaRowTpl.unshift('
');
- return errors;
- },
-
- getValue : function() {
- return this.fixPrecision(this.parseValue(Ext.form.NumberField.superclass.getValue.call(this)));
- },
-
- setValue : function(v) {
- v = this.fixPrecision(v);
- v = Ext.isNumber(v) ? v : parseFloat(String(v).replace(this.decimalSeparator, "."));
- v = isNaN(v) ? '' : String(v).replace(".", this.decimalSeparator);
- return Ext.form.NumberField.superclass.setValue.call(this, v);
+ metaRowTpl.push('
');
},
-
- setMinValue : function(value) {
- this.minValue = Ext.num(value, Number.NEGATIVE_INFINITY);
+ embedColSpan: function() {
+ return '{colspan}';
},
-
- setMaxValue : function(value) {
- this.maxValue = Ext.num(value, Number.MAX_VALUE);
+ embedFullWidth: function() {
+ return '{fullWidth}';
},
-
- parseValue : function(value) {
- value = parseFloat(String(value).replace(this.decimalSeparator, "."));
- return isNaN(value) ? '' : value;
- },
+ getAdditionalData: function(data, idx, record, orig) {
+ var headerCt = this.view.headerCt,
+ colspan = headerCt.getColumnCount(),
+ fullWidth = headerCt.getFullWidth(),
+ items = headerCt.query('gridcolumn'),
+ itemsLn = items.length,
+ i = 0,
+ o = {
+ colspan: colspan,
+ fullWidth: fullWidth
+ },
+ id,
+ tdClsKey,
+ colResizerCls;
-
- fixPrecision : function(value) {
- var nan = isNaN(value);
-
- if (!this.allowDecimals || this.decimalPrecision == -1 || nan || !value) {
- return nan ? '' : value;
+ for (; i < itemsLn; i++) {
+ id = items[i].id;
+ tdClsKey = id + '-tdCls';
+ colResizerCls = Ext.baseCSSPrefix + 'grid-col-resizer-'+id;
+
+
+
+ o[tdClsKey] = colResizerCls + " " + (orig[tdClsKey] ? orig[tdClsKey] : '');
+
+ o[id+'-tdAttr'] = " style=\"width: " + (items[i].hidden ? 0 : items[i].getDesiredWidth()) + "px;\" ";
+ if (orig[id+'-tdAttr']) {
+ o[id+'-tdAttr'] += orig[id+'-tdAttr'];
+ }
+
}
-
- return parseFloat(parseFloat(value).toFixed(this.decimalPrecision));
- },
- beforeBlur : function() {
- var v = this.parseValue(this.getRawValue());
-
- if (!Ext.isEmpty(v)) {
- this.setValue(v);
- }
+ return o;
+ },
+
+ getMetaRowTplFragments: function() {
+ return {
+ embedFullWidth: this.embedFullWidth,
+ embedColSpan: this.embedColSpan
+ };
}
+
});
-Ext.reg('numberfield', Ext.form.NumberField);
-
-Ext.form.DateField = Ext.extend(Ext.form.TriggerField, {
-
- format : "m/d/Y",
+Ext.define('Ext.grid.feature.Summary', {
- altFormats : "m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d|n-j|n/j",
- disabledDaysText : "Disabled",
- disabledDatesText : "Disabled",
+ extend: 'Ext.grid.feature.AbstractSummary',
- minText : "The date in this field must be equal to or after {0}",
+ alias: 'feature.summary',
- maxText : "The date in this field must be equal to or before {0}",
- invalidText : "{0} is not a valid date - it must be in the format {1}",
- triggerClass : 'x-form-date-trigger',
- showToday : true,
+ getFragmentTpl: function() {
+
+ this.summaryData = this.generateSummaryData();
+ return this.getSummaryFragments();
+ },
- startDay : 0,
+ getTableFragments: function(){
+ if (this.showSummaryRow) {
+ return {
+ closeRows: this.closeRows
+ };
+ }
+ },
+ closeRows: function() {
+ return '{[this.printSummaryRow()]}';
+ },
+ getPrintData: function(index){
+ var me = this,
+ columns = me.view.headerCt.getColumnsForTpl(),
+ i = 0,
+ length = columns.length,
+ data = [],
+ active = me.summaryData,
+ column;
+
+ for (; i < length; ++i) {
+ column = columns[i];
+ column.gridSummaryValue = this.getColumnValue(column, active);
+ data.push(column);
+ }
+ return data;
+ },
+ generateSummaryData: function(){
+ var me = this,
+ data = {},
+ store = me.view.store,
+ columns = me.view.headerCt.getColumnsForTpl(),
+ i = 0,
+ length = columns.length,
+ fieldData,
+ key,
+ comp;
+
+ for (i = 0, length = columns.length; i < length; ++i) {
+ comp = Ext.getCmp(columns[i].id);
+ data[comp.dataIndex] = me.getSummary(store, comp.summaryType, comp.dataIndex, false);
+ }
+ return data;
+ }
+});
+
+Ext.define('Ext.grid.header.DragZone', {
+ extend: 'Ext.dd.DragZone',
+ colHeaderCls: Ext.baseCSSPrefix + 'column-header',
+ maxProxyWidth: 120,
-
- defaultAutoCreate : {tag: "input", type: "text", size: "10", autocomplete: "off"},
+ constructor: function(headerCt) {
+ this.headerCt = headerCt;
+ this.ddGroup = this.getDDGroup();
+ this.callParent([headerCt.el]);
+ this.proxy.el.addCls(Ext.baseCSSPrefix + 'grid-col-dd');
+ },
+
+ getDDGroup: function() {
+ return 'header-dd-zone-' + this.headerCt.up('[scrollerOwner]').id;
+ },
+
+ getDragData: function(e) {
+ var header = e.getTarget('.'+this.colHeaderCls),
+ headerCmp;
+
+ if (header) {
+ headerCmp = Ext.getCmp(header.id);
+ if (!this.headerCt.dragging && headerCmp.draggable && !(headerCmp.isOnLeftEdge(e) || headerCmp.isOnRightEdge(e))) {
+ var ddel = document.createElement('div');
+ ddel.innerHTML = Ext.getCmp(header.id).text;
+ return {
+ ddel: ddel,
+ header: headerCmp
+ };
+ }
+ }
+ return false;
+ },
+
+ onBeforeDrag: function() {
+ return !(this.headerCt.dragging || this.disabled);
+ },
+
+ onInitDrag: function() {
+ this.headerCt.dragging = true;
+ this.callParent(arguments);
+ },
+ onDragDrop: function() {
+ this.headerCt.dragging = false;
+ this.callParent(arguments);
+ },
+
+ afterRepair: function() {
+ this.callParent();
+ this.headerCt.dragging = false;
+ },
+
+ getRepairXY: function() {
+ return this.dragData.header.el.getXY();
+ },
+ disable: function() {
+ this.disabled = true;
+ },
- initTime: '12',
+ enable: function() {
+ this.disabled = false;
+ }
+});
- initTimeFormat: 'H',
-
- safeParse : function(value, format) {
- if (/[gGhH]/.test(format.replace(/(\\.)/g, ''))) {
-
- return Date.parseDate(value, format);
- } else {
-
- var parsedDate = Date.parseDate(value + ' ' + this.initTime, format + ' ' + this.initTimeFormat);
+Ext.define('Ext.grid.header.DropZone', {
+ extend: 'Ext.dd.DropZone',
+ colHeaderCls: Ext.baseCSSPrefix + 'column-header',
+ proxyOffsets: [-4, -9],
- if (parsedDate) {
- return parsedDate.clearTime();
- }
- }
+ constructor: function(headerCt){
+ this.headerCt = headerCt;
+ this.ddGroup = this.getDDGroup();
+ this.callParent([headerCt.el]);
},
- initComponent : function(){
- Ext.form.DateField.superclass.initComponent.call(this);
+ getDDGroup: function() {
+ return 'header-dd-zone-' + this.headerCt.up('[scrollerOwner]').id;
+ },
- this.addEvents(
-
- 'select'
- );
+ getTargetFromEvent : function(e){
+ return e.getTarget('.' + this.colHeaderCls);
+ },
- if(Ext.isString(this.minValue)){
- this.minValue = this.parseDate(this.minValue);
+ getTopIndicator: function() {
+ if (!this.topIndicator) {
+ this.topIndicator = Ext.core.DomHelper.append(Ext.getBody(), {
+ cls: "col-move-top",
+ html: " "
+ }, true);
}
- if(Ext.isString(this.maxValue)){
- this.maxValue = this.parseDate(this.maxValue);
+ return this.topIndicator;
+ },
+
+ getBottomIndicator: function() {
+ if (!this.bottomIndicator) {
+ this.bottomIndicator = Ext.core.DomHelper.append(Ext.getBody(), {
+ cls: "col-move-bottom",
+ html: " "
+ }, true);
}
- this.disabledDatesRE = null;
- this.initDisabledDays();
+ return this.bottomIndicator;
},
- initEvents: function() {
- Ext.form.DateField.superclass.initEvents.call(this);
- this.keyNav = new Ext.KeyNav(this.el, {
- "down": function(e) {
- this.onTriggerClick();
- },
- scope: this,
- forceKeyDown: true
- });
+ getLocation: function(e, t) {
+ var x = e.getXY()[0],
+ region = Ext.fly(t).getRegion(),
+ pos, header;
+
+ if ((region.right - x) <= (region.right - region.left) / 2) {
+ pos = "after";
+ } else {
+ pos = "before";
+ }
+ return {
+ pos: pos,
+ header: Ext.getCmp(t.id),
+ node: t
+ };
},
+ positionIndicator: function(draggedHeader, node, e){
+ var location = this.getLocation(e, node),
+ header = location.header,
+ pos = location.pos,
+ nextHd = draggedHeader.nextSibling('gridcolumn:not([hidden])'),
+ prevHd = draggedHeader.previousSibling('gridcolumn:not([hidden])'),
+ region, topIndicator, bottomIndicator, topAnchor, bottomAnchor,
+ topXY, bottomXY, headerCtEl, minX, maxX;
-
- initDisabledDays : function(){
- if(this.disabledDates){
- var dd = this.disabledDates,
- len = dd.length - 1,
- re = "(?:";
+
+ if (!header.draggable && header.getIndex() == 0) {
+ return false;
+ }
- Ext.each(dd, function(d, i){
- re += Ext.isDate(d) ? '^' + Ext.escapeRe(d.dateFormat(this.format)) + '$' : dd[i];
- if(i != len){
- re += '|';
+ this.lastLocation = location;
+
+ if ((draggedHeader !== header) &&
+ ((pos === "before" && nextHd !== header) ||
+ (pos === "after" && prevHd !== header)) &&
+ !header.isDescendantOf(draggedHeader)) {
+
+
+
+
+ var allDropZones = Ext.dd.DragDropManager.getRelated(this),
+ ln = allDropZones.length,
+ i = 0,
+ dropZone;
+
+ for (; i < ln; i++) {
+ dropZone = allDropZones[i];
+ if (dropZone !== this && dropZone.invalidateDrop) {
+ dropZone.invalidateDrop();
}
- }, this);
- this.disabledDatesRE = new RegExp(re + ')');
+ }
+
+
+ this.valid = true;
+ topIndicator = this.getTopIndicator();
+ bottomIndicator = this.getBottomIndicator();
+ if (pos === 'before') {
+ topAnchor = 'tl';
+ bottomAnchor = 'bl';
+ } else {
+ topAnchor = 'tr';
+ bottomAnchor = 'br';
+ }
+ topXY = header.el.getAnchorXY(topAnchor);
+ bottomXY = header.el.getAnchorXY(bottomAnchor);
+
+
+ headerCtEl = this.headerCt.el;
+ minX = headerCtEl.getLeft();
+ maxX = headerCtEl.getRight();
+
+ topXY[0] = Ext.Number.constrain(topXY[0], minX, maxX);
+ bottomXY[0] = Ext.Number.constrain(bottomXY[0], minX, maxX);
+
+
+
+ topXY[0] -= 4;
+ topXY[1] -= 9;
+ bottomXY[0] -= 4;
+
+
+ topIndicator.setXY(topXY);
+ bottomIndicator.setXY(bottomXY);
+ topIndicator.show();
+ bottomIndicator.show();
+
+ } else {
+ this.invalidateDrop();
}
},
-
- setDisabledDates : function(dd){
- this.disabledDates = dd;
- this.initDisabledDays();
- if(this.menu){
- this.menu.picker.setDisabledDates(this.disabledDatesRE);
- }
+ invalidateDrop: function() {
+ this.valid = false;
+ this.hideIndicators();
},
-
- setDisabledDays : function(dd){
- this.disabledDays = dd;
- if(this.menu){
- this.menu.picker.setDisabledDays(dd);
+ onNodeOver: function(node, dragZone, e, data) {
+ if (data.header.el.dom !== node) {
+ this.positionIndicator(data.header, node, e);
}
+ return this.valid ? this.dropAllowed : this.dropNotAllowed;
},
-
- setMinValue : function(dt){
- this.minValue = (Ext.isString(dt) ? this.parseDate(dt) : dt);
- if(this.menu){
- this.menu.picker.setMinDate(this.minValue);
- }
+ hideIndicators: function() {
+ this.getTopIndicator().hide();
+ this.getBottomIndicator().hide();
},
-
- setMaxValue : function(dt){
- this.maxValue = (Ext.isString(dt) ? this.parseDate(dt) : dt);
- if(this.menu){
- this.menu.picker.setMaxDate(this.maxValue);
- }
+ onNodeOut: function() {
+ this.hideIndicators();
},
-
- getErrors: function(value) {
- var errors = Ext.form.DateField.superclass.getErrors.apply(this, arguments);
+ onNodeDrop: function(node, dragZone, e, data) {
+ if (this.valid) {
+ this.invalidateDrop();
+ var hd = data.header,
+ lastLocation = this.lastLocation,
+ fromCt = hd.ownerCt,
+ fromIdx = fromCt.items.indexOf(hd),
+ toCt = lastLocation.header.ownerCt,
+ toIdx = toCt.items.indexOf(lastLocation.header),
+ headerCt = this.headerCt,
+ groupCt,
+ scrollerOwner;
- value = this.formatDate(value || this.processValue(this.getRawValue()));
+ if (lastLocation.pos === 'after') {
+ toIdx++;
+ }
- if (value.length < 1) {
- return errors;
- }
+
+
+
+ if (fromCt !== toCt && fromCt.lockableInjected && toCt.lockableInjected && toCt.lockedCt) {
+ scrollerOwner = fromCt.up('[scrollerOwner]');
+ scrollerOwner.lock(hd, toIdx);
+ } else if (fromCt !== toCt && fromCt.lockableInjected && toCt.lockableInjected && fromCt.lockedCt) {
+ scrollerOwner = fromCt.up('[scrollerOwner]');
+ scrollerOwner.unlock(hd, toIdx);
+ } else {
+
+
+ if ((fromCt === toCt) && (toIdx > fromCt.items.indexOf(hd))) {
+ toIdx--;
+ }
- var svalue = value;
- value = this.parseDate(value);
- if (!value) {
- errors.push(String.format(this.invalidText, svalue, this.format));
- return errors;
- }
+
+ if (fromCt !== toCt) {
+ fromCt.suspendLayout = true;
+ fromCt.remove(hd, false);
+ fromCt.suspendLayout = false;
+ }
- var time = value.getTime();
- if (this.minValue && time < this.minValue.clearTime().getTime()) {
- errors.push(String.format(this.minText, this.formatDate(this.minValue)));
- }
+
+ if (fromCt.isGroupHeader) {
+ if (!fromCt.items.getCount()) {
+ groupCt = fromCt.ownerCt;
+ groupCt.suspendLayout = true;
+ groupCt.remove(fromCt, false);
+ fromCt.el.dom.parentNode.removeChild(fromCt.el.dom);
+ groupCt.suspendLayout = false;
+ } else {
+ fromCt.minWidth = fromCt.getWidth() - hd.getWidth();
+ fromCt.setWidth(fromCt.minWidth);
+ }
+ }
- if (this.maxValue && time > this.maxValue.clearTime().getTime()) {
- errors.push(String.format(this.maxText, this.formatDate(this.maxValue)));
- }
+
+ toCt.suspendLayout = true;
+ if (fromCt === toCt) {
+ toCt.move(fromIdx, toIdx);
+ } else {
+ toCt.insert(toIdx, hd);
+ }
+ toCt.suspendLayout = false;
+
+
+
+
+ if (toCt.isGroupHeader) {
+ hd.savedFlex = hd.flex;
+ delete hd.flex;
+ hd.width = hd.getWidth();
+
+
+ toCt.minWidth = toCt.getWidth() + hd.getWidth() - (hd.savedFlex ? 1 : 0);
+ toCt.setWidth(toCt.minWidth);
+ } else {
+ if (hd.savedFlex) {
+ hd.flex = hd.savedFlex;
+ delete hd.width;
+ }
+ }
- if (this.disabledDays) {
- var day = value.getDay();
- for(var i = 0; i < this.disabledDays.length; i++) {
- if (day === this.disabledDays[i]) {
- errors.push(this.disabledDaysText);
- break;
+
+ headerCt.purgeCache();
+ headerCt.doLayout();
+ headerCt.onHeaderMoved(hd, fromIdx, toIdx);
+
+ if (!fromCt.items.getCount()) {
+ fromCt.destroy();
}
}
}
+ }
+});
- var fvalue = this.formatDate(value);
- if (this.disabledDatesRE && this.disabledDatesRE.test(fvalue)) {
- errors.push(String.format(this.disabledDatesText, fvalue));
- }
- return errors;
+
+Ext.define('Ext.grid.plugin.Editing', {
+ alias: 'editing.editing',
+
+ requires: [
+ 'Ext.grid.column.Column',
+ 'Ext.util.KeyNav'
+ ],
+
+ mixins: {
+ observable: 'Ext.util.Observable'
},
+ clicksToEdit: 2,
+
- validateBlur : function(){
- return !this.menu || !this.menu.isVisible();
- },
+ defaultFieldXType: 'textfield',
- getValue : function(){
- return this.parseDate(Ext.form.DateField.superclass.getValue.call(this)) || "";
+ editStyle: '',
+
+ constructor: function(config) {
+ var me = this;
+ Ext.apply(me, config);
+
+ me.addEvents(
+
+ 'beforeedit',
+
+
+ 'edit',
+
+
+ 'validateedit'
+ );
+ me.mixins.observable.constructor.call(me);
+
+ me.relayEvents(me, ['afteredit'], 'after');
},
- setValue : function(date){
- return Ext.form.DateField.superclass.setValue.call(this, this.formatDate(this.parseDate(date)));
+ init: function(grid) {
+ var me = this;
+
+ me.grid = grid;
+ me.view = grid.view;
+ me.initEvents();
+ me.initFieldAccessors(me.view.getGridColumns());
+
+ grid.relayEvents(me, ['beforeedit', 'edit', 'validateedit']);
+
+
+ grid.isEditable = true;
+ grid.editingPlugin = grid.view.editingPlugin = me;
},
- parseDate : function(value) {
- if(!value || Ext.isDate(value)){
- return value;
- }
+ destroy: function() {
+ var me = this,
+ grid = me.grid,
+ headerCt = grid.headerCt,
+ events = grid.events;
- var v = this.safeParse(value, this.format),
- af = this.altFormats,
- afa = this.altFormatsArray;
+ Ext.destroy(me.keyNav);
+ me.removeFieldAccessors(grid.getView().getGridColumns());
- if (!v && af) {
- afa = afa || af.split("|");
+
+ me.clearListeners();
- for (var i = 0, len = afa.length; i < len && !v; i++) {
- v = this.safeParse(value, afa[i]);
- }
- }
- return v;
+ delete me.grid.editingPlugin;
+ delete me.grid.view.editingPlugin;
+ delete me.grid;
+ delete me.view;
+ delete me.editor;
+ delete me.keyNav;
},
- onDestroy : function(){
- Ext.destroy(this.menu, this.keyNav);
- Ext.form.DateField.superclass.onDestroy.call(this);
+ getEditStyle: function() {
+ return this.editStyle;
},
- formatDate : function(date){
- return Ext.isDate(date) ? date.dateFormat(this.format) : date;
+ initFieldAccessors: function(column) {
+ var me = this;
+
+ if (Ext.isArray(column)) {
+ Ext.Array.forEach(column, me.initFieldAccessors, me);
+ return;
+ }
+
+
+
+ Ext.applyIf(column, {
+ getEditor: function(record, defaultField) {
+ return me.getColumnField(this, defaultField);
+ },
+
+ setEditor: function(field) {
+ me.setColumnField(this, field);
+ }
+ });
},
+ removeFieldAccessors: function(column) {
+ var me = this;
+
+ if (Ext.isArray(column)) {
+ Ext.Array.forEach(column, me.removeFieldAccessors, me);
+ return;
+ }
+
+ delete column.getEditor;
+ delete column.setEditor;
+ },
+
- onTriggerClick : function(){
- if(this.disabled){
- return;
+ getColumnField: function(columnHeader, defaultField) {
+ var field = columnHeader.field;
+
+ if (!field && columnHeader.editor) {
+ field = columnHeader.editor;
+ delete columnHeader.editor;
}
- if(this.menu == null){
- this.menu = new Ext.menu.DateMenu({
- hideOnClick: false,
- focusOnSelect: false
+
+ if (!field && defaultField) {
+ field = defaultField;
+ }
+
+ if (field) {
+ if (Ext.isString(field)) {
+ field = { xtype: field };
+ }
+ if (Ext.isObject(field) && !field.isFormField) {
+ field = Ext.ComponentManager.create(field, this.defaultFieldXType);
+ columnHeader.field = field;
+ }
+
+ Ext.apply(field, {
+ name: columnHeader.dataIndex
});
+
+ return field;
}
- 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);
+
+ setColumnField: function(column, field) {
+ if (Ext.isObject(field) && !field.isFormField) {
+ field = Ext.ComponentManager.create(field, this.defaultFieldXType);
+ }
+ column.field = field;
},
- onSelect: function(m, d){
- this.setValue(d);
- this.fireEvent('select', this, d);
- this.menu.hide();
+
+ initEvents: function() {
+ var me = this;
+ me.initEditTriggers();
+ me.initCancelTriggers();
},
- onMenuHide: function(){
- this.focus(false, 60);
- this.menuEvents('un');
+
+ initCancelTriggers: Ext.emptyFn,
+
+
+ initEditTriggers: function() {
+ var me = this,
+ view = me.view,
+ clickEvent = me.clicksToEdit === 1 ? 'click' : 'dblclick';
+
+
+ me.mon(view, 'cell' + clickEvent, me.startEditByClick, me);
+ view.on('render', function() {
+ me.keyNav = Ext.create('Ext.util.KeyNav', view.el, {
+ enter: me.onEnterKey,
+ esc: me.onEscKey,
+ scope: me
+ });
+ }, me, { single: true });
},
- beforeBlur : function(){
- var v = this.parseDate(this.getRawValue());
- if(v){
- this.setValue(v);
+ onEnterKey: function(e) {
+ var me = this,
+ grid = me.grid,
+ selModel = grid.getSelectionModel(),
+ record,
+ columnHeader = grid.headerCt.getHeaderAtIndex(0);
+
+
+
+ if (selModel.getCurrentPosition) {
+ pos = selModel.getCurrentPosition();
+ record = grid.store.getAt(pos.row);
+ columnHeader = grid.headerCt.getHeaderAtIndex(pos.column);
}
- }
+
+ else {
+ record = selModel.getLastSelected();
+ }
+ me.startEdit(record, columnHeader);
+ },
-
-
-
-});
-Ext.reg('datefield', Ext.form.DateField);
+ onEscKey: function(e) {
+ this.cancelEdit();
+ },
-Ext.form.DisplayField = Ext.extend(Ext.form.Field, {
- validationEvent : false,
- validateOnBlur : false,
- defaultAutoCreate : {tag: "div"},
- fieldClass : "x-form-display-field",
+ startEditByClick: function(view, cell, colIdx, record, row, rowIdx, e) {
+ this.startEdit(record, view.getHeaderAtIndex(colIdx));
+ },
+
- htmlEncode: false,
+ beforeEdit: Ext.emptyFn,
- initEvents : Ext.emptyFn,
+ startEdit: function(record, columnHeader) {
+ var me = this,
+ context = me.getEditingContext(record, columnHeader);
- isValid : function(){
- return true;
- },
+ if (me.beforeEdit(context) === false || me.fireEvent('beforeedit', context) === false || context.cancel) {
+ return false;
+ }
- validate : function(){
- return true;
+ me.context = context;
+ me.editing = true;
},
- getRawValue : function(){
- var v = this.rendered ? this.el.dom.innerHTML : Ext.value(this.value, '');
- if(v === this.emptyText){
- v = '';
+
+ getEditingContext: function(record, columnHeader) {
+ var me = this,
+ grid = me.grid,
+ store = grid.store,
+ rowIdx,
+ colIdx,
+ view = grid.getView(),
+ value;
+
+
+ if (Ext.isNumber(record)) {
+ rowIdx = record;
+ record = store.getAt(rowIdx);
+ } else {
+ rowIdx = store.indexOf(record);
}
- if(this.htmlEncode){
- v = Ext.util.Format.htmlDecode(v);
+ if (Ext.isNumber(columnHeader)) {
+ colIdx = columnHeader;
+ columnHeader = grid.headerCt.getHeaderAtIndex(colIdx);
+ } else {
+ colIdx = columnHeader.getIndex();
}
- return v;
- },
- getValue : function(){
- return this.getRawValue();
+ value = record.get(columnHeader.dataIndex);
+ return {
+ grid: grid,
+ record: record,
+ field: columnHeader.dataIndex,
+ value: value,
+ row: view.getNode(rowIdx),
+ column: columnHeader,
+ rowIdx: rowIdx,
+ colIdx: colIdx
+ };
},
+
- getName: function() {
- return this.name;
+ cancelEdit: function() {
+ this.editing = false;
},
- setRawValue : function(v){
- if(this.htmlEncode){
- v = Ext.util.Format.htmlEncode(v);
+
+ completeEdit: function() {
+ var me = this;
+
+ if (me.editing && me.validateEdit()) {
+ me.fireEvent('edit', me.context);
}
- return this.rendered ? (this.el.dom.innerHTML = (Ext.isEmpty(v) ? '' : v)) : (this.value = v);
+
+ delete me.context;
+ me.editing = false;
},
- setValue : function(v){
- this.setRawValue(v);
- return this;
- }
-
-
-
-
-
+ validateEdit: function() {
+ var me = this,
+ context = me.context;
+
+ return me.fireEvent('validateedit', me, context) !== false && !context.cancel;
+ }
});
-Ext.reg('displayfield', Ext.form.DisplayField);
+Ext.define('Ext.grid.plugin.CellEditing', {
+ alias: 'plugin.cellediting',
+ extend: 'Ext.grid.plugin.Editing',
+ requires: ['Ext.grid.CellEditor'],
-Ext.form.ComboBox = Ext.extend(Ext.form.TriggerField, {
-
-
-
-
-
+ constructor: function() {
+
+
+
+ this.callParent(arguments);
+ this.editors = Ext.create('Ext.util.MixedCollection', false, function(editor) {
+ return editor.editorId;
+ });
+ },
- defaultAutoCreate : {tag: "input", type: "text", size: "24", autocomplete: "off"},
-
-
-
-
-
-
-
- listClass : '',
-
- selectedClass : 'x-combo-selected',
-
- listEmptyText: '',
-
- triggerClass : 'x-form-arrow-trigger',
-
- shadow : 'sides',
-
- listAlign : 'tl-bl?',
-
- maxHeight : 300,
-
- minHeight : 90,
-
- triggerAction : 'query',
-
- minChars : 4,
-
- autoSelect : true,
-
- typeAhead : false,
-
- queryDelay : 500,
-
- pageSize : 0,
-
- selectOnFocus : false,
-
- queryParam : 'query',
-
- loadingText : 'Loading...',
-
- resizable : false,
-
- handleHeight : 8,
-
- allQuery: '',
-
- mode: 'remote',
-
- minListWidth : 70,
-
- forceSelection : false,
+ destroy: function() {
+ var me = this;
+ me.editors.each(Ext.destroy, Ext);
+ me.editors.clear();
+ me.callParent(arguments);
+ },
+
- typeAheadDelay : 250,
+ initCancelTriggers: function() {
+ var me = this;
+ grid = me.grid,
+ view = grid.view;
-
- lazyInit : true,
+ me.mon(view, {
+ mousewheel: {
+ element: 'el',
+ fn: me.cancelEdit,
+ scope: me
+ }
+ });
+ me.mon(grid, {
+ columnresize: me.cancelEdit,
+ columnmove: me.cancelEdit,
+ scope: me
+ });
+ },
- clearFilterOnReset : true,
+ startEdit: function(record, columnHeader) {
+ var me = this,
+ ed = me.getEditor(record, columnHeader),
+ value = record.get(columnHeader.dataIndex),
+ context = me.getEditingContext(record, columnHeader);
-
- submitValue: undefined,
+ record = context.record;
+ columnHeader = context.column;
-
+
+
+ me.completeEdit();
+
+
+ if (columnHeader && !columnHeader.getEditor(record)) {
+ return false;
+ }
+
+ if (ed) {
+ context.originalValue = context.value = value;
+ if (me.beforeEdit(context) === false || me.fireEvent('beforeedit', context) === false || context.cancel) {
+ return false;
+ }
+
+ me.context = context;
+ me.setActiveEditor(ed);
+ me.setActiveRecord(record);
+ me.setActiveColumn(columnHeader);
-
- initComponent : function(){
- Ext.form.ComboBox.superclass.initComponent.call(this);
- this.addEvents(
- 'expand',
+ Ext.defer(ed.startEdit, 15, ed, [me.getCell(record, columnHeader), value]);
+ } else {
- 'collapse',
-
- 'beforeselect',
- 'select',
- 'beforequery'
- );
- if(this.transform){
- var s = Ext.getDom(this.transform);
- if(!this.hiddenName){
- this.hiddenName = s.name;
- }
- if(!this.store){
- this.mode = 'local';
- var d = [], opts = s.options;
- for(var i = 0, len = opts.length;i < len; i++){
- var o = opts[i],
- value = (o.hasAttribute ? o.hasAttribute('value') : o.getAttributeNode('value').specified) ? o.value : o.text;
- if(o.selected && Ext.isEmpty(this.value, true)) {
- this.value = value;
- }
- d.push([value, o.text]);
- }
- this.store = new Ext.data.ArrayStore({
- idIndex: 0,
- fields: ['value', 'text'],
- data : d,
- autoDestroy: true
- });
- this.valueField = 'value';
- this.displayField = 'text';
- }
- s.name = Ext.id();
- if(!this.lazyRender){
- this.target = true;
- this.el = Ext.DomHelper.insertBefore(s, this.autoCreate || this.defaultAutoCreate);
- this.render(this.el.parentNode, s);
- }
- Ext.removeNode(s);
- }
-
- else if(this.store){
- this.store = Ext.StoreMgr.lookup(this.store);
- if(this.store.autoCreated){
- this.displayField = this.valueField = 'field1';
- if(!this.store.expandData){
- this.displayField = 'field2';
- }
- this.mode = 'local';
- }
+ me.grid.getView().el.focus((Ext.isWebKit || Ext.isIE) ? 10 : false);
}
+ },
- this.selectedIndex = -1;
- if(this.mode == 'local'){
- if(!Ext.isDefined(this.initialConfig.queryDelay)){
- this.queryDelay = 10;
- }
- if(!Ext.isDefined(this.initialConfig.minChars)){
- this.minChars = 0;
- }
+ completeEdit: function() {
+ var activeEd = this.getActiveEditor();
+ if (activeEd) {
+ activeEd.completeEdit();
}
},
- onRender : function(ct, position){
- if(this.hiddenName && !Ext.isDefined(this.submitValue)){
- this.submitValue = false;
- }
- Ext.form.ComboBox.superclass.onRender.call(this, ct, position);
- if(this.hiddenName){
- this.hiddenField = this.el.insertSibling({tag:'input', type:'hidden', name: this.hiddenName,
- id: (this.hiddenId || Ext.id())}, 'before', true);
-
- }
- if(Ext.isGecko){
- this.el.dom.setAttribute('autocomplete', 'off');
- }
+ setActiveEditor: function(ed) {
+ this.activeEditor = ed;
+ },
- if(!this.lazyInit){
- this.initList();
- }else{
- this.on('focus', this.initList, this, {single: true});
- }
+ getActiveEditor: function() {
+ return this.activeEditor;
},
-
- initValue : function(){
- Ext.form.ComboBox.superclass.initValue.call(this);
- if(this.hiddenField){
- this.hiddenField.value =
- Ext.value(Ext.isDefined(this.hiddenValue) ? this.hiddenValue : this.value, '');
- }
+ setActiveColumn: function(column) {
+ this.activeColumn = column;
},
- getParentZIndex : function(){
- var zindex;
- if (this.ownerCt){
- this.findParentBy(function(ct){
- zindex = parseInt(ct.getPositionEl().getStyle('z-index'), 10);
- return !!zindex;
- });
- }
- return zindex;
+ getActiveColumn: function() {
+ return this.activeColumn;
},
-
- getZIndex : function(listParent){
- listParent = listParent || Ext.getDom(this.getListParent() || Ext.getBody());
- var zindex = parseInt(Ext.fly(listParent).getStyle('z-index'), 10);
- if(!zindex){
- zindex = this.getParentZIndex();
- }
- return (zindex || 12000) + 5;
+
+ setActiveRecord: function(record) {
+ this.activeRecord = record;
},
-
- initList : function(){
- if(!this.list){
- var cls = 'x-combo-list',
- listParent = Ext.getDom(this.getListParent() || Ext.getBody());
+ getActiveRecord: function() {
+ return this.activeRecord;
+ },
- this.list = new Ext.Layer({
- parentEl: listParent,
- shadow: this.shadow,
- cls: [cls, this.listClass].join(' '),
- constrain:false,
- zindex: this.getZIndex(listParent)
- });
+ getEditor: function(record, column) {
+ var editors = this.editors,
+ editorId = column.itemId || column.id,
+ editor = editors.getByKey(editorId);
- var lw = this.listWidth || Math.max(this.wrap.getWidth(), this.minListWidth);
- this.list.setSize(lw, 0);
- this.list.swallowEvent('mousewheel');
- this.assetHeight = 0;
- if(this.syncFont !== false){
- this.list.setStyle('font-size', this.el.getStyle('font-size'));
- }
- if(this.title){
- this.header = this.list.createChild({cls:cls+'-hd', html: this.title});
- this.assetHeight += this.header.getHeight();
+ if (editor) {
+ return editor;
+ } else {
+ editor = column.getEditor(record);
+ if (!editor) {
+ return false;
}
- this.innerList = this.list.createChild({cls:cls+'-inner'});
- this.mon(this.innerList, 'mouseover', this.onViewOver, this);
- this.mon(this.innerList, 'mousemove', this.onViewMove, this);
- this.innerList.setWidth(lw - this.list.getFrameWidth('lr'));
-
- if(this.pageSize){
- this.footer = this.list.createChild({cls:cls+'-ft'});
- this.pageTb = new Ext.PagingToolbar({
- store: this.store,
- pageSize: this.pageSize,
- renderTo:this.footer
+
+ if (!(editor instanceof Ext.grid.CellEditor)) {
+ editor = Ext.create('Ext.grid.CellEditor', {
+ editorId: editorId,
+ field: editor
});
- this.assetHeight += this.footer.getHeight();
- }
-
- if(!this.tpl){
-
- this.tpl = '
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
-sayHi('Fred'); // alerts "Hi, Fred"
+Ext.define('Ext.chart.Label', {
-// create a new function that validates input without
-// directly modifying the original function:
-var sayHiToFriend = Ext.createInterceptor(sayHi, function(name){
- return name == 'Brian';
-});
+
-sayHiToFriend('Fred'); // no alert
-sayHiToFriend('Brian'); // alerts "Hi, Brian"
- this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- */
- createInterceptor: function(origFn, newFn, scope) {
- var method = origFn;
- if (!Ext.isFunction(newFn)) {
- return origFn;
- }
- else {
- return function() {
- var me = this,
- args = arguments;
- newFn.target = me;
- newFn.method = origFn;
- return (newFn.apply(scope || me || window, args) !== false) ?
- origFn.apply(me || window, args) :
- null;
- };
- }
- },
+ requires: ['Ext.draw.Color'],
+
+
- /**
- * Creates a delegate (callback) that sets the scope to obj.
- * Call directly on any function. Example: Ext.createDelegate(this.myFunction, this, [arg1, arg2])
- * Will create a function that is automatically scoped to obj so that the this variable inside the
- * callback points to obj. Example usage:
- *
-var sayHi = function(name){
- // Note this use of "this.text" here. This function expects to
- // execute within a scope that contains a text property. In this
- // example, the "this" variable is pointing to the btn object that
- // was passed in createDelegate below.
- alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');
-}
+
-var btn = new Ext.Button({
- text: 'Say Hi',
- renderTo: Ext.getBody()
-});
-
-// This callback will execute in the scope of the
-// button instance. Clicking the button alerts
-// "Hi, Fred. You clicked the "Say Hi" button."
-btn.on('click', Ext.createDelegate(sayHi, btn, ['Fred']));
- this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Function} The new function
- */
- createDelegate: function(fn, obj, args, appendArgs) {
- if (!Ext.isFunction(fn)) {
- return fn;
- }
- return function() {
- var callArgs = args || arguments;
- if (appendArgs === true) {
- callArgs = Array.prototype.slice.call(arguments, 0);
- callArgs = callArgs.concat(args);
- }
- else if (Ext.isNumber(appendArgs)) {
- callArgs = Array.prototype.slice.call(arguments, 0);
- // copy arguments first
- var applyArgs = [appendArgs, 0].concat(args);
- // create method call params
- Array.prototype.splice.apply(callArgs, applyArgs);
- // splice them in
- }
- return fn.apply(obj || window, callArgs);
- };
- },
+
- /**
- * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
- *
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
+
-// executes immediately:
-sayHi('Fred');
-
-// executes after 2 seconds:
-Ext.defer(sayHi, 2000, this, ['Fred']);
-
-// this syntax is sometimes useful for deferring
-// execution of an anonymous function:
-Ext.defer(function(){
- alert('Anonymous');
-}, 100);
- this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Number} The timeout id that can be used with clearTimeout
- */
- defer: function(fn, millis, obj, args, appendArgs) {
- fn = Ext.util.Functions.createDelegate(fn, obj, args, appendArgs);
- if (millis > 0) {
- return setTimeout(fn, millis);
- }
- fn();
- return 0;
- },
+
+
- /**
- * Create a combined function call sequence of the original function + the passed function.
- * The resulting function returns the results of the original function.
- * The passed fcn is called with the parameters of the original function. Example usage:
- *
+
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
+
-sayHi('Fred'); // alerts "Hi, Fred"
+ //@private a regex to parse url type colors.
-var sayGoodbye = Ext.createSequence(sayHi, function(name){
- alert('Bye, ' + name);
-});
+ colorStringRe: /url\s*\(\s*#([^\/)]+)\s*\)/,
+
+ //@private the mixin constructor. Used internally by Series.
-sayGoodbye('Fred'); // both alerts show
+ constructor: function(config) {
+ var me = this;
+ me.label = Ext.applyIf(me.label || {},
+ {
+ display: "none",
+ color: "#000",
+ field: "name",
+ minMargin: 50,
+ font: "11px Helvetica, sans-serif",
+ orientation: "horizontal",
+ renderer: function(v) {
+ return v;
+ }
+ });
- * @param {Function} origFn The original function.
- * @param {Function} newFn The function to sequence
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- */
- createSequence: function(origFn, newFn, scope) {
- if (!Ext.isFunction(newFn)) {
- return origFn;
- }
- else {
- return function() {
- var retval = origFn.apply(this || window, arguments);
- newFn.apply(scope || this || window, arguments);
- return retval;
- };
+ if (me.label.display !== 'none') {
+ me.labelsGroup = me.chart.surface.getGroup(me.seriesId + '-labels');
}
- }
-};
-
-/**
- * Shorthand for {@link Ext.util.Functions#defer}
- * @param {Function} fn The function to defer.
- * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Number} The timeout id that can be used with clearTimeout
- * @member Ext
- * @method defer
- */
-
-Ext.defer = Ext.util.Functions.defer;
+ },
-/**
- * Shorthand for {@link Ext.util.Functions#createInterceptor}
- * @param {Function} origFn The original function.
- * @param {Function} newFn The function to call before the original
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- * @member Ext
- * @method defer
- */
+ //@private a method to render all labels in the labelGroup
-Ext.createInterceptor = Ext.util.Functions.createInterceptor;
+ renderLabels: function() {
+ var me = this,
+ chart = me.chart,
+ gradients = chart.gradients,
+ gradient,
+ items = me.items,
+ animate = chart.animate,
+ config = me.label,
+ display = config.display,
+ color = config.color,
+ field = [].concat(config.field),
+ group = me.labelsGroup,
+ store = me.chart.store,
+ len = store.getCount(),
+ ratio = items.length / len,
+ i, count, j,
+ k, gradientsCount = (gradients || 0) && gradients.length,
+ colorStopTotal, colorStopIndex, colorStop,
+ item, label, storeItem,
+ sprite, spriteColor, spriteBrightness, labelColor,
+ Color = Ext.draw.Color,
+ colorString;
+
+ if (display == 'none') {
+ return;
+ }
-/**
- * Shorthand for {@link Ext.util.Functions#createSequence}
- * @param {Function} origFn The original function.
- * @param {Function} newFn The function to sequence
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- * @member Ext
- * @method defer
- */
+ for (i = 0, count = 0; i < len; i++) {
+ for (j = 0; j < ratio; j++) {
+ item = items[count];
+ label = group.getAt(count);
+ storeItem = store.getAt(i);
-Ext.createSequence = Ext.util.Functions.createSequence;
+ if (!item && label) {
+ label.hide(true);
+ }
-/**
- * Shorthand for {@link Ext.util.Functions#createDelegate}
- * @param {Function} fn The function to delegate.
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Function} The new function
- * @member Ext
- * @method defer
- */
-Ext.createDelegate = Ext.util.Functions.createDelegate;
-/**
- * @class Ext.util.Observable
- */
-Ext.apply(Ext.util.Observable.prototype, function(){
- // this is considered experimental (along with beforeMethod, afterMethod, removeMethodListener?)
- // allows for easier interceptor and sequences, including cancelling and overwriting the return value of the call
- // private
- function getMethodEvent(method){
- var e = (this.methodEvents = this.methodEvents ||
- {})[method], returnValue, v, cancel, obj = this;
-
- if (!e) {
- this.methodEvents[method] = e = {};
- e.originalFn = this[method];
- e.methodName = method;
- e.before = [];
- e.after = [];
-
- var makeCall = function(fn, scope, args){
- if((v = fn.apply(scope || obj, args)) !== undefined){
- if (typeof v == 'object') {
- if(v.returnValue !== undefined){
- returnValue = v.returnValue;
- }else{
- returnValue = v;
- }
- cancel = !!v.cancel;
+ if (item && field[j]) {
+ if (!label) {
+ label = me.onCreateLabel(storeItem, item, i, display, j, count);
}
- else
- if (v === false) {
- cancel = true;
+ me.onPlaceLabel(label, storeItem, item, i, display, animate, j, count);
+
+
+ if (config.contrast && item.sprite) {
+ sprite = item.sprite;
+ colorString = sprite._to && sprite._to.fill || sprite.attr.fill;
+ spriteColor = Color.fromString(colorString);
+
+ if (colorString && !spriteColor) {
+ colorString = colorString.match(me.colorStringRe)[1];
+ for (k = 0; k < gradientsCount; k++) {
+ gradient = gradients[k];
+ if (gradient.id == colorString) {
+
+ colorStop = 0; colorStopTotal = 0;
+ for (colorStopIndex in gradient.stops) {
+ colorStop++;
+ colorStopTotal += Color.fromString(gradient.stops[colorStopIndex].color).getGrayscale();
+ }
+ spriteBrightness = (colorStopTotal / colorStop) / 255;
+ break;
+ }
+ }
}
else {
- returnValue = v;
+ spriteBrightness = spriteColor.getGrayscale() / 255;
}
- }
- };
-
- this[method] = function(){
- var args = Array.prototype.slice.call(arguments, 0),
- b;
- returnValue = v = undefined;
- cancel = false;
-
- for(var i = 0, len = e.before.length; i < len; i++){
- b = e.before[i];
- makeCall(b.fn, b.scope, args);
- if (cancel) {
- return returnValue;
- }
- }
-
- if((v = e.originalFn.apply(obj, args)) !== undefined){
- returnValue = v;
- }
-
- for(var i = 0, len = e.after.length; i < len; i++){
- b = e.after[i];
- makeCall(b.fn, b.scope, args);
- if (cancel) {
- return returnValue;
+ labelColor = Color.fromString(label.attr.color || label.attr.fill).getHSL();
+
+ labelColor[2] = spriteBrightness > 0.5? 0.2 : 0.8;
+ label.setAttributes({
+ fill: String(Color.fromHSL.apply({}, labelColor))
+ }, true);
}
}
- return returnValue;
- };
+ count++;
+ }
}
- return e;
- }
-
- return {
- // these are considered experimental
- // allows for easier interceptor and sequences, including cancelling and overwriting the return value of the call
- // adds an 'interceptor' called before the original method
- beforeMethod : function(method, fn, scope){
- getMethodEvent.call(this, method).before.push({
- fn: fn,
- scope: scope
- });
- },
+ me.hideLabels(count);
+ },
- // adds a 'sequence' called after the original method
- afterMethod : function(method, fn, scope){
- getMethodEvent.call(this, method).after.push({
- fn: fn,
- scope: scope
- });
- },
+ //@private a method to hide labels.
- removeMethodListener: function(method, fn, scope){
- var e = this.getMethodEvent(method);
- for(var i = 0, len = e.before.length; i < len; i++){
- if(e.before[i].fn == fn && e.before[i].scope == scope){
- e.before.splice(i, 1);
- return;
- }
- }
- for(var i = 0, len = e.after.length; i < len; i++){
- if(e.after[i].fn == fn && e.after[i].scope == scope){
- e.after.splice(i, 1);
- return;
- }
+ hideLabels: function(index) {
+ var labelsGroup = this.labelsGroup, len;
+ if (labelsGroup) {
+ len = labelsGroup.getCount();
+ while (len-->index) {
+ labelsGroup.getAt(len).hide(true);
}
- },
+ }
+ }
+});
+Ext.define('Ext.chart.MaskLayer', {
+ extend: 'Ext.Component',
+
+ constructor: function(config) {
+ config = Ext.apply(config || {}, {
+ style: 'position:absolute;background-color:#888;cursor:move;opacity:0.6;border:1px solid #222;'
+ });
+ this.callParent([config]);
+ },
+
+ initComponent: function() {
+ var me = this;
+ me.callParent(arguments);
+ me.addEvents(
+ 'mousedown',
+ 'mouseup',
+ 'mousemove',
+ 'mouseenter',
+ 'mouseleave'
+ );
+ },
- /**
- * Relays selected events from the specified Observable as if the events were fired by this.
- * @param {Object} o The Observable whose events this object is to relay.
- * @param {Array} events Array of event names to relay.
- */
- relayEvents : function(o, events){
- var me = this;
- function createHandler(ename){
- return function(){
- return me.fireEvent.apply(me, [ename].concat(Array.prototype.slice.call(arguments, 0)));
- };
+ initDraggable: function() {
+ this.callParent(arguments);
+ this.dd.onStart = function (e) {
+ var me = this,
+ comp = me.comp;
+
+
+ this.startPosition = comp.getPosition(true);
+
+
+
+ if (comp.ghost && !comp.liveDrag) {
+ me.proxy = comp.ghost();
+ me.dragTarget = me.proxy.header.el;
}
- for(var i = 0, len = events.length; i < len; i++){
- var ename = events[i];
- me.events[ename] = me.events[ename] || true;
- o.on(ename, createHandler(ename), me);
+
+
+ if (me.constrain || me.constrainDelegate) {
+ me.constrainTo = me.calculateConstrainRegion();
}
- },
+ };
+ }
+});
+
+Ext.define('Ext.chart.TipSurface', {
- /**
- * Enables events fired by this Observable to bubble up an owner hierarchy by calling
- * this.getBubbleTarget() if present. There is no implementation in the Observable base class.
This is commonly used by Ext.Components to bubble events to owner Containers. See {@link Ext.Component.getBubbleTarget}. The default - * implementation in Ext.Component returns the Component's immediate owner. But if a known target is required, this can be overridden to - * access the required target more quickly.
- *Example:
-Ext.override(Ext.form.Field, {
- initComponent : Ext.form.Field.prototype.initComponent.createSequence(function() {
- this.enableBubble('change');
- }),
+
+ extend: 'Ext.draw.Component',
- getBubbleTarget : function() {
- if (!this.formPanel) {
- this.formPanel = this.findParentByType('form');
+
+ spriteArray: false,
+ renderFirst: true,
+
+ constructor: function(config) {
+ this.callParent([config]);
+ if (config.sprites) {
+ this.spriteArray = [].concat(config.sprites);
+ delete config.sprites;
}
- return this.formPanel;
- }
-});
+ },
-var myForm = new Ext.formPanel({
- title: 'User Details',
- items: [{
- ...
- }],
- listeners: {
- change: function() {
-
- myForm.header.setStyle('color', 'red');
+ onRender: function() {
+ var me = this,
+ i = 0,
+ l = 0,
+ sp,
+ sprites;
+ this.callParent(arguments);
+ sprites = me.spriteArray;
+ if (me.renderFirst && sprites) {
+ me.renderFirst = false;
+ for (l = sprites.length; i < l; i++) {
+ sp = me.surface.add(sprites[i]);
+ sp.setAttributes({
+ hidden: false
+ },
+ true);
+ }
}
}
});
-" + String.format(Ext.Element.boxMarkup, cls) + "
"));
- Ext.DomQuery.selectNode('.' + cls + '-mc', el.dom).appendChild(this.dom);
- return el;
- },
+
+ defaultProxyType: 'memory',
-
- setSize : function(width, height, animate){
- var me = this;
- if(typeof width == 'object'){
- height = width.height;
- width = width.width;
- }
- width = me.adjustWidth(width);
- height = me.adjustHeight(height);
- if(!animate || !me.anim){
- me.dom.style.width = me.addUnits(width);
- me.dom.style.height = me.addUnits(height);
- }else{
- me.anim({width: {to: width}, height: {to: height}}, me.preanim(arguments, 2));
- }
- return me;
- },
+
+ isDestroyed: false,
-
- getComputedHeight : function(){
- var me = this,
- h = Math.max(me.dom.offsetHeight, me.dom.clientHeight);
- if(!h){
- h = parseFloat(me.getStyle('height')) || 0;
- if(!me.isBorderBox()){
- h += me.getFrameWidth('tb');
- }
- }
- return h;
- },
+ isStore: true,
+
+
+
+
+ sortRoot: 'data',
+
+
+ constructor: function(config) {
+ var me = this;
- getComputedWidth : function(){
- var w = Math.max(this.dom.offsetWidth, this.dom.clientWidth);
- if(!w){
- w = parseFloat(this.getStyle('width')) || 0;
- if(!this.isBorderBox()){
- w += this.getFrameWidth('lr');
- }
- }
- return w;
- },
+ me.addEvents(
+
+ 'add',
+
+
+ 'remove',
+
+
+ 'update',
+
+
+ 'datachanged',
+
+
+ 'beforeload',
+
+
+ 'load',
+
+ 'beforesync',
+
+ 'clear'
+ );
- getFrameWidth : function(sides, onlyContentBox){
- return onlyContentBox && this.isBorderBox() ? 0 : (this.getPadding(sides) + this.getBorderWidth(sides));
- },
+ Ext.apply(me, config);
- addClassOnOver : function(className){
- this.hover(
- function(){
- Ext.fly(this, INTERNAL).addClass(className);
- },
- function(){
- Ext.fly(this, INTERNAL).removeClass(className);
- }
- );
- return this;
- },
+ me.removed = [];
+
+ me.mixins.observable.constructor.apply(me, arguments);
+ me.model = Ext.ModelManager.getModel(config.model || me.model);
- addClassOnFocus : function(className){
- this.on("focus", function(){
- Ext.fly(this, INTERNAL).addClass(className);
- }, this.dom);
- this.on("blur", function(){
- Ext.fly(this, INTERNAL).removeClass(className);
- }, this.dom);
- return this;
- },
+ Ext.applyIf(me, {
+ modelDefaults: {}
+ });
- addClassOnClick : function(className){
- var dom = this.dom;
- this.on("mousedown", function(){
- Ext.fly(dom, INTERNAL).addClass(className);
- var d = Ext.getDoc(),
- fn = function(){
- Ext.fly(dom, INTERNAL).removeClass(className);
- d.removeListener("mouseup", fn);
- };
- d.on("mouseup", fn);
+ if (!me.model && me.fields) {
+ me.model = Ext.define('Ext.data.Store.ImplicitModel-' + (me.storeId || Ext.id()), {
+ extend: 'Ext.data.Model',
+ fields: me.fields,
+ proxy: me.proxy || me.defaultProxyType
});
- return this;
- },
-
+ delete me.fields;
- getViewSize : function(){
- var doc = document,
- d = this.dom,
- isDoc = (d == doc || d == doc.body);
+ me.implicitModel = true;
+ }
-
- if (isDoc) {
- var extdom = Ext.lib.Dom;
- return {
- width : extdom.getViewWidth(),
- height : extdom.getViewHeight()
- };
+
+ me.setProxy(config.proxy || me.proxy || me.model.getProxy());
-
- } else {
- return {
- width : d.clientWidth,
- height : d.clientHeight
- };
- }
- },
+ if (me.id && !me.storeId) {
+ me.storeId = me.id;
+ delete me.id;
+ }
+ if (me.storeId) {
+ Ext.data.StoreManager.register(me);
+ }
+ me.mixins.sortable.initSortable.call(me);
+
+
+ me.filters = Ext.create('Ext.util.MixedCollection');
+ me.filters.addAll(me.decodeFilters(config.filters));
+ },
- getStyleSize : function(){
- var me = this,
- w, h,
- doc = document,
- d = this.dom,
- isDoc = (d == doc || d == doc.body),
- s = d.style;
-
-
- if (isDoc) {
- var extdom = Ext.lib.Dom;
- return {
- width : extdom.getViewWidth(),
- height : extdom.getViewHeight()
+
+ setProxy: function(proxy) {
+ var me = this;
+
+ if (proxy instanceof Ext.data.proxy.Proxy) {
+ proxy.setModel(me.model);
+ } else {
+ if (Ext.isString(proxy)) {
+ proxy = {
+ type: proxy
};
}
+ Ext.applyIf(proxy, {
+ model: me.model
+ });
- if(s.width && s.width != 'auto'){
- w = parseFloat(s.width);
- if(me.isBorderBox()){
- w -= me.getFrameWidth('lr');
- }
- }
-
- if(s.height && s.height != 'auto'){
- h = parseFloat(s.height);
- if(me.isBorderBox()){
- h -= me.getFrameWidth('tb');
- }
- }
-
- return {width: w || me.getWidth(true), height: h || me.getHeight(true)};
- },
-
+ proxy = Ext.createByAlias('proxy.' + proxy.type, proxy);
+ }
- getSize : function(contentSize){
- return {width: this.getWidth(contentSize), height: this.getHeight(contentSize)};
- },
-
+ me.proxy = proxy;
- repaint : function(){
- var dom = this.dom;
- this.addClass("x-repaint");
- setTimeout(function(){
- Ext.fly(dom).removeClass("x-repaint");
- }, 1);
- return this;
- },
+ return me.proxy;
+ },
+
+
+ getProxy: function() {
+ return this.proxy;
+ },
+
+ create: function(data, options) {
+ var me = this,
+ instance = Ext.ModelManager.create(Ext.applyIf(data, me.modelDefaults), me.model.modelName),
+ operation;
- unselectable : function(){
- this.dom.unselectable = "on";
- return this.swallowEvent("selectstart", true).
- applyStyles("-moz-user-select:none;-khtml-user-select:none;").
- addClass("x-unselectable");
- },
+ options = options || {};
+ Ext.applyIf(options, {
+ action : 'create',
+ records: [instance]
+ });
+
+ operation = Ext.create('Ext.data.Operation', options);
+
+ me.proxy.create(operation, me.onProxyWrite, me);
- getMargins : function(side){
- var me = this,
- key,
- hash = {t:"top", l:"left", r:"right", b: "bottom"},
- o = {};
+ return instance;
+ },
- if (!side) {
- for (key in me.margins){
- o[hash[key]] = parseFloat(me.getStyle(me.margins[key])) || 0;
- }
- return o;
- } else {
- return me.addStyles.call(me, side, me.margins);
- }
- }
- };
-}());
+ read: function() {
+ return this.load.apply(this, arguments);
+ },
-Ext.Element.addMethods({
-
- setBox : function(box, adjust, animate){
+ onProxyRead: Ext.emptyFn,
+
+ update: function(options) {
var me = this,
- w = box.width,
- h = box.height;
- if((adjust && !me.autoBoxAdjust) && !me.isBorderBox()){
- w -= (me.getBorderWidth("lr") + me.getPadding("lr"));
- h -= (me.getBorderWidth("tb") + me.getPadding("tb"));
- }
- me.setBounds(box.x, box.y, w, h, me.animTest.call(me, arguments, animate, 2));
- return me;
+ operation;
+ options = options || {};
+
+ Ext.applyIf(options, {
+ action : 'update',
+ records: me.getUpdatedRecords()
+ });
+
+ operation = Ext.create('Ext.data.Operation', options);
+
+ return me.proxy.update(operation, me.onProxyWrite, me);
},
- getBox : function(contentBox, local) {
- var me = this,
- xy,
- left,
- top,
- getBorderWidth = me.getBorderWidth,
- getPadding = me.getPadding,
- l,
- r,
- t,
- b;
- if(!local){
- xy = me.getXY();
- }else{
- left = parseInt(me.getStyle("left"), 10) || 0;
- top = parseInt(me.getStyle("top"), 10) || 0;
- xy = [left, top];
+ onProxyWrite: function(operation) {
+ var me = this,
+ success = operation.wasSuccessful(),
+ records = operation.getRecords();
+
+ switch (operation.action) {
+ case 'create':
+ me.onCreateRecords(records, operation, success);
+ break;
+ case 'update':
+ me.onUpdateRecords(records, operation, success);
+ break;
+ case 'destroy':
+ me.onDestroyRecords(records, operation, success);
+ break;
}
- var el = me.dom, w = el.offsetWidth, h = el.offsetHeight, bx;
- if(!contentBox){
- bx = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: w, height: h};
- }else{
- l = getBorderWidth.call(me, "l") + getPadding.call(me, "l");
- r = getBorderWidth.call(me, "r") + getPadding.call(me, "r");
- t = getBorderWidth.call(me, "t") + getPadding.call(me, "t");
- b = getBorderWidth.call(me, "b") + getPadding.call(me, "b");
- bx = {x: xy[0]+l, y: xy[1]+t, 0: xy[0]+l, 1: xy[1]+t, width: w-(l+r), height: h-(t+b)};
+
+ if (success) {
+ me.fireEvent('write', me, operation);
+ me.fireEvent('datachanged', me);
}
- bx.right = bx.x + bx.width;
- bx.bottom = bx.y + bx.height;
- return bx;
- },
-
-
- move : function(direction, distance, animate){
- var me = this,
- xy = me.getXY(),
- x = xy[0],
- y = xy[1],
- left = [x - distance, y],
- right = [x + distance, y],
- top = [x, y - distance],
- bottom = [x, y + distance],
- hash = {
- l : left,
- left : left,
- r : right,
- right : right,
- t : top,
- top : top,
- up : top,
- b : bottom,
- bottom : bottom,
- down : bottom
- };
-
- direction = direction.toLowerCase();
- me.moveTo(hash[direction][0], hash[direction][1], me.animTest.call(me, arguments, animate, 2));
- },
-
-
- setLeftTop : function(left, top){
- var me = this,
- style = me.dom.style;
- style.left = me.addUnits(left);
- style.top = me.addUnits(top);
- return me;
+
+ Ext.callback(operation.callback, operation.scope || me, [records, operation, success]);
},
+
+
-
- getRegion : function(){
- return Ext.lib.Dom.getRegion(this.dom);
+ destroy: function(options) {
+ var me = this,
+ operation;
+
+ options = options || {};
+
+ Ext.applyIf(options, {
+ action : 'destroy',
+ records: me.getRemovedRecords()
+ });
+
+ operation = Ext.create('Ext.data.Operation', options);
+
+ return me.proxy.destroy(operation, me.onProxyWrite, me);
},
+
-
- setBounds : function(x, y, width, height, animate){
- var me = this;
- if (!animate || !me.anim) {
- me.setSize(width, height);
- me.setLocation(x, y);
- } else {
- me.anim({points: {to: [x, y]},
- width: {to: me.adjustWidth(width)},
- height: {to: me.adjustHeight(height)}},
- me.preanim(arguments, 4),
- 'motion');
- }
- return me;
+ onBatchOperationComplete: function(batch, operation) {
+ return this.onProxyWrite(operation);
},
- setRegion : function(region, animate) {
- return this.setBounds(region.left, region.top, region.right-region.left, region.bottom-region.top, this.animTest.call(this, arguments, animate, 1));
- }
-});
-Ext.Element.addMethods({
-
- scrollTo : function(side, value, animate) {
-
- var top = /top/i.test(side),
- me = this,
- dom = me.dom,
- prop;
- if (!animate || !me.anim) {
-
- prop = 'scroll' + (top ? 'Top' : 'Left');
- dom[prop] = value;
- }
- else {
-
- prop = 'scroll' + (top ? 'Left' : 'Top');
- me.anim({scroll: {to: top ? [dom[prop], value] : [value, dom[prop]]}}, me.preanim(arguments, 2), 'scroll');
+ onBatchComplete: function(batch, operation) {
+ var me = this,
+ operations = batch.operations,
+ length = operations.length,
+ i;
+
+ me.suspendEvents();
+
+ for (i = 0; i < length; i++) {
+ me.onProxyWrite(operations[i]);
}
- return me;
+
+ me.resumeEvents();
+
+ me.fireEvent('datachanged', me);
},
-
-
- scrollIntoView : function(container, hscroll) {
- var c = Ext.getDom(container) || Ext.getBody().dom,
- el = this.dom,
- o = this.getOffsetsTo(c),
- l = o[0] + c.scrollLeft,
- t = o[1] + c.scrollTop,
- b = t + el.offsetHeight,
- r = l + el.offsetWidth,
- ch = c.clientHeight,
- ct = parseInt(c.scrollTop, 10),
- cl = parseInt(c.scrollLeft, 10),
- cb = ct + ch,
- cr = cl + c.clientWidth;
- if (el.offsetHeight > ch || t < ct) {
- c.scrollTop = t;
- }
- else if (b > cb) {
- c.scrollTop = b-ch;
- }
+ onBatchException: function(batch, operation) {
+
+
+
- c.scrollTop = c.scrollTop;
+
+ },
- if (hscroll !== false) {
- if (el.offsetWidth > c.clientWidth || l < cl) {
- c.scrollLeft = l;
- }
- else if (r > cr) {
- c.scrollLeft = r - c.clientWidth;
- }
- c.scrollLeft = c.scrollLeft;
- }
- return this;
+
+ filterNew: function(item) {
+
+ return item.phantom === true && item.isValid();
},
- scrollChildIntoView : function(child, hscroll) {
- Ext.fly(child, '_scrollChildIntoView').scrollIntoView(this, hscroll);
+ getNewRecords: function() {
+ return [];
},
+
+ getUpdatedRecords: function() {
+ return [];
+ },
+
- scroll : function(direction, distance, animate) {
- if (!this.isScrollable()) {
- return false;
- }
- var el = this.dom,
- l = el.scrollLeft, t = el.scrollTop,
- w = el.scrollWidth, h = el.scrollHeight,
- cw = el.clientWidth, ch = el.clientHeight,
- scrolled = false, v,
- hash = {
- l: Math.min(l + distance, w-cw),
- r: v = Math.max(l - distance, 0),
- t: Math.max(t - distance, 0),
- b: Math.min(t + distance, h-ch)
- };
- hash.d = hash.b;
- hash.u = hash.t;
+ filterUpdated: function(item) {
- direction = direction.substr(0, 1);
- if ((v = hash[direction]) > -1) {
- scrolled = true;
- this.scrollTo(direction == 'l' || direction == 'r' ? 'left' : 'top', v, this.preanim(arguments, 2));
- }
- return scrolled;
- }
-});
-Ext.Element.addMethods(
- function() {
- var VISIBILITY = "visibility",
- DISPLAY = "display",
- HIDDEN = "hidden",
- NONE = "none",
- XMASKED = "x-masked",
- XMASKEDRELATIVE = "x-masked-relative",
- data = Ext.Element.data;
+ return item.dirty === true && item.phantom !== true && item.isValid();
+ },
- return {
-
- isVisible : function(deep) {
- var vis = !this.isStyle(VISIBILITY, HIDDEN) && !this.isStyle(DISPLAY, NONE),
- p = this.dom.parentNode;
-
- if (deep !== true || !vis) {
- return vis;
- }
-
- while (p && !(/^body/i.test(p.tagName))) {
- if (!Ext.fly(p, '_isVisible').isVisible()) {
- return false;
- }
- p = p.parentNode;
- }
- return true;
- },
+
+ getRemovedRecords: function() {
+ return this.removed;
+ },
-
- isDisplayed : function() {
- return !this.isStyle(DISPLAY, NONE);
- },
+ filter: function(filters, value) {
+
+ },
-
- enableDisplayMode : function(display) {
- this.setVisibilityMode(Ext.Element.DISPLAY);
-
- if (!Ext.isEmpty(display)) {
- data(this.dom, 'originalDisplay', display);
- }
-
- return this;
- },
+
+ decodeFilters: function(filters) {
+ if (!Ext.isArray(filters)) {
+ if (filters === undefined) {
+ filters = [];
+ } else {
+ filters = [filters];
+ }
+ }
-
- mask : function(msg, msgCls) {
- var me = this,
- dom = me.dom,
- dh = Ext.DomHelper,
- EXTELMASKMSG = "ext-el-mask-msg",
- el,
- mask;
+ var length = filters.length,
+ Filter = Ext.util.Filter,
+ config, i;
- if (!(/^body/i.test(dom.tagName) && me.getStyle('position') == 'static')) {
- me.addClass(XMASKEDRELATIVE);
- }
- if (el = data(dom, 'maskMsg')) {
- el.remove();
- }
- if (el = data(dom, 'mask')) {
- el.remove();
- }
+ for (i = 0; i < length; i++) {
+ config = filters[i];
- mask = dh.append(dom, {cls : "ext-el-mask"}, true);
- data(dom, 'mask', mask);
+ if (!(config instanceof Filter)) {
+ Ext.apply(config, {
+ root: 'data'
+ });
- me.addClass(XMASKED);
- mask.setDisplayed(true);
- if (typeof msg == 'string') {
- var mm = dh.append(dom, {cls : EXTELMASKMSG, cn:{tag:'div'}}, true);
- data(dom, 'maskMsg', mm);
- mm.dom.className = msgCls ? EXTELMASKMSG + " " + msgCls : EXTELMASKMSG;
- mm.dom.firstChild.innerHTML = msg;
- mm.setDisplayed(true);
- mm.center(me);
+ if (config.fn) {
+ config.filterFn = config.fn;
}
+
-
- if (Ext.isIE && !(Ext.isIE7 && Ext.isStrict) && me.getStyle('height') == 'auto') {
- mask.setSize(undefined, me.getHeight());
+ if (typeof config == 'function') {
+ config = {
+ filterFn: config
+ };
}
-
- return mask;
- },
-
- unmask : function() {
- var me = this,
- dom = me.dom,
- mask = data(dom, 'mask'),
- maskMsg = data(dom, 'maskMsg');
+ filters[i] = new Filter(config);
+ }
+ }
- if (mask) {
- if (maskMsg) {
- maskMsg.remove();
- data(dom, 'maskMsg', undefined);
- }
-
- mask.remove();
- data(dom, 'mask', undefined);
- me.removeClass([XMASKED, XMASKEDRELATIVE]);
- }
- },
+ return filters;
+ },
-
- isMasked : function() {
- var m = data(this.dom, 'mask');
- return m && m.isVisible();
- },
+ clearFilter: function(supressEvent) {
+
+ },
+
+ isFiltered: function() {
-
- createShim : function() {
- var el = document.createElement('iframe'),
- shim;
-
- el.frameBorder = '0';
- el.className = 'ext-shim';
- el.src = Ext.SSL_SECURE_URL;
- shim = Ext.get(this.dom.parentNode.insertBefore(el, this.dom));
- shim.autoBoxAdjust = false;
- return shim;
- }
- };
- }()
-);
-Ext.Element.addMethods({
-
- addKeyListener : function(key, fn, scope){
- var config;
- if(typeof key != 'object' || Ext.isArray(key)){
- config = {
- key: key,
- fn: fn,
- scope: scope
- };
- }else{
- config = {
- key : key.key,
- shift : key.shift,
- ctrl : key.ctrl,
- alt : key.alt,
- fn: fn,
- scope: scope
- };
- }
- return new Ext.KeyMap(this, config);
},
+ filterBy: function(fn, scope) {
+
+ },
- addKeyMap : function(config){
- return new Ext.KeyMap(this, config);
- }
-});
+
+ sync: function() {
+ var me = this,
+ options = {},
+ toCreate = me.getNewRecords(),
+ toUpdate = me.getUpdatedRecords(),
+ toDestroy = me.getRemovedRecords(),
+ needsSync = false;
+ if (toCreate.length > 0) {
+ options.create = toCreate;
+ needsSync = true;
+ }
+ if (toUpdate.length > 0) {
+ options.update = toUpdate;
+ needsSync = true;
+ }
-Ext.CompositeElementLite.importElementMethods();
-Ext.apply(Ext.CompositeElementLite.prototype, {
- addElements : function(els, root){
- if(!els){
- return this;
+ if (toDestroy.length > 0) {
+ options.destroy = toDestroy;
+ needsSync = true;
}
- if(typeof els == "string"){
- els = Ext.Element.selectorFunction(els, root);
+
+ if (needsSync && me.fireEvent('beforesync', options) !== false) {
+ me.proxy.batch(options, me.getBatchListeners());
}
- var yels = this.elements;
- Ext.each(els, function(e) {
- yels.push(Ext.get(e));
- });
- return this;
},
-
- first : function(){
- return this.item(0);
- },
- last : function(){
- return this.item(this.getCount()-1);
+ getBatchListeners: function() {
+ var me = this,
+ listeners = {
+ scope: me,
+ exception: me.onBatchException
+ };
+
+ if (me.batchUpdateMode == 'operation') {
+ listeners.operationcomplete = me.onBatchOperationComplete;
+ } else {
+ listeners.complete = me.onBatchComplete;
+ }
+
+ return listeners;
},
- contains : function(el){
- return this.indexOf(el) != -1;
+ save: function() {
+ return this.sync.apply(this, arguments);
},
- removeElement : function(keys, removeDom){
+ load: function(options) {
var me = this,
- els = this.elements,
- el;
- Ext.each(keys, function(val){
- if ((el = (els[val] || els[val = me.indexOf(val)]))) {
- if(removeDom){
- if(el.dom){
- el.remove();
- }else{
- Ext.removeNode(el);
- }
- }
- els.splice(val, 1);
- }
+ operation;
+
+ options = options || {};
+
+ Ext.applyIf(options, {
+ action : 'read',
+ filters: me.filters.items,
+ sorters: me.getSorters()
});
- return this;
- }
-});
+
+ operation = Ext.create('Ext.data.Operation', options);
+
+ if (me.fireEvent('beforeload', me, operation) !== false) {
+ me.loading = true;
+ me.proxy.read(operation, me.onProxyLoad, me);
+ }
+
+ return me;
+ },
-Ext.CompositeElement = Ext.extend(Ext.CompositeElementLite, {
- constructor : function(els, root){
- this.elements = [];
- this.add(els, root);
+ afterEdit : function(record) {
+ var me = this;
+
+ if (me.autoSync) {
+ me.sync();
+ }
+
+ me.fireEvent('update', me, record, Ext.data.Model.EDIT);
},
+
+ afterReject : function(record) {
+ this.fireEvent('update', this, record, Ext.data.Model.REJECT);
+ },
+
- getElement : function(el){
+ afterCommit : function(record) {
+ this.fireEvent('update', this, record, Ext.data.Model.COMMIT);
+ },
+
+ clearData: Ext.emptyFn,
+
+ destroyStore: function() {
+ var me = this;
- return el;
+ if (!me.isDestroyed) {
+ if (me.storeId) {
+ Ext.data.StoreManager.unregister(me);
+ }
+ me.clearData();
+ me.data = null;
+ me.tree = null;
+
+ me.reader = me.writer = null;
+ me.clearListeners();
+ me.isDestroyed = true;
+
+ if (me.implicitModel) {
+ Ext.destroy(me.model);
+ }
+ }
},
+ doSort: function(sorterFn) {
+ var me = this;
+ if (me.remoteSort) {
+
+ me.load();
+ } else {
+ me.data.sortBy(sorterFn);
+ me.fireEvent('datachanged', me);
+ }
+ },
+
+ getCount: Ext.emptyFn,
+
+ getById: Ext.emptyFn,
- transformElement : function(el){
- return Ext.get(el);
- }
+
+ removeAll: Ext.emptyFn,
+
+
+
+
+ isLoading: function() {
+ return this.loading;
+ }
+});
+
+
+
+Ext.define('Ext.util.Grouper', {
+ extend: 'Ext.util.Sorter',
+
+ getGroupString: function(instance) {
+ return instance.get(this.property);
+ }
});
+Ext.define('Ext.data.Store', {
+ extend: 'Ext.data.AbstractStore',
-Ext.Element.select = function(selector, unique, root){
- var els;
- if(typeof selector == "string"){
- els = Ext.Element.selectorFunction(selector, root);
- }else if(selector.length !== undefined){
- els = selector;
- }else{
- throw "Invalid selector";
- }
+ alias: 'store.store',
- return (unique === true) ? new Ext.CompositeElement(els) : new Ext.CompositeElementLite(els);
-};
+ requires: ['Ext.ModelManager', 'Ext.data.Model', 'Ext.util.Grouper'],
+ uses: ['Ext.data.proxy.Memory'],
+
+ remoteSort: false,
-Ext.select = Ext.Element.select;
-Ext.UpdateManager = Ext.Updater = Ext.extend(Ext.util.Observable,
-function() {
- var BEFOREUPDATE = "beforeupdate",
- UPDATE = "update",
- FAILURE = "failure";
+
+ remoteFilter: false,
+
+
+ remoteGroup : false,
- function processSuccess(response){
- var me = this;
- me.transaction = null;
- if (response.argument.form && response.argument.reset) {
- try {
- response.argument.form.reset();
- } catch(e){}
- }
- if (me.loadScripts) {
- me.renderer.render(me.el, response, me,
- updateComplete.createDelegate(me, [response]));
- } else {
- me.renderer.render(me.el, response, me);
- updateComplete.call(me, response);
- }
- }
- function updateComplete(response, type, success){
- this.fireEvent(type || UPDATE, this.el, response);
- if(Ext.isFunction(response.argument.callback)){
- response.argument.callback.call(response.argument.scope, this.el, Ext.isEmpty(success) ? true : false, response, response.argument.options);
- }
- }
- function processFailure(response){
- updateComplete.call(this, response, FAILURE, !!(this.transaction = null));
- }
- return {
- constructor: function(el, forceNew){
- var me = this;
- el = Ext.get(el);
- if(!forceNew && el.updateManager){
- return el.updateManager;
- }
-
- me.el = el;
-
- me.defaultUrl = null;
+
+ groupField: undefined,
- me.addEvents(
-
- BEFOREUPDATE,
-
- UPDATE,
-
- FAILURE
- );
+
+ groupDir: "ASC",
- Ext.apply(me, Ext.Updater.defaults);
-
-
-
-
-
-
+
+ pageSize: 25,
+
+
+ currentPage: 1,
+
+
+ clearOnPageLoad: true,
+
+
+ loading: false,
+
+
+ sortOnFilter: true,
+
+
+ buffered: false,
+
+
+ purgePageCount: 5,
+
+ isStore: true,
+
+
+ constructor: function(config) {
+ config = config || {};
+ var me = this,
+ groupers = config.groupers,
+ proxy,
+ data;
- me.transaction = null;
+ if (config.buffered || me.buffered) {
+ me.prefetchData = Ext.create('Ext.util.MixedCollection', false, function(record) {
+ return record.index;
+ });
+ me.pendingRequests = [];
+ me.pagesRequested = [];
- me.refreshDelegate = me.refresh.createDelegate(me);
+ me.sortOnLoad = false;
+ me.filterOnLoad = false;
+ }
- me.updateDelegate = me.update.createDelegate(me);
+ me.addEvents(
- me.formUpdateDelegate = (me.formUpdate || function(){}).createDelegate(me);
-
+ 'beforeprefetch',
- me.renderer = me.renderer || me.getDefaultRenderer();
-
- Ext.Updater.superclass.constructor.call(me);
- },
+ 'groupchange',
+
+ 'prefetch'
+ );
+ data = config.data || me.data;
- setRenderer : function(renderer){
- this.renderer = renderer;
- },
+ me.data = Ext.create('Ext.util.MixedCollection', false, function(record) {
+ return record.internalId;
+ });
+ if (data) {
+ me.inlineData = data;
+ delete config.data;
+ }
- getRenderer : function(){
- return this.renderer;
- },
-
+ if (!groupers && config.groupField) {
+ groupers = [{
+ property : config.groupField,
+ direction: config.groupDir
+ }];
+ }
+ delete config.groupers;
- getDefaultRenderer: function() {
- return new Ext.Updater.BasicRenderer();
- },
-
- setDefaultUrl : function(defaultUrl){
- this.defaultUrl = defaultUrl;
- },
+ me.groupers = Ext.create('Ext.util.MixedCollection');
+ me.groupers.addAll(me.decodeGroupers(groupers));
+ this.callParent([config]);
- getEl : function(){
- return this.el;
- },
+ if (me.groupers.items.length) {
+ me.sort(me.groupers.items, 'prepend', false);
+ }
-
- update : function(url, params, callback, discardUrl){
- var me = this,
- cfg,
- callerScope;
-
- if(me.fireEvent(BEFOREUPDATE, me.el, url, params) !== false){
- if(Ext.isObject(url)){
- cfg = url;
- url = cfg.url;
- params = params || cfg.params;
- callback = callback || cfg.callback;
- discardUrl = discardUrl || cfg.discardUrl;
- callerScope = cfg.scope;
- if(!Ext.isEmpty(cfg.nocache)){me.disableCaching = cfg.nocache;};
- if(!Ext.isEmpty(cfg.text)){me.indicatorText = ''+cfg.text+"
";};
- if(!Ext.isEmpty(cfg.scripts)){me.loadScripts = cfg.scripts;};
- if(!Ext.isEmpty(cfg.timeout)){me.timeout = cfg.timeout;};
- }
- me.showLoading();
-
- if(!discardUrl){
- me.defaultUrl = url;
- }
- if(Ext.isFunction(url)){
- url = url.call(me);
- }
-
- var o = Ext.apply({}, {
- url : url,
- params: (Ext.isFunction(params) && callerScope) ? params.createDelegate(callerScope) : params,
- success: processSuccess,
- failure: processFailure,
- scope: me,
- callback: undefined,
- timeout: (me.timeout*1000),
- disableCaching: me.disableCaching,
- argument: {
- "options": cfg,
- "url": url,
- "form": null,
- "callback": callback,
- "scope": callerScope || window,
- "params": params
- }
- }, cfg);
+ proxy = me.proxy;
+ data = me.inlineData;
- me.transaction = Ext.Ajax.request(o);
+ if (data) {
+ if (proxy instanceof Ext.data.proxy.Memory) {
+ proxy.data = data;
+ me.read();
+ } else {
+ me.add.apply(me, data);
}
- },
-
- formUpdate : function(form, url, reset, callback){
- var me = this;
- if(me.fireEvent(BEFOREUPDATE, me.el, form, url) !== false){
- if(Ext.isFunction(url)){
- url = url.call(me);
- }
- form = Ext.getDom(form);
- me.transaction = Ext.Ajax.request({
- form: form,
- url:url,
- success: processSuccess,
- failure: processFailure,
- scope: me,
- timeout: (me.timeout*1000),
- argument: {
- "url": url,
- "form": form,
- "callback": callback,
- "reset": reset
- }
- });
- me.showLoading.defer(1, me);
+ me.sort();
+ delete me.inlineData;
+ } else if (me.autoLoad) {
+ Ext.defer(me.load, 10, me, [typeof me.autoLoad === 'object' ? me.autoLoad: undefined]);
+
+
+ }
+ },
+
+ onBeforeSort: function() {
+ this.sort(this.groupers.items, 'prepend', false);
+ },
+
+
+ decodeGroupers: function(groupers) {
+ if (!Ext.isArray(groupers)) {
+ if (groupers === undefined) {
+ groupers = [];
+ } else {
+ groupers = [groupers];
}
- },
+ }
-
- startAutoRefresh : function(interval, url, params, callback, refreshNow){
- var me = this;
- if(refreshNow){
- me.update(url || me.defaultUrl, params, callback, true);
- }
- if(me.autoRefreshProcId){
- clearInterval(me.autoRefreshProcId);
- }
- me.autoRefreshProcId = setInterval(me.update.createDelegate(me, [url || me.defaultUrl, params, callback, true]), interval * 1000);
- },
+ var length = groupers.length,
+ Grouper = Ext.util.Grouper,
+ config, i;
-
- stopAutoRefresh : function(){
- if(this.autoRefreshProcId){
- clearInterval(this.autoRefreshProcId);
- delete this.autoRefreshProcId;
+ for (i = 0; i < length; i++) {
+ config = groupers[i];
+
+ if (!(config instanceof Grouper)) {
+ if (Ext.isString(config)) {
+ config = {
+ property: config
+ };
+ }
+
+ Ext.applyIf(config, {
+ root : 'data',
+ direction: "ASC"
+ });
+
+
+ if (config.fn) {
+ config.sorterFn = config.fn;
+ }
+
+
+ if (typeof config == 'function') {
+ config = {
+ sorterFn: config
+ };
+ }
+
+ groupers[i] = new Grouper(config);
}
- },
+ }
+ return groupers;
+ },
+
+
+ group: function(groupers, direction) {
+ var me = this,
+ grouper,
+ newGroupers;
+
+ if (Ext.isArray(groupers)) {
+ newGroupers = groupers;
+ } else if (Ext.isObject(groupers)) {
+ newGroupers = [groupers];
+ } else if (Ext.isString(groupers)) {
+ grouper = me.groupers.get(groupers);
+
+ if (!grouper) {
+ grouper = {
+ property : groupers,
+ direction: direction
+ };
+ newGroupers = [grouper];
+ } else if (direction === undefined) {
+ grouper.toggle();
+ } else {
+ grouper.setDirection(direction);
+ }
+ }
- isAutoRefreshing : function(){
- return !!this.autoRefreshProcId;
- },
-
+ if (newGroupers && newGroupers.length) {
+ newGroupers = me.decodeGroupers(newGroupers);
+ me.groupers.clear();
+ me.groupers.addAll(newGroupers);
+ }
+
+ if (me.remoteGroup) {
+ me.load({
+ scope: me,
+ callback: me.fireGroupChange
+ });
+ } else {
+ me.sort();
+ me.fireEvent('groupchange', me, me.groupers);
+ }
+ },
+
+
+ clearGrouping: function(){
+ var me = this;
- showLoading : function(){
- if(this.showLoadIndicator){
- this.el.dom.innerHTML = this.indicatorText;
+ me.groupers.each(function(grouper){
+ me.sorters.remove(grouper);
+ });
+ me.groupers.clear();
+ if (me.remoteGroup) {
+ me.load({
+ scope: me,
+ callback: me.fireGroupChange
+ });
+ } else {
+ me.sort();
+ me.fireEvent('groupchange', me, me.groupers);
+ }
+ },
+
+
+ isGrouped: function() {
+ return this.groupers.getCount() > 0;
+ },
+
+
+ fireGroupChange: function(){
+ this.fireEvent('groupchange', this, this.groupers);
+ },
+
+
+ getGroups: function(requestGroupString) {
+ var records = this.data.items,
+ length = records.length,
+ groups = [],
+ pointers = {},
+ record,
+ groupStr,
+ group,
+ i;
+
+ for (i = 0; i < length; i++) {
+ record = records[i];
+ groupStr = this.getGroupString(record);
+ group = pointers[groupStr];
+
+ if (group === undefined) {
+ group = {
+ name: groupStr,
+ children: []
+ };
+
+ groups.push(group);
+ pointers[groupStr] = group;
}
- },
-
- abort : function(){
- if(this.transaction){
- Ext.Ajax.abort(this.transaction);
+ group.children.push(record);
+ }
+
+ return requestGroupString ? pointers[requestGroupString] : groups;
+ },
+
+
+ getGroupsForGrouper: function(records, grouper) {
+ var length = records.length,
+ groups = [],
+ oldValue,
+ newValue,
+ record,
+ group,
+ i;
+
+ for (i = 0; i < length; i++) {
+ record = records[i];
+ newValue = grouper.getGroupString(record);
+
+ if (newValue !== oldValue) {
+ group = {
+ name: newValue,
+ grouper: grouper,
+ records: []
+ };
+ groups.push(group);
}
- },
-
- isUpdating : function(){
- return this.transaction ? Ext.Ajax.isLoading(this.transaction) : false;
- },
+ group.records.push(record);
-
- refresh : function(callback){
- if(this.defaultUrl){
- this.update(this.defaultUrl, null, callback, true);
+ oldValue = newValue;
+ }
+
+ return groups;
+ },
+
+
+ getGroupsForGrouperIndex: function(records, grouperIndex) {
+ var me = this,
+ groupers = me.groupers,
+ grouper = groupers.getAt(grouperIndex),
+ groups = me.getGroupsForGrouper(records, grouper),
+ length = groups.length,
+ i;
+
+ if (grouperIndex + 1 < groupers.length) {
+ for (i = 0; i < length; i++) {
+ groups[i].children = me.getGroupsForGrouperIndex(groups[i].records, grouperIndex + 1);
}
}
- };
-}());
+ for (i = 0; i < length; i++) {
+ groups[i].depth = grouperIndex;
+ }
+
+ return groups;
+ },
-Ext.Updater.defaults = {
-
- timeout : 30,
- disableCaching : false,
+ getGroupData: function(sort) {
+ var me = this;
+ if (sort !== false) {
+ me.sort();
+ }
+
+ return me.getGroupsForGrouperIndex(me.data.items, 0);
+ },
+
- showLoadIndicator : true,
+ getGroupString: function(instance) {
+ var group = this.groupers.first();
+ if (group) {
+ return instance.get(group.property);
+ }
+ return '';
+ },
- indicatorText : 'Loading...
',
-
- loadScripts : false,
+ insert: function(index, records) {
+ var me = this,
+ sync = false,
+ i,
+ record,
+ len;
+
+ records = [].concat(records);
+ for (i = 0, len = records.length; i < len; i++) {
+ record = me.createModel(records[i]);
+ record.set(me.modelDefaults);
+
+ records[i] = record;
+
+ me.data.insert(index + i, record);
+ record.join(me);
+
+ sync = sync || record.phantom === true;
+ }
+
+ if (me.snapshot) {
+ me.snapshot.addAll(records);
+ }
+
+ me.fireEvent('add', me, records, index);
+ me.fireEvent('datachanged', me);
+ if (me.autoSync && sync) {
+ me.sync();
+ }
+ },
+
- sslBlankUrl : Ext.SSL_SECURE_URL
-};
+ add: function(records) {
+
+ if (!Ext.isArray(records)) {
+ records = Array.prototype.slice.apply(arguments);
+ }
+
+ var me = this,
+ i = 0,
+ length = records.length,
+ record;
+ for (; i < length; i++) {
+ record = me.createModel(records[i]);
+
+ records[i] = record;
+ }
+ me.insert(me.data.length, records);
-Ext.Updater.updateElement = function(el, url, params, options){
- var um = Ext.get(el).getUpdater();
- Ext.apply(um, options);
- um.update(url, params, options ? options.callback : null);
-};
+ return records;
+ },
+
+ createModel: function(record) {
+ if (!record.isModel) {
+ record = Ext.ModelManager.create(record, this.model);
+ }
-Ext.Updater.BasicRenderer = function(){};
+ return record;
+ },
-Ext.Updater.BasicRenderer.prototype = {
- render : function(el, response, updateManager, callback){
- el.update(response.responseText, updateManager.loadScripts, callback);
- }
-};
+ each: function(fn, scope) {
+ this.data.each(fn, scope);
+ },
+
+ remove: function(records, isMove) {
+ if (!Ext.isArray(records)) {
+ records = [records];
+ }
+
+ isMove = isMove === true;
+ var me = this,
+ sync = false,
+ i = 0,
+ length = records.length,
+ isPhantom,
+ index,
+ record;
-(function() {
+ for (; i < length; i++) {
+ record = records[i];
+ index = me.data.indexOf(record);
+
+ if (me.snapshot) {
+ me.snapshot.remove(record);
+ }
+
+ if (index > -1) {
+ isPhantom = record.phantom === true;
+ if (!isMove && !isPhantom) {
+
+ me.removed.push(record);
+ }
+ record.unjoin(me);
+ me.data.remove(record);
+ sync = sync || !isPhantom;
-Date.useStrict = false;
+ me.fireEvent('remove', me, record, index);
+ }
+ }
+ me.fireEvent('datachanged', me);
+ if (!isMove && me.autoSync && sync) {
+ me.sync();
+ }
+ },
+
+ removeAt: function(index) {
+ var record = this.getAt(index);
+ if (record) {
+ this.remove(record);
+ }
+ },
+
+ load: function(options) {
+ var me = this;
+
+ options = options || {};
-function xf(format) {
- var args = Array.prototype.slice.call(arguments, 1);
- return format.replace(/\{(\d+)\}/g, function(m, i) {
- return args[i];
- });
-}
+ if (Ext.isFunction(options)) {
+ options = {
+ callback: options
+ };
+ }
+ Ext.applyIf(options, {
+ groupers: me.groupers.items,
+ page: me.currentPage,
+ start: (me.currentPage - 1) * me.pageSize,
+ limit: me.pageSize,
+ addRecords: false
+ });
+ return me.callParent([options]);
+ },
-Date.formatCodeToRegex = function(character, currentGroup) {
- var p = Date.parseCodes[character];
+ onProxyLoad: function(operation) {
+ var me = this,
+ resultSet = operation.getResultSet(),
+ records = operation.getRecords(),
+ successful = operation.wasSuccessful();
- if (p) {
- p = typeof p == 'function'? p() : p;
- Date.parseCodes[character] = p;
- }
+ if (resultSet) {
+ me.totalCount = resultSet.total;
+ }
- return p ? Ext.applyIf({
- c: p.c ? xf(p.c, currentGroup || "{0}") : p.c
- }, p) : {
- g:0,
- c:null,
- s:Ext.escapeRe(character)
- };
-};
+ if (successful) {
+ me.loadRecords(records, operation);
+ }
+ me.loading = false;
+ me.fireEvent('load', me, records, successful);
-var $f = Date.formatCodeToRegex;
+
+
+ me.fireEvent('read', me, records, operation.wasSuccessful());
-Ext.apply(Date, {
+
+ Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
+ },
- parseFunctions: {
- "M$": function(input, strict) {
-
+
+ onCreateRecords: function(records, operation, success) {
+ if (success) {
+ var i = 0,
+ data = this.data,
+ snapshot = this.snapshot,
+ length = records.length,
+ originalRecords = operation.records,
+ record,
+ original,
+ index;
+
- var re = new RegExp('\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/');
- var r = (input || '').match(re);
- return r? new Date(((r[1] || '') + r[2]) * 1) : null;
+ for (; i < length; ++i) {
+ record = records[i];
+ original = originalRecords[i];
+ if (original) {
+ index = data.indexOf(original);
+ if (index > -1) {
+ data.removeAt(index);
+ data.insert(index, record);
+ }
+ if (snapshot) {
+ index = snapshot.indexOf(original);
+ if (index > -1) {
+ snapshot.removeAt(index);
+ snapshot.insert(index, record);
+ }
+ }
+ record.phantom = false;
+ record.join(this);
+ }
+ }
}
},
- parseRegexes: [],
- formatFunctions: {
- "M$": function() {
-
- return '\\/Date(' + this.getTime() + ')\\/';
+ onUpdateRecords: function(records, operation, success){
+ if (success) {
+ var i = 0,
+ length = records.length,
+ data = this.data,
+ snapshot = this.snapshot,
+ record;
+
+ for (; i < length; ++i) {
+ record = records[i];
+ data.replace(record);
+ if (snapshot) {
+ snapshot.replace(record);
+ }
+ record.join(this);
+ }
+ }
+ },
+
+
+ onDestroyRecords: function(records, operation, success){
+ if (success) {
+ var me = this,
+ i = 0,
+ length = records.length,
+ data = me.data,
+ snapshot = me.snapshot,
+ record;
+
+ for (; i < length; ++i) {
+ record = records[i];
+ record.unjoin(me);
+ data.remove(record);
+ if (snapshot) {
+ snapshot.remove(record);
+ }
+ }
+ me.removed = [];
}
},
- y2kYear : 50,
-
- MILLI : "ms",
+ getNewRecords: function() {
+ return this.data.filterBy(this.filterNew).items;
+ },
- SECOND : "s",
+ getUpdatedRecords: function() {
+ return this.data.filterBy(this.filterUpdated).items;
+ },
- MINUTE : "mi",
+ filter: function(filters, value) {
+ if (Ext.isString(filters)) {
+ filters = {
+ property: filters,
+ value: value
+ };
+ }
-
- HOUR : "h",
+ var me = this,
+ decoded = me.decodeFilters(filters),
+ i = 0,
+ doLocalSort = me.sortOnFilter && !me.remoteSort,
+ length = decoded.length;
-
- DAY : "d",
+ for (; i < length; i++) {
+ me.filters.replace(decoded[i]);
+ }
-
- MONTH : "mo",
+ if (me.remoteFilter) {
+
+ me.load();
+ } else {
+
+ if (me.filters.getCount()) {
+ me.snapshot = me.snapshot || me.data.clone();
+ me.data = me.data.filter(me.filters.items);
-
- YEAR : "y",
+ if (doLocalSort) {
+ me.sort();
+ }
+
+ if (!doLocalSort || me.sorters.length < 1) {
+ me.fireEvent('datachanged', me);
+ }
+ }
+ }
+ },
- defaults: {},
+ clearFilter: function(suppressEvent) {
+ var me = this;
-
- dayNames : [
- "Sunday",
- "Monday",
- "Tuesday",
- "Wednesday",
- "Thursday",
- "Friday",
- "Saturday"
- ],
+ me.filters.clear();
-
- monthNames : [
- "January",
- "February",
- "March",
- "April",
- "May",
- "June",
- "July",
- "August",
- "September",
- "October",
- "November",
- "December"
- ],
+ if (me.remoteFilter) {
+ me.load();
+ } else if (me.isFiltered()) {
+ me.data = me.snapshot.clone();
+ delete me.snapshot;
-
- monthNumbers : {
- Jan:0,
- Feb:1,
- Mar:2,
- Apr:3,
- May:4,
- Jun:5,
- Jul:6,
- Aug:7,
- Sep:8,
- Oct:9,
- Nov:10,
- Dec:11
+ if (suppressEvent !== true) {
+ me.fireEvent('datachanged', me);
+ }
+ }
},
- getShortMonthName : function(month) {
- return Date.monthNames[month].substring(0, 3);
+ isFiltered: function() {
+ var snapshot = this.snapshot;
+ return !! snapshot && snapshot !== this.data;
},
- getShortDayName : function(day) {
- return Date.dayNames[day].substring(0, 3);
+ filterBy: function(fn, scope) {
+ var me = this;
+
+ me.snapshot = me.snapshot || me.data.clone();
+ me.data = me.queryBy(fn, scope || me);
+ me.fireEvent('datachanged', me);
},
- getMonthNumber : function(name) {
-
- return Date.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];
+ queryBy: function(fn, scope) {
+ var me = this,
+ data = me.snapshot || me.data;
+ return data.filterBy(fn, scope || me);
},
- formatCodes : {
- d: "String.leftPad(this.getDate(), 2, '0')",
- D: "Date.getShortDayName(this.getDay())",
- j: "this.getDate()",
- l: "Date.dayNames[this.getDay()]",
- N: "(this.getDay() ? this.getDay() : 7)",
- S: "this.getSuffix()",
- w: "this.getDay()",
- z: "this.getDayOfYear()",
- W: "String.leftPad(this.getWeekOfYear(), 2, '0')",
- F: "Date.monthNames[this.getMonth()]",
- m: "String.leftPad(this.getMonth() + 1, 2, '0')",
- M: "Date.getShortMonthName(this.getMonth())",
- n: "(this.getMonth() + 1)",
- t: "this.getDaysInMonth()",
- L: "(this.isLeapYear() ? 1 : 0)",
- o: "(this.getFullYear() + (this.getWeekOfYear() == 1 && this.getMonth() > 0 ? +1 : (this.getWeekOfYear() >= 52 && this.getMonth() < 11 ? -1 : 0)))",
- Y: "String.leftPad(this.getFullYear(), 4, '0')",
- y: "('' + this.getFullYear()).substring(2, 4)",
- a: "(this.getHours() < 12 ? 'am' : 'pm')",
- A: "(this.getHours() < 12 ? 'AM' : 'PM')",
- g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
- G: "this.getHours()",
- h: "String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
- H: "String.leftPad(this.getHours(), 2, '0')",
- i: "String.leftPad(this.getMinutes(), 2, '0')",
- s: "String.leftPad(this.getSeconds(), 2, '0')",
- u: "String.leftPad(this.getMilliseconds(), 3, '0')",
- O: "this.getGMTOffset()",
- P: "this.getGMTOffset(true)",
- T: "this.getTimezone()",
- Z: "(this.getTimezoneOffset() * -60)",
+ loadData: function(data, append) {
+ var model = this.model,
+ length = data.length,
+ i,
+ record;
- c: function() {
- for (var c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
- var e = c.charAt(i);
- code.push(e == "T" ? "'T'" : Date.getFormatCode(e));
- }
- return code.join(" + ");
- },
+ for (i = 0; i < length; i++) {
+ record = data[i];
- U: "Math.round(this.getTime() / 1000)"
+ if (! (record instanceof Ext.data.Model)) {
+ data[i] = Ext.ModelManager.create(record, model);
+ }
+ }
+
+ this.loadRecords(data, {addRecords: append});
},
- isValid : function(y, m, d, h, i, s, ms) {
-
- h = h || 0;
- i = i || 0;
- s = s || 0;
- ms = ms || 0;
+ loadRecords: function(records, options) {
+ var me = this,
+ i = 0,
+ length = records.length;
-
- var dt = new Date(y < 100 ? 100 : y, m - 1, d, h, i, s, ms).add(Date.YEAR, y < 100 ? y - 100 : 0);
+ options = options || {};
- return y == dt.getFullYear() &&
- m == dt.getMonth() + 1 &&
- d == dt.getDate() &&
- h == dt.getHours() &&
- i == dt.getMinutes() &&
- s == dt.getSeconds() &&
- ms == dt.getMilliseconds();
- },
-
- parseDate : function(input, format, strict) {
- var p = Date.parseFunctions;
- if (p[format] == null) {
- Date.createParser(format);
+ if (!options.addRecords) {
+ delete me.snapshot;
+ me.data.clear();
}
- return p[format](input, Ext.isDefined(strict) ? strict : Date.useStrict);
- },
-
- getFormatCode : function(character) {
- var f = Date.formatCodes[character];
+ me.data.addAll(records);
- if (f) {
- f = typeof f == 'function'? f() : f;
- Date.formatCodes[character] = f;
+
+ for (; i < length; i++) {
+ if (options.start !== undefined) {
+ records[i].index = options.start + i;
+
+ }
+ records[i].join(me);
}
- return f || ("'" + String.escape(character) + "'");
- },
+ me.suspendEvents();
-
- createFormat : function(format) {
- var code = [],
- special = false,
- ch = '';
+ if (me.filterOnLoad && !me.remoteFilter) {
+ me.filter();
+ }
- for (var i = 0; i < format.length; ++i) {
- ch = format.charAt(i);
- if (!special && ch == "\\") {
- special = true;
- } else if (special) {
- special = false;
- code.push("'" + String.escape(ch) + "'");
- } else {
- code.push(Date.getFormatCode(ch));
- }
+ if (me.sortOnLoad && !me.remoteSort) {
+ me.sort();
}
- Date.formatFunctions[format] = new Function("return " + code.join('+'));
+
+ me.resumeEvents();
+ me.fireEvent('datachanged', me, records);
},
- createParser : function() {
- var code = [
- "var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,",
- "def = Date.defaults,",
- "results = String(input).match(Date.parseRegexes[{0}]);",
-
- "if(results){",
- "{1}",
-
- "if(u != null){",
- "v = new Date(u * 1000);",
- "}else{",
-
-
-
- "dt = (new Date()).clearTime();",
-
-
- "y = Ext.num(y, Ext.num(def.y, dt.getFullYear()));",
- "m = Ext.num(m, Ext.num(def.m - 1, dt.getMonth()));",
- "d = Ext.num(d, Ext.num(def.d, dt.getDate()));",
+
+ loadPage: function(page) {
+ var me = this;
-
- "h = Ext.num(h, Ext.num(def.h, dt.getHours()));",
- "i = Ext.num(i, Ext.num(def.i, dt.getMinutes()));",
- "s = Ext.num(s, Ext.num(def.s, dt.getSeconds()));",
- "ms = Ext.num(ms, Ext.num(def.ms, dt.getMilliseconds()));",
+ me.currentPage = page;
- "if(z >= 0 && y >= 0){",
-
-
+ me.read({
+ page: page,
+ start: (page - 1) * me.pageSize,
+ limit: me.pageSize,
+ addRecords: !me.clearOnPageLoad
+ });
+ },
-
-
- "v = new Date(y < 100 ? 100 : y, 0, 1, h, i, s, ms).add(Date.YEAR, y < 100 ? y - 100 : 0);",
+
+ nextPage: function() {
+ this.loadPage(this.currentPage + 1);
+ },
-
- "v = !strict? v : (strict === true && (z <= 364 || (v.isLeapYear() && z <= 365))? v.add(Date.DAY, z) : null);",
- "}else if(strict === true && !Date.isValid(y, m + 1, d, h, i, s, ms)){",
- "v = null;",
- "}else{",
-
-
- "v = new Date(y < 100 ? 100 : y, m, d, h, i, s, ms).add(Date.YEAR, y < 100 ? y - 100 : 0);",
- "}",
- "}",
- "}",
+
+ previousPage: function() {
+ this.loadPage(this.currentPage - 1);
+ },
- "if(v){",
-
- "if(zz != null){",
-
- "v = v.add(Date.SECOND, -v.getTimezoneOffset() * 60 - zz);",
- "}else if(o){",
-
- "v = v.add(Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));",
- "}",
- "}",
+
+ clearData: function() {
+ this.data.each(function(record) {
+ record.unjoin();
+ });
- "return v;"
- ].join('\n');
+ this.data.clear();
+ },
+
+
+
+ prefetch: function(options) {
+ var me = this,
+ operation,
+ requestId = me.getRequestId();
- return function(format) {
- var regexNum = Date.parseRegexes.length,
- currentGroup = 1,
- calc = [],
- regex = [],
- special = false,
- ch = "",
- i = 0,
- obj,
- last;
+ options = options || {};
- for (; i < format.length; ++i) {
- ch = format.charAt(i);
- if (!special && ch == "\\") {
- special = true;
- } else if (special) {
- special = false;
- regex.push(String.escape(ch));
- } else {
- obj = $f(ch, currentGroup);
- currentGroup += obj.g;
- regex.push(obj.s);
- if (obj.g && obj.c) {
- if (obj.calcLast) {
- last = obj.c;
- } else {
- calc.push(obj.c);
- }
- }
- }
- }
-
- if (last) {
- calc.push(last);
- }
+ Ext.applyIf(options, {
+ action : 'read',
+ filters: me.filters.items,
+ sorters: me.sorters.items,
+ requestId: requestId
+ });
+ me.pendingRequests.push(requestId);
- Date.parseRegexes[regexNum] = new RegExp("^" + regex.join('') + "$", 'i');
- Date.parseFunctions[format] = new Function("input", "strict", xf(code, regexNum, calc.join('')));
- };
- }(),
+ operation = Ext.create('Ext.data.Operation', options);
-
- parseCodes : {
- d: {
- g:1,
- c:"d = parseInt(results[{0}], 10);\n",
- s:"(\\d{2})"
- },
- j: {
- g:1,
- c:"d = parseInt(results[{0}], 10);\n",
- s:"(\\d{1,2})"
- },
- D: function() {
- for (var a = [], i = 0; i < 7; a.push(Date.getShortDayName(i)), ++i);
- return {
- g:0,
- c:null,
- s:"(?:" + a.join("|") +")"
- };
- },
- l: function() {
- return {
- g:0,
- c:null,
- s:"(?:" + Date.dayNames.join("|") + ")"
- };
- },
- N: {
- g:0,
- c:null,
- s:"[1-7]"
- },
- S: {
- g:0,
- c:null,
- s:"(?:st|nd|rd|th)"
- },
- w: {
- g:0,
- c:null,
- s:"[0-6]"
- },
- z: {
- g:1,
- c:"z = parseInt(results[{0}], 10);\n",
- s:"(\\d{1,3})"
- },
- W: {
- g:0,
- c:null,
- s:"(?:\\d{2})"
- },
- F: function() {
- return {
- g:1,
- c:"m = parseInt(Date.getMonthNumber(results[{0}]), 10);\n",
- s:"(" + Date.monthNames.join("|") + ")"
- };
- },
- M: function() {
- for (var a = [], i = 0; i < 12; a.push(Date.getShortMonthName(i)), ++i);
- return Ext.applyIf({
- s:"(" + a.join("|") + ")"
- }, $f("F"));
- },
- m: {
- g:1,
- c:"m = parseInt(results[{0}], 10) - 1;\n",
- s:"(\\d{2})"
- },
- n: {
- g:1,
- c:"m = parseInt(results[{0}], 10) - 1;\n",
- s:"(\\d{1,2})"
- },
- t: {
- g:0,
- c:null,
- s:"(?:\\d{2})"
- },
- L: {
- g:0,
- c:null,
- s:"(?:1|0)"
- },
- o: function() {
- return $f("Y");
- },
- Y: {
- g:1,
- c:"y = parseInt(results[{0}], 10);\n",
- s:"(\\d{4})"
- },
- y: {
- g:1,
- c:"var ty = parseInt(results[{0}], 10);\n"
- + "y = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;\n",
- s:"(\\d{1,2})"
- },
- a: function(){
- return $f("A");
- },
- A: {
-
- calcLast: true,
- g:1,
- c:"if (/(am)/i.test(results[{0}])) {\n"
- + "if (!h || h == 12) { h = 0; }\n"
- + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
- s:"(AM|PM|am|pm)"
- },
- g: function() {
- return $f("G");
- },
- G: {
- g:1,
- c:"h = parseInt(results[{0}], 10);\n",
- s:"(\\d{1,2})"
- },
- h: function() {
- return $f("H");
- },
- H: {
- g:1,
- c:"h = parseInt(results[{0}], 10);\n",
- s:"(\\d{2})"
- },
- i: {
- g:1,
- c:"i = parseInt(results[{0}], 10);\n",
- s:"(\\d{2})"
- },
- s: {
- g:1,
- c:"s = parseInt(results[{0}], 10);\n",
- s:"(\\d{2})"
- },
- u: {
- g:1,
- c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n",
- s:"(\\d+)"
- },
- O: {
- g:1,
- c:[
- "o = results[{0}];",
- "var sn = o.substring(0,1),",
- "hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),",
- "mn = o.substring(3,5) % 60;",
- "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + String.leftPad(hr, 2, '0') + String.leftPad(mn, 2, '0')) : null;\n"
- ].join("\n"),
- s: "([+\-]\\d{4})"
- },
- P: {
- g:1,
- c:[
- "o = results[{0}];",
- "var sn = o.substring(0,1),",
- "hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),",
- "mn = o.substring(4,6) % 60;",
- "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + String.leftPad(hr, 2, '0') + String.leftPad(mn, 2, '0')) : null;\n"
- ].join("\n"),
- s: "([+\-]\\d{2}:\\d{2})"
- },
- T: {
- g:0,
- c:null,
- s:"[A-Z]{1,4}"
- },
- Z: {
- g:1,
- c:"zz = results[{0}] * 1;\n"
- + "zz = (-43200 <= zz && zz <= 50400)? zz : null;\n",
- s:"([+\-]?\\d{1,5})"
- },
- c: function() {
- var calc = [],
- arr = [
- $f("Y", 1),
- $f("m", 2),
- $f("d", 3),
- $f("h", 4),
- $f("i", 5),
- $f("s", 6),
- {c:"ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"},
- {c:[
- "if(results[8]) {",
- "if(results[8] == 'Z'){",
- "zz = 0;",
- "}else if (results[8].indexOf(':') > -1){",
- $f("P", 8).c,
- "}else{",
- $f("O", 8).c,
- "}",
- "}"
- ].join('\n')}
- ];
-
- for (var i = 0, l = arr.length; i < l; ++i) {
- calc.push(arr[i].c);
- }
-
- return {
- g:1,
- c:calc.join(""),
- s:[
- arr[0].s,
- "(?:", "-", arr[1].s,
- "(?:", "-", arr[2].s,
- "(?:",
- "(?:T| )?",
- arr[3].s, ":", arr[4].s,
- "(?::", arr[5].s, ")?",
- "(?:(?:\\.|,)(\\d+))?",
- "(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?",
- ")?",
- ")?",
- ")?"
- ].join("")
- };
- },
- U: {
- g:1,
- c:"u = parseInt(results[{0}], 10);\n",
- s:"(-?\\d+)"
+
+
+ if (me.fireEvent('beforeprefetch', me, operation) !== false) {
+ me.loading = true;
+ me.proxy.read(operation, me.onProxyPrefetch, me);
}
- }
-});
-
-}());
-
-Ext.apply(Date.prototype, {
+
+ return me;
+ },
- dateFormat : function(format) {
- if (Date.formatFunctions[format] == null) {
- Date.createFormat(format);
+
+ prefetchPage: function(page, options) {
+ var me = this,
+ pageSize = me.pageSize,
+ start = (page - 1) * me.pageSize,
+ end = start + pageSize;
+
+
+ if (Ext.Array.indexOf(me.pagesRequested, page) === -1 && !me.rangeSatisfied(start, end)) {
+ options = options || {};
+ me.pagesRequested.push(page);
+ Ext.applyIf(options, {
+ page : page,
+ start: start,
+ limit: pageSize,
+ callback: me.onWaitForGuarantee,
+ scope: me
+ });
+
+ me.prefetch(options);
}
- return Date.formatFunctions[format].call(this);
+
},
-
- getTimezone : function() {
+
+ getRequestId: function() {
+ this.requestSeed = this.requestSeed || 1;
+ return this.requestSeed++;
+ },
+
+
+ onProxyPrefetch: function(operation) {
+ var me = this,
+ resultSet = operation.getResultSet(),
+ records = operation.getRecords(),
+
+ successful = operation.wasSuccessful();
+
+ if (resultSet) {
+ me.totalCount = resultSet.total;
+ me.fireEvent('totalcountchange', me.totalCount);
+ }
+
+ if (successful) {
+ me.cacheRecords(records, operation);
+ }
+ Ext.Array.remove(me.pendingRequests, operation.requestId);
+ if (operation.page) {
+ Ext.Array.remove(me.pagesRequested, operation.page);
+ }
+ me.loading = false;
+ me.fireEvent('prefetch', me, records, successful, operation);
+ if (operation.blocking) {
+ me.fireEvent('load', me, records, successful);
+ }
+
+
+ Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
+ },
+
+
+ cacheRecords: function(records, operation) {
+ var me = this,
+ i = 0,
+ length = records.length,
+ start = operation ? operation.start : 0;
+
+ if (!Ext.isDefined(me.totalCount)) {
+ me.totalCount = records.length;
+ me.fireEvent('totalcountchange', me.totalCount);
+ }
+ for (; i < length; i++) {
+
+ records[i].index = start + i;
+ }
+ me.prefetchData.addAll(records);
+ if (me.purgePageCount) {
+ me.purgeRecords();
+ }
+ },
+
+
+
+ purgeRecords: function() {
+ var me = this,
+ prefetchCount = me.prefetchData.getCount(),
+ purgeCount = me.purgePageCount * me.pageSize,
+ numRecordsToPurge = prefetchCount - purgeCount - 1,
+ i = 0;
+
+ for (; i <= numRecordsToPurge; i++) {
+ me.prefetchData.removeAt(0);
+ }
+ },
+
+
+ rangeSatisfied: function(start, end) {
+ var me = this,
+ i = start,
+ satisfied = true;
+
+ for (; i < end; i++) {
+ if (!me.prefetchData.getByKey(i)) {
+ satisfied = false;
+ if (end - i > me.pageSize) {
+ Ext.Error.raise("A single page prefetch could never satisfy this request.");
+ }
+ break;
+ }
+ }
+ return satisfied;
+ },
+
+
+ getPageFromRecordIndex: function(index) {
+ return Math.floor(index / this.pageSize) + 1;
+ },
+
+
+ onGuaranteedRange: function() {
+ var me = this,
+ totalCount = me.getTotalCount(),
+ start = me.requestStart,
+ end = ((totalCount - 1) < me.requestEnd) ? totalCount - 1 : me.requestEnd,
+ range = [],
+ record,
+ i = start;
+
+ if (start > end) {
+ Ext.Error.raise("Start (" + start + ") was greater than end (" + end + ")");
+ }
+ if (start !== me.guaranteedStart && end !== me.guaranteedEnd) {
+ me.guaranteedStart = start;
+ me.guaranteedEnd = end;
+
+ for (; i <= end; i++) {
+ record = me.prefetchData.getByKey(i);
+ if (!record) {
+ Ext.Error.raise("Record was not found and store said it was guaranteed");
+ }
+ range.push(record);
+ }
+ me.fireEvent('guaranteedrange', range, start, end);
+ if (me.cb) {
+ me.cb.call(me.scope || me, range);
+ }
+ }
+ me.unmask();
+ },
+
+
+ mask: function() {
+ this.masked = true;
+ this.fireEvent('beforeload');
+ },
+
+
+ unmask: function() {
+ if (this.masked) {
+ this.fireEvent('load');
+ }
+ },
+
+
+ hasPendingRequests: function() {
+ return this.pendingRequests.length;
+ },
+
+
+
+ onWaitForGuarantee: function() {
+ if (!this.hasPendingRequests()) {
+ this.onGuaranteedRange();
+ }
+ },
+
+
+ guaranteeRange: function(start, end, cb, scope) {
+ if (start && end) {
+ if (end - start > this.pageSize) {
+ Ext.Error.raise({
+ start: start,
+ end: end,
+ pageSize: this.pageSize,
+ msg: "Requested a bigger range than the specified pageSize"
+ });
+ }
+ }
+ end = (end > this.totalCount) ? this.totalCount - 1 : end;
+ var me = this,
+ i = start,
+ prefetchData = me.prefetchData,
+ range = [],
+ startLoaded = !!prefetchData.getByKey(start),
+ endLoaded = !!prefetchData.getByKey(end),
+ startPage = me.getPageFromRecordIndex(start),
+ endPage = me.getPageFromRecordIndex(end);
+
+ me.cb = cb;
+ me.scope = scope;
+
+ me.requestStart = start;
+ me.requestEnd = end;
+ if (!startLoaded || !endLoaded) {
+
+ if (startPage === endPage) {
+ me.mask();
+ me.prefetchPage(startPage, {
+
+ callback: me.onWaitForGuarantee,
+ scope: me
+ });
+
+ } else {
+ me.mask();
+ me.prefetchPage(startPage, {
+
+ callback: me.onWaitForGuarantee,
+ scope: me
+ });
+ me.prefetchPage(endPage, {
+
+ callback: me.onWaitForGuarantee,
+ scope: me
+ });
+ }
- return this.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, "");
+ } else {
+ me.onGuaranteedRange();
+ }
},
-
- getGMTOffset : function(colon) {
- return (this.getTimezoneOffset() > 0 ? "-" : "+")
- + String.leftPad(Math.floor(Math.abs(this.getTimezoneOffset()) / 60), 2, "0")
- + (colon ? ":" : "")
- + String.leftPad(Math.abs(this.getTimezoneOffset() % 60), 2, "0");
+
+
+ sort: function() {
+ var me = this,
+ prefetchData = me.prefetchData,
+ sorters,
+ start,
+ end,
+ range;
+
+ if (me.buffered) {
+ if (me.remoteSort) {
+ prefetchData.clear();
+ me.callParent(arguments);
+ } else {
+ sorters = me.getSorters();
+ start = me.guaranteedStart;
+ end = me.guaranteedEnd;
+ range;
+
+ if (sorters.length) {
+ prefetchData.sort(sorters);
+ range = prefetchData.getRange();
+ prefetchData.clear();
+ me.cacheRecords(range);
+ delete me.guaranteedStart;
+ delete me.guaranteedEnd;
+ me.guaranteeRange(start, end);
+ }
+ me.callParent(arguments);
+ }
+ } else {
+ me.callParent(arguments);
+ }
},
- getDayOfYear: function() {
- var num = 0,
- d = this.clone(),
- m = this.getMonth(),
- i;
-
- for (i = 0, d.setDate(1), d.setMonth(0); i < m; d.setMonth(++i)) {
- num += d.getDaysInMonth();
+
+
+ doSort: function(sorterFn) {
+ var me = this;
+ if (me.remoteSort) {
+
+ me.load();
+ } else {
+ me.data.sortBy(sorterFn);
+ if (!me.buffered) {
+ var range = me.getRange(),
+ ln = range.length,
+ i = 0;
+ for (; i < ln; i++) {
+ range[i].index = i;
+ }
+ }
+ me.fireEvent('datachanged', me);
}
- return num + this.getDate() - 1;
},
-
- getWeekOfYear : function() {
-
- var ms1d = 864e5,
- ms7d = 7 * ms1d;
+
+ find: function(property, value, start, anyMatch, caseSensitive, exactMatch) {
+ var fn = this.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch);
+ return fn ? this.data.findIndexBy(fn, null, start) : -1;
+ },
- return function() {
- var DC3 = Date.UTC(this.getFullYear(), this.getMonth(), this.getDate() + 3) / ms1d,
- AWN = Math.floor(DC3 / 7),
- Wyr = new Date(AWN * ms7d).getUTCFullYear();
+
+ findRecord: function() {
+ var me = this,
+ index = me.find.apply(me, arguments);
+ return index !== -1 ? me.getAt(index) : null;
+ },
- return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;
+
+ createFilterFn: function(property, value, anyMatch, caseSensitive, exactMatch) {
+ if (Ext.isEmpty(value)) {
+ return false;
+ }
+ value = this.data.createValueMatcher(value, anyMatch, caseSensitive, exactMatch);
+ return function(r) {
+ return value.test(r.data[property]);
};
- }(),
+ },
- isLeapYear : function() {
- var year = this.getFullYear();
- return !!((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
+ findExact: function(property, value, start) {
+ return this.data.findIndexBy(function(rec) {
+ return rec.get(property) === value;
+ },
+ this, start);
},
- getFirstDayOfMonth : function() {
- var day = (this.getDay() - (this.getDate() - 1)) % 7;
- return (day < 0) ? (day + 7) : day;
+ findBy: function(fn, scope, start) {
+ return this.data.findIndexBy(fn, scope, start);
},
- getLastDayOfMonth : function() {
- return this.getLastDateOfMonth().getDay();
- },
+ collect: function(dataIndex, allowNull, bypassFilter) {
+ var me = this,
+ data = (bypassFilter === true && me.snapshot) ? me.snapshot: me.data;
+ return data.collect(dataIndex, 'data', allowNull);
+ },
- getFirstDateOfMonth : function() {
- return new Date(this.getFullYear(), this.getMonth(), 1);
+ getCount: function() {
+ return this.data.length || 0;
},
- getLastDateOfMonth : function() {
- return new Date(this.getFullYear(), this.getMonth(), this.getDaysInMonth());
+ getTotalCount: function() {
+ return this.totalCount;
},
- getDaysInMonth: function() {
- var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-
- return function() {
- var m = this.getMonth();
-
- return m == 1 && this.isLeapYear() ? 29 : daysInMonth[m];
- };
- }(),
+ getAt: function(index) {
+ return this.data.getAt(index);
+ },
- getSuffix : function() {
- switch (this.getDate()) {
- case 1:
- case 21:
- case 31:
- return "st";
- case 2:
- case 22:
- return "nd";
- case 3:
- case 23:
- return "rd";
- default:
- return "th";
- }
+ getRange: function(start, end) {
+ return this.data.getRange(start, end);
},
- clone : function() {
- return new Date(this.getTime());
+ getById: function(id) {
+ return (this.snapshot || this.data).findBy(function(record) {
+ return record.getId() === id;
+ });
},
- isDST : function() {
-
-
- return new Date(this.getFullYear(), 0, 1).getTimezoneOffset() != this.getTimezoneOffset();
+ indexOf: function(record) {
+ return this.data.indexOf(record);
},
+
- clearTime : function(clone) {
- if (clone) {
- return this.clone().clearTime();
- }
+ indexOfTotal: function(record) {
+ return record.index || this.indexOf(record);
+ },
+
+ indexOfId: function(id) {
+ return this.data.indexOfKey(id);
+ },
- var d = this.getDate();
+
+ removeAll: function(silent) {
+ var me = this;
-
- this.setHours(0);
- this.setMinutes(0);
- this.setSeconds(0);
- this.setMilliseconds(0);
+ me.clearData();
+ if (me.snapshot) {
+ me.snapshot.clear();
+ }
+ if (silent !== true) {
+ me.fireEvent('clear', me);
+ }
+ },
- if (this.getDate() != d) {
-
-
+
-
- for (var hr = 1, c = this.add(Date.HOUR, hr); c.getDate() != d; hr++, c = this.add(Date.HOUR, hr));
+
+ first: function(grouped) {
+ var me = this;
- this.setDate(d);
- this.setHours(c.getHours());
+ if (grouped && me.isGrouped()) {
+ return me.aggregate(function(records) {
+ return records.length ? records[0] : undefined;
+ }, me, true);
+ } else {
+ return me.data.first();
}
-
- return this;
},
- add : function(interval, value) {
- var d = this.clone();
- if (!interval || value === 0) return d;
+ last: function(grouped) {
+ var me = this;
- switch(interval.toLowerCase()) {
- case Date.MILLI:
- d.setMilliseconds(this.getMilliseconds() + value);
- break;
- case Date.SECOND:
- d.setSeconds(this.getSeconds() + value);
- break;
- case Date.MINUTE:
- d.setMinutes(this.getMinutes() + value);
- break;
- case Date.HOUR:
- d.setHours(this.getHours() + value);
- break;
- case Date.DAY:
- d.setDate(this.getDate() + value);
- break;
- case Date.MONTH:
- var day = this.getDate();
- if (day > 28) {
- day = Math.min(day, this.getFirstDateOfMonth().add('mo', value).getLastDateOfMonth().getDate());
- }
- d.setDate(day);
- d.setMonth(this.getMonth() + value);
- break;
- case Date.YEAR:
- d.setFullYear(this.getFullYear() + value);
- break;
+ if (grouped && me.isGrouped()) {
+ return me.aggregate(function(records) {
+ var len = records.length;
+ return len ? records[len - 1] : undefined;
+ }, me, true);
+ } else {
+ return me.data.last();
}
- return d;
},
- between : function(start, end) {
- var t = this.getTime();
- return start.getTime() <= t && t <= end.getTime();
- }
-});
-
-
-
-Date.prototype.format = Date.prototype.dateFormat;
-
-
-
-if (Ext.isSafari && (navigator.userAgent.match(/WebKit\/(\d+)/)[1] || NaN) < 420) {
- Ext.apply(Date.prototype, {
- _xMonth : Date.prototype.setMonth,
- _xDate : Date.prototype.setDate,
-
-
-
- setMonth : function(num) {
- if (num <= -1) {
- var n = Math.ceil(-num),
- back_year = Math.ceil(n / 12),
- month = (n % 12) ? 12 - n % 12 : 0;
+ sum: function(field, grouped) {
+ var me = this;
- this.setFullYear(this.getFullYear() - back_year);
+ if (grouped && me.isGrouped()) {
+ return me.aggregate(me.getSum, me, true, [field]);
+ } else {
+ return me.getSum(me.data.items, field);
+ }
+ },
- return this._xMonth(month);
- } else {
- return this._xMonth(num);
- }
- },
+
+ getSum: function(records, field) {
+ var total = 0,
+ i = 0,
+ len = records.length;
-
-
-
- setDate : function(d) {
-
-
- return this.setTime(this.getTime() - (this.getDate() - d) * 864e5);
+ for (; i < len; ++i) {
+ total += records[i].get(field);
}
- });
-}
-
+ return total;
+ },
+
+ count: function(grouped) {
+ var me = this;
+ if (grouped && me.isGrouped()) {
+ return me.aggregate(function(records) {
+ return records.length;
+ }, me, true);
+ } else {
+ return me.getCount();
+ }
+ },
-Ext.util.MixedCollection = function(allowFunctions, keyFn){
- this.items = [];
- this.map = {};
- this.keys = [];
- this.length = 0;
- this.addEvents(
-
- 'clear',
-
- 'add',
-
- 'replace',
-
- 'remove',
- 'sort'
- );
- this.allowFunctions = allowFunctions === true;
- if(keyFn){
- this.getKey = keyFn;
- }
- Ext.util.MixedCollection.superclass.constructor.call(this);
-};
+
+ min: function(field, grouped) {
+ var me = this;
-Ext.extend(Ext.util.MixedCollection, Ext.util.Observable, {
+ if (grouped && me.isGrouped()) {
+ return me.aggregate(me.getMin, me, true, [field]);
+ } else {
+ return me.getMin(me.data.items, field);
+ }
+ },
- allowFunctions : false,
+ getMin: function(records, field){
+ var i = 1,
+ len = records.length,
+ value, min;
-
- add : function(key, o){
- if(arguments.length == 1){
- o = arguments[0];
- key = this.getKey(o);
+ if (len > 0) {
+ min = records[0].get(field);
}
- if(typeof key != 'undefined' && key !== null){
- var old = this.map[key];
- if(typeof old != 'undefined'){
- return this.replace(key, o);
+
+ for (; i < len; ++i) {
+ value = records[i].get(field);
+ if (value < min) {
+ min = value;
}
- this.map[key] = o;
}
- this.length++;
- this.items.push(o);
- this.keys.push(key);
- this.fireEvent('add', this.length-1, o, key);
- return o;
+ return min;
},
- getKey : function(o){
- return o.id;
- },
+ max: function(field, grouped) {
+ var me = this;
-
- replace : function(key, o){
- if(arguments.length == 1){
- o = arguments[0];
- key = this.getKey(o);
- }
- var old = this.map[key];
- if(typeof key == 'undefined' || key === null || typeof old == 'undefined'){
- return this.add(key, o);
+ if (grouped && me.isGrouped()) {
+ return me.aggregate(me.getMax, me, true, [field]);
+ } else {
+ return me.getMax(me.data.items, field);
}
- var index = this.indexOfKey(key);
- this.items[index] = o;
- this.map[key] = o;
- this.fireEvent('replace', key, old, o);
- return o;
},
- addAll : function(objs){
- if(arguments.length > 1 || Ext.isArray(objs)){
- var args = arguments.length > 1 ? arguments : objs;
- for(var i = 0, len = args.length; i < len; i++){
- this.add(args[i]);
- }
- }else{
- for(var key in objs){
- if(this.allowFunctions || typeof objs[key] != 'function'){
- this.add(key, objs[key]);
- }
- }
+ getMax: function(records, field) {
+ var i = 1,
+ len = records.length,
+ value,
+ max;
+
+ if (len > 0) {
+ max = records[0].get(field);
}
- },
-
- each : function(fn, scope){
- var items = [].concat(this.items);
- for(var i = 0, len = items.length; i < len; i++){
- if(fn.call(scope || items[i], items[i], i, len) === false){
- break;
+ for (; i < len; ++i) {
+ value = records[i].get(field);
+ if (value > max) {
+ max = value;
}
}
+ return max;
},
- eachKey : function(fn, scope){
- for(var i = 0, len = this.keys.length; i < len; i++){
- fn.call(scope || window, this.keys[i], this.items[i], i, len);
+ average: function(field, grouped) {
+ var me = this;
+ if (grouped && me.isGrouped()) {
+ return me.aggregate(me.getAverage, me, true, [field]);
+ } else {
+ return me.getAverage(me.data.items, field);
}
},
- find : function(fn, scope){
- for(var i = 0, len = this.items.length; i < len; i++){
- if(fn.call(scope || window, this.items[i], this.keys[i])){
- return this.items[i];
+ getAverage: function(records, field) {
+ var i = 0,
+ len = records.length,
+ sum = 0;
+
+ if (records.length > 0) {
+ for (; i < len; ++i) {
+ sum += records[i].get(field);
}
+ return sum / len;
}
- return null;
+ return 0;
},
- insert : function(index, key, o){
- if(arguments.length == 2){
- o = arguments[1];
- key = this.getKey(o);
- }
- if(this.containsKey(key)){
- this.suspendEvents();
- this.removeKey(key);
- this.resumeEvents();
- }
- if(index >= this.length){
- return this.add(key, o);
- }
- this.length++;
- this.items.splice(index, 0, o);
- if(typeof key != 'undefined' && key !== null){
- this.map[key] = o;
+ aggregate: function(fn, scope, grouped, args) {
+ args = args || [];
+ if (grouped && this.isGrouped()) {
+ var groups = this.getGroups(),
+ i = 0,
+ len = groups.length,
+ out = {},
+ group;
+
+ for (; i < len; ++i) {
+ group = groups[i];
+ out[group.name] = fn.apply(scope || this, [group.children].concat(args));
+ }
+ return out;
+ } else {
+ return fn.apply(scope || this, [this.data.items].concat(args));
}
- this.keys.splice(index, 0, key);
- this.fireEvent('add', index, o, key);
- return o;
- },
+ }
+});
-
- remove : function(o){
- return this.removeAt(this.indexOf(o));
- },
-
- removeAt : function(index){
- if(index < this.length && index >= 0){
- this.length--;
- var o = this.items[index];
- this.items.splice(index, 1);
- var key = this.keys[index];
- if(typeof key != 'undefined'){
- delete this.map[key];
- }
- this.keys.splice(index, 1);
- this.fireEvent('remove', o, key);
- return o;
- }
- return false;
- },
+Ext.define('Ext.data.JsonStore', {
+ extend: 'Ext.data.Store',
+ alias: 'store.json',
- removeKey : function(key){
- return this.removeAt(this.indexOfKey(key));
- },
+ constructor: function(config) {
+ config = config || {};
-
- getCount : function(){
- return this.length;
- },
+ Ext.applyIf(config, {
+ proxy: {
+ type : 'ajax',
+ reader: 'json',
+ writer: 'json'
+ }
+ });
-
- indexOf : function(o){
- return this.items.indexOf(o);
- },
+ this.callParent([config]);
+ }
+});
-
- indexOfKey : function(key){
- return this.keys.indexOf(key);
- },
-
- item : function(key){
- var mk = this.map[key],
- item = mk !== undefined ? mk : (typeof key == 'number') ? this.items[key] : undefined;
- return typeof item != 'function' || this.allowFunctions ? item : null;
- },
+Ext.define('Ext.chart.axis.Time', {
- itemAt : function(index){
- return this.items[index];
- },
-
- key : function(key){
- return this.map[key];
- },
+ extend: 'Ext.chart.axis.Category',
-
- contains : function(o){
- return this.indexOf(o) != -1;
- },
+ alternateClassName: 'Ext.chart.TimeAxis',
-
- containsKey : function(key){
- return typeof this.map[key] != 'undefined';
- },
+ alias: 'axis.time',
-
- clear : function(){
- this.length = 0;
- this.items = [];
- this.keys = [];
- this.map = {};
- this.fireEvent('clear');
- },
+ requires: ['Ext.data.Store', 'Ext.data.JsonStore'],
- first : function(){
- return this.items[0];
- },
+
+ calculateByLabelSize: true,
- last : function(){
- return this.items[this.length-1];
+
+ dateFormat: false,
+
+
+ groupBy: 'year,month,day',
+
+
+ aggregateOp: 'sum',
+
+
+ fromDate: false,
+
+
+ toDate: false,
+
+
+ step: [Ext.Date.DAY, 1],
+
+
+ constrain: false,
+
+
+ dateMethods: {
+ 'year': function(date) {
+ return date.getFullYear();
+ },
+ 'month': function(date) {
+ return date.getMonth() + 1;
+ },
+ 'day': function(date) {
+ return date.getDate();
+ },
+ 'hour': function(date) {
+ return date.getHours();
+ },
+ 'minute': function(date) {
+ return date.getMinutes();
+ },
+ 'second': function(date) {
+ return date.getSeconds();
+ },
+ 'millisecond': function(date) {
+ return date.getMilliseconds();
+ }
},
-
- _sort : function(property, dir, fn){
- var i, len,
- dsc = String(dir).toUpperCase() == 'DESC' ? -1 : 1,
-
-
- c = [],
- keys = this.keys,
- items = this.items;
-
-
- fn = fn || function(a, b) {
- return a - b;
+
+ aggregateFn: (function() {
+ var etype = (function() {
+ var rgxp = /^\[object\s(.*)\]$/,
+ toString = Object.prototype.toString;
+ return function(e) {
+ return toString.call(e).match(rgxp)[1];
+ };
+ })();
+ return {
+ 'sum': function(list) {
+ var i = 0, l = list.length, acum = 0;
+ if (!list.length || etype(list[0]) != 'Number') {
+ return list[0];
+ }
+ for (; i < l; i++) {
+ acum += list[i];
+ }
+ return acum;
+ },
+ 'max': function(list) {
+ if (!list.length || etype(list[0]) != 'Number') {
+ return list[0];
+ }
+ return Math.max.apply(Math, list);
+ },
+ 'min': function(list) {
+ if (!list.length || etype(list[0]) != 'Number') {
+ return list[0];
+ }
+ return Math.min.apply(Math, list);
+ },
+ 'avg': function(list) {
+ var i = 0, l = list.length, acum = 0;
+ if (!list.length || etype(list[0]) != 'Number') {
+ return list[0];
+ }
+ for (; i < l; i++) {
+ acum += list[i];
+ }
+ return acum / l;
+ }
};
-
+ })(),
+
+
+ constrainDates: function() {
+ var fromDate = Ext.Date.clone(this.fromDate),
+ toDate = Ext.Date.clone(this.toDate),
+ step = this.step,
+ field = this.fields,
+ store = this.chart.store,
+ record, recObj, fieldNames = [],
+ newStore = Ext.create('Ext.data.Store', {
+ model: store.model
+ });
- for(i = 0, len = items.length; i < len; i++){
- c[c.length] = {
- key : keys[i],
- value: items[i],
- index: i
+ var getRecordByDate = (function() {
+ var index = 0, l = store.getCount();
+ return function(date) {
+ var rec, recDate;
+ for (; index < l; index++) {
+ rec = store.getAt(index);
+ recDate = rec.get(field);
+ if (+recDate > +date) {
+ return false;
+ } else if (+recDate == +date) {
+ return rec;
+ }
+ }
+ return false;
};
+ })();
+
+ if (!this.constrain) {
+ this.chart.filteredStore = this.chart.store;
+ return;
}
-
- c.sort(function(a, b){
- var v = fn(a[property], b[property]) * dsc;
- if(v === 0){
- v = (a.index < b.index ? -1 : 1);
+ while(+fromDate <= +toDate) {
+ record = getRecordByDate(fromDate);
+ recObj = {};
+ if (record) {
+ newStore.add(record.data);
+ } else {
+ newStore.model.prototype.fields.each(function(f) {
+ recObj[f.name] = false;
+ });
+ recObj.date = fromDate;
+ newStore.add(recObj);
+ }
+ fromDate = Ext.Date.add(fromDate, step[0], step[1]);
+ }
+
+ this.chart.filteredStore = newStore;
+ },
+
+
+ aggregate: function() {
+ var aggStore = {},
+ aggKeys = [], key, value,
+ op = this.aggregateOp,
+ field = this.fields, i,
+ fields = this.groupBy.split(','),
+ curField,
+ recFields = [],
+ recFieldsLen = 0,
+ obj,
+ dates = [],
+ json = [],
+ l = fields.length,
+ dateMethods = this.dateMethods,
+ aggregateFn = this.aggregateFn,
+ store = this.chart.filteredStore || this.chart.store;
+
+ store.each(function(rec) {
+
+ if (!recFields.length) {
+ rec.fields.each(function(f) {
+ recFields.push(f.name);
+ });
+ recFieldsLen = recFields.length;
+ }
+
+ value = rec.get(field);
+
+ for (i = 0; i < l; i++) {
+ if (i == 0) {
+ key = String(dateMethods[fields[i]](value));
+ } else {
+ key += '||' + dateMethods[fields[i]](value);
+ }
+ }
+
+ if (key in aggStore) {
+ obj = aggStore[key];
+ } else {
+ obj = aggStore[key] = {};
+ aggKeys.push(key);
+ dates.push(value);
+ }
+
+ for (i = 0; i < recFieldsLen; i++) {
+ curField = recFields[i];
+ if (!obj[curField]) {
+ obj[curField] = [];
+ }
+ if (rec.get(curField) !== undefined) {
+ obj[curField].push(rec.get(curField));
+ }
}
- return v;
});
-
- for(i = 0, len = c.length; i < len; i++){
- items[i] = c[i].value;
- keys[i] = c[i].key;
+ for (key in aggStore) {
+ obj = aggStore[key];
+ for (i = 0; i < recFieldsLen; i++) {
+ curField = recFields[i];
+ obj[curField] = aggregateFn[op](obj[curField]);
+ }
+ json.push(obj);
}
+ this.chart.substore = Ext.create('Ext.data.JsonStore', {
+ fields: recFields,
+ data: json
+ });
+
+ this.dates = dates;
+ },
+
+
+ setLabels: function() {
+ var store = this.chart.substore,
+ fields = this.fields,
+ format = this.dateFormat,
+ labels, i, dates = this.dates,
+ formatFn = Ext.Date.format;
+ this.labels = labels = [];
+ store.each(function(record, i) {
+ if (!format) {
+ labels.push(record.get(fields));
+ } else {
+ labels.push(formatFn(dates[i], format));
+ }
+ }, this);
+ },
- this.fireEvent('sort', this);
+ processView: function() {
+
+ if (this.constrain) {
+ this.constrainDates();
+ this.aggregate();
+ this.chart.substore = this.chart.filteredStore;
+ } else {
+ this.aggregate();
+ }
},
+
+ applyData: function() {
+ this.setLabels();
+ var count = this.chart.substore.getCount();
+ return {
+ from: 0,
+ to: count,
+ steps: count - 1,
+ step: 1
+ };
+ }
+ });
+
+
+
+Ext.define('Ext.chart.series.Series', {
+
- sort : function(dir, fn){
- this._sort('value', dir, fn);
+
+ mixins: {
+ observable: 'Ext.util.Observable',
+ labels: 'Ext.chart.Label',
+ highlights: 'Ext.chart.Highlight',
+ tips: 'Ext.chart.Tip',
+ callouts: 'Ext.chart.Callout'
},
- reorder: function(mapping) {
- this.suspendEvents();
-
- var items = this.items,
- index = 0,
- length = items.length,
- order = [],
- remaining = [],
- oldIndex;
-
- for (oldIndex in mapping) {
- order[mapping[oldIndex]] = items[oldIndex];
- }
+
- for (index = 0; index < length; index++) {
- if (mapping[index] == undefined) {
- remaining.push(items[index]);
- }
- }
+
- for (index = 0; index < length; index++) {
- if (order[index] == undefined) {
- order[index] = remaining.shift();
- }
- }
+
+ type: null,
- this.clear();
- this.addAll(order);
+
+ title: null,
- this.resumeEvents();
- this.fireEvent('sort', this);
- },
+
+ showInLegend: true,
- keySort : function(dir, fn){
- this._sort('key', dir, fn || function(a, b){
- var v1 = String(a).toUpperCase(), v2 = String(b).toUpperCase();
- return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
- });
+ renderer: function(sprite, record, attributes, index, store) {
+ return attributes;
},
- getRange : function(start, end){
- var items = this.items;
- if(items.length < 1){
- return [];
- }
- start = start || 0;
- end = Math.min(typeof end == 'undefined' ? this.length-1 : end, this.length-1);
- var i, r = [];
- if(start <= end){
- for(i = start; i <= end; i++) {
- r[r.length] = items[i];
- }
- }else{
- for(i = start; i >= end; i--) {
- r[r.length] = items[i];
- }
- }
- return r;
- },
+ shadowAttributes: null,
+
+ //@private triggerdrawlistener flag
+
+ triggerAfterDraw: false,
- filter : function(property, value, anyMatch, caseSensitive){
- if(Ext.isEmpty(value, false)){
- return this.clone();
+
+ constructor: function(config) {
+ var me = this;
+ if (config) {
+ Ext.apply(me, config);
}
- value = this.createValueMatcher(value, anyMatch, caseSensitive);
- return this.filterBy(function(o){
- return o && value.test(o[property]);
+
+ me.shadowGroups = [];
+
+ me.mixins.labels.constructor.call(me, config);
+ me.mixins.highlights.constructor.call(me, config);
+ me.mixins.tips.constructor.call(me, config);
+ me.mixins.callouts.constructor.call(me, config);
+
+ me.addEvents({
+ scope: me,
+ itemmouseover: true,
+ itemmouseout: true,
+ itemmousedown: true,
+ itemmouseup: true,
+ mouseleave: true,
+ afterdraw: true,
+
+
+ titlechange: true
+ });
+
+ me.mixins.observable.constructor.call(me, config);
+
+ me.on({
+ scope: me,
+ itemmouseover: me.onItemMouseOver,
+ itemmouseout: me.onItemMouseOut,
+ mouseleave: me.onMouseLeave
});
},
- filterBy : function(fn, scope){
- var r = new Ext.util.MixedCollection();
- r.getKey = this.getKey;
- var k = this.keys, it = this.items;
- for(var i = 0, len = it.length; i < len; i++){
- if(fn.call(scope||this, it[i], k[i])){
- r.add(k[i], it[i]);
- }
- }
- return r;
+ setBBox: function(noGutter) {
+ var me = this,
+ chart = me.chart,
+ chartBBox = chart.chartBBox,
+ gutterX = noGutter ? 0 : chart.maxGutter[0],
+ gutterY = noGutter ? 0 : chart.maxGutter[1],
+ clipBox, bbox;
+
+ clipBox = {
+ x: chartBBox.x,
+ y: chartBBox.y,
+ width: chartBBox.width,
+ height: chartBBox.height
+ };
+ me.clipBox = clipBox;
+
+ bbox = {
+ x: (clipBox.x + gutterX) - (chart.zoom.x * chart.zoom.width),
+ y: (clipBox.y + gutterY) - (chart.zoom.y * chart.zoom.height),
+ width: (clipBox.width - (gutterX * 2)) * chart.zoom.width,
+ height: (clipBox.height - (gutterY * 2)) * chart.zoom.height
+ };
+ me.bbox = bbox;
},
- findIndex : function(property, value, start, anyMatch, caseSensitive){
- if(Ext.isEmpty(value, false)){
- return -1;
+ onAnimate: function(sprite, attr) {
+ var me = this;
+ sprite.stopAnimation();
+ if (me.triggerAfterDraw) {
+ return sprite.animate(Ext.applyIf(attr, me.chart.animate));
+ } else {
+ me.triggerAfterDraw = true;
+ return sprite.animate(Ext.apply(Ext.applyIf(attr, me.chart.animate), {
+ listeners: {
+ 'afteranimate': function() {
+ me.triggerAfterDraw = false;
+ me.fireEvent('afterrender');
+ }
+ }
+ }));
}
- value = this.createValueMatcher(value, anyMatch, caseSensitive);
- return this.findIndexBy(function(o){
- return o && value.test(o[property]);
- }, null, start);
+ },
+
+
+ getGutters: function() {
+ return [0, 0];
},
- findIndexBy : function(fn, scope, start){
- var k = this.keys, it = this.items;
- for(var i = (start||0), len = it.length; i < len; i++){
- if(fn.call(scope||this, it[i], k[i])){
- return i;
+ onItemMouseOver: function(item) {
+ var me = this;
+ if (item.series === me) {
+ if (me.highlight) {
+ me.highlightItem(item);
+ }
+ if (me.tooltip) {
+ me.showTip(item);
}
}
- return -1;
},
- createValueMatcher : function(value, anyMatch, caseSensitive, exactMatch) {
- if (!value.exec) {
- var er = Ext.escapeRe;
- value = String(value);
-
- if (anyMatch === true) {
- value = er(value);
- } else {
- value = '^' + er(value);
- if (exactMatch === true) {
- value += '$';
- }
+ onItemMouseOut: function(item) {
+ var me = this;
+ if (item.series === me) {
+ me.unHighlightItem();
+ if (me.tooltip) {
+ me.hideTip(item);
}
- value = new RegExp(value, caseSensitive ? '' : 'i');
- }
- return value;
+ }
},
- clone : function(){
- var r = new Ext.util.MixedCollection();
- var k = this.keys, it = this.items;
- for(var i = 0, len = it.length; i < len; i++){
- r.add(k[i], it[i]);
+ onMouseLeave: function() {
+ var me = this;
+ me.unHighlightItem();
+ if (me.tooltip) {
+ me.hideTip();
}
- r.getKey = this.getKey;
- return r;
- }
-});
-
-Ext.util.MixedCollection.prototype.get = Ext.util.MixedCollection.prototype.item;
+ },
-Ext.AbstractManager = Ext.extend(Object, {
- typeName: 'type',
- constructor: function(config) {
- Ext.apply(this, config || {});
+ getItemForPoint: function(x, y) {
+ if (!this.items || !this.items.length || this.seriesIsHidden) {
+ return null;
+ }
+ var me = this,
+ items = me.items,
+ bbox = me.bbox,
+ item, i, ln;
- this.all = new Ext.util.MixedCollection();
-
- this.types = {};
- },
-
-
- get : function(id){
- return this.all.get(id);
+ if (!Ext.draw.Draw.withinBox(x, y, bbox)) {
+ return null;
+ }
+ for (i = 0, ln = items.length; i < ln; i++) {
+ if (items[i] && this.isItemInPoint(x, y, items[i], i)) {
+ return items[i];
+ }
+ }
+
+ return null;
},
-
- register: function(item) {
- this.all.add(item);
+ isItemInPoint: function(x, y, item, i) {
+ return false;
},
+
-
- unregister: function(item) {
- this.all.remove(item);
+ hideAll: function() {
+ var me = this,
+ items = me.items,
+ item, len, i, sprite;
+
+ me.seriesIsHidden = true;
+ me._prevShowMarkers = me.showMarkers;
+
+ me.showMarkers = false;
+
+ me.hideLabels(0);
+
+ for (i = 0, len = items.length; i < len; i++) {
+ item = items[i];
+ sprite = item.sprite;
+ if (sprite) {
+ sprite.setAttributes({
+ hidden: true
+ }, true);
+ }
+ }
},
+
-
- registerType : function(type, cls){
- this.types[type] = cls;
- cls[this.typeName] = type;
+ showAll: function() {
+ var me = this,
+ prevAnimate = me.chart.animate;
+ me.chart.animate = false;
+ me.seriesIsHidden = false;
+ me.showMarkers = me._prevShowMarkers;
+ me.drawSeries();
+ me.chart.animate = prevAnimate;
},
- isRegistered : function(type){
- return this.types[type] !== undefined;
+ getLegendColor: function(index) {
+ var me = this, fill, stroke;
+ if (me.seriesStyle) {
+ fill = me.seriesStyle.fill;
+ stroke = me.seriesStyle.stroke;
+ if (fill && fill != 'none') {
+ return fill;
+ }
+ return stroke;
+ }
+ return '#000';
},
- create: function(config, defaultType) {
- var type = config[this.typeName] || config.type || defaultType,
- Constructor = this.types[type];
-
- if (Constructor == undefined) {
- throw new Error(String.format("The '{0}' type has not been registered with this manager", type));
+ visibleInLegend: function(index){
+ var excludes = this.__excludes;
+ if (excludes) {
+ return !excludes[index];
}
-
- return new Constructor(config);
+ return !this.seriesIsHidden;
},
+
-
- onAvailable : function(id, fn, scope){
- var all = this.all;
-
- all.on("add", function(index, o){
- if (o.id == id) {
- fn.call(scope || o, o);
- all.un("add", fn, scope);
- }
- });
+ setTitle: function(index, title) {
+ var me = this,
+ oldTitle = me.title;
+
+ if (Ext.isString(index)) {
+ title = index;
+ index = 0;
+ }
+
+ if (Ext.isArray(oldTitle)) {
+ oldTitle[index] = title;
+ } else {
+ me.title = title;
+ }
+
+ me.fireEvent('titlechange', title, index);
}
});
-Ext.util.Format = function() {
- var trimRe = /^\s+|\s+$/g,
- stripTagsRE = /<\/?[^>]+>/gi,
- stripScriptsRe = /(?:'); + for (areaIndex = 0; areaIndex < bounds.areasLen; areaIndex++) { + + if (me.__excludes[areaIndex]) { + continue; + } + path = paths[areaIndex]; + + if (areaIndex == 0 || first) { + first = false; + path.push('L', x, bbox.y + bbox.height, + 'L', bbox.x, bbox.y + bbox.height, + 'Z'); + } + + else { + componentPath = componentPaths[prevAreaIndex]; + componentPath.reverse(); + path.push('L', x, componentPath[0][2]); + for (i = 0; i < ln; i++) { + path.push(componentPath[i][0], + componentPath[i][1], + componentPath[i][2]); + items[areaIndex].pointsDown[ln -i -1] = [componentPath[i][1], componentPath[i][2]]; + } + path.push('L', bbox.x, path[2], 'Z'); + } + prevAreaIndex = areaIndex; } - }; -}(); - -Ext.XTemplate = function(){ - Ext.XTemplate.superclass.constructor.apply(this, arguments); - - var me = this, - s = me.html, - re = /
',
- '',
- '
'
- );
- t.disableFormats = true;
- return t.compile();
- })(),
+ node.updateInfo(suppressNodeUpdate);
+
+
+ if (!me.isLoaded()) {
+ me.set('loaded', true);
+ }
+
+ else if (me.childNodes.length === 1) {
+ me.set('loaded', me.isLoaded());
+ }
+
+ if (suppressEvents !== true) {
+ me.fireEvent("append", me, node, index);
-
- destroy : function(){
-
- if(this.resizeTask && this.resizeTask.cancel){
- this.resizeTask.cancel();
- }
- if(this.container) {
- this.container.un(this.container.resizeEvent, this.onResize, this);
- }
- if(!Ext.isEmpty(this.targetCls)){
- var target = this.container.getLayoutTarget();
- if(target){
- target.removeClass(this.targetCls);
- }
- }
- }
-});
-Ext.layout.AutoLayout = Ext.extend(Ext.layout.ContainerLayout, {
- type: 'auto',
+ if (oldParent) {
+ node.fireEvent("move", node, oldParent, me, index);
+ }
+ }
- monitorResize: true,
+ return node;
+ }
+ },
+
+
+ getBubbleTarget: function() {
+ return this.parentNode;
+ },
- onLayout : function(ct, target){
- Ext.layout.AutoLayout.superclass.onLayout.call(this, ct, target);
- var cs = this.getRenderedItems(ct), len = cs.length, i, c;
- for(i = 0; i < len; i++){
- c = cs[i];
- if (c.doLayout){
- c.doLayout(true);
- }
- }
- }
-});
+ removeChild : function(node, destroy, suppressEvents, suppressNodeUpdate) {
+ var me = this,
+ index = me.indexOf(node);
+
+ if (index == -1 || (suppressEvents !== true && me.fireEvent("beforeremove", me, node) === false)) {
+ return false;
+ }
-Ext.Container.LAYOUTS['auto'] = Ext.layout.AutoLayout;
+
+ me.childNodes.splice(index, 1);
-Ext.layout.FitLayout = Ext.extend(Ext.layout.ContainerLayout, {
-
- monitorResize:true,
+
+ if (me.firstChild == node) {
+ me.setFirstChild(node.nextSibling);
+ }
+ if (me.lastChild == node) {
+ me.setLastChild(node.previousSibling);
+ }
+
+
+ if (node.previousSibling) {
+ node.previousSibling.nextSibling = node.nextSibling;
+ node.previousSibling.updateInfo(suppressNodeUpdate);
+ }
+ if (node.nextSibling) {
+ node.nextSibling.previousSibling = node.previousSibling;
+ node.nextSibling.updateInfo(suppressNodeUpdate);
+ }
- type: 'fit',
+ if (suppressEvents !== true) {
+ me.fireEvent("remove", me, node);
+ }
+
+
+
+ if (!me.childNodes.length) {
+ me.set('loaded', me.isLoaded());
+ }
+
+ if (destroy) {
+ node.destroy(true);
+ } else {
+ node.clear();
+ }
- getLayoutTargetSize : function() {
- var target = this.container.getLayoutTarget();
- if (!target) {
- return {};
- }
-
- return target.getStyleSize();
- },
+ return node;
+ },
-
- onLayout : function(ct, target){
- Ext.layout.FitLayout.superclass.onLayout.call(this, ct, target);
- if(!ct.collapsed){
- this.setItemSize(this.activeItem || ct.items.itemAt(0), this.getLayoutTargetSize());
- }
- },
+
+ copy: function(newId, deep) {
+ var me = this,
+ result = me.callOverridden(arguments),
+ len = me.childNodes ? me.childNodes.length : 0,
+ i;
-
- setItemSize : function(item, size){
- if(item && size.height > 0){
- item.setSize(size);
- }
- }
-});
-Ext.Container.LAYOUTS['fit'] = Ext.layout.FitLayout;
-Ext.layout.CardLayout = Ext.extend(Ext.layout.FitLayout, {
-
- deferredRender : false,
+
+ if (deep) {
+ for (i = 0; i < len; i++) {
+ result.appendChild(me.childNodes[i].copy(true));
+ }
+ }
+ return result;
+ },
-
- layoutOnCardChange : false,
+
+ clear : function(destroy) {
+ var me = this;
+
+
+ me.parentNode = me.previousSibling = me.nextSibling = null;
+ if (destroy) {
+ me.firstChild = me.lastChild = null;
+ }
+ },
-
-
- renderHidden : true,
+
+ destroy : function(silent) {
+
+ var me = this;
+
+ if (silent === true) {
+ me.clear(true);
+ Ext.each(me.childNodes, function(n) {
+ n.destroy(true);
+ });
+ me.childNodes = null;
+ } else {
+ me.remove(true);
+ }
- type: 'card',
+ me.callOverridden();
+ },
-
- setActiveItem : function(item){
- var ai = this.activeItem,
- ct = this.container;
- item = ct.getComponent(item);
+
+ insertBefore : function(node, refNode, suppressEvents) {
+ var me = this,
+ index = me.indexOf(refNode),
+ oldParent = node.parentNode,
+ refIndex = index,
+ ps;
+
+ if (!refNode) {
+ return me.appendChild(node);
+ }
+
+
+ if (node == refNode) {
+ return false;
+ }
-
- if(item && ai != item){
+
+ node = me.createNode(node);
+
+ if (suppressEvents !== true && me.fireEvent("beforeinsert", me, node, refNode) === false) {
+ return false;
+ }
+
+
+ if (oldParent == me && me.indexOf(node) < index) {
+ refIndex--;
+ }
-
- if(ai){
- ai.hide();
- if (ai.hidden !== true) {
- return false;
- }
- ai.fireEvent('deactivate', ai);
- }
+
+ if (oldParent) {
+ if (suppressEvents !== true && node.fireEvent("beforemove", node, oldParent, me, index, refNode) === false) {
+ return false;
+ }
+ oldParent.removeChild(node);
+ }
- var layout = item.doLayout && (this.layoutOnCardChange || !item.rendered);
+ if (refIndex === 0) {
+ me.setFirstChild(node);
+ }
-
- this.activeItem = item;
+ me.childNodes.splice(refIndex, 0, node);
+ node.parentNode = me;
+
+ node.nextSibling = refNode;
+ refNode.previousSibling = node;
+
+ ps = me.childNodes[refIndex - 1];
+ if (ps) {
+ node.previousSibling = ps;
+ ps.nextSibling = node;
+ ps.updateInfo();
+ } else {
+ node.previousSibling = null;
+ }
+
+ node.updateInfo();
+
+ if (!me.isLoaded()) {
+ me.set('loaded', true);
+ }
+
+ else if (me.childNodes.length === 1) {
+ me.set('loaded', me.isLoaded());
+ }
-
-
- delete item.deferLayout;
+ if (suppressEvents !== true) {
+ me.fireEvent("insert", me, node, refNode);
-
- item.show();
+ if (oldParent) {
+ node.fireEvent("move", node, oldParent, me, refIndex, refNode);
+ }
+ }
- this.layout();
+ return node;
+ },
+
+
+ insertChild: function(index, node) {
+ var sibling = this.childNodes[index];
+ if (sibling) {
+ return this.insertBefore(node, sibling);
+ }
+ else {
+ return this.appendChild(node);
+ }
+ },
- if(layout){
- item.doLayout();
- }
- item.fireEvent('activate', item);
- }
- },
+
+ remove : function(destroy, suppressEvents) {
+ var parentNode = this.parentNode;
-
- renderAll : function(ct, target){
- if(this.deferredRender){
- this.renderItem(this.activeItem, undefined, target);
- }else{
- Ext.layout.CardLayout.superclass.renderAll.call(this, ct, target);
- }
- }
-});
-Ext.Container.LAYOUTS['card'] = Ext.layout.CardLayout;
+ if (parentNode) {
+ parentNode.removeChild(this, destroy, suppressEvents, true);
+ }
+ return this;
+ },
-Ext.layout.AnchorLayout = Ext.extend(Ext.layout.ContainerLayout, {
-
+
+ removeAll : function(destroy, suppressEvents) {
+ var cn = this.childNodes,
+ n;
-
- monitorResize : true,
+ while ((n = cn[0])) {
+ this.removeChild(n, destroy, suppressEvents);
+ }
+ return this;
+ },
- type : 'anchor',
+
+ getChildAt : function(index) {
+ return this.childNodes[index];
+ },
-
- defaultAnchor : '100%',
+
+ replaceChild : function(newChild, oldChild, suppressEvents) {
+ var s = oldChild ? oldChild.nextSibling : null;
+
+ this.removeChild(oldChild, suppressEvents);
+ this.insertBefore(newChild, s, suppressEvents);
+ return oldChild;
+ },
- parseAnchorRE : /^(r|right|b|bottom)$/i,
+
+ indexOf : function(child) {
+ return Ext.Array.indexOf(this.childNodes, child);
+ },
+
+ getDepth : function() {
+ return this.get('depth');
+ },
- getLayoutTargetSize : function() {
- var target = this.container.getLayoutTarget(), ret = {};
- if (target) {
- ret = target.getViewSize();
+
+ bubble : function(fn, scope, args) {
+ var p = this;
+ while (p) {
+ if (fn.apply(scope || p, args || [p]) === false) {
+ break;
+ }
+ p = p.parentNode;
+ }
+ },
-
-
-
- if (Ext.isIE && Ext.isStrict && ret.width == 0){
- ret = target.getStyleSize();
- }
- ret.width -= target.getPadding('lr');
- ret.height -= target.getPadding('tb');
- }
- return ret;
- },
+ cascade: function() {
+ if (Ext.isDefined(Ext.global.console)) {
+ Ext.global.console.warn('Ext.data.Node: cascade has been deprecated. Please use cascadeBy instead.');
+ }
+ return this.cascadeBy.apply(this, arguments);
+ },
-
- onLayout : function(container, target) {
- Ext.layout.AnchorLayout.superclass.onLayout.call(this, container, target);
+
+ cascadeBy : function(fn, scope, args) {
+ if (fn.apply(scope || this, args || [this]) !== false) {
+ var childNodes = this.childNodes,
+ length = childNodes.length,
+ i;
+
+ for (i = 0; i < length; i++) {
+ childNodes[i].cascadeBy(fn, scope, args);
+ }
+ }
+ },
- var size = this.getLayoutTargetSize(),
- containerWidth = size.width,
- containerHeight = size.height,
- overflow = target.getStyle('overflow'),
- components = this.getRenderedItems(container),
- len = components.length,
- boxes = [],
- box,
- anchorWidth,
- anchorHeight,
- component,
- anchorSpec,
- calcWidth,
- calcHeight,
- anchorsArray,
- totalHeight = 0,
- i,
- el;
+
+ eachChild : function(fn, scope, args) {
+ var childNodes = this.childNodes,
+ length = childNodes.length,
+ i;
- if(containerWidth < 20 && containerHeight < 20){
- return;
- }
+ for (i = 0; i < length; i++) {
+ if (fn.apply(scope || this, args || [childNodes[i]]) === false) {
+ break;
+ }
+ }
+ },
-
- if(container.anchorSize) {
- if(typeof container.anchorSize == 'number') {
- anchorWidth = container.anchorSize;
- } else {
- anchorWidth = container.anchorSize.width;
- anchorHeight = container.anchorSize.height;
- }
- } else {
- anchorWidth = container.initialConfig.width;
- anchorHeight = container.initialConfig.height;
- }
+
+ findChild : function(attribute, value, deep) {
+ return this.findChildBy(function() {
+ return this.get(attribute) == value;
+ }, null, deep);
+ },
- for(i = 0; i < len; i++) {
- component = components[i];
- el = component.getPositionEl();
+
+ findChildBy : function(fn, scope, deep) {
+ var cs = this.childNodes,
+ len = cs.length,
+ i = 0, n, res;
+
+ for (; i < len; i++) {
+ n = cs[i];
+ if (fn.call(scope || n, n) === true) {
+ return n;
+ }
+ else if (deep) {
+ res = n.findChildBy(fn, scope, deep);
+ if (res !== null) {
+ return res;
+ }
+ }
+ }
-
- if (!component.anchor && component.items && !Ext.isNumber(component.width) && !(Ext.isIE6 && Ext.isStrict)){
- component.anchor = this.defaultAnchor;
- }
+ return null;
+ },
- if(component.anchor) {
- anchorSpec = component.anchorSpec;
- if(!anchorSpec){
- anchorsArray = component.anchor.split(' ');
- component.anchorSpec = anchorSpec = {
- right: this.parseAnchor(anchorsArray[0], component.initialConfig.width, anchorWidth),
- bottom: this.parseAnchor(anchorsArray[1], component.initialConfig.height, anchorHeight)
- };
- }
- calcWidth = anchorSpec.right ? this.adjustWidthAnchor(anchorSpec.right(containerWidth) - el.getMargins('lr'), component) : undefined;
- calcHeight = anchorSpec.bottom ? this.adjustHeightAnchor(anchorSpec.bottom(containerHeight) - el.getMargins('tb'), component) : undefined;
+ contains : function(node) {
+ return node.isAncestor(this);
+ },
- if(calcWidth || calcHeight) {
- boxes.push({
- component: component,
- width: calcWidth || undefined,
- height: calcHeight || undefined
- });
- }
- }
- }
- for (i = 0, len = boxes.length; i < len; i++) {
- box = boxes[i];
- box.component.setSize(box.width, box.height);
- }
+
+ isAncestor : function(node) {
+ var p = this.parentNode;
+ while (p) {
+ if (p == node) {
+ return true;
+ }
+ p = p.parentNode;
+ }
+ return false;
+ },
+
+
+ sort : function(sortFn, recursive, suppressEvent) {
+ var cs = this.childNodes,
+ ln = cs.length,
+ i, n;
+
+ if (ln > 0) {
+ Ext.Array.sort(cs, sortFn);
+ for (i = 0; i < ln; i++) {
+ n = cs[i];
+ n.previousSibling = cs[i-1];
+ n.nextSibling = cs[i+1];
+
+ if (i === 0) {
+ this.setFirstChild(n);
+ n.updateInfo();
+ }
+ if (i == ln - 1) {
+ this.setLastChild(n);
+ n.updateInfo();
+ }
+ if (recursive && !n.isLeaf()) {
+ n.sort(sortFn, true, true);
+ }
+ }
+
+ if (suppressEvent !== true) {
+ this.fireEvent('sort', this, cs);
+ }
+ }
+ },
+
+
+ isExpanded: function() {
+ return this.get('expanded');
+ },
+
+
+ isLoaded: function() {
+ return this.get('loaded');
+ },
+
+
+ isLoading: function() {
+ return this.get('loading');
+ },
+
+
+ isRoot: function() {
+ return !this.parentNode;
+ },
+
+
+ isVisible: function() {
+ var parent = this.parentNode;
+ while (parent) {
+ if (!parent.isExpanded()) {
+ return false;
+ }
+ parent = parent.parentNode;
+ }
+ return true;
+ },
+
+
+ expand: function(recursive, callback, scope) {
+ var me = this;
+
+
+
+
+
+ if (!me.isLeaf()) {
+
+ if (!me.isLoading() && !me.isExpanded()) {
+
+
+
+
+ me.fireEvent('beforeexpand', me, function(records) {
+ me.set('expanded', true);
+ me.fireEvent('expand', me, me.childNodes, false);
+
+
+ if (recursive) {
+ me.expandChildren(true, callback, scope);
+ }
+ else {
+ Ext.callback(callback, scope || me, [me.childNodes]);
+ }
+ }, me);
+ }
+
+ else if (recursive) {
+ me.expandChildren(true, callback, scope);
+ }
+ else {
+ Ext.callback(callback, scope || me, [me.childNodes]);
+ }
- if (overflow && overflow != 'hidden' && !this.adjustmentPass) {
- var newTargetSize = this.getLayoutTargetSize();
- if (newTargetSize.width != size.width || newTargetSize.height != size.height){
- this.adjustmentPass = true;
- this.onLayout(container, target);
- }
- }
+
+
+
+ }
+
+ else {
+ Ext.callback(callback, scope || me);
+ }
+ },
+
+
+ expandChildren: function(recursive, callback, scope) {
+ var me = this,
+ i = 0,
+ nodes = me.childNodes,
+ ln = nodes.length,
+ node,
+ expanding = 0;
+
+ for (; i < ln; ++i) {
+ node = nodes[i];
+ if (!node.isLeaf() && !node.isExpanded()) {
+ expanding++;
+ nodes[i].expand(recursive, function () {
+ expanding--;
+ if (callback && !expanding) {
+ Ext.callback(callback, scope || me, me.childNodes);
+ }
+ });
+ }
+ }
+
+ if (!expanding && callback) {
+ Ext.callback(callback, scope || me, me.childNodes);
+ }
+ },
- delete this.adjustmentPass;
- },
+
+ collapse: function(recursive, callback, scope) {
+ var me = this;
-
- parseAnchor : function(a, start, cstart) {
- if (a && a != 'none') {
- var last;
-
- if (this.parseAnchorRE.test(a)) {
- var diff = cstart - start;
- return function(v){
- if(v !== last){
- last = v;
- return v - diff;
+
+ if (!me.isLeaf()) {
+
+ if (!me.collapsing && me.isExpanded()) {
+ me.fireEvent('beforecollapse', me, function(records) {
+ me.set('expanded', false);
+ me.fireEvent('collapse', me, me.childNodes, false);
+
+
+ if (recursive) {
+ me.collapseChildren(true, callback, scope);
+ }
+ else {
+ Ext.callback(callback, scope || me, [me.childNodes]);
+ }
+ }, me);
+ }
+
+ else if (recursive) {
+ me.collapseChildren(true, callback, scope);
+ }
}
- };
-
- } else if(a.indexOf('%') != -1) {
- var ratio = parseFloat(a.replace('%', ''))*.01;
- return function(v){
- if(v !== last){
- last = v;
- return Math.floor(v*ratio);
+
+ else {
+ Ext.callback(callback, scope || me, me.childNodes);
}
- };
-
- } else {
- a = parseInt(a, 10);
- if (!isNaN(a)) {
- return function(v) {
- if (v !== last) {
- last = v;
- return v + a;
+ },
+
+
+ collapseChildren: function(recursive, callback, scope) {
+ var me = this,
+ i = 0,
+ nodes = me.childNodes,
+ ln = nodes.length,
+ node,
+ collapsing = 0;
+
+ for (; i < ln; ++i) {
+ node = nodes[i];
+ if (!node.isLeaf() && node.isExpanded()) {
+ collapsing++;
+ nodes[i].collapse(recursive, function () {
+ collapsing--;
+ if (callback && !collapsing) {
+ Ext.callback(callback, scope || me, me.childNodes);
+ }
+ });
}
- };
+ }
+
+ if (!collapsing && callback) {
+ Ext.callback(callback, scope || me, me.childNodes);
+ }
}
- }
+ };
}
- return false;
- },
+ }
+});
+Ext.define('Ext.data.NodeStore', {
+ extend: 'Ext.data.Store',
+ alias: 'store.node',
+ requires: ['Ext.data.NodeInterface'],
- adjustWidthAnchor : function(value, comp){
- return value;
- },
-
- adjustHeightAnchor : function(value, comp){
- return value;
- }
-
+ node: null,
-});
-Ext.Container.LAYOUTS['anchor'] = Ext.layout.AnchorLayout;
-
-Ext.layout.ColumnLayout = Ext.extend(Ext.layout.ContainerLayout, {
- monitorResize:true,
-
- type: 'column',
-
- extraCls: 'x-column',
-
- scrollOffset : 0,
-
+ recursive: false,
+
+
+ rootVisible: false,
+ constructor: function(config) {
+ var me = this,
+ node;
+
+ config = config || {};
+ Ext.apply(me, config);
+
+ if (Ext.isDefined(me.proxy)) {
+ Ext.Error.raise("A NodeStore cannot be bound to a proxy. Instead bind it to a record " +
+ "decorated with the NodeInterface by setting the node config.");
+ }
- targetCls: 'x-column-layout-ct',
+ config.proxy = {type: 'proxy'};
+ me.callParent([config]);
- isValidParent : function(c, target){
- return this.innerCt && c.getPositionEl().dom.parentNode == this.innerCt.dom;
+ me.addEvents('expand', 'collapse', 'beforeexpand', 'beforecollapse');
+
+ node = me.node;
+ if (node) {
+ me.node = null;
+ me.setNode(node);
+ }
},
-
- getLayoutTargetSize : function() {
- var target = this.container.getLayoutTarget(), ret;
- if (target) {
- ret = target.getViewSize();
-
-
-
+
+ setNode: function(node) {
+ var me = this;
+
+ if (me.node && me.node != node) {
- if (Ext.isIE && Ext.isStrict && ret.width == 0){
- ret = target.getStyleSize();
+ me.mun(me.node, {
+ expand: me.onNodeExpand,
+ collapse: me.onNodeCollapse,
+ append: me.onNodeAppend,
+ insert: me.onNodeInsert,
+ remove: me.onNodeRemove,
+ sort: me.onNodeSort,
+ scope: me
+ });
+ me.node = null;
+ }
+
+ if (node) {
+ Ext.data.NodeInterface.decorate(node);
+ me.removeAll();
+ if (me.rootVisible) {
+ me.add(node);
+ }
+ me.mon(node, {
+ expand: me.onNodeExpand,
+ collapse: me.onNodeCollapse,
+ append: me.onNodeAppend,
+ insert: me.onNodeInsert,
+ remove: me.onNodeRemove,
+ sort: me.onNodeSort,
+ scope: me
+ });
+ me.node = node;
+ if (node.isExpanded() && node.isLoaded()) {
+ me.onNodeExpand(node, node.childNodes, true);
}
-
- ret.width -= target.getPadding('lr');
- ret.height -= target.getPadding('tb');
}
- return ret;
},
-
- renderAll : function(ct, target) {
- if(!this.innerCt){
-
-
- this.innerCt = target.createChild({cls:'x-column-inner'});
- this.innerCt.createChild({cls:'x-clear'});
+
+ onNodeSort: function(node, childNodes) {
+ var me = this;
+
+ if ((me.indexOf(node) !== -1 || (node === me.node && !me.rootVisible) && node.isExpanded())) {
+ me.onNodeCollapse(node, childNodes, true);
+ me.onNodeExpand(node, childNodes, true);
}
- Ext.layout.ColumnLayout.superclass.renderAll.call(this, ct, this.innerCt);
},
-
- onLayout : function(ct, target){
- var cs = ct.items.items,
- len = cs.length,
- c,
- i,
- m,
- margins = [];
-
- this.renderAll(ct, target);
-
- var size = this.getLayoutTargetSize();
-
- if(size.width < 1 && size.height < 1){
+ onNodeExpand: function(parent, records, suppressEvent) {
+ var me = this,
+ insertIndex = me.indexOf(parent) + 1,
+ ln = records ? records.length : 0,
+ i, record;
+
+ if (!me.recursive && parent !== me.node) {
return;
}
-
- var w = size.width - this.scrollOffset,
- h = size.height,
- pw = w;
-
- this.innerCt.setWidth(w);
-
-
-
- for(i = 0; i < len; i++){
- c = cs[i];
- m = c.getPositionEl().getMargins('lr');
- margins[i] = m;
- if(!c.columnWidth){
- pw -= (c.getWidth() + m);
- }
+ if (!me.isVisible(parent)) {
+ return;
}
- pw = pw < 0 ? 0 : pw;
-
- for(i = 0; i < len; i++){
- c = cs[i];
- m = margins[i];
- if(c.columnWidth){
- c.setSize(Math.floor(c.columnWidth * pw) - m);
- }
+ if (!suppressEvent && me.fireEvent('beforeexpand', parent, records, insertIndex) === false) {
+ return;
}
-
-
- if (Ext.isIE) {
- if (i = target.getStyle('overflow') && i != 'hidden' && !this.adjustmentPass) {
- var ts = this.getLayoutTargetSize();
- if (ts.width != size.width){
- this.adjustmentPass = true;
- this.onLayout(ct, target);
+ if (ln) {
+ me.insert(insertIndex, records);
+ for (i = 0; i < ln; i++) {
+ record = records[i];
+ if (record.isExpanded()) {
+ if (record.isLoaded()) {
+
+ me.onNodeExpand(record, record.childNodes, true);
+ }
+ else {
+ record.set('expanded', false);
+ record.expand();
+ }
}
}
}
- delete this.adjustmentPass;
- }
-
-
-});
-
-Ext.Container.LAYOUTS['column'] = Ext.layout.ColumnLayout;
-
-Ext.layout.BorderLayout = Ext.extend(Ext.layout.ContainerLayout, {
-
- monitorResize:true,
-
- rendered : false,
-
- type: 'border',
-
- targetCls: 'x-border-layout-ct',
-
- getLayoutTargetSize : function() {
- var target = this.container.getLayoutTarget();
- return target ? target.getViewSize() : {};
- },
-
- onLayout : function(ct, target){
- var collapsed, i, c, pos, items = ct.items.items, len = items.length;
- if(!this.rendered){
- collapsed = [];
- for(i = 0; i < len; i++) {
- c = items[i];
- pos = c.region;
- if(c.collapsed){
- collapsed.push(c);
- }
- c.collapsed = false;
- if(!c.rendered){
- c.render(target, i);
- c.getPositionEl().addClass('x-border-panel');
- }
- this[pos] = pos != 'center' && c.split ?
- new Ext.layout.BorderLayout.SplitRegion(this, c.initialConfig, pos) :
- new Ext.layout.BorderLayout.Region(this, c.initialConfig, pos);
- this[pos].render(target, c);
- }
- this.rendered = true;
+ if (!suppressEvent) {
+ me.fireEvent('expand', parent, records);
}
+ },
- var size = this.getLayoutTargetSize();
- if(size.width < 20 || size.height < 20){
- if(collapsed){
- this.restoreCollapsed = collapsed;
- }
+ onNodeCollapse: function(parent, records, suppressEvent) {
+ var me = this,
+ ln = records.length,
+ collapseIndex = me.indexOf(parent) + 1,
+ i, record;
+
+ if (!me.recursive && parent !== me.node) {
return;
- }else if(this.restoreCollapsed){
- collapsed = this.restoreCollapsed;
- delete this.restoreCollapsed;
- }
-
- var w = size.width, h = size.height,
- centerW = w, centerH = h, centerY = 0, centerX = 0,
- n = this.north, s = this.south, west = this.west, e = this.east, c = this.center,
- b, m, totalWidth, totalHeight;
- if(!c && Ext.layout.BorderLayout.WARN !== false){
- throw 'No center region defined in BorderLayout ' + ct.id;
- }
-
- if(n && n.isVisible()){
- b = n.getSize();
- m = n.getMargins();
- b.width = w - (m.left+m.right);
- b.x = m.left;
- b.y = m.top;
- centerY = b.height + b.y + m.bottom;
- centerH -= centerY;
- n.applyLayout(b);
- }
- if(s && s.isVisible()){
- b = s.getSize();
- m = s.getMargins();
- b.width = w - (m.left+m.right);
- b.x = m.left;
- totalHeight = (b.height + m.top + m.bottom);
- b.y = h - totalHeight + m.top;
- centerH -= totalHeight;
- s.applyLayout(b);
- }
- if(west && west.isVisible()){
- b = west.getSize();
- m = west.getMargins();
- b.height = centerH - (m.top+m.bottom);
- b.x = m.left;
- b.y = centerY + m.top;
- totalWidth = (b.width + m.left + m.right);
- centerX += totalWidth;
- centerW -= totalWidth;
- west.applyLayout(b);
- }
- if(e && e.isVisible()){
- b = e.getSize();
- m = e.getMargins();
- b.height = centerH - (m.top+m.bottom);
- totalWidth = (b.width + m.left + m.right);
- b.x = w - totalWidth + m.left;
- b.y = centerY + m.top;
- centerW -= totalWidth;
- e.applyLayout(b);
}
- if(c){
- m = c.getMargins();
- var centerBox = {
- x: centerX + m.left,
- y: centerY + m.top,
- width: centerW - (m.left+m.right),
- height: centerH - (m.top+m.bottom)
- };
- c.applyLayout(centerBox);
+
+ if (!suppressEvent && me.fireEvent('beforecollapse', parent, records, collapseIndex) === false) {
+ return;
}
- if(collapsed){
- for(i = 0, len = collapsed.length; i < len; i++){
- collapsed[i].collapse(false);
+
+ for (i = 0; i < ln; i++) {
+ record = records[i];
+ me.remove(record);
+ if (record.isExpanded()) {
+ me.onNodeCollapse(record, record.childNodes, true);
}
}
- if(Ext.isIE && Ext.isStrict){
- target.repaint();
- }
- if (i = target.getStyle('overflow') && i != 'hidden' && !this.adjustmentPass) {
- var ts = this.getLayoutTargetSize();
- if (ts.width != size.width || ts.height != size.height){
- this.adjustmentPass = true;
- this.onLayout(ct, target);
- }
+ if (!suppressEvent) {
+ me.fireEvent('collapse', parent, records, collapseIndex);
}
- delete this.adjustmentPass;
},
+
+ onNodeAppend: function(parent, node, index) {
+ var me = this,
+ refNode, sibling;
- destroy: function() {
- var r = ['north', 'south', 'east', 'west'], i, region;
- for (i = 0; i < r.length; i++) {
- region = this[r[i]];
- if(region){
- if(region.destroy){
- region.destroy();
- }else if (region.split){
- region.split.destroy(true);
+ if (me.isVisible(node)) {
+ if (index === 0) {
+ refNode = parent;
+ } else {
+ sibling = node.previousSibling;
+ while (sibling.isExpanded() && sibling.lastChild) {
+ sibling = sibling.lastChild;
+ }
+ refNode = sibling;
+ }
+ me.insert(me.indexOf(refNode) + 1, node);
+ if (!node.isLeaf() && node.isExpanded()) {
+ if (node.isLoaded()) {
+
+ me.onNodeExpand(node, node.childNodes, true);
+ }
+ else {
+ node.set('expanded', false);
+ node.expand();
+ }
+ }
+ }
+ },
+
+ onNodeInsert: function(parent, node, refNode) {
+ var me = this,
+ index = this.indexOf(refNode);
+
+ if (index != -1 && me.isVisible(node)) {
+ me.insert(index, node);
+ if (!node.isLeaf() && node.isExpanded()) {
+ if (node.isLoaded()) {
+
+ me.onNodeExpand(node, node.childNodes, true);
+ }
+ else {
+ node.set('expanded', false);
+ node.expand();
}
}
}
- Ext.layout.BorderLayout.superclass.destroy.call(this);
- }
-
+ },
-});
-
-
-Ext.layout.BorderLayout.Region = function(layout, config, pos){
- Ext.apply(this, config);
- this.layout = layout;
- this.position = pos;
- this.state = {};
- if(typeof this.margins == 'string'){
- this.margins = this.layout.parseMargins(this.margins);
- }
- this.margins = Ext.applyIf(this.margins || {}, this.defaultMargins);
- if(this.collapsible){
- if(typeof this.cmargins == 'string'){
- this.cmargins = this.layout.parseMargins(this.cmargins);
+ onNodeRemove: function(parent, node, index) {
+ var me = this;
+ if (me.indexOf(node) != -1) {
+ if (!node.isLeaf() && node.isExpanded()) {
+ me.onNodeCollapse(node, node.childNodes, true);
+ }
+ me.remove(node);
}
- if(this.collapseMode == 'mini' && !this.cmargins){
- this.cmargins = {left:0,top:0,right:0,bottom:0};
- }else{
- this.cmargins = Ext.applyIf(this.cmargins || {},
- pos == 'north' || pos == 'south' ? this.defaultNSCMargins : this.defaultEWCMargins);
+ },
+
+ isVisible: function(node) {
+ var parent = node.parentNode;
+ while (parent) {
+ if (parent === this.node && !this.rootVisible && parent.isExpanded()) {
+ return true;
+ }
+
+ if (this.indexOf(parent) === -1 || !parent.isExpanded()) {
+ return false;
+ }
+
+ parent = parent.parentNode;
}
+ return true;
}
-};
+});
-Ext.layout.BorderLayout.Region.prototype = {
-
-
+Ext.define('Ext.data.Request', {
+ action: undefined,
+ params: undefined,
- collapsible : false,
-
- split:false,
-
- floatable: true,
-
- minWidth:50,
-
- minHeight:50,
-
-
- defaultMargins : {left:0,top:0,right:0,bottom:0},
- defaultNSCMargins : {left:5,top:5,right:5,bottom:5},
+ method: 'GET',
- defaultEWCMargins : {left:5,top:0,right:5,bottom:0},
- floatingZIndex: 100,
-
- isCollapsed : false,
+ url: undefined,
-
-
-
+ constructor: function(config) {
+ Ext.apply(this, config);
+ }
+});
+Ext.define('Ext.data.Tree', {
+ alias: 'data.tree',
- render : function(ct, p){
- this.panel = p;
- p.el.enableDisplayMode();
- this.targetEl = ct;
- this.el = p.el;
-
- var gs = p.getState, ps = this.position;
- p.getState = function(){
- return Ext.apply(gs.call(p) || {}, this.state);
- }.createDelegate(this);
-
- if(ps != 'center'){
- p.allowQueuedExpand = false;
- p.on({
- beforecollapse: this.beforeCollapse,
- collapse: this.onCollapse,
- beforeexpand: this.beforeExpand,
- expand: this.onExpand,
- hide: this.onHide,
- show: this.onShow,
- scope: this
- });
- if(this.collapsible || this.floatable){
- p.collapseEl = 'el';
- p.slideAnchor = this.getSlideAnchor();
- }
- if(p.tools && p.tools.toggle){
- p.tools.toggle.addClass('x-tool-collapse-'+ps);
- p.tools.toggle.addClassOnOver('x-tool-collapse-'+ps+'-over');
- }
- }
+ mixins: {
+ observable: "Ext.util.Observable"
},
- getCollapsedEl : function(){
- if(!this.collapsedEl){
- if(!this.toolTemplate){
- var tt = new Ext.Template(
- '',
- '
',
- '| ',
- ' | ',
- '',
- '
| ',
- '
| ', Date.getShortMonthName(i), ' | ', - '', Date.getShortMonthName(i + 6), ' | ', - i === 0 ? - '' - ); - } - buf.push( - ' | |
{1}
',
- '
'
- );
+ completeEdit : function(remainVisible) {
+ var me = this,
+ field = me.field,
+ value;
- this.el = position ? tpl.insertBefore(position, {cls: this.baseCls}, true)
- : tpl.append(ct, {cls: this.baseCls}, true);
-
- if(this.id){
- this.el.dom.id = this.id;
+ if (!me.editing) {
+ return;
}
- var inner = this.el.dom.firstChild;
- this.progressBar = Ext.get(inner.firstChild);
- if(this.textEl){
-
- this.textEl = Ext.get(this.textEl);
- delete this.textTopEl;
- }else{
-
- this.textTopEl = Ext.get(this.progressBar.dom.firstChild);
- var textBackEl = Ext.get(inner.childNodes[1]);
- this.textTopEl.setStyle("z-index", 99).addClass('x-hidden');
- this.textEl = new Ext.CompositeElement([this.textTopEl.dom.firstChild, textBackEl.dom.firstChild]);
- this.textEl.setWidth(inner.offsetWidth);
+
+ if (field.assertValue) {
+ field.assertValue();
}
- this.progressBar.setHeight(inner.offsetHeight);
- },
-
-
- afterRender : function(){
- Ext.ProgressBar.superclass.afterRender.call(this);
- if(this.value){
- this.updateProgress(this.value, this.text);
- }else{
- this.updateText(this.text);
+
+ value = me.getValue();
+ if (!field.isValid()) {
+ if (me.revertInvalid !== false) {
+ me.cancelEdit(remainVisible);
+ }
+ return;
}
- },
-
- updateProgress : function(value, text, animate){
- this.value = value || 0;
- if(text){
- this.updateText(text);
+ if (String(value) === String(me.startValue) && me.ignoreNoChange) {
+ me.hideEdit(remainVisible);
+ return;
}
- if(this.rendered && !this.isDestroyed){
- var w = Math.floor(value*this.el.dom.firstChild.offsetWidth);
- this.progressBar.setWidth(w, animate === true || (animate !== false && this.animate));
- if(this.textTopEl){
-
- this.textTopEl.removeClass('x-hidden').setWidth(w);
+
+ if (me.fireEvent('beforecomplete', me, value, me.startValue) !== false) {
+
+ value = me.getValue();
+ if (me.updateEl && me.boundEl) {
+ me.boundEl.update(value);
}
+ me.hideEdit(remainVisible);
+ me.fireEvent('complete', me, value, me.startValue);
}
- this.fireEvent('update', this, value, text);
- return this;
},
- wait : function(o){
- if(!this.waitTimer){
- var scope = this;
- o = o || {};
- this.updateText(o.text);
- this.waitTimer = Ext.TaskMgr.start({
- run: function(i){
- var inc = o.increment || 10;
- i -= 1;
- this.updateProgress(((((i+inc)%inc)+1)*(100/inc))*0.01, null, o.animate);
- },
- interval: o.interval || 1000,
- duration: o.duration,
- onStop: function(){
- if(o.fn){
- o.fn.apply(o.scope || this);
- }
- this.reset();
- },
- scope: scope
- });
+ onShow : function() {
+ var me = this;
+
+ me.callParent(arguments);
+ if (me.hideEl !== false) {
+ me.boundEl.hide();
}
- return this;
+ me.fireEvent("startedit", me.boundEl, me.startValue);
},
- isWaiting : function(){
- return this.waitTimer !== null;
- },
+ cancelEdit : function(remainVisible) {
+ var me = this,
+ startValue = me.startValue,
+ value;
-
- updateText : function(text){
- this.text = text || ' ';
- if(this.rendered){
- this.textEl.update(this.text);
+ if (me.editing) {
+ value = me.getValue();
+ me.setValue(startValue);
+ me.hideEdit(remainVisible);
+ me.fireEvent('canceledit', me, value, startValue);
}
- return this;
},
+
-
- syncProgressBar : function(){
- if(this.value){
- this.updateProgress(this.value, this.text);
+ hideEdit: function(remainVisible) {
+ if (remainVisible !== true) {
+ this.editing = false;
+ this.hide();
}
- return this;
},
- setSize : function(w, h){
- Ext.ProgressBar.superclass.setSize.call(this, w, h);
- if(this.textTopEl){
- var inner = this.el.dom.firstChild;
- this.textEl.setSize(inner.offsetWidth, inner.offsetHeight);
+ onBlur : function() {
+ var me = this;
+
+
+ if(me.allowBlur === true && me.editing && me.selectSameEditor !== true) {
+ me.completeEdit();
}
- this.syncProgressBar();
- return this;
},
- reset : function(hide){
- this.updateProgress(0);
- if(this.textTopEl){
- this.textTopEl.addClass('x-hidden');
+ onHide : function() {
+ var me = this,
+ field = me.field;
+
+ if (me.editing) {
+ me.completeEdit();
+ return;
}
- this.clearTimer();
- if(hide === true){
- this.hide();
+ field.blur();
+ if (field.collapse) {
+ field.collapse();
}
- return this;
- },
-
-
- clearTimer : function(){
- if(this.waitTimer){
- this.waitTimer.onStop = null;
- Ext.TaskMgr.stop(this.waitTimer);
- this.waitTimer = null;
+
+
+ if (me.hideEl !== false) {
+ me.boundEl.show();
}
+ me.callParent(arguments);
},
+
- onDestroy: function(){
- this.clearTimer();
- if(this.rendered){
- if(this.textEl.isComposite){
- this.textEl.clear();
- }
- Ext.destroyMembers(this, 'textEl', 'progressBar', 'textTopEl');
- }
- Ext.ProgressBar.superclass.onDestroy.call(this);
- }
-});
-Ext.reg('progress', Ext.ProgressBar);
+ setValue : function(value) {
+ this.field.setValue(value);
+ },
-(function() {
+
+ getValue : function() {
+ return this.field.getValue();
+ },
-var Event=Ext.EventManager;
-var Dom=Ext.lib.Dom;
+ beforeDestroy : function() {
+ var me = this;
+ Ext.destroy(me.field);
+ delete me.field;
+ delete me.parentEl;
+ delete me.boundEl;
-Ext.dd.DragDrop = function(id, sGroup, config) {
- if(id) {
- this.init(id, sGroup, config);
+ me.callParent(arguments);
}
-};
-
-Ext.dd.DragDrop.prototype = {
-
-
+});
+Ext.define('Ext.Img', {
+ extend: 'Ext.Component',
+ alias: ['widget.image', 'widget.imagecomponent'],
- id: null,
+ src: '',
+ getElConfig: function() {
+ return {
+ tag: 'img',
+ src: this.src
+ };
+ },
- config: null,
-
- dragElId: null,
+ setSrc: function(src) {
+ var me = this,
+ img = me.el;
+ me.src = src;
+ if (img) {
+ img.dom.src = src;
+ }
+ }
+});
-
- handleElId: null,
-
- invalidHandleTypes: null,
+Ext.define('Ext.Layer', {
+ uses: ['Ext.Shadow'],
- invalidHandleIds: null,
+ statics: {
+ shims: []
+ },
-
- invalidHandleClasses: null,
+ extend: 'Ext.core.Element',
-
- startPageX: 0,
+ constructor: function(config, existingEl) {
+ config = config || {};
+ var me = this,
+ dh = Ext.core.DomHelper,
+ cp = config.parentEl,
+ pel = cp ? Ext.getDom(cp) : document.body,
+ hm = config.hideMode;
+
+ if (existingEl) {
+ me.dom = Ext.getDom(existingEl);
+ }
+ if (!me.dom) {
+ me.dom = dh.append(pel, config.dh || {
+ tag: 'div',
+ cls: Ext.baseCSSPrefix + 'layer'
+ });
+ } else {
+ me.addCls(Ext.baseCSSPrefix + 'layer');
+ if (!me.dom.parentNode) {
+ pel.appendChild(me.dom);
+ }
+ }
-
- startPageY: 0,
+ if (config.cls) {
+ me.addCls(config.cls);
+ }
+ me.constrain = config.constrain !== false;
-
- groups: null,
+
+
+
+ if (hm) {
+ me.setVisibilityMode(Ext.core.Element[hm.toUpperCase()]);
+ if (me.visibilityMode == Ext.core.Element.ASCLASS) {
+ me.visibilityCls = config.visibilityCls;
+ }
+ } else if (config.useDisplay) {
+ me.setVisibilityMode(Ext.core.Element.DISPLAY);
+ } else {
+ me.setVisibilityMode(Ext.core.Element.VISIBILITY);
+ }
-
- locked: false,
+ if (config.id) {
+ me.id = me.dom.id = config.id;
+ } else {
+ me.id = Ext.id(me.dom);
+ }
+ me.position('absolute');
+ if (config.shadow) {
+ me.shadowOffset = config.shadowOffset || 4;
+ me.shadow = Ext.create('Ext.Shadow', {
+ offset: me.shadowOffset,
+ mode: config.shadow
+ });
+ me.disableShadow();
+ } else {
+ me.shadowOffset = 0;
+ }
+ me.useShim = config.shim !== false && Ext.useShims;
+ if (config.hidden === true) {
+ me.hide();
+ } else {
+ this.show();
+ }
+ },
-
- lock: function() {
- this.locked = true;
+ getZIndex: function() {
+ return parseInt((this.getShim() || this).getStyle('z-index'), 10);
},
-
- moveOnly: false,
+ getShim: function() {
+ var me = this,
+ shim, pn;
-
- unlock: function() {
- this.locked = false;
+ if (!me.useShim) {
+ return null;
+ }
+ if (!me.shim) {
+ shim = me.self.shims.shift();
+ if (!shim) {
+ shim = me.createShim();
+ shim.enableDisplayMode('block');
+ shim.hide();
+ }
+ pn = me.dom.parentNode;
+ if (shim.dom.parentNode != pn) {
+ pn.insertBefore(shim.dom, me.dom);
+ }
+ me.shim = shim;
+ }
+ return me.shim;
},
-
- isTarget: true,
+ hideShim: function() {
+ if (this.shim) {
+ this.shim.setDisplayed(false);
+ this.self.shims.push(this.shim);
+ delete this.shim;
+ }
+ },
-
- padding: null,
+ disableShadow: function() {
+ if (this.shadow) {
+ this.shadowDisabled = true;
+ this.shadow.hide();
+ this.lastShadowOffset = this.shadowOffset;
+ this.shadowOffset = 0;
+ }
+ },
-
- _domRef: null,
+ enableShadow: function(show) {
+ if (this.shadow) {
+ this.shadowDisabled = false;
+ this.shadowOffset = this.lastShadowOffset;
+ delete this.lastShadowOffset;
+ if (show) {
+ this.sync(true);
+ }
+ }
+ },
- __ygDragDrop: true,
+ sync: function(doShow) {
+ var me = this,
+ shadow = me.shadow,
+ shadowPos, shimStyle, shadowSize;
-
- constrainX: false,
+ if (!this.updating && this.isVisible() && (shadow || this.useShim)) {
+ var shim = this.getShim(),
+ l = this.getLeft(true),
+ t = this.getTop(true),
+ w = this.getWidth(),
+ h = this.getHeight(),
+ shimIndex;
-
- constrainY: false,
+ if (shadow && !this.shadowDisabled) {
+ if (doShow && !shadow.isVisible()) {
+ shadow.show(this);
+ } else {
+ shadow.realign(l, t, w, h);
+ }
+ if (shim) {
+
+ shimIndex = shim.getStyle('z-index');
+ if (shimIndex > me.zindex) {
+ me.shim.setStyle('z-index', me.zindex - 2);
+ }
+ shim.show();
+
+ if (shadow.isVisible()) {
+ shadowPos = shadow.el.getXY();
+ shimStyle = shim.dom.style;
+ shadowSize = shadow.el.getSize();
+ shimStyle.left = (shadowPos[0]) + 'px';
+ shimStyle.top = (shadowPos[1]) + 'px';
+ shimStyle.width = (shadowSize.width) + 'px';
+ shimStyle.height = (shadowSize.height) + 'px';
+ } else {
+ shim.setSize(w, h);
+ shim.setLeftTop(l, t);
+ }
+ }
+ } else if (shim) {
+
+ shimIndex = shim.getStyle('z-index');
+ if (shimIndex > me.zindex) {
+ me.shim.setStyle('z-index', me.zindex - 2);
+ }
+ shim.show();
+ shim.setSize(w, h);
+ shim.setLeftTop(l, t);
+ }
+ }
+ return this;
+ },
-
- minX: 0,
+ remove: function() {
+ this.hideUnders();
+ this.callParent();
+ },
- maxX: 0,
+ beginUpdate: function() {
+ this.updating = true;
+ },
- minY: 0,
+ endUpdate: function() {
+ this.updating = false;
+ this.sync(true);
+ },
- maxY: 0,
+ hideUnders: function() {
+ if (this.shadow) {
+ this.shadow.hide();
+ }
+ this.hideShim();
+ },
- maintainOffset: false,
+ constrainXY: function() {
+ if (this.constrain) {
+ var vw = Ext.core.Element.getViewWidth(),
+ vh = Ext.core.Element.getViewHeight(),
+ s = Ext.getDoc().getScroll(),
+ xy = this.getXY(),
+ x = xy[0],
+ y = xy[1],
+ so = this.shadowOffset,
+ w = this.dom.offsetWidth + so,
+ h = this.dom.offsetHeight + so,
+ moved = false;
+
+ if ((x + w) > vw + s.left) {
+ x = vw - w - so;
+ moved = true;
+ }
+ if ((y + h) > vh + s.top) {
+ y = vh - h - so;
+ moved = true;
+ }
+
+ if (x < s.left) {
+ x = s.left;
+ moved = true;
+ }
+ if (y < s.top) {
+ y = s.top;
+ moved = true;
+ }
+ if (moved) {
+ Ext.Layer.superclass.setXY.call(this, [x, y]);
+ this.sync();
+ }
+ }
+ return this;
+ },
-
- xTicks: null,
+ getConstrainOffset: function() {
+ return this.shadowOffset;
+ },
- yTicks: null,
+ setVisible: function(visible, animate, duration, callback, easing) {
+ var me = this,
+ cb;
-
- primaryButtonOnly: true,
+
+ cb = function() {
+ if (visible) {
+ me.sync(true);
+ }
+ if (callback) {
+ callback();
+ }
+ };
-
- available: false,
+
+ if (!visible) {
+ this.hideUnders(true);
+ }
+ this.callParent([visible, animate, duration, callback, easing]);
+ if (!animate) {
+ cb();
+ }
+ return this;
+ },
- hasOuterHandles: false,
+ beforeFx: function() {
+ this.beforeAction();
+ return this.callParent(arguments);
+ },
- b4StartDrag: function(x, y) { },
+ afterFx: function() {
+ this.callParent(arguments);
+ this.sync(this.isVisible());
+ },
- startDrag: function(x, y) { },
+ beforeAction: function() {
+ if (!this.updating && this.shadow) {
+ this.shadow.hide();
+ }
+ },
- b4Drag: function(e) { },
+ setLeft: function(left) {
+ this.callParent(arguments);
+ return this.sync();
+ },
-
- onDrag: function(e) { },
+ setTop: function(top) {
+ this.callParent(arguments);
+ return this.sync();
+ },
-
- onDragEnter: function(e, id) { },
+ setLeftTop: function(left, top) {
+ this.callParent(arguments);
+ return this.sync();
+ },
-
- b4DragOver: function(e) { },
+ setXY: function(xy, animate, duration, callback, easing) {
-
- onDragOver: function(e, id) { },
+
+ callback = this.createCB(callback);
-
- b4DragOut: function(e) { },
+ this.fixDisplay();
+ this.beforeAction();
+ this.callParent([xy, animate, duration, callback, easing]);
+ if (!animate) {
+ callback();
+ }
+ return this;
+ },
- onDragOut: function(e, id) { },
+ createCB: function(callback) {
+ var me = this,
+ showShadow = me.shadow && me.shadow.isVisible();
-
- b4DragDrop: function(e) { },
+ return function() {
+ me.constrainXY();
+ me.sync(showShadow);
+ if (callback) {
+ callback();
+ }
+ };
+ },
- onDragDrop: function(e, id) { },
+ setX: function(x, animate, duration, callback, easing) {
+ this.setXY([x, this.getY()], animate, duration, callback, easing);
+ return this;
+ },
- onInvalidDrop: function(e) { },
+ setY: function(y, animate, duration, callback, easing) {
+ this.setXY([this.getX(), y], animate, duration, callback, easing);
+ return this;
+ },
- b4EndDrag: function(e) { },
+ setSize: function(w, h, animate, duration, callback, easing) {
+
+ callback = this.createCB(callback);
-
- endDrag: function(e) { },
+ this.beforeAction();
+ this.callParent([w, h, animate, duration, callback, easing]);
+ if (!animate) {
+ callback();
+ }
+ return this;
+ },
- b4MouseDown: function(e) { },
+ setWidth: function(w, animate, duration, callback, easing) {
+
+ callback = this.createCB(callback);
-
- onMouseDown: function(e) { },
+ this.beforeAction();
+ this.callParent([w, animate, duration, callback, easing]);
+ if (!animate) {
+ callback();
+ }
+ return this;
+ },
- onMouseUp: function(e) { },
+ setHeight: function(h, animate, duration, callback, easing) {
+
+ callback = this.createCB(callback);
-
- onAvailable: function () {
+ this.beforeAction();
+ this.callParent([h, animate, duration, callback, easing]);
+ if (!animate) {
+ callback();
+ }
+ return this;
},
- defaultPadding : {left:0, right:0, top:0, bottom:0},
+ setBounds: function(x, y, width, height, animate, duration, callback, easing) {
+
+ callback = this.createCB(callback);
+
+ this.beforeAction();
+ if (!animate) {
+ Ext.Layer.superclass.setXY.call(this, [x, y]);
+ Ext.Layer.superclass.setSize.call(this, width, height);
+ callback();
+ } else {
+ this.callParent([x, y, width, height, animate, duration, callback, easing]);
+ }
+ return this;
+ },
- constrainTo : function(constrainTo, pad, inContent){
- if(Ext.isNumber(pad)){
- pad = {left: pad, right:pad, top:pad, bottom:pad};
+ setZIndex: function(zindex) {
+ this.zindex = zindex;
+ if (this.getShim()) {
+ this.shim.setStyle('z-index', zindex++);
}
- pad = pad || this.defaultPadding;
- var b = Ext.get(this.getEl()).getBox(),
- ce = Ext.get(constrainTo),
- s = ce.getScroll(),
- c,
- cd = ce.dom;
- if(cd == document.body){
- c = { x: s.left, y: s.top, width: Ext.lib.Dom.getViewWidth(), height: Ext.lib.Dom.getViewHeight()};
- }else{
- var xy = ce.getXY();
- c = {x : xy[0], y: xy[1], width: cd.clientWidth, height: cd.clientHeight};
+ if (this.shadow) {
+ this.shadow.setZIndex(zindex++);
}
+ this.setStyle('z-index', zindex);
+ return this;
+ }
+});
- var topSpace = b.y - c.y,
- leftSpace = b.x - c.x;
- this.resetConstraints();
- this.setXConstraint(leftSpace - (pad.left||0),
- c.width - leftSpace - b.width - (pad.right||0),
- this.xTickSize
- );
- this.setYConstraint(topSpace - (pad.top||0),
- c.height - topSpace - b.height - (pad.bottom||0),
- this.yTickSize
- );
- },
+Ext.define('Ext.layout.component.ProgressBar', {
- getEl: function() {
- if (!this._domRef) {
- this._domRef = Ext.getDom(this.id);
- }
-
- return this._domRef;
- },
-
- getDragEl: function() {
- return Ext.getDom(this.dragElId);
- },
+ alias: ['layout.progressbar'],
-
- init: function(id, sGroup, config) {
- this.initTarget(id, sGroup, config);
- Event.on(this.id, "mousedown", this.handleMouseDown, this);
-
- },
+ extend: 'Ext.layout.component.Component',
- initTarget: function(id, sGroup, config) {
-
- this.config = config || {};
+ type: 'progressbar',
+ onLayout: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ textEl = owner.textEl;
- this.DDM = Ext.dd.DDM;
-
- this.groups = {};
-
+ me.setElementSize(owner.el, width, height);
+ textEl.setWidth(owner.el.getWidth(true));
+ me.callParent([width, height]);
- if (typeof id !== "string") {
- id = Ext.id(id);
- }
+ owner.updateProgress(owner.value);
+ }
+});
-
- this.id = id;
+Ext.define('Ext.ProgressBar', {
+ extend: 'Ext.Component',
+ alias: 'widget.progressbar',
-
- this.addToGroup((sGroup) ? sGroup : "default");
+ requires: [
+ 'Ext.Template',
+ 'Ext.CompositeElement',
+ 'Ext.TaskManager',
+ 'Ext.layout.component.ProgressBar'
+ ],
-
-
- this.handleElId = id;
+ uses: ['Ext.fx.Anim'],
+
+ baseCls: Ext.baseCSSPrefix + 'progress',
+ config: {
- this.setDragElId(id);
+ animate: false,
- this.invalidHandleTypes = { A: "A" };
- this.invalidHandleIds = {};
- this.invalidHandleClasses = [];
-
- this.applyConfig();
-
- this.handleOnAvailable();
+ text: ''
},
- applyConfig: function() {
+ waitTimer: null,
-
-
- this.padding = this.config.padding || [0, 0, 0, 0];
- this.isTarget = (this.config.isTarget !== false);
- this.maintainOffset = (this.config.maintainOffset);
- this.primaryButtonOnly = (this.config.primaryButtonOnly !== false);
-
- },
-
-
- handleOnAvailable: function() {
- this.available = true;
- this.resetConstraints();
- this.onAvailable();
- },
+ renderTpl: [
+ '',
- '',
- '
',
- '',
- ' ',
- '
',
- '',
+ ' ',
+ '
',
+ ''
+ ],
-
- setPadding: function(iTop, iRight, iBot, iLeft) {
-
- if (!iRight && 0 !== iRight) {
- this.padding = [iTop, iTop, iTop, iTop];
- } else if (!iBot && 0 !== iBot) {
- this.padding = [iTop, iRight, iTop, iRight];
- } else {
- this.padding = [iTop, iRight, iBot, iLeft];
- }
- },
+ componentLayout: 'progressbar',
- setInitPosition: function(diffX, diffY) {
- var el = this.getEl();
-
- if (!this.DDM.verifyEl(el)) {
- return;
- }
-
- var dx = diffX || 0;
- var dy = diffY || 0;
+ initComponent: function() {
+ this.callParent();
- var p = Dom.getXY( el );
+ this.renderSelectors = Ext.apply(this.renderSelectors || {}, {
+ textTopEl: '.' + this.baseCls + '-text',
+ textBackEl: '.' + this.baseCls + '-text-back',
+ bar: '.' + this.baseCls + '-bar'
+ });
- this.initPageX = p[0] - dx;
- this.initPageY = p[1] - dy;
+ this.addEvents(
+
+ "update"
+ );
+ },
- this.lastPageX = p[0];
- this.lastPageY = p[1];
+ afterRender : function() {
+ var me = this;
- this.setStartPosition(p);
- },
+ me.textEl = me.textEl ? Ext.get(me.textEl) : me.el.select('.' + me.baseCls + '-text');
-
- setStartPosition: function(pos) {
- var p = pos || Dom.getXY( this.getEl() );
- this.deltaSetXY = null;
+ this.callParent(arguments);
- this.startPageX = p[0];
- this.startPageY = p[1];
+ if (me.value) {
+ me.updateProgress(me.value, me.text);
+ }
+ else {
+ me.updateText(me.text);
+ }
},
- addToGroup: function(sGroup) {
- this.groups[sGroup] = true;
- this.DDM.regDragDrop(this, sGroup);
+ updateProgress: function(value, text, animate) {
+ var newWidth;
+ this.value = value || 0;
+ if (text) {
+ this.updateText(text);
+ }
+ if (this.rendered && !this.isDestroyed) {
+ newWidth = Math.floor(this.value * this.el.getWidth(true));
+ if (Ext.isForcedBorderBox) {
+ newWidth += this.bar.getBorderWidth("lr");
+ }
+ if (animate === true || (animate !== false && this.animate)) {
+ this.bar.stopAnimation();
+ this.bar.animate(Ext.apply({
+ to: {
+ width: newWidth + 'px'
+ }
+ }, this.animate));
+ } else {
+ this.bar.setWidth(newWidth);
+ }
+ }
+ this.fireEvent('update', this, this.value, text);
+ return this;
},
- removeFromGroup: function(sGroup) {
- if (this.groups[sGroup]) {
- delete this.groups[sGroup];
+ updateText: function(text) {
+ this.text = text;
+ if (this.rendered) {
+ this.textEl.update(this.text);
}
-
- this.DDM.removeDDFromGroup(this, sGroup);
+ return this;
},
-
- setDragElId: function(id) {
- this.dragElId = id;
+ applyText : function(text) {
+ this.updateText(text);
},
- setHandleElId: function(id) {
- if (typeof id !== "string") {
- id = Ext.id(id);
+ wait: function(o) {
+ if (!this.waitTimer) {
+ var scope = this;
+ o = o || {};
+ this.updateText(o.text);
+ this.waitTimer = Ext.TaskManager.start({
+ run: function(i){
+ var inc = o.increment || 10;
+ i -= 1;
+ this.updateProgress(((((i+inc)%inc)+1)*(100/inc))*0.01, null, o.animate);
+ },
+ interval: o.interval || 1000,
+ duration: o.duration,
+ onStop: function(){
+ if (o.fn) {
+ o.fn.apply(o.scope || this);
+ }
+ this.reset();
+ },
+ scope: scope
+ });
}
- this.handleElId = id;
- this.DDM.regHandle(this.id, id);
+ return this;
},
- setOuterHandleElId: function(id) {
- if (typeof id !== "string") {
- id = Ext.id(id);
- }
- Event.on(id, "mousedown",
- this.handleMouseDown, this);
- this.setHandleElId(id);
-
- this.hasOuterHandles = true;
+ isWaiting: function(){
+ return this.waitTimer !== null;
},
- unreg: function() {
- Event.un(this.id, "mousedown",
- this.handleMouseDown);
- this._domRef = null;
- this.DDM._remove(this);
- },
-
- destroy : function(){
- this.unreg();
+ reset: function(hide){
+ this.updateProgress(0);
+ this.clearTimer();
+ if (hide === true) {
+ this.hide();
+ }
+ return this;
},
- isLocked: function() {
- return (this.DDM.isLocked() || this.locked);
+ clearTimer: function(){
+ if (this.waitTimer) {
+ this.waitTimer.onStop = null;
+ Ext.TaskManager.stop(this.waitTimer);
+ this.waitTimer = null;
+ }
},
-
- handleMouseDown: function(e, oDD){
- if (this.primaryButtonOnly && e.button != 0) {
- return;
+ onDestroy: function(){
+ this.clearTimer();
+ if (this.rendered) {
+ if (this.textEl.isComposite) {
+ this.textEl.clear();
+ }
+ Ext.destroyMembers(this, 'textEl', 'progressBar', 'textTopEl');
}
+ this.callParent();
+ }
+});
- if (this.isLocked()) {
- return;
- }
- this.DDM.refreshCache(this.groups);
+Ext.define('Ext.ShadowPool', {
+ singleton: true,
+ requires: ['Ext.core.DomHelper'],
- var pt = new Ext.lib.Point(Ext.lib.Event.getPageX(e), Ext.lib.Event.getPageY(e));
- if (!this.hasOuterHandles && !this.DDM.isOverTarget(pt, this) ) {
+ markup: function() {
+ if (Ext.supports.CSS3BoxShadow) {
+ return '';
+ } else if (Ext.isIE) {
+ return '';
} else {
- if (this.clickValidator(e)) {
-
-
- this.setStartPosition();
+ return '' +
+ '
';
+ }
+ }(),
- this.b4MouseDown(e);
- this.onMouseDown(e);
+ shadows: [],
- this.DDM.handleMouseDown(e, this);
+ pull: function() {
+ var sh = this.shadows.shift();
+ if (!sh) {
+ sh = Ext.get(Ext.core.DomHelper.insertHtml("beforeBegin", document.body.firstChild, this.markup));
+ sh.autoBoxAdjust = false;
+ }
+ return sh;
+ },
- this.DDM.stopEvent(e);
- } else {
+ push: function(sh) {
+ this.shadows.push(sh);
+ },
+
+ reset: function() {
+ Ext.Array.each(this.shadows, function(shadow) {
+ shadow.remove();
+ });
+ this.shadows = [];
+ }
+});
+Ext.define('Ext.Shadow', {
+ requires: ['Ext.ShadowPool'],
- }
+ constructor: function(config) {
+ Ext.apply(this, config);
+ if (typeof this.mode != "string") {
+ this.mode = this.defaultMode;
}
- },
+ var offset = this.offset,
+ adjusts = {
+ h: 0
+ },
+ rad = Math.floor(this.offset / 2);
- clickValidator: function(e) {
- var target = e.getTarget();
- return ( this.isValidHandleChild(target) &&
- (this.id == this.handleElId ||
- this.DDM.handleWasClicked(target, this.id)) );
+ switch (this.mode.toLowerCase()) {
+
+ case "drop":
+ if (Ext.supports.CSS3BoxShadow) {
+ adjusts.w = adjusts.h = -offset;
+ adjusts.l = adjusts.t = offset;
+ } else {
+ adjusts.w = 0;
+ adjusts.l = adjusts.t = offset;
+ adjusts.t -= 1;
+ if (Ext.isIE) {
+ adjusts.l -= offset + rad;
+ adjusts.t -= offset + rad;
+ adjusts.w -= rad;
+ adjusts.h -= rad;
+ adjusts.t += 1;
+ }
+ }
+ break;
+ case "sides":
+ if (Ext.supports.CSS3BoxShadow) {
+ adjusts.h -= offset;
+ adjusts.t = offset;
+ adjusts.l = adjusts.w = 0;
+ } else {
+ adjusts.w = (offset * 2);
+ adjusts.l = -offset;
+ adjusts.t = offset - 1;
+ if (Ext.isIE) {
+ adjusts.l -= (offset - rad);
+ adjusts.t -= offset + rad;
+ adjusts.l += 1;
+ adjusts.w -= (offset - rad) * 2;
+ adjusts.w -= rad + 1;
+ adjusts.h -= 1;
+ }
+ }
+ break;
+ case "frame":
+ if (Ext.supports.CSS3BoxShadow) {
+ adjusts.l = adjusts.w = adjusts.t = 0;
+ } else {
+ adjusts.w = adjusts.h = (offset * 2);
+ adjusts.l = adjusts.t = -offset;
+ adjusts.t += 1;
+ adjusts.h -= 2;
+ if (Ext.isIE) {
+ adjusts.l -= (offset - rad);
+ adjusts.t -= (offset - rad);
+ adjusts.l += 1;
+ adjusts.w -= (offset + rad + 1);
+ adjusts.h -= (offset + rad);
+ adjusts.h += 1;
+ }
+ break;
+ }
+ }
+ this.adjusts = adjusts;
},
- addInvalidHandleType: function(tagName) {
- var type = tagName.toUpperCase();
- this.invalidHandleTypes[type] = type;
- },
+
+ offset: 4,
- addInvalidHandleId: function(id) {
- if (typeof id !== "string") {
- id = Ext.id(id);
- }
- this.invalidHandleIds[id] = id;
- },
+ defaultMode: "drop",
- addInvalidHandleClass: function(cssClass) {
- this.invalidHandleClasses.push(cssClass);
+ show: function(target) {
+ target = Ext.get(target);
+ if (!this.el) {
+ this.el = Ext.ShadowPool.pull();
+ if (this.el.dom.nextSibling != target.dom) {
+ this.el.insertBefore(target);
+ }
+ }
+ this.el.setStyle("z-index", this.zIndex || parseInt(target.getStyle("z-index"), 10) - 1);
+ if (Ext.isIE && !Ext.supports.CSS3BoxShadow) {
+ this.el.dom.style.filter = "progid:DXImageTransform.Microsoft.alpha(opacity=50) progid:DXImageTransform.Microsoft.Blur(pixelradius=" + (this.offset) + ")";
+ }
+ this.realign(
+ target.getLeft(true),
+ target.getTop(true),
+ target.getWidth(),
+ target.getHeight()
+ );
+ this.el.dom.style.display = "block";
},
- removeInvalidHandleType: function(tagName) {
- var type = tagName.toUpperCase();
-
- delete this.invalidHandleTypes[type];
+ isVisible: function() {
+ return this.el ? true: false;
},
- removeInvalidHandleId: function(id) {
- if (typeof id !== "string") {
- id = Ext.id(id);
+ realign: function(l, t, targetWidth, targetHeight) {
+ if (!this.el) {
+ return;
}
- delete this.invalidHandleIds[id];
- },
+ var adjusts = this.adjusts,
+ d = this.el.dom,
+ targetStyle = d.style,
+ shadowWidth,
+ shadowHeight,
+ cn,
+ sww,
+ sws,
+ shs;
+
+ targetStyle.left = (l + adjusts.l) + "px";
+ targetStyle.top = (t + adjusts.t) + "px";
+ shadowWidth = Math.max(targetWidth + adjusts.w, 0);
+ shadowHeight = Math.max(targetHeight + adjusts.h, 0);
+ sws = shadowWidth + "px";
+ shs = shadowHeight + "px";
+ if (targetStyle.width != sws || targetStyle.height != shs) {
+ targetStyle.width = sws;
+ targetStyle.height = shs;
+ if (Ext.supports.CSS3BoxShadow) {
+ targetStyle.boxShadow = '0 0 ' + this.offset + 'px 0 #888';
+ } else {
-
- removeInvalidHandleClass: function(cssClass) {
- for (var i=0, len=this.invalidHandleClasses.length; i' +
+ '' +
+ '' +
+ '' +
+ '
' +
+ '' +
+ '' +
+ '' +
+ '' +
+ '
' +
+ '' +
+ '' +
+ '' +
+ '' +
+ '
' +
+ ' id="{baseBodyCls}-{inputId}" role="presentation">{subTplMarkup}
',
+ '',
+ '',
+ {
+ compiled: true,
+ disableFormats: true
}
- };
+ ],
+
- var doScroll = function(){
- if(ddm.dragCurrent){
- var dds = Ext.dd.ScrollManager;
- var inc = proc.el.ddScrollConfig ?
- proc.el.ddScrollConfig.increment : dds.increment;
- if(!dds.animate){
- if(proc.el.scroll(proc.dir, inc)){
- triggerRefresh();
- }
- }else{
- proc.el.scroll(proc.dir, inc, true, dds.animDuration, triggerRefresh);
- }
- }
- };
+ activeErrorsTpl: [
+ ''); - - notifyOver : function(dd, e, data){ - var n = this.getTargetFromEvent(e); - if(!n){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; - } - return this.onContainerOver(dd, e, data); - } - if(this.lastOverNode != n){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - } - this.onNodeEnter(n, dd, e, data); - this.lastOverNode = n; - } - return this.onNodeOver(n, dd, e, data); - }, + + calcHeight = Ext.util.TextMetrics.measure(inputEl, value, curWidth).height + + inputEl.getBorderWidth("tb") + inputEl.getPadding("tb"); - - notifyOut : function(dd, e, data){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; + + max = owner.growMax; + if (Ext.isNumber(height)) { + max = Math.min(max, height); + } + result[1] = Ext.Number.constrain(calcHeight, owner.growMin, max); } - }, - - notifyDrop : function(dd, e, data){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; - } - var n = this.getTargetFromEvent(e); - return n ? - this.onNodeDrop(n, dd, e, data) : - this.onContainerDrop(dd, e, data); - }, + return result; + } - - triggerCacheRefresh : function(){ - Ext.dd.DDM.refreshCache(this.groups); - } }); -Ext.Element.addMethods({ - - initDD : function(group, config, overrides){ - var dd = new Ext.dd.DD(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - }, - - initDDProxy : function(group, config, overrides){ - var dd = new Ext.dd.DDProxy(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - }, + +Ext.define('Ext.layout.container.Anchor', { - initDDTarget : function(group, config, overrides){ - var dd = new Ext.dd.DDTarget(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - } -}); -Ext.data.Api = (function() { + alias: 'layout.anchor', + extend: 'Ext.layout.container.Container', + alternateClassName: 'Ext.layout.AnchorLayout', + + + type: 'anchor', + + defaultAnchor: '100%', + + parseAnchorRE: /^(r|right|b|bottom)$/i, + - var validActions = {}; + onLayout: function() { + this.callParent(arguments); - return { - - actions : { - create : 'create', - read : 'read', - update : 'update', - destroy : 'destroy' - }, + var me = this, + size = me.getLayoutTargetSize(), + owner = me.owner, + target = me.getTarget(), + ownerWidth = size.width, + ownerHeight = size.height, + overflow = target.getStyle('overflow'), + components = me.getVisibleItems(owner), + len = components.length, + boxes = [], + box, newTargetSize, anchorWidth, anchorHeight, component, anchorSpec, calcWidth, calcHeight, + anchorsArray, anchor, i, el; - - restActions : { - create : 'POST', - read : 'GET', - update : 'PUT', - destroy : 'DELETE' - }, + if (ownerWidth < 20 && ownerHeight < 20) { + return; + } - isAction : function(action) { - return (Ext.data.Api.actions[action]) ? true : false; - }, + + + if (!me.clearEl) { + me.clearEl = target.createChild({ + cls: Ext.baseCSSPrefix + 'clear', + role: 'presentation' + }); + } - getVerb : function(name) { - if (validActions[name]) { - return validActions[name]; + if (owner.anchorSize) { + if (typeof owner.anchorSize == 'number') { + anchorWidth = owner.anchorSize; } - for (var verb in this.actions) { - if (this.actions[verb] === name) { - validActions[name] = verb; - break; - } + else { + anchorWidth = owner.anchorSize.width; + anchorHeight = owner.anchorSize.height; } - return (validActions[name] !== undefined) ? validActions[name] : null; - }, + } + else { + anchorWidth = owner.initialConfig.width; + anchorHeight = owner.initialConfig.height; + } - isValid : function(api){ - var invalid = []; - var crud = this.actions; - for (var action in api) { - if (!(action in crud)) { - invalid.push(action); - } - } - return (!invalid.length) ? true : invalid; - }, + if (!Ext.supports.RightMargin) { + target.addCls(Ext.baseCSSPrefix + 'inline-children'); + } - - hasUniqueUrl : function(proxy, verb) { - var url = (proxy.api[verb]) ? proxy.api[verb].url : null; - var unique = true; - for (var action in proxy.api) { - if ((unique = (action === verb) ? true : (proxy.api[action].url != url) ? true : false) === false) { - break; - } - } - return unique; - }, + for (i = 0; i < len; i++) { + component = components[i]; + el = component.el; + anchor = component.anchor; - - prepare : function(proxy) { - if (!proxy.api) { - proxy.api = {}; + if (!component.anchor && component.items && !Ext.isNumber(component.width) && !(Ext.isIE6 && Ext.isStrict)) { + component.anchor = anchor = me.defaultAnchor; } - for (var verb in this.actions) { - var action = this.actions[verb]; - proxy.api[action] = proxy.api[action] || proxy.url || proxy.directFn; - if (typeof(proxy.api[action]) == 'string') { - proxy.api[action] = { - url: proxy.api[action], - method: (proxy.restful === true) ? Ext.data.Api.restActions[action] : undefined + + if (anchor) { + anchorSpec = component.anchorSpec; + + if (!anchorSpec) { + anchorsArray = anchor.split(' '); + component.anchorSpec = anchorSpec = { + right: me.parseAnchor(anchorsArray[0], component.initialConfig.width, anchorWidth), + bottom: me.parseAnchor(anchorsArray[1], component.initialConfig.height, anchorHeight) }; } + calcWidth = anchorSpec.right ? me.adjustWidthAnchor(anchorSpec.right(ownerWidth) - el.getMargin('lr'), component) : undefined; + calcHeight = anchorSpec.bottom ? me.adjustHeightAnchor(anchorSpec.bottom(ownerHeight) - el.getMargin('tb'), component) : undefined; + + boxes.push({ + component: component, + anchor: true, + width: calcWidth || undefined, + height: calcHeight || undefined + }); + } else { + boxes.push({ + component: component, + anchor: false + }); } - }, + } - restify : function(proxy) { - proxy.restful = true; - for (var verb in this.restActions) { - proxy.api[this.actions[verb]].method || - (proxy.api[this.actions[verb]].method = this.restActions[verb]); - } - - - proxy.onWrite = proxy.onWrite.createInterceptor(function(action, o, response, rs) { - var reader = o.reader; - var res = new Ext.data.Response({ - action: action, - raw: response - }); - - switch (response.status) { - case 200: - return true; - break; - case 201: - if (Ext.isEmpty(res.raw.responseText)) { - res.success = true; - } else { - - return true; - } - break; - case 204: - res.success = true; - res.data = null; - break; - default: - return true; - break; - } - if (res.success === true) { - this.fireEvent("write", this, action, res.data, res, rs, o.request.arg); - } else { - this.fireEvent('exception', this, 'remote', action, o, res, rs); - } - o.request.callback.call(o.request.scope, res.data, res, res.success); - - return false; - }, proxy); + if (!Ext.supports.RightMargin) { + target.removeCls(Ext.baseCSSPrefix + 'inline-children'); } - }; -})(); + for (i = 0; i < len; i++) { + box = boxes[i]; + me.setItemSize(box.component, box.width, box.height); + } -Ext.data.Response = function(params, response) { - Ext.apply(this, params, { - raw: response - }); -}; -Ext.data.Response.prototype = { - message : null, - success : false, - status : null, - root : null, - raw : null, + if (overflow && overflow != 'hidden' && !me.adjustmentPass) { + newTargetSize = me.getLayoutTargetSize(); + if (newTargetSize.width != size.width || newTargetSize.height != size.height) { + me.adjustmentPass = true; + me.onLayout(); + } + } - getMessage : function() { - return this.message; - }, - getSuccess : function() { - return this.success; + delete me.adjustmentPass; }, - getStatus : function() { - return this.status; - }, - getRoot : function() { - return this.root; - }, - getRawResponse : function() { - return this.raw; - } -}; + + parseAnchor: function(a, start, cstart) { + if (a && a != 'none') { + var ratio; + + if (this.parseAnchorRE.test(a)) { + var diff = cstart - start; + return function(v) { + return v - diff; + }; + } + + else if (a.indexOf('%') != -1) { + ratio = parseFloat(a.replace('%', '')) * 0.01; + return function(v) { + return Math.floor(v * ratio); + }; + } + + else { + a = parseInt(a, 10); + if (!isNaN(a)) { + return function(v) { + return v + a; + }; + } + } + } + return null; + }, -Ext.data.Api.Error = Ext.extend(Ext.Error, { - constructor : function(message, arg) { - this.arg = arg; - Ext.Error.call(this, message); + + adjustWidthAnchor: function(value, comp) { + return value; }, - name: 'Ext.data.Api' -}); -Ext.apply(Ext.data.Api.Error.prototype, { - lang: { - 'action-url-undefined': 'No fallback url defined for this action. When defining a DataProxy api, please be sure to define an url for each CRUD action in Ext.data.Api.actions or define a default url in addition to your api-configuration.', - 'invalid': 'received an invalid API-configuration. Please ensure your proxy API-configuration contains only the actions defined in Ext.data.Api.actions', - 'invalid-url': 'Invalid url. Please review your proxy configuration.', - 'execute': 'Attempted to execute an unknown action. Valid API actions are defined in Ext.data.Api.actions"' + + + adjustHeightAnchor: function(value, comp) { + return value; } -}); +}); +Ext.define('Ext.form.action.Load', { + extend:'Ext.form.action.Action', + requires: ['Ext.data.Connection'], + alternateClassName: 'Ext.form.Action.Load', + alias: 'formaction.load', + type: 'load', -Ext.data.SortTypes = { - none : function(s){ - return s; + run: function() { + Ext.Ajax.request(Ext.apply( + this.createCallback(), + { + method: this.getMethod(), + url: this.getUrl(), + headers: this.headers, + params: this.getParams() + } + )); }, + - - stripTagsRE : /<\/?[^>]+>/gi, - - - asText : function(s){ - return String(s).replace(this.stripTagsRE, ""); + onSuccess: function(response){ + var result = this.processResponse(response), + form = this.form; + if (result === true || !result.success || !result.data) { + this.failureType = Ext.form.action.Action.LOAD_FAILURE; + form.afterAction(this, false); + return; + } + form.clearInvalid(); + form.setValues(result.data); + form.afterAction(this, true); }, + + handleResponse: function(response) { + var reader = this.form.reader, + rs, data; + if (reader) { + rs = reader.read(response); + data = rs.records && rs.records[0] ? rs.records[0].data : null; + return { + success : rs.success, + data : data + }; + } + return Ext.decode(response.responseText); + } +}); + + + +Ext.define('Ext.window.Window', { + extend: 'Ext.panel.Panel', + + alternateClassName: 'Ext.Window', + + requires: ['Ext.util.ComponentDragger', 'Ext.util.Region', 'Ext.EventManager'], + + alias: 'widget.window', + - asUCText : function(s){ - return String(s).toUpperCase().replace(this.stripTagsRE, ""); - }, - asUCString : function(s) { - return String(s).toUpperCase(); - }, - asDate : function(s) { - if(!s){ - return 0; - } - if(Ext.isDate(s)){ - return s.getTime(); - } - return Date.parse(String(s)); - }, - asFloat : function(s) { - var val = parseFloat(String(s).replace(/,/g, "")); - return isNaN(val) ? 0 : val; - }, + - asInt : function(s) { - var val = parseInt(String(s).replace(/,/g, ""), 10); - return isNaN(val) ? 0 : val; - } -}; -Ext.data.Record = function(data, id){ + baseCls: Ext.baseCSSPrefix + 'window', + - this.id = (id || id === 0) ? id : Ext.data.Record.id(this); - this.data = data || {}; -}; + resizable: true, + + draggable: true, -Ext.data.Record.create = function(o){ - var f = Ext.extend(Ext.data.Record, {}); - var p = f.prototype; - p.fields = new Ext.util.MixedCollection(false, function(field){ - return field.name; - }); - for(var i = 0, len = o.length; i < len; i++){ - p.fields.add(new Ext.data.Field(o[i])); - } - f.getField = function(name){ - return p.fields.get(name); - }; - return f; -}; + + constrain: false, -Ext.data.Record.PREFIX = 'ext-record'; -Ext.data.Record.AUTO_ID = 1; -Ext.data.Record.EDIT = 'edit'; -Ext.data.Record.REJECT = 'reject'; -Ext.data.Record.COMMIT = 'commit'; + + constrainHeader: false, + + plain: false, + + minimizable: false, -Ext.data.Record.id = function(rec) { - rec.phantom = true; - return [Ext.data.Record.PREFIX, '-', Ext.data.Record.AUTO_ID++].join(''); -}; + + maximizable: false, -Ext.data.Record.prototype = { + minHeight: 100, + + minWidth: 200, + + expandOnShow: true, + + collapsible: false, + + closable: true, + - dirty : false, - editing : false, - error : null, + hidden: true, + - modified : null, + autoRender: true, + - phantom : false, + hideMode: 'visibility', - join : function(store){ - - this.store = store; - }, + floating: true, + ariaRole: 'alertdialog', - set : function(name, value){ - var encode = Ext.isPrimitive(value) ? String : Ext.encode; - if(encode(this.data[name]) == encode(value)) { - return; - } - this.dirty = true; - if(!this.modified){ - this.modified = {}; - } - if(this.modified[name] === undefined){ - this.modified[name] = this.data[name]; - } - this.data[name] = value; - if(!this.editing){ - this.afterEdit(); - } - }, + itemCls: 'x-window-item', + overlapHeader: true, - afterEdit : function(){ - if (this.store != undefined && typeof this.store.afterEdit == "function") { - this.store.afterEdit(this); - } - }, + ignoreHeaderBorderManagement: true, - afterReject : function(){ - if(this.store){ - this.store.afterReject(this); + initComponent: function() { + var me = this; + me.callParent(); + me.addEvents( + + + + 'resize', + + 'maximize', + + 'minimize', + + 'restore' + ); + + if (me.plain) { + me.addClsWithUI('plain'); } - }, - - afterCommit : function(){ - if(this.store){ - this.store.afterCommit(this); + if (me.modal) { + me.ariaRole = 'dialog'; } }, - get : function(name){ - return this.data[name]; - }, - - beginEdit : function(){ - this.editing = true; - this.modified = this.modified || {}; - }, - - cancelEdit : function(){ - this.editing = false; - delete this.modified; + initStateEvents: function(){ + var events = this.stateEvents; + + Ext.each(['maximize', 'restore', 'resize', 'dragend'], function(event){ + if (Ext.Array.indexOf(events, event)) { + events.push(event); + } + }); + this.callParent(); }, - - endEdit : function(){ - this.editing = false; - if(this.dirty){ - this.afterEdit(); - } + getState: function() { + var me = this, + state = me.callParent() || {}, + maximized = !!me.maximized; + + state.maximized = maximized; + Ext.apply(state, { + size: maximized ? me.restoreSize : me.getSize(), + pos: maximized ? me.restorePos : me.getPosition() + }); + return state; }, - - reject : function(silent){ - var m = this.modified; - for(var n in m){ - if(typeof m[n] != "function"){ - this.data[n] = m[n]; + applyState: function(state){ + var me = this; + + if (state) { + me.maximized = state.maximized; + if (me.maximized) { + me.hasSavedRestore = true; + me.restoreSize = state.size; + me.restorePos = state.pos; + } else { + Ext.apply(me, { + width: state.size.width, + height: state.size.height, + x: state.pos[0], + y: state.pos[1] + }); } } - this.dirty = false; - delete this.modified; - this.editing = false; - if(silent !== true){ - this.afterReject(); - } }, - commit : function(silent){ - this.dirty = false; - delete this.modified; - this.editing = false; - if(silent !== true){ - this.afterCommit(); + onMouseDown: function () { + if (this.floating) { + this.toFront(); } }, - getChanges : function(){ - var m = this.modified, cs = {}; - for(var n in m){ - if(m.hasOwnProperty(n)){ - cs[n] = this.data[n]; - } - } - return cs; - }, + onRender: function(ct, position) { + var me = this; + me.callParent(arguments); + me.focusEl = me.el; - - hasError : function(){ - return this.error !== null; + + if (me.maximizable) { + me.header.on({ + dblclick: { + fn: me.toggleMaximize, + element: 'el', + scope: me + } + }); + } }, - clearError : function(){ - this.error = null; - }, + afterRender: function() { + var me = this, + hidden = me.hidden, + keyMap; - - copy : function(newId) { - return new this.constructor(Ext.apply({}, this.data), newId || this.id); - }, + me.hidden = false; + + me.callParent(); + me.hidden = hidden; - - isModified : function(fieldName){ - return !!(this.modified && this.modified.hasOwnProperty(fieldName)); - }, + + me.proxy = me.getProxy(); - - isValid : function() { - return this.fields.find(function(f) { - return (f.allowBlank === false && Ext.isEmpty(this.data[f.name])) ? true : false; - },this) ? false : true; - }, + + me.mon(me.el, 'mousedown', me.onMouseDown, me); - - markDirty : function(){ - this.dirty = true; - if(!this.modified){ - this.modified = {}; + + if (me.maximized) { + me.maximized = false; + me.maximize(); } - this.fields.each(function(f) { - this.modified[f.name] = this.data[f.name]; - },this); - } -}; - -Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), { - - - register : function(){ - for(var i = 0, s; (s = arguments[i]); i++){ - this.add(s); + if (me.closable) { + keyMap = me.getKeyMap(); + keyMap.on(27, me.onEsc, me); + keyMap.disable(); } }, - unregister : function(){ - for(var i = 0, s; (s = arguments[i]); i++){ - this.remove(this.lookup(s)); + initDraggable: function() { + var me = this, + ddConfig; + + if (!me.header) { + me.updateHeader(true); } - }, - - lookup : function(id){ - if(Ext.isArray(id)){ - var fields = ['field1'], expand = !Ext.isArray(id[0]); - if(!expand){ - for(var i = 2, len = id[0].length; i <= len; ++i){ - fields.push('field' + i); - } - } - return new Ext.data.ArrayStore({ - fields: fields, - data: id, - expandData: expand, - autoDestroy: true, - autoCreated: true + ddConfig = Ext.applyIf({ + el: me.el, + delegate: '#' + me.header.id + }, me.draggable); - }); + + if (me.constrain || me.constrainHeader) { + ddConfig.constrain = me.constrain; + ddConfig.constrainDelegate = me.constrainHeader; + ddConfig.constrainTo = me.constrainTo || me.container; } - return Ext.isObject(id) ? (id.events ? id : Ext.create(id, 'store')) : this.get(id); + + + me.dd = Ext.create('Ext.util.ComponentDragger', this, ddConfig); + me.relayEvents(me.dd, ['dragstart', 'drag', 'dragend']); }, - getKey : function(o){ - return o.storeId; - } -}); -Ext.data.Store = Ext.extend(Ext.util.Observable, { - - - - - - - - writer : undefined, - - - - remoteSort : false, + onEsc: function(k, e) { + e.stopEvent(); + this[this.closeAction](); + }, - autoDestroy : false, + beforeDestroy: function() { + var me = this; + if (me.rendered) { + delete this.animateTarget; + me.hide(); + Ext.destroy( + me.keyMap + ); + } + me.callParent(); + }, - pruneModifiedRecords : false, + addTools: function() { + var me = this; - - lastOptions : null, + + me.callParent(); - - autoSave : true, + if (me.minimizable) { + me.addTool({ + type: 'minimize', + handler: Ext.Function.bind(me.minimize, me, []) + }); + } + if (me.maximizable) { + me.addTool({ + type: 'maximize', + handler: Ext.Function.bind(me.maximize, me, []) + }); + me.addTool({ + type: 'restore', + handler: Ext.Function.bind(me.restore, me, []), + hidden: true + }); + } + }, - batch : true, + getFocusEl: function() { + var me = this, + f = me.focusEl, + defaultComp = me.defaultButton || me.defaultFocus, + t = typeof db, + el, + ct; - - restful: false, + if (Ext.isDefined(defaultComp)) { + if (Ext.isNumber(defaultComp)) { + f = me.query('button')[defaultComp]; + } else if (Ext.isString(defaultComp)) { + f = me.down('#' + defaultComp); + } else { + f = defaultComp; + } + } + return f || me.focusEl; + }, - paramNames : undefined, + beforeShow: function() { + this.callParent(); - - defaultParamNames : { - start : 'start', - limit : 'limit', - sort : 'sort', - dir : 'dir' + if (this.expandOnShow) { + this.expand(false); + } }, - isDestroyed: false, - hasMultiSort: false, - - batchKey : '_ext_batch_', + afterShow: function(animateTarget) { + var me = this, + size; - constructor : function(config){ - - - this.data = new Ext.util.MixedCollection(false); - this.data.getKey = function(o){ - return o.id; - }; - + me.callParent(arguments); - - this.removed = []; + if (me.maximized) { + me.fitContainer(); + } - if(config && config.data){ - this.inlineData = config.data; - delete config.data; + if (me.monitorResize || me.constrain || me.constrainHeader) { + Ext.EventManager.onWindowResize(me.onWindowResize, me); + } + me.doConstrain(); + if (me.keyMap) { + me.keyMap.enable(); } + }, - Ext.apply(this, config); + + doClose: function() { + var me = this; - this.baseParams = Ext.isObject(this.baseParams) ? this.baseParams : {}; + if (me.hidden) { + me.fireEvent('close', me); + me[me.closeAction](); + } else { + + me.hide(me.animTarget, me.doClose, me); + } + }, - this.paramNames = Ext.applyIf(this.paramNames || {}, this.defaultParamNames); + + afterHide: function() { + var me = this; - if((this.url || this.api) && !this.proxy){ - this.proxy = new Ext.data.HttpProxy({url: this.url, api: this.api}); - } - if (this.restful === true && this.proxy) { - - - this.batch = false; - Ext.data.Api.restify(this.proxy); + if (me.monitorResize || me.constrain || me.constrainHeader) { + Ext.EventManager.removeResizeListener(me.onWindowResize, me); } - if(this.reader){ - if(!this.recordType){ - this.recordType = this.reader.recordType; - } - if(this.reader.onMetaChange){ - this.reader.onMetaChange = this.reader.onMetaChange.createSequence(this.onMetaChange, this); - } - if (this.writer) { - if (this.writer instanceof(Ext.data.DataWriter) === false) { - this.writer = this.buildWriter(this.writer); - } - this.writer.meta = this.reader.meta; - this.pruneModifiedRecords = true; - } + + if (me.keyMap) { + me.keyMap.disable(); } + me.callParent(arguments); + }, - if(this.recordType){ - - this.fields = this.recordType.prototype.fields; + + onWindowResize: function() { + if (this.maximized) { + this.fitContainer(); } - this.modified = []; + this.doConstrain(); + }, - this.addEvents( - - 'datachanged', - - 'metachange', - - 'add', - - 'remove', - - 'update', - - 'clear', - - 'exception', - - 'beforeload', - - 'load', - - 'loadexception', - - 'beforewrite', - - 'write', - - 'beforesave', - - 'save' + + minimize: function() { + this.fireEvent('minimize', this); + return this; + }, - ); + afterCollapse: function() { + var me = this; - if(this.proxy){ - - this.relayEvents(this.proxy, ['loadexception', 'exception']); - } - - if (this.writer) { - this.on({ - scope: this, - add: this.createRecords, - remove: this.destroyRecord, - update: this.updateRecord, - clear: this.onClear - }); + if (me.maximizable) { + me.tools.maximize.hide(); + me.tools.restore.hide(); } - - this.sortToggle = {}; - if(this.sortField){ - this.setDefaultSort(this.sortField, this.sortDir); - }else if(this.sortInfo){ - this.setDefaultSort(this.sortInfo.field, this.sortInfo.direction); + if (me.resizer) { + me.resizer.disable(); } + me.callParent(arguments); + }, - Ext.data.Store.superclass.constructor.call(this); + afterExpand: function() { + var me = this; - if(this.id){ - this.storeId = this.id; - delete this.id; - } - if(this.storeId){ - Ext.StoreMgr.register(this); + if (me.maximized) { + me.tools.restore.show(); + } else if (me.maximizable) { + me.tools.maximize.show(); } - if(this.inlineData){ - this.loadData(this.inlineData); - delete this.inlineData; - }else if(this.autoLoad){ - this.load.defer(10, this, [ - typeof this.autoLoad == 'object' ? - this.autoLoad : undefined]); + if (me.resizer) { + me.resizer.enable(); } - - this.batchCounter = 0; - this.batches = {}; + me.callParent(arguments); }, - - buildWriter : function(config) { - var klass = undefined, - type = (config.format || 'json').toLowerCase(); - switch (type) { - case 'json': - klass = Ext.data.JsonWriter; - break; - case 'xml': - klass = Ext.data.XmlWriter; - break; - default: - klass = Ext.data.JsonWriter; + + maximize: function() { + var me = this; + + if (!me.maximized) { + me.expand(false); + if (!me.hasSavedRestore) { + me.restoreSize = me.getSize(); + me.restorePos = me.getPosition(true); + } + if (me.maximizable) { + me.tools.maximize.hide(); + me.tools.restore.show(); + } + me.maximized = true; + me.el.disableShadow(); + + if (me.dd) { + me.dd.disable(); + } + if (me.collapseTool) { + me.collapseTool.hide(); + } + me.el.addCls(Ext.baseCSSPrefix + 'window-maximized'); + me.container.addCls(Ext.baseCSSPrefix + 'window-maximized-ct'); + + me.setPosition(0, 0); + me.fitContainer(); + me.fireEvent('maximize', me); } - return new klass(config); + return me; }, - destroy : function(){ - if(!this.isDestroyed){ - if(this.storeId){ - Ext.StoreMgr.unregister(this); + restore: function() { + var me = this, + tools = me.tools; + + if (me.maximized) { + delete me.hasSavedRestore; + me.removeCls(Ext.baseCSSPrefix + 'window-maximized'); + + + if (tools.restore) { + tools.restore.hide(); + } + if (tools.maximize) { + tools.maximize.show(); + } + if (me.collapseTool) { + me.collapseTool.show(); } - this.clearData(); - this.data = null; - Ext.destroy(this.proxy); - this.reader = this.writer = null; - this.purgeListeners(); - this.isDestroyed = true; - } - }, - - add : function(records) { - var i, len, record, index; - - records = [].concat(records); - if (records.length < 1) { - return; - } - - for (i = 0, len = records.length; i < len; i++) { - record = records[i]; - record.join(this); + me.setPosition(me.restorePos); + me.setSize(me.restoreSize); + + + delete me.restorePos; + delete me.restoreSize; + + me.maximized = false; + + me.el.enableShadow(true); + - if (record.dirty || record.phantom) { - this.modified.push(record); + if (me.dd) { + me.dd.enable(); } + + me.container.removeCls(Ext.baseCSSPrefix + 'window-maximized-ct'); + + me.doConstrain(); + me.fireEvent('restore', me); } - - index = this.data.length; - this.data.addAll(records); - - if (this.snapshot) { - this.snapshot.addAll(records); - } - - this.fireEvent('add', this, records, index); + return me; }, - addSorted : function(record){ - var index = this.findInsertIndex(record); - this.insert(index, record); - }, - + toggleMaximize: function() { + return this[this.maximized ? 'restore': 'maximize'](); + } + - doUpdate : function(rec){ - this.data.replace(rec.id, rec); - if(this.snapshot){ - this.snapshot.replace(rec.id, rec); +}); + +Ext.define('Ext.form.field.Base', { + extend: 'Ext.Component', + mixins: { + labelable: 'Ext.form.Labelable', + field: 'Ext.form.field.Field' + }, + alias: 'widget.field', + alternateClassName: ['Ext.form.Field', 'Ext.form.BaseField'], + requires: ['Ext.util.DelayedTask', 'Ext.XTemplate', 'Ext.layout.component.field.Field'], + + fieldSubTpl: [ + 'name="{name}" ', + '
',
+ '{triggerEl}',
+ '',
+ '
',
+ {
+ compiled: true,
+ disableFormats: true
}
- };
+ ],
- var updateButtons = function(b){
- var width = 0,
- cfg;
- if(!b){
- Ext.each(buttonNames, function(name){
- buttons[name].hide();
- });
- return width;
- }
- dlg.footer.dom.style.display = '';
- Ext.iterate(buttons, function(name, btn){
- cfg = b[name];
- if(cfg){
- btn.show();
- btn.setText(Ext.isString(cfg) ? cfg : Ext.MessageBox.buttonText[name]);
- width += btn.getEl().getWidth() + 15;
- }else{
- btn.hide();
- }
- });
- return width;
- };
- return {
-
- getDialog : function(titleText){
- if(!dlg){
- var btns = [];
-
- buttons = {};
- Ext.each(buttonNames, function(name){
- btns.push(buttons[name] = new Ext.Button({
- text: this.buttonText[name],
- handler: handleButton.createCallback(name),
- hideMode: 'offsets'
- }));
- }, this);
- dlg = new Ext.Window({
- autoCreate : true,
- title:titleText,
- resizable:false,
- constrain:true,
- constrainHeader:true,
- minimizable : false,
- maximizable : false,
- stateful: false,
- modal: true,
- shim:true,
- buttonAlign:"center",
- width:400,
- height:100,
- minHeight: 80,
- plain:true,
- footer:true,
- closable:true,
- close : function(){
- if(opt && opt.buttons && opt.buttons.no && !opt.buttons.cancel){
- handleButton("no");
- }else{
- handleButton("cancel");
- }
- },
- fbar: new Ext.Toolbar({
- items: btns,
- enableOverflow: false
- })
- });
- dlg.render(document.body);
- dlg.getEl().addClass('x-window-dlg');
- mask = dlg.mask;
- bodyEl = dlg.body.createChild({
- html:''+this.loadingText+'
');
- this.all.clear();
+ onSpinUp: function() {
+ var me = this;
+ if (!me.readOnly) {
+ me.setValue(Ext.Number.constrain(me.getValue() + me.step, me.minValue, me.maxValue));
}
},
- onDestroy : function(){
- this.all.clear();
- this.selected.clear();
- Ext.DataView.superclass.onDestroy.call(this);
- this.bindStore(null);
+ onSpinDown: function() {
+ var me = this;
+ if (!me.readOnly) {
+ me.setValue(Ext.Number.constrain(me.getValue() - me.step, me.minValue, me.maxValue));
+ }
}
});
-Ext.DataView.prototype.setStore = Ext.DataView.prototype.bindStore;
-
-Ext.reg('dataview', Ext.DataView);
-
-Ext.list.ListView = Ext.extend(Ext.DataView, {
+Ext.define('Ext.toolbar.Paging', {
+ extend: 'Ext.toolbar.Toolbar',
+ alias: 'widget.pagingtoolbar',
+ alternateClassName: 'Ext.PagingToolbar',
+ requires: ['Ext.toolbar.TextItem', 'Ext.form.field.Number'],
+
+
+ displayInfo: false,
+ prependButtons: false,
+ displayMsg : 'Displaying {0} - {1} of {2}',
+
+ emptyMsg : 'No data to display',
- itemSelector: 'dl',
+ beforePageText : 'Page',
- selectedClass:'x-list-selected',
+ afterPageText : 'of {0}',
- overClass:'x-list-over',
+ firstText : 'First Page',
+ prevText : 'Previous Page',
- scrollOffset : undefined,
+ nextText : 'Next Page',
- columnResize: true,
+ lastText : 'Last Page',
+ refreshText : 'Refresh',
- columnSort: true,
+ inputItemWidth : 30,
-
- maxColumnWidth: Ext.isIE ? 99 : 100,
+ getPagingItems: function() {
+ var me = this;
+
+ return [{
+ itemId: 'first',
+ tooltip: me.firstText,
+ overflowText: me.firstText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-first',
+ disabled: true,
+ handler: me.moveFirst,
+ scope: me
+ },{
+ itemId: 'prev',
+ tooltip: me.prevText,
+ overflowText: me.prevText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-prev',
+ disabled: true,
+ handler: me.movePrevious,
+ scope: me
+ },
+ '-',
+ me.beforePageText,
+ {
+ xtype: 'numberfield',
+ itemId: 'inputItem',
+ name: 'inputItem',
+ cls: Ext.baseCSSPrefix + 'tbar-page-number',
+ allowDecimals: false,
+ minValue: 1,
+ hideTrigger: true,
+ enableKeyEvents: true,
+ selectOnFocus: true,
+ submitValue: false,
+ width: me.inputItemWidth,
+ margins: '-1 2 3 2',
+ listeners: {
+ scope: me,
+ keydown: me.onPagingKeyDown,
+ blur: me.onPagingBlur
+ }
+ },{
+ xtype: 'tbtext',
+ itemId: 'afterTextItem',
+ text: Ext.String.format(me.afterPageText, 1)
+ },
+ '-',
+ {
+ itemId: 'next',
+ tooltip: me.nextText,
+ overflowText: me.nextText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-next',
+ disabled: true,
+ handler: me.moveNext,
+ scope: me
+ },{
+ itemId: 'last',
+ tooltip: me.lastText,
+ overflowText: me.lastText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-last',
+ disabled: true,
+ handler: me.moveLast,
+ scope: me
+ },
+ '-',
+ {
+ itemId: 'refresh',
+ tooltip: me.refreshText,
+ overflowText: me.refreshText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-loading',
+ handler: me.doRefresh,
+ scope: me
+ }];
+ },
initComponent : function(){
- if(this.columnResize){
- this.colResizer = new Ext.list.ColumnResizer(this.colResizer);
- this.colResizer.init(this);
- }
- if(this.columnSort){
- this.colSorter = new Ext.list.Sorter(this.columnSort);
- this.colSorter.init(this);
- }
- if(!this.internalTpl){
- this.internalTpl = new Ext.XTemplate(
- '',
- '',
- ' ',
- '',
- '
',
- '{header}',
- '
',
- '',
- '
- ',
- '
- ', - ' class="{cls}
- ' + me.getInnerTpl(me.displayField) + ' ', + '
',
+ '',
+ '',
+ '
',
+ '',
+ '',
+ ' ',
+ '
',
+ {
+ firstInitial: function(value) {
+ return value.substr(0,1);
+ },
+ isEndOfWeek: function(value) {
+
+
+ value--;
+ var end = value % 7 === 0 && value !== 0;
+ return end ? '| {.:this.firstInitial} | ', + '
|---|
| ', + '', + '', + '', + ' | ', + '
',Ext.util.Format.htmlEncode(token),'
'].join('');
- try {
- var doc = iframe.contentWindow.document;
- doc.open();
- doc.write(html);
- doc.close();
- return true;
- } catch (e) {
- return false;
- }
+ onDestroy: function(){
+ Ext.destroyMembers(this, 'fileInputEl', 'button');
+ this.callParent();
}
- function checkIFrame() {
- if (!iframe.contentWindow || !iframe.contentWindow.document) {
- setTimeout(checkIFrame, 10);
- return;
- }
-
- var doc = iframe.contentWindow.document;
- var elem = doc.getElementById("state");
- var token = elem ? elem.innerText : null;
-
- var hash = getHash();
-
- setInterval(function () {
-
- doc = iframe.contentWindow.document;
- elem = doc.getElementById("state");
-
- var newtoken = elem ? elem.innerText : null;
-
- var newHash = getHash();
-
- if (newtoken !== token) {
- token = newtoken;
- handleStateChange(token);
- top.location.hash = token;
- hash = token;
- doSave();
- } else if (newHash !== hash) {
- hash = newHash;
- updateIFrame(newHash);
- }
-
- }, 50);
-
- ready = true;
- Ext.History.fireEvent('ready', Ext.History);
- }
+});
- function startUp() {
- currentToken = hiddenField.value ? hiddenField.value : getHash();
- if (Ext.isIE) {
- checkIFrame();
- } else {
- var hash = getHash();
- setInterval(function () {
- var newHash = getHash();
- if (newHash !== hash) {
- hash = newHash;
- handleStateChange(hash);
- doSave();
- }
- }, 50);
- ready = true;
- Ext.History.fireEvent('ready', Ext.History);
- }
- }
+Ext.define('Ext.form.field.Hidden', {
+ extend:'Ext.form.field.Base',
+ alias: ['widget.hiddenfield', 'widget.hidden'],
+ alternateClassName: 'Ext.form.Hidden',
- return {
-
- fieldId: 'x-history-field',
-
- iframeId: 'x-history-frame',
+
+ inputType : 'hidden',
+ hideLabel: true,
+
+ initComponent: function(){
+ this.formItemCls += '-hidden';
+ this.callParent();
+ },
- events:{},
+
+ initEvents: Ext.emptyFn,
+ setSize : Ext.emptyFn,
+ setWidth : Ext.emptyFn,
+ setHeight : Ext.emptyFn,
+ setPosition : Ext.emptyFn,
+ setPagePosition : Ext.emptyFn,
+ markInvalid : Ext.emptyFn,
+ clearInvalid : Ext.emptyFn
+});
-
- init: function (onReady, scope) {
- if(ready) {
- Ext.callback(onReady, scope, [this]);
- return;
- }
- if(!Ext.isReady){
- Ext.onReady(function(){
- Ext.History.init(onReady, scope);
- });
- return;
- }
- hiddenField = Ext.getDom(Ext.History.fieldId);
- if (Ext.isIE) {
- iframe = Ext.getDom(Ext.History.iframeId);
- }
- this.addEvents(
-
- 'ready',
-
- 'change'
- );
- if(onReady){
- this.on('ready', onReady, scope, {single:true});
- }
- startUp();
- },
-
- add: function (token, preventDup) {
- if(preventDup !== false){
- if(this.getToken() == token){
- return true;
- }
- }
- if (Ext.isIE) {
- return updateIFrame(token);
- } else {
- top.location.hash = token;
- return true;
- }
- },
+Ext.define('Ext.picker.Color', {
+ extend: 'Ext.Component',
+ requires: 'Ext.XTemplate',
+ alias: 'widget.colorpicker',
+ alternateClassName: 'Ext.ColorPalette',
+
+
+ componentCls : Ext.baseCSSPrefix + 'color-picker',
+
+
+ selectedCls: Ext.baseCSSPrefix + 'color-picker-selected',
+
+
+ value : null,
+
+
+ clickEvent :'click',
-
- back: function(){
- history.go(-1);
- },
+
+ allowReselect : false,
-
- forward: function(){
- history.go(1);
- },
+
+ colors : [
+ '000000', '993300', '333300', '003300', '003366', '000080', '333399', '333333',
+ '800000', 'FF6600', '808000', '008000', '008080', '0000FF', '666699', '808080',
+ 'FF0000', 'FF9900', '99CC00', '339966', '33CCCC', '3366FF', '800080', '969696',
+ 'FF00FF', 'FFCC00', 'FFFF00', '00FF00', '00FFFF', '00CCFF', '993366', 'C0C0C0',
+ 'FF99CC', 'FFCC99', 'FFFF99', 'CCFFCC', 'CCFFFF', '99CCFF', 'CC99FF', 'FFFFFF'
+ ],
-
- getToken: function() {
- return ready ? currentToken : getHash();
- }
- };
-})();
-Ext.apply(Ext.History, new Ext.util.Observable());
-Ext.Tip = Ext.extend(Ext.Panel, {
- minWidth : 40,
+ colorRe: /(?:^|\s)color-(.{6})(?:\s|$)/,
- maxWidth : 300,
+ constructor: function() {
+ this.renderTpl = Ext.create('Ext.XTemplate', '' + html + '
';
}
}
- },
-
-
- ddDisable : function(){
-
- if(tip && !disabled){
- tip.disable();
- }
- },
-
-
- ddEnable : function(){
-
- if(tip && !disabled){
- tip.enable();
- }
- },
-
-
- enable : function(){
- if(tip){
- tip.enable();
- }
- disabled = false;
- },
-
-
- disable : function(){
- if(tip){
- tip.disable();
+ html = me.cleanHtml(html);
+ if (me.fireEvent('beforesync', me, html) !== false) {
+ me.textareaEl.dom.value = html;
+ me.fireEvent('sync', me, html);
}
- disabled = true;
- },
-
-
- isEnabled : function(){
- return tip !== undefined && !tip.disabled;
- },
-
-
- getQuickTip : function(){
- return tip;
- },
-
-
- register : function(){
- tip.register.apply(tip, arguments);
- },
-
-
- unregister : function(){
- tip.unregister.apply(tip, arguments);
- },
-
-
- tips : function(){
- tip.register.apply(tip, arguments);
}
- };
-}();
-Ext.slider.Tip = Ext.extend(Ext.Tip, {
- minWidth: 10,
- offsets : [0, -10],
-
- init: function(slider) {
- slider.on({
- scope : this,
- dragstart: this.onSlide,
- drag : this.onSlide,
- dragend : this.hide,
- destroy : this.destroy
- });
},
+
-
- onSlide : function(slider, e, thumb) {
- this.show();
- this.body.update(this.getText(thumb));
- this.doAutoWidth();
- this.el.alignTo(thumb.el, 'b-t?', this.offsets);
+ getValue : function() {
+ var me = this,
+ value;
+ if (!me.sourceEditMode) {
+ me.syncValue();
+ }
+ value = me.rendered ? me.textareaEl.dom.value : me.value;
+ me.value = value;
+ return value;
},
- getText : function(thumb) {
- return String(thumb.value);
- }
-});
-
-
-Ext.ux.SliderTip = Ext.slider.Tip;
-Ext.tree.TreePanel = Ext.extend(Ext.Panel, {
- rootVisible : true,
- animate : Ext.enableFx,
- lines : true,
- enableDD : false,
- hlDrop : Ext.enableFx,
- pathSeparator : '/',
+ pushValue: function() {
+ var me = this,
+ v;
+ if(me.initialized){
+ v = me.textareaEl.dom.value || '';
+ if (!me.activated && v.length < 1) {
+ v = me.defaultValue;
+ }
+ if (me.fireEvent('beforepush', me, v) !== false) {
+ me.getEditorBody().innerHTML = v;
+ if (Ext.isGecko) {
+
+ me.setDesignMode(false);
+ me.setDesignMode(true);
+ }
+ me.fireEvent('push', me, v);
+ }
+ }
+ },
- bubbleEvents : [],
-
- initComponent : function(){
- Ext.tree.TreePanel.superclass.initComponent.call(this);
+ deferFocus : function(){
+ this.focus(false, true);
+ },
- if(!this.eventModel){
- this.eventModel = new Ext.tree.TreeEventModel(this);
- }
+ getFocusEl: function() {
+ var me = this,
+ win = me.win;
+ return win && !me.sourceEditMode ? win : me.textareaEl;
+ },
+
+ initEditor : function(){
- var l = this.loader;
- if(!l){
- l = new Ext.tree.TreeLoader({
- dataUrl: this.dataUrl,
- requestMethod: this.requestMethod
- });
- }else if(Ext.isObject(l) && !l.load){
- l = new Ext.tree.TreeLoader(l);
- }
- this.loader = l;
+ try {
+ var me = this,
+ dbody = me.getEditorBody(),
+ ss = me.textareaEl.getStyles('font-size', 'font-family', 'background-image', 'background-repeat', 'background-color', 'color'),
+ doc,
+ fn;
- this.nodeHash = {};
+ ss['background-attachment'] = 'fixed';
+ dbody.bgProperties = 'fixed';
-
- if(this.root){
- var r = this.root;
- delete this.root;
- this.setRootNode(r);
- }
+ Ext.core.DomHelper.applyStyles(dbody, ss);
+ doc = me.getDoc();
- this.addEvents(
+ if (doc) {
+ try {
+ Ext.EventManager.removeAll(doc);
+ } catch(e) {}
+ }
- 'append',
-
- 'remove',
-
- 'movenode',
-
- 'insert',
-
- 'beforeappend',
-
- 'beforeremove',
-
- 'beforemovenode',
-
- 'beforeinsert',
+ fn = Ext.Function.bind(me.onEditorEvent, me);
+ Ext.EventManager.on(doc, {
+ mousedown: fn,
+ dblclick: fn,
+ click: fn,
+ keyup: fn,
+ buffer:100
+ });
- 'beforeload',
-
- 'load',
-
- 'textchange',
-
- 'beforeexpandnode',
-
- 'beforecollapsenode',
-
- 'expandnode',
-
- 'disabledchange',
-
- 'collapsenode',
-
- 'beforeclick',
-
- 'click',
-
- 'containerclick',
-
- 'checkchange',
- 'beforedblclick',
- 'dblclick',
- 'containerdblclick',
-
- 'contextmenu',
-
- 'containercontextmenu',
-
- 'beforechildrenrendered',
-
- 'startdrag',
-
- 'enddrag',
-
- 'dragdrop',
- 'beforenodedrop',
+ fn = me.onRelayedEvent;
+ Ext.EventManager.on(doc, {
+ mousedown: fn,
+ mousemove: fn,
+ mouseup: fn,
+ click: fn,
+ dblclick: fn,
+ scope: me
+ });
+
+ if (Ext.isGecko) {
+ Ext.EventManager.on(doc, 'keypress', me.applyCommand, me);
+ }
+ if (me.fixKeys) {
+ Ext.EventManager.on(doc, 'keydown', me.fixKeys, me);
+ }
+
- 'nodedrop',
-
- 'nodedragover'
- );
- if(this.singleExpand){
- this.on('beforeexpandnode', this.restrictExpand, this);
- }
- },
+ Ext.EventManager.on(window, 'unload', me.beforeDestroy, me);
+ doc.editorInitialized = true;
-
- proxyNodeEvent : function(ename, a1, a2, a3, a4, a5, a6){
- if(ename == 'collapse' || ename == 'expand' || ename == 'beforecollapse' || ename == 'beforeexpand' || ename == 'move' || ename == 'beforemove'){
- ename = ename+'node';
+ me.initialized = true;
+ me.pushValue();
+ me.setReadOnly(me.readOnly);
+ me.fireEvent('initialize', me);
+ } catch(ex) {
+
}
-
- return this.fireEvent(ename, a1, a2, a3, a4, a5, a6);
},
-
- getRootNode : function(){
- return this.root;
- },
+ beforeDestroy : function(){
+ var me = this,
+ monitorTask = me.monitorTask,
+ doc, prop;
-
- setRootNode : function(node){
- this.destroyRoot();
- if(!node.render){
- node = this.loader.createNode(node);
+ if (monitorTask) {
+ Ext.TaskManager.stop(monitorTask);
}
- this.root = node;
- node.ownerTree = this;
- node.isRoot = true;
- this.registerNode(node);
- if(!this.rootVisible){
- var uiP = node.attributes.uiProvider;
- node.ui = uiP ? new uiP(node) : new Ext.tree.RootTreeNodeUI(node);
- }
- if(this.innerCt){
- this.clearInnerCt();
- this.renderRoot();
- }
- return node;
- },
-
- clearInnerCt : function(){
- this.innerCt.update('');
- },
-
-
- renderRoot : function(){
- this.root.render();
- if(!this.rootVisible){
- this.root.renderChildren();
+ if (me.rendered) {
+ try {
+ doc = me.getDoc();
+ if (doc) {
+ Ext.EventManager.removeAll(doc);
+ for (prop in doc) {
+ if (doc.hasOwnProperty(prop)) {
+ delete doc[prop];
+ }
+ }
+ }
+ } catch(e) {
+
+ }
+ Ext.destroyMembers('tb', 'toolbarWrap', 'iframeEl', 'textareaEl');
}
+ me.callParent();
},
- getNodeById : function(id){
- return this.nodeHash[id];
- },
-
-
- registerNode : function(node){
- this.nodeHash[node.id] = node;
- },
+ onRelayedEvent: function (event) {
+
-
- unregisterNode : function(node){
- delete this.nodeHash[node.id];
+ var iframeEl = this.iframeEl,
+ iframeXY = iframeEl.getXY(),
+ eventXY = event.getXY();
+
+
+
+ event.xy = [iframeXY[0] + eventXY[0], iframeXY[1] + eventXY[1]];
+
+ event.injectEvent(iframeEl);
+
+ event.xy = eventXY;
},
- toString : function(){
- return '[Tree'+(this.id?' '+this.id:'')+']';
+ onFirstFocus : function(){
+ var me = this,
+ selection, range;
+ me.activated = true;
+ me.disableItems(me.readOnly);
+ if (Ext.isGecko) {
+ me.win.focus();
+ selection = me.win.getSelection();
+ if (!selection.focusNode || selection.focusNode.nodeType !== 3) {
+ range = selection.getRangeAt(0);
+ range.selectNodeContents(me.getEditorBody());
+ range.collapse(true);
+ me.deferFocus();
+ }
+ try {
+ me.execCmd('useCSS', true);
+ me.execCmd('styleWithCSS', false);
+ } catch(e) {
+
+ }
+ }
+ me.fireEvent('activate', me);
},
- restrictExpand : function(node){
- var p = node.parentNode;
- if(p){
- if(p.expandedChild && p.expandedChild.parentNode == p){
- p.expandedChild.collapse();
+ adjustFont: function(btn) {
+ var adjust = btn.getItemId() === 'increasefontsize' ? 1 : -1,
+ size = this.getDoc().queryCommandValue('FontSize') || '2',
+ isPxSize = Ext.isString(size) && size.indexOf('px') !== -1,
+ isSafari;
+ size = parseInt(size, 10);
+ if (isPxSize) {
+
+
+ if (size <= 10) {
+ size = 1 + adjust;
+ }
+ else if (size <= 13) {
+ size = 2 + adjust;
+ }
+ else if (size <= 16) {
+ size = 3 + adjust;
+ }
+ else if (size <= 18) {
+ size = 4 + adjust;
+ }
+ else if (size <= 24) {
+ size = 5 + adjust;
+ }
+ else {
+ size = 6 + adjust;
+ }
+ size = Ext.Number.constrain(size, 1, 6);
+ } else {
+ isSafari = Ext.isSafari;
+ if (isSafari) {
+ adjust *= 2;
}
- p.expandedChild = node;
+ size = Math.max(1, size + adjust) + (isSafari ? 'px' : 0);
}
+ this.execCmd('FontSize', size);
},
- getChecked : function(a, startNode){
- startNode = startNode || this.root;
- var r = [];
- var f = function(){
- if(this.attributes.checked){
- r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a]));
- }
- };
- startNode.cascade(f);
- return r;
+ onEditorEvent: function(e) {
+ this.updateToolbar();
},
- getLoader : function(){
- return this.loader;
+ updateToolbar: function() {
+ var me = this,
+ btns, doc, name, fontSelect;
+
+ if (me.readOnly) {
+ return;
+ }
+
+ if (!me.activated) {
+ me.onFirstFocus();
+ return;
+ }
+
+ btns = me.getToolbar().items.map;
+ doc = me.getDoc();
+
+ if (me.enableFont && !Ext.isSafari2) {
+ name = (doc.queryCommandValue('FontName') || me.defaultFont).toLowerCase();
+ fontSelect = me.fontSelect.dom;
+ if (name !== fontSelect.value) {
+ fontSelect.value = name;
+ }
+ }
+
+ function updateButtons() {
+ Ext.Array.forEach(Ext.Array.toArray(arguments), function(name) {
+ btns[name].toggle(doc.queryCommandState(name));
+ });
+ }
+ if(me.enableFormat){
+ updateButtons('bold', 'italic', 'underline');
+ }
+ if(me.enableAlignments){
+ updateButtons('justifyleft', 'justifycenter', 'justifyright');
+ }
+ if(!Ext.isSafari2 && me.enableLists){
+ updateButtons('insertorderedlist', 'insertunorderedlist');
+ }
+
+ Ext.menu.Manager.hideAll();
+
+ me.syncValue();
},
- expandAll : function(){
- this.root.expand(true);
+ relayBtnCmd: function(btn) {
+ this.relayCmd(btn.getItemId());
},
- collapseAll : function(){
- this.root.collapse(true);
+ relayCmd: function(cmd, value) {
+ Ext.defer(function() {
+ var me = this;
+ me.focus();
+ me.execCmd(cmd, value);
+ me.updateToolbar();
+ }, 10, this);
},
- getSelectionModel : function(){
- if(!this.selModel){
- this.selModel = new Ext.tree.DefaultSelectionModel();
- }
- return this.selModel;
+ execCmd : function(cmd, value){
+ var me = this,
+ doc = me.getDoc(),
+ undef;
+ doc.execCommand(cmd, false, value === undef ? null : value);
+ me.syncValue();
},
- expandPath : function(path, attr, callback){
- if(Ext.isEmpty(path)){
- if(callback){
- callback(false, undefined);
- }
- return;
- }
- attr = attr || 'id';
- var keys = path.split(this.pathSeparator);
- var curNode = this.root;
- if(curNode.attributes[attr] != keys[1]){
- if(callback){
- callback(false, null);
- }
- return;
- }
- var index = 1;
- var f = function(){
- if(++index == keys.length){
- if(callback){
- callback(true, curNode);
+ applyCommand : function(e){
+ if (e.ctrlKey) {
+ var me = this,
+ 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;
}
- return;
- }
- var c = curNode.findChild(attr, keys[index]);
- if(!c){
- if(callback){
- callback(false, curNode);
+ if (cmd) {
+ me.win.focus();
+ me.execCmd(cmd);
+ me.deferFocus();
+ e.preventDefault();
}
- return;
}
- curNode = c;
- c.expand(false, false, f);
- };
- curNode.expand(false, false, f);
+ }
},
- selectPath : function(path, attr, callback){
- if(Ext.isEmpty(path)){
- if(callback){
- callback(false, undefined);
+ insertAtCursor : function(text){
+ var me = this,
+ range;
+
+ if (me.activated) {
+ me.win.focus();
+ if (Ext.isIE) {
+ range = me.getDoc().selection.createRange();
+ if (range) {
+ range.pasteHTML(text);
+ me.syncValue();
+ me.deferFocus();
+ }
+ }else{
+ me.execCmd('InsertHTML', text);
+ me.deferFocus();
}
- return;
}
- attr = attr || 'id';
- var keys = path.split(this.pathSeparator),
- v = keys.pop();
- if(keys.length > 1){
- var f = function(success, node){
- if(success && node){
- var n = node.findChild(attr, v);
- if(n){
- n.select();
- if(callback){
- callback(true, n);
- }
- }else if(callback){
- callback(false, n);
+ },
+
+
+ fixKeys: function() {
+ if (Ext.isIE) {
+ return function(e){
+ var me = this,
+ k = e.getKey(),
+ doc = me.getDoc(),
+ range, target;
+ if (k === e.TAB) {
+ e.stopEvent();
+ range = doc.selection.createRange();
+ if(range){
+ range.collapse(true);
+ range.pasteHTML(' ');
+ me.deferFocus();
}
- }else{
- if(callback){
- callback(false, n);
+ }
+ else if (k === e.ENTER) {
+ range = doc.selection.createRange();
+ if (range) {
+ target = range.parentElement();
+ if(!target || target.tagName.toLowerCase() !== 'li'){
+ e.stopEvent();
+ range.pasteHTML(''); + range.collapse(false); + range.select(); + } } } }; - this.expandPath(keys.join(this.pathSeparator), attr, f); - }else{ - this.root.select(); - if(callback){ - callback(true, this.root); - } } - }, - - - getTreeEl : function(){ - return this.body; - }, - - - onRender : function(ct, position){ - Ext.tree.TreePanel.superclass.onRender.call(this, ct, position); - this.el.addClass('x-tree'); - this.innerCt = this.body.createChild({tag:'ul', - cls:'x-tree-root-ct ' + - (this.useArrows ? 'x-tree-arrows' : this.lines ? 'x-tree-lines' : 'x-tree-no-lines')}); - }, - - initEvents : function(){ - Ext.tree.TreePanel.superclass.initEvents.call(this); - - if(this.containerScroll){ - Ext.dd.ScrollManager.register(this.body); - } - if((this.enableDD || this.enableDrop) && !this.dropZone){ - - this.dropZone = new Ext.tree.TreeDropZone(this, this.dropConfig || { - ddGroup: this.ddGroup || 'TreeDD', appendOnly: this.ddAppendOnly === true - }); + if (Ext.isOpera) { + return function(e){ + var me = this; + if (e.getKey() === e.TAB) { + e.stopEvent(); + me.win.focus(); + me.execCmd('InsertHTML',' '); + me.deferFocus(); + } + }; } - if((this.enableDD || this.enableDrag) && !this.dragZone){ - - this.dragZone = new Ext.tree.TreeDragZone(this, this.dragConfig || { - ddGroup: this.ddGroup || 'TreeDD', - scroll: this.ddScroll - }); + + if (Ext.isWebKit) { + return function(e){ + var me = this, + k = e.getKey(); + if (k === e.TAB) { + e.stopEvent(); + me.execCmd('InsertText','\t'); + me.deferFocus(); + } + else if (k === e.ENTER) { + e.stopEvent(); + me.execCmd('InsertHtml','
'); + me.deferFocus(); + } + }; } - this.getSelectionModel().init(this); - }, + + return null; + }(), - afterRender : function(){ - Ext.tree.TreePanel.superclass.afterRender.call(this); - this.renderRoot(); + getToolbar : function(){ + return this.toolbar; }, - beforeDestroy : function(){ - if(this.rendered){ - Ext.dd.ScrollManager.unregister(this.body); - Ext.destroy(this.dropZone, this.dragZone); - } - this.destroyRoot(); - Ext.destroy(this.loader); - this.nodeHash = this.root = this.loader = null; - Ext.tree.TreePanel.superclass.beforeDestroy.call(this); - }, - - destroyRoot : function(){ - if(this.root && this.root.destroy){ - this.root.destroy(true); + buttonTips : { + bold : { + title: 'Bold (Ctrl+B)', + text: 'Make the selected text bold.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + italic : { + title: 'Italic (Ctrl+I)', + text: 'Make the selected text italic.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + underline : { + title: 'Underline (Ctrl+U)', + text: 'Underline the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + increasefontsize : { + title: 'Grow Text', + text: 'Increase the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + decreasefontsize : { + title: 'Shrink Text', + text: 'Decrease the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + backcolor : { + title: 'Text Highlight Color', + text: 'Change the background color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + forecolor : { + title: 'Font Color', + text: 'Change the color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyleft : { + title: 'Align Text Left', + text: 'Align text to the left.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifycenter : { + title: 'Center Text', + text: 'Center text in the editor.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyright : { + title: 'Align Text Right', + text: 'Align text to the right.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertunorderedlist : { + title: 'Bullet List', + text: 'Start a bulleted list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertorderedlist : { + title: 'Numbered List', + text: 'Start a numbered list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + createlink : { + title: 'Hyperlink', + text: 'Make the selected text a hyperlink.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + sourceedit : { + title: 'Source Edit', + text: 'Switch to source editing mode.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' } } @@ -33546,5722 +71601,5378 @@ Ext.tree.TreePanel = Ext.extend(Ext.Panel, { - - - - - - - - - - - - - - +}); +Ext.define('Ext.form.field.Radio', { + extend:'Ext.form.field.Checkbox', + alias: ['widget.radiofield', 'widget.radio'], + alternateClassName: 'Ext.form.Radio', + requires: ['Ext.form.RadioManager'], - - - - - - - - - - - - - - - - -}); + isRadio: true, -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); -}; + + inputType: 'radio', + ariaRole: 'radio', -Ext.tree.TreeEventModel.prototype = { - initEvents : function(){ - var t = this.tree; + + getGroupValue: function() { + var selected = this.getManager().getChecked(this.name); + return selected ? selected.inputValue : null; + }, - if(t.trackMouseOver !== false){ - t.mon(t.innerCt, { - scope: this, - mouseover: this.delegateOver, - mouseout: this.delegateOut - }); + + onBoxClick: function(e) { + var me = this; + if (!me.disabled && !me.readOnly) { + this.setValue(true); } - 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); + + setValue: function(v) { + var me = this, + active; + + if (Ext.isBoolean(v)) { + me.callParent(arguments); + } else { + active = me.getManager().getWithValue(me.name, v).getAt(0); + if (active) { + active.setValue(true); } } - return null; + return me; }, - getNodeTarget : function(e){ - var t = e.getTarget('.x-tree-node-icon', 1); - if(!t){ - t = e.getTarget('.x-tree-node-el', 6); - } - return t; + + getSubmitValue: function() { + return this.checked ? this.inputValue : null; }, - 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)); + + onChange: function(newVal, oldVal) { + var me = this; + me.callParent(arguments); + + if (newVal) { + this.getManager().getByName(me.name).each(function(item){ + if (item !== me) { + item.setValue(false); + } + }, me); } }, - 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)); - } + + beforeDestroy: function(){ + this.callParent(); + this.getManager().removeAtKey(this.id); }, - 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; - } + + getManager: function() { + return Ext.form.RadioManager; + } +}); - }, - 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'); - } - }, +Ext.define('Ext.picker.Time', { + extend: 'Ext.view.BoundList', + alias: 'widget.timepicker', + requires: ['Ext.data.Store', 'Ext.Date'], - 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); - }, + + increment: 15, - onNodeClick : function(e, node){ - node.ui.onClick(e); - }, + + format : "g:i A", - onNodeOver : function(e, node){ - this.lastOverNode = node; - node.ui.onOver(e); - }, + + displayField: 'disp', - onNodeOut : function(e, node){ - node.ui.onOut(e); - }, + + initDate: [2008,1,1], - onIconOver : function(e, node){ - node.ui.addClass('x-tree-ec-over'); - }, + componentCls: Ext.baseCSSPrefix + 'timepicker', - onIconOut : function(e, node){ - node.ui.removeClass('x-tree-ec-over'); - }, + + loadingText: '', - onIconClick : function(e, node){ - node.ui.ecClick(e); - }, + initComponent: function() { + var me = this, + dateUtil = Ext.Date, + clearTime = dateUtil.clearTime, + initDate = me.initDate.join('/'); - onCheckboxClick : function(e, node){ - node.ui.onCheckChange(e); + + me.absMin = clearTime(new Date(initDate)); + me.absMax = dateUtil.add(clearTime(new Date(initDate)), 'mi', (24 * 60) - 1); + + me.store = me.createStore(); + me.updateList(); + + this.callParent(); }, - onNodeDblClick : function(e, node){ - node.ui.onDblClick(e); + + setMinValue: function(value) { + this.minValue = value; + this.updateList(); }, - onNodeContextMenu : function(e, node){ - node.ui.onContextMenu(e); + + setMaxValue: function(value) { + this.maxValue = value; + this.updateList(); }, - beforeEvent : function(e){ - var node = this.getNode(e); - if(this.disabled || !node || !node.ui){ - e.stopEvent(); - return false; - } - return true; + + normalizeDate: function(date) { + var initDate = this.initDate; + date.setFullYear(initDate[0], initDate[1] - 1, initDate[2]); + return date; }, - disable: function(){ - this.disabled = true; + + updateList: function() { + var me = this, + min = me.normalizeDate(me.minValue || me.absMin), + max = me.normalizeDate(me.maxValue || me.absMax); + + me.store.filterBy(function(record) { + var date = record.get('date'); + return date >= min && date <= max; + }); }, - enable: function(){ - this.disabled = false; - } -}; -Ext.tree.DefaultSelectionModel = Ext.extend(Ext.util.Observable, { - constructor : function(config){ - this.selNode = null; - - this.addEvents( - - 'selectionchange', + createStore: function() { + var me = this, + utilDate = Ext.Date, + times = [], + min = me.absMin, + max = me.absMax; - - 'beforeselect' - ); + while(min <= max){ + times.push({ + disp: utilDate.dateFormat(min, me.format), + date: min + }); + min = utilDate.add(min, 'mi', me.increment); + } + + return Ext.create('Ext.data.Store', { + fields: ['disp', 'date'], + data: times + }); + } + +}); + + +Ext.define('Ext.form.field.Time', { + extend:'Ext.form.field.Picker', + alias: 'widget.timefield', + requires: ['Ext.form.field.Date', 'Ext.picker.Time', 'Ext.view.BoundListKeyNav', 'Ext.Date'], + alternateClassName: ['Ext.form.TimeField', 'Ext.form.Time'], - 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); - }, + triggerCls: Ext.baseCSSPrefix + 'form-time-trigger', + - 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; - node.ui.onSelectedChange(true); - this.fireEvent('selectionchange', this, node, last); - } - return node; - }, + minText : "The time in this field must be equal to or after {0}", + + maxText : "The time in this field must be equal to or before {0}", + - unselect : function(node, silent){ - if(this.selNode == node){ - this.clearSelections(silent); - } - }, + invalidText : "{0} is not a valid time", + + format : "g:i A", + - clearSelections : function(silent){ - var n = this.selNode; - if(n){ - n.ui.onSelectedChange(false); - this.selNode = null; - if(silent !== true){ - this.fireEvent('selectionchange', this, null); - } - } - return n; - }, + + altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A", + - getSelectedNode : function(){ - return this.selNode; - }, + increment: 15, + + pickerMaxHeight: 300, + - isSelected : function(node){ - return this.selNode == node; - }, + selectOnTab: true, - selectPrevious : function( s){ - if(!(s = s || this.selNode || this.lastSelNode)){ - return null; + initDate: '1/1/2008', + initDateFormat: 'j/n/Y', + + + initComponent: function() { + var me = this, + min = me.minValue, + max = me.maxValue; + if (min) { + me.setMinValue(min); } - - var ps = s.previousSibling; - if(ps){ - if(!ps.isExpanded() || ps.childNodes.length < 1){ - return this.select(ps, this.selectPrevious); - } else{ - var lc = ps.lastChild; - while(lc && lc.isExpanded() && Ext.fly(lc.ui.wrap).isVisible() && lc.childNodes.length > 0){ - lc = lc.lastChild; - } - return this.select(lc, this.selectPrevious); - } - } else if(s.parentNode && (this.tree.rootVisible || !s.parentNode.isRoot)){ - return this.select(s.parentNode, this.selectPrevious); + if (max) { + me.setMaxValue(max); } - return null; + this.callParent(); }, - - selectNext : function( s){ - if(!(s = s || this.selNode || this.lastSelNode)){ - return null; - } - - if(s.firstChild && s.isExpanded() && Ext.fly(s.ui.wrap).isVisible()){ - return this.select(s.firstChild, this.selectNext); - }else if(s.nextSibling){ - return this.select(s.nextSibling, this.selectNext); - }else if(s.parentNode){ - var newS = null; - s.parentNode.bubble(function(){ - if(this.nextSibling){ - newS = this.getOwnerTree().selModel.select(this.nextSibling, this.selectNext); - return false; - } - }); - return newS; - } - return null; - }, + initValue: function() { + var me = this, + value = me.value; - onKeyDown : function(e){ - var s = this.selNode || this.lastSelNode; - var sm = this; - if(!s){ - return; + if (Ext.isString(value)) { + me.value = me.rawToValue(value); } - var k = e.getKey(); - switch(k){ - case e.DOWN: - e.stopEvent(); - this.selectNext(); - break; - case e.UP: - e.stopEvent(); - this.selectPrevious(); - break; - case e.RIGHT: - e.preventDefault(); - if(s.hasChildNodes()){ - if(!s.isExpanded()){ - s.expand(); - }else if(s.firstChild){ - this.select(s.firstChild, e); - } - } - break; - case e.LEFT: - e.preventDefault(); - if(s.hasChildNodes() && s.isExpanded()){ - s.collapse(); - }else if(s.parentNode && (this.tree.rootVisible || s.parentNode != this.tree.getRootNode())){ - this.select(s.parentNode, e); - } - break; - }; - } -}); - -Ext.tree.MultiSelectionModel = Ext.extend(Ext.util.Observable, { - - constructor : function(config){ - this.selNodes = []; - this.selMap = {}; - this.addEvents( - - 'selectionchange' - ); - Ext.apply(this, config); - Ext.tree.MultiSelectionModel.superclass.constructor.call(this); + me.callParent(); }, + - init : function(tree){ - this.tree = tree; - tree.mon(tree.getTreeEl(), 'keydown', this.onKeyDown, this); - tree.on('click', this.onNodeClick, this); + setMinValue: function(value) { + var me = this, + picker = me.picker; + me.setLimit(value, true); + if (picker) { + picker.setMinValue(me.minValue); + } }, + - onNodeClick : function(node, e){ - if(e.ctrlKey && this.isSelected(node)){ - this.unselect(node); - }else{ - this.select(node, e, e.ctrlKey); + setMaxValue: function(value) { + var me = this, + picker = me.picker; + me.setLimit(value, false); + if (picker) { + picker.setMaxValue(me.maxValue); } }, + - - select : function(node, e, keepExisting){ - if(keepExisting !== true){ - this.clearSelections(true); + setLimit: function(value, isMin) { + var me = this, + d, val; + if (Ext.isString(value)) { + d = me.parseDate(value); } - if(this.isSelected(node)){ - this.lastSelNode = node; - return node; + else if (Ext.isDate(value)) { + d = value; } - this.selNodes.push(node); - this.selMap[node.id] = node; - this.lastSelNode = node; - node.ui.onSelectedChange(true); - this.fireEvent('selectionchange', this, this.selNodes); - return node; - }, - - - unselect : function(node){ - if(this.selMap[node.id]){ - node.ui.onSelectedChange(false); - var sn = this.selNodes; - var index = sn.indexOf(node); - if(index != -1){ - this.selNodes.splice(index, 1); - } - delete this.selMap[node.id]; - this.fireEvent('selectionchange', this, this.selNodes); + if (d) { + val = Ext.Date.clearTime(new Date(me.initDate)); + val.setHours(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()); + me[isMin ? 'minValue' : 'maxValue'] = val; } }, - - - clearSelections : function(suppressEvent){ - var sn = this.selNodes; - if(sn.length > 0){ - for(var i = 0, len = sn.length; i < len; i++){ - sn[i].ui.onSelectedChange(false); - } - this.selNodes = []; - this.selMap = {}; - if(suppressEvent !== true){ - this.fireEvent('selectionchange', this, this.selNodes); - } - } + + rawToValue: function(rawValue) { + return this.parseDate(rawValue) || rawValue || null; }, - - - isSelected : function(node){ - return this.selMap[node.id] ? true : false; + + valueToRaw: function(value) { + return this.formatDate(this.parseDate(value)); }, + - - getSelectedNodes : function(){ - return this.selNodes.concat([]); - }, + getErrors: function(value) { + var me = this, + format = Ext.String.format, + errors = me.callParent(arguments), + minValue = me.minValue, + maxValue = me.maxValue, + date; - onKeyDown : Ext.tree.DefaultSelectionModel.prototype.onKeyDown, + value = me.formatDate(value || me.processRawValue(me.getRawValue())); - selectNext : Ext.tree.DefaultSelectionModel.prototype.selectNext, + if (value === null || value.length < 1) { + return errors; + } + + date = me.parseDate(value); + if (!date) { + errors.push(format(me.invalidText, value, me.format)); + return errors; + } + + if (minValue && date < minValue) { + errors.push(format(me.minText, me.formatDate(minValue))); + } + + if (maxValue && date > maxValue) { + errors.push(format(me.maxText, me.formatDate(maxValue))); + } + + return errors; + }, + + formatDate: function() { + return Ext.form.field.Date.prototype.formatDate.apply(this, arguments); + }, - selectPrevious : Ext.tree.DefaultSelectionModel.prototype.selectPrevious -}); -Ext.data.Tree = Ext.extend(Ext.util.Observable, { - constructor: function(root){ - this.nodeHash = {}; - - this.root = null; - if(root){ - this.setRootNode(root); + parseDate: function(value) { + if (!value || Ext.isDate(value)) { + return value; } - this.addEvents( - - "append", - - "remove", - - "move", - - "insert", - - "beforeappend", - - "beforeremove", + + var me = this, + val = me.safeParse(value, me.format), + altFormats = me.altFormats, + altFormatsArray = me.altFormatsArray, + i = 0, + len; + + if (!val && altFormats) { + altFormatsArray = altFormatsArray || altFormats.split('|'); + len = altFormatsArray.length; + for (; i < len && !val; ++i) { + val = me.safeParse(value, altFormatsArray[i]); + } + } + return val; + }, + + safeParse: function(value, format){ + var me = this, + utilDate = Ext.Date, + parsedDate, + result = null; + + if (utilDate.formatContainsDateInfo(format)) { - "beforemove", + result = utilDate.parse(value, format); + } else { - "beforeinsert" - ); - Ext.data.Tree.superclass.constructor.call(this); + parsedDate = utilDate.parse(me.initDate + ' ' + value, me.initDateFormat + ' ' + format); + if (parsedDate) { + result = parsedDate; + } + } + return result; }, - - - pathSeparator: "/", - proxyNodeEvent : function(){ - return this.fireEvent.apply(this, arguments); + getSubmitValue: function() { + var me = this, + format = me.submitFormat || me.format, + value = me.getValue(); + + return value ? Ext.Date.format(value, format) : null; }, - getRootNode : function(){ - return this.root; + createPicker: function() { + var me = this, + picker = Ext.create('Ext.picker.Time', { + selModel: { + mode: 'SINGLE' + }, + floating: true, + hidden: true, + minValue: me.minValue, + maxValue: me.maxValue, + increment: me.increment, + format: me.format, + ownerCt: this.ownerCt, + renderTo: document.body, + maxHeight: me.pickerMaxHeight, + focusOnToFront: false + }); + + me.mon(picker.getSelectionModel(), { + selectionchange: me.onListSelect, + scope: me + }); + + return picker; }, - setRootNode : function(node){ - this.root = node; - node.ownerTree = this; - node.isRoot = true; - this.registerNode(node); - return node; - }, + onExpand: function() { + var me = this, + keyNav = me.pickerKeyNav, + selectOnTab = me.selectOnTab, + picker = me.getPicker(), + lastSelected = picker.getSelectionModel().lastSelected, + itemNode; + + if (!keyNav) { + keyNav = me.pickerKeyNav = Ext.create('Ext.view.BoundListKeyNav', this.inputEl, { + boundList: picker, + forceKeyDown: true, + tab: function(e) { + if (selectOnTab) { + this.selectHighlighted(e); + me.triggerBlur(); + } + + return true; + } + }); + + if (selectOnTab) { + me.ignoreMonitorTab = true; + } + } + Ext.defer(keyNav.enable, 1, keyNav); - - getNodeById : function(id){ - return this.nodeHash[id]; + + if (lastSelected) { + itemNode = picker.getNode(lastSelected); + if (itemNode) { + picker.highlightItem(itemNode); + picker.el.scrollChildIntoView(itemNode, false); + } + } }, - registerNode : function(node){ - this.nodeHash[node.id] = node; + onCollapse: function() { + var me = this, + keyNav = me.pickerKeyNav; + if (keyNav) { + keyNav.disable(); + me.ignoreMonitorTab = false; + } }, - unregisterNode : function(node){ - delete this.nodeHash[node.id]; - }, - - toString : function(){ - return "[Tree"+(this.id?" "+this.id:"")+"]"; + onListSelect: function(list, recordArray) { + var me = this, + record = recordArray[0], + val = record ? record.get('date') : null; + me.setValue(val); + me.fireEvent('select', me, val); + me.picker.clearHighlight(); + me.collapse(); + me.inputEl.focus(); } }); -Ext.data.Node = Ext.extend(Ext.util.Observable, { - - constructor: function(attributes){ - - this.attributes = attributes || {}; - this.leaf = this.attributes.leaf; - - this.id = this.attributes.id; - if(!this.id){ - this.id = Ext.id(null, "xnode-"); - this.attributes.id = this.id; - } - - this.childNodes = []; - - this.parentNode = null; - - this.firstChild = null; - - this.lastChild = null; - - this.previousSibling = null; - - this.nextSibling = null; - this.addEvents({ - - "append" : true, - - "remove" : true, - - "move" : true, - - "insert" : true, - - "beforeappend" : true, - - "beforeremove" : true, - - "beforemove" : true, - - "beforeinsert" : true - }); - this.listeners = this.attributes.listeners; - Ext.data.Node.superclass.constructor.call(this); +Ext.define('Ext.grid.CellEditor', { + extend: 'Ext.Editor', + constructor: function(config) { + if (config.field) { + config.field.monitorTab = false; + } + config.autoSize = { + width: 'boundEl' + }; + this.callParent(arguments); }, - fireEvent : function(evtName){ - - if(Ext.data.Node.superclass.fireEvent.apply(this, arguments) === false){ - return false; + onShow: function() { + var first = this.boundEl.first(); + if (first) { + first.hide(); } - - var ot = this.getOwnerTree(); - if(ot){ - if(ot.proxyNodeEvent.apply(ot, arguments) === false){ - return false; - } + this.callParent(arguments); + }, + + + onHide: function() { + var first = this.boundEl.first(); + if (first) { + first.show(); } - return true; + this.callParent(arguments); }, - - isLeaf : function(){ - return this.leaf === true; + + afterRender: function() { + this.callParent(arguments); + var field = this.field; + if (field.isXType('checkboxfield')) { + field.mon(field.inputEl, 'mousedown', this.onCheckBoxMouseDown, this); + field.mon(field.inputEl, 'click', this.onCheckBoxClick, this); + } }, - - setFirstChild : function(node){ - this.firstChild = node; + + onCheckBoxMouseDown: function() { + this.completeEdit = Ext.emptyFn; }, - - setLastChild : function(node){ - this.lastChild = node; + + onCheckBoxClick: function() { + delete this.completeEdit; + this.field.focus(false, 10); }, + + alignment: "tl-tl", + hideEl : false, + cls: Ext.baseCSSPrefix + "small-editor " + Ext.baseCSSPrefix + "grid-editor", + shim: false, + shadow: false +}); +Ext.define('Ext.grid.ColumnLayout', { + extend: 'Ext.layout.container.HBox', + alias: 'layout.gridcolumn', + type : 'column', - isLast : function(){ - return (!this.parentNode ? true : this.parentNode.lastChild == this); - }, + clearInnerCtOnLayout: false, - - isFirst : function(){ - return (!this.parentNode ? true : this.parentNode.firstChild == this); + constructor: function() { + var me = this; + me.callParent(arguments); + if (!Ext.isDefined(me.availableSpaceOffset)) { + me.availableSpaceOffset = (Ext.getScrollBarWidth() - 2); + } }, - - hasChildNodes : function(){ - return !this.isLeaf() && this.childNodes.length > 0; - }, + beforeLayout: function() { + var me = this, + i = 0, + items = me.getLayoutItems(), + len = items.length, + item, returnValue; - - isExpandable : function(){ - return this.attributes.expandable || this.hasChildNodes(); - }, + returnValue = me.callParent(arguments); - - appendChild : function(node){ - var multi = false; - if(Ext.isArray(node)){ - multi = node; - }else if(arguments.length > 1){ - multi = arguments; - } - if(multi){ - for(var i = 0, len = multi.length; i < len; i++) { - this.appendChild(multi[i]); - } - }else{ - if(this.fireEvent("beforeappend", this.ownerTree, this, node) === false){ - return false; - } - var index = this.childNodes.length; - var oldParent = node.parentNode; - - if(oldParent){ - if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index) === false){ - return false; + me.innerCt.setHeight(23); + + + if (me.align == 'stretchmax') { + for (; i < len; i++) { + item = items[i]; + item.el.setStyle({ + height: 'auto' + }); + item.titleContainer.setStyle({ + height: 'auto', + paddingTop: '0' + }); + if (item.componentLayout && item.componentLayout.lastComponentSize) { + item.componentLayout.lastComponentSize.height = item.el.dom.offsetHeight; } - oldParent.removeChild(node); - } - index = this.childNodes.length; - if(index === 0){ - this.setFirstChild(node); - } - this.childNodes.push(node); - node.parentNode = this; - var ps = this.childNodes[index-1]; - if(ps){ - node.previousSibling = ps; - ps.nextSibling = node; - }else{ - node.previousSibling = null; } - node.nextSibling = null; - this.setLastChild(node); - node.setOwnerTree(this.getOwnerTree()); - this.fireEvent("append", this.ownerTree, this, node, index); - if(oldParent){ - node.fireEvent("move", this.ownerTree, node, oldParent, this, index); - } - return node; } + return returnValue; }, - removeChild : function(node, destroy){ - var index = this.childNodes.indexOf(node); - if(index == -1){ - return false; - } - if(this.fireEvent("beforeremove", this.ownerTree, this, node) === false){ - return false; - } + calculateChildBoxes: function(visibleItems, targetSize) { + var me = this, + calculations = me.callParent(arguments), + boxes = calculations.boxes, + metaData = calculations.meta, + len = boxes.length, i = 0, box, item; - - this.childNodes.splice(index, 1); + if (targetSize.width && !me.isColumn) { + + if (me.owner.forceFit) { - - if(node.previousSibling){ - node.previousSibling.nextSibling = node.nextSibling; - } - if(node.nextSibling){ - node.nextSibling.previousSibling = node.previousSibling; - } + for (; i < len; i++) { + box = boxes[i]; + item = box.component; - - if(this.firstChild == node){ - this.setFirstChild(node.nextSibling); - } - if(this.lastChild == node){ - this.setLastChild(node.previousSibling); - } + + item.minWidth = Ext.grid.plugin.HeaderResizer.prototype.minColWidth; - this.fireEvent("remove", this.ownerTree, this, node); - if(destroy){ - node.destroy(true); - }else{ - node.clear(); - } - return node; - }, + + + item.flex = box.width; + } - - clear : function(destroy){ - - this.setOwnerTree(null, destroy); - this.parentNode = this.previousSibling = this.nextSibling = null; - if(destroy){ - this.firstChild = this.lastChild = null; + + calculations = me.callParent(arguments); + } + else if (metaData.tooNarrow) { + targetSize.width = metaData.desiredSize; + } } - }, - - destroy : function( silent){ - - if(silent === true){ - this.purgeListeners(); - this.clear(true); - Ext.each(this.childNodes, function(n){ - n.destroy(true); - }); - this.childNodes = null; - }else{ - this.remove(true); - } + return calculations; }, - - insertBefore : function(node, refNode){ - if(!refNode){ - return this.appendChild(node); - } - - if(node == refNode){ - return false; - } - - if(this.fireEvent("beforeinsert", this.ownerTree, this, node, refNode) === false){ - return false; - } - var index = this.childNodes.indexOf(refNode); - var oldParent = node.parentNode; - var refIndex = index; + afterLayout: function() { + var me = this, + i = 0, + items = me.getLayoutItems(), + len = items.length; - - if(oldParent == this && this.childNodes.indexOf(node) < index){ - refIndex--; - } + me.callParent(arguments); - if(oldParent){ - if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index, refNode) === false){ - return false; + if (me.align == 'stretchmax') { + for (; i < len; i++) { + items[i].setPadding(); } - oldParent.removeChild(node); - } - if(refIndex === 0){ - this.setFirstChild(node); - } - this.childNodes.splice(refIndex, 0, node); - node.parentNode = this; - var ps = this.childNodes[refIndex-1]; - if(ps){ - node.previousSibling = ps; - ps.nextSibling = node; - }else{ - node.previousSibling = null; } - node.nextSibling = refNode; - refNode.previousSibling = node; - node.setOwnerTree(this.getOwnerTree()); - this.fireEvent("insert", this.ownerTree, this, node, refNode); - if(oldParent){ - node.fireEvent("move", this.ownerTree, node, oldParent, this, refIndex, refNode); - } - return node; }, - remove : function(destroy){ - if (this.parentNode) { - this.parentNode.removeChild(this, destroy); - } - return this; - }, - - removeAll : function(destroy){ - var cn = this.childNodes, - n; - while((n = cn[0])){ - this.removeChild(n, destroy); + updateInnerCtSize: function(tSize, calcs) { + var me = this, + extra = 0; + + + if (!me.isColumn && calcs.meta.tooNarrow) { + if ( + Ext.isWebKit || + Ext.isGecko || + (Ext.isIEQuirks && (Ext.isIE6 || Ext.isIE7 || Ext.isIE8)) + ) { + extra = 1; + + } else if (Ext.isIE6 || Ext.isIE7 || Ext.isIE8) { + extra = 2; + } + + + extra++; + tSize.width = calcs.meta.desiredSize + (me.reserveOffset ? me.availableSpaceOffset : 0) + extra; } - return this; + return me.callParent(arguments); }, - - item : function(index){ - return this.childNodes[index]; - }, + doOwnerCtLayouts: function() { + var ownerCt = this.owner.ownerCt; + if (!ownerCt.componentLayout.layoutBusy) { + ownerCt.doComponentLayout(); + } + } +}); +Ext.define('Ext.grid.LockingView', { - replaceChild : function(newChild, oldChild){ - var s = oldChild ? oldChild.nextSibling : null; - this.removeChild(oldChild); - this.insertBefore(newChild, s); - return oldChild; + mixins: { + observable: 'Ext.util.Observable' }, - - indexOf : function(child){ - return this.childNodes.indexOf(child); - }, - + eventRelayRe: /^(beforeitem|beforecontainer|item|container|cell)/, - getOwnerTree : function(){ + constructor: function(config){ + var me = this, + eventNames = [], + eventRe = me.eventRelayRe, + locked = config.locked.getView(), + normal = config.normal.getView(), + events, + event; + + Ext.apply(me, { + lockedView: locked, + normalView: normal, + lockedGrid: config.locked, + normalGrid: config.normal, + panel: config.panel + }); + me.mixins.observable.constructor.call(me, config); - if(!this.ownerTree){ - var p = this; - while(p){ - if(p.ownerTree){ - this.ownerTree = p.ownerTree; - break; - } - p = p.parentNode; + + events = locked.events; + for (event in events) { + if (events.hasOwnProperty(event) && eventRe.test(event)) { + eventNames.push(event); } } - return this.ownerTree; + me.relayEvents(locked, eventNames); + me.relayEvents(normal, eventNames); + + normal.on({ + scope: me, + itemmouseleave: me.onItemMouseLeave, + itemmouseenter: me.onItemMouseEnter + }); + + locked.on({ + scope: me, + itemmouseleave: me.onItemMouseLeave, + itemmouseenter: me.onItemMouseEnter + }); }, - - getDepth : function(){ - var depth = 0; - var p = this; - while(p.parentNode){ - ++depth; - p = p.parentNode; - } - return depth; + getGridColumns: function() { + var cols = this.lockedGrid.headerCt.getGridColumns(); + return cols.concat(this.normalGrid.headerCt.getGridColumns()); }, - - setOwnerTree : function(tree, destroy){ - - if(tree != this.ownerTree){ - if(this.ownerTree){ - this.ownerTree.unregisterNode(this); - } - this.ownerTree = tree; + onItemMouseEnter: function(view, record){ + var me = this, + locked = me.lockedView, + other = me.normalView, + item; - if(destroy !== true){ - Ext.each(this.childNodes, function(n){ - n.setOwnerTree(tree); - }); - } - if(tree){ - tree.registerNode(this); + if (view.trackOver) { + if (view !== locked) { + other = locked; } + item = other.getNode(record); + other.highlightItem(item); } }, - - setId: function(id){ - if(id !== this.id){ - var t = this.ownerTree; - if(t){ - t.unregisterNode(this); - } - this.id = this.attributes.id = id; - if(t){ - t.registerNode(this); + onItemMouseLeave: function(view, record){ + var me = this, + locked = me.lockedView, + other = me.normalView; + + if (view.trackOver) { + if (view !== locked) { + other = locked; } - this.onIdChange(id); + other.clearHighlight(); } }, - - onIdChange: Ext.emptyFn, - + relayFn: function(name, args){ + args = args || []; + + var view = this.lockedView; + view[name].apply(view, args || []); + view = this.normalView; + view[name].apply(view, args || []); + }, - getPath : function(attr){ - attr = attr || "id"; - var p = this.parentNode; - var b = [this.attributes[attr]]; - while(p){ - b.unshift(p.attributes[attr]); - p = p.parentNode; - } - var sep = this.getOwnerTree().pathSeparator; - return sep + b.join(sep); + getSelectionModel: function(){ + return this.panel.getSelectionModel(); }, - - bubble : function(fn, scope, args){ - var p = this; - while(p){ - if(fn.apply(scope || p, args || [p]) === false){ - break; - } - p = p.parentNode; - } + getStore: function(){ + return this.panel.store; }, - - cascade : function(fn, scope, args){ - if(fn.apply(scope || this, args || [this]) !== false){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].cascade(fn, scope, args); - } + getNode: function(nodeInfo){ + + return this.normalView.getNode(nodeInfo); + }, + + getCell: function(record, column){ + var view = this.lockedView, + row; + + + if (view.getHeaderAtIndex(column) === -1) { + view = this.normalView; } + + row = view.getNode(record); + return Ext.fly(row).down(column.getCellSelector()); }, - - eachChild : function(fn, scope, args){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - if(fn.apply(scope || cs[i], args || [cs[i]]) === false){ - break; - } + getRecord: function(node){ + var result = this.lockedView.getRecord(node); + if (!node) { + result = this.normalView.getRecord(node); } + return result; }, - - findChild : function(attribute, value, deep){ - return this.findChildBy(function(){ - return this.attributes[attribute] == value; - }, null, deep); + refreshNode: function(){ + this.relayFn('refreshNode', arguments); }, - - findChildBy : function(fn, scope, deep){ - var cs = this.childNodes, - len = cs.length, - i = 0, - n, - res; - for(; i < len; i++){ - n = cs[i]; - if(fn.call(scope || n, n) === true){ - return n; - }else if (deep){ - res = n.findChildBy(fn, scope, deep); - if(res != null){ - return res; - } - } - - } - return null; + refresh: function(){ + this.relayFn('refresh', arguments); }, - - sort : function(fn, scope){ - var cs = this.childNodes; - var len = cs.length; - if(len > 0){ - var sortFn = scope ? function(){fn.apply(scope, arguments);} : fn; - cs.sort(sortFn); - for(var i = 0; i < len; i++){ - var n = cs[i]; - n.previousSibling = cs[i-1]; - n.nextSibling = cs[i+1]; - if(i === 0){ - this.setFirstChild(n); - } - if(i == len-1){ - this.setLastChild(n); - } - } - } + bindStore: function(){ + this.relayFn('bindStore', arguments); }, - - contains : function(node){ - return node.isAncestor(this); + addRowCls: function(){ + this.relayFn('addRowCls', arguments); }, + + removeRowCls: function(){ + this.relayFn('removeRowCls', arguments); + } + +}); +Ext.define('Ext.grid.Lockable', { - isAncestor : function(node){ - var p = this.parentNode; - while(p){ - if(p == node){ - return true; + requires: ['Ext.grid.LockingView'], + + + syncRowHeight: true, + + + + + + + + + spacerHidden: true, + + + unlockText: 'Unlock', + lockText: 'Lock', + + determineXTypeToCreate: function() { + var me = this, + typeToCreate; + + if (me.subGridXType) { + typeToCreate = me.subGridXType; + } else { + var xtypes = this.getXTypes().split('/'), + xtypesLn = xtypes.length, + xtype = xtypes[xtypesLn - 1], + superxtype = xtypes[xtypesLn - 2]; + + if (superxtype !== 'tablepanel') { + typeToCreate = superxtype; + } else { + typeToCreate = xtype; } - p = p.parentNode; } - return false; + + return typeToCreate; }, - - toString : function(){ - return "[Node"+(this.id?" "+this.id:"")+"]"; - } -}); -Ext.tree.TreeNode = Ext.extend(Ext.data.Node, { - constructor : function(attributes){ - attributes = attributes || {}; - if(Ext.isString(attributes)){ - attributes = {text: attributes}; - } - this.childrenRendered = false; - this.rendered = false; - Ext.tree.TreeNode.superclass.constructor.call(this, attributes); - this.expanded = attributes.expanded === true; - this.isTarget = attributes.isTarget !== false; - this.draggable = attributes.draggable !== false && attributes.allowDrag !== false; - this.allowChildren = attributes.allowChildren !== false && attributes.allowDrop !== false; - + + + injectLockable: function() { - this.text = attributes.text; + this.lockable = true; - this.disabled = attributes.disabled === true; - this.hidden = attributes.hidden === true; - - this.addEvents( - - 'textchange', - - 'beforeexpand', - - 'beforecollapse', - - 'expand', - - 'disabledchange', + this.hasView = true; + + var me = this, - 'collapse', - 'beforeclick', - 'click', + xtype = me.determineXTypeToCreate(), - 'checkchange', + selModel = me.getSelectionModel(), + lockedGrid = { + xtype: xtype, + + enableAnimations: false, + scroll: false, + scrollerOwner: false, + selModel: selModel, + border: false, + cls: Ext.baseCSSPrefix + 'grid-inner-locked' + }, + normalGrid = { + xtype: xtype, + enableAnimations: false, + scrollerOwner: false, + selModel: selModel, + border: false + }, + i = 0, + columns, + lockedHeaderCt, + normalHeaderCt; + + me.addCls(Ext.baseCSSPrefix + 'grid-locked'); + + + + + Ext.copyTo(normalGrid, me, me.normalCfgCopy); + Ext.copyTo(lockedGrid, me, me.lockedCfgCopy); + for (; i < me.normalCfgCopy.length; i++) { + delete me[me.normalCfgCopy[i]]; + } + for (i = 0; i < me.lockedCfgCopy.length; i++) { + delete me[me.lockedCfgCopy[i]]; + } + + me.lockedHeights = []; + me.normalHeights = []; + + columns = me.processColumns(me.columns); + + lockedGrid.width = columns.lockedWidth; + lockedGrid.columns = columns.locked; + normalGrid.columns = columns.normal; + + me.store = Ext.StoreManager.lookup(me.store); + lockedGrid.store = me.store; + normalGrid.store = me.store; + + + normalGrid.flex = 1; + lockedGrid.viewConfig = me.lockedViewConfig || {}; + lockedGrid.viewConfig.loadingUseMsg = false; + normalGrid.viewConfig = me.normalViewConfig || {}; + + Ext.applyIf(lockedGrid.viewConfig, me.viewConfig); + Ext.applyIf(normalGrid.viewConfig, me.viewConfig); + + me.normalGrid = Ext.ComponentManager.create(normalGrid); + me.lockedGrid = Ext.ComponentManager.create(lockedGrid); + + me.view = Ext.create('Ext.grid.LockingView', { + locked: me.lockedGrid, + normal: me.normalGrid, + panel: me + }); + + if (me.syncRowHeight) { + me.lockedGrid.getView().on({ + refresh: me.onLockedGridAfterRefresh, + itemupdate: me.onLockedGridAfterUpdate, + scope: me + }); - 'beforedblclick', + me.normalGrid.getView().on({ + refresh: me.onNormalGridAfterRefresh, + itemupdate: me.onNormalGridAfterUpdate, + scope: me + }); + } + + lockedHeaderCt = me.lockedGrid.headerCt; + normalHeaderCt = me.normalGrid.headerCt; + + lockedHeaderCt.lockedCt = true; + lockedHeaderCt.lockableInjected = true; + normalHeaderCt.lockableInjected = true; + + lockedHeaderCt.on({ + columnshow: me.onLockedHeaderShow, + columnhide: me.onLockedHeaderHide, + columnmove: me.onLockedHeaderMove, + sortchange: me.onLockedHeaderSortChange, + columnresize: me.onLockedHeaderResize, + scope: me + }); + + normalHeaderCt.on({ + columnmove: me.onNormalHeaderMove, + sortchange: me.onNormalHeaderSortChange, + scope: me + }); + + me.normalGrid.on({ + scrollershow: me.onScrollerShow, + scrollerhide: me.onScrollerHide, + scope: me + }); + + me.lockedGrid.on('afterlayout', me.onLockedGridAfterLayout, me, {single: true}); + + me.modifyHeaderCt(); + me.items = [me.lockedGrid, me.normalGrid]; + + me.layout = { + type: 'hbox', + align: 'stretch' + }; + }, + + processColumns: function(columns){ + + var i = 0, + len = columns.length, + lockedWidth = 0, + lockedHeaders = [], + normalHeaders = [], + column; - 'dblclick', + for (; i < len; ++i) { + column = columns[i]; - 'contextmenu', - 'beforechildrenrendered' - ); + column.processed = true; + if (column.locked) { + if (column.flex) { + Ext.Error.raise("Columns which are locked do NOT support a flex width. You must set a width on the " + columns[i].text + "column."); + } + lockedWidth += column.width; + lockedHeaders.push(column); + } else { + normalHeaders.push(column); + } + } + return { + lockedWidth: lockedWidth, + locked: lockedHeaders, + normal: normalHeaders + }; + }, - var uiClass = this.attributes.uiProvider || this.defaultUI || Ext.tree.TreeNodeUI; - - this.ui = new uiClass(this); + onLockedGridAfterLayout: function() { + var me = this, + lockedView = me.lockedGrid.getView(); + lockedView.on({ + refresh: me.createSpacer, + beforerefresh: me.destroySpacer, + scope: me + }); }, - preventHScroll : true, - isExpanded : function(){ - return this.expanded; + onLockedHeaderMove: function() { + if (this.syncRowHeight) { + this.onNormalGridAfterRefresh(); + } }, - - - getUI : function(){ - return this.ui; + + + onNormalHeaderMove: function() { + if (this.syncRowHeight) { + this.onLockedGridAfterRefresh(); + } }, + + + + createSpacer: function() { + var me = this, + + + w = Ext.getScrollBarWidth() + (Ext.isIE ? 2 : 0), + view = me.lockedGrid.getView(), + el = view.el; - getLoader : function(){ - var owner; - return this.loader || ((owner = this.getOwnerTree()) && owner.loader ? owner.loader : (this.loader = new Ext.tree.TreeLoader())); + me.spacerEl = Ext.core.DomHelper.append(el, { + cls: me.spacerHidden ? (Ext.baseCSSPrefix + 'hidden') : '', + style: 'height: ' + w + 'px;' + }, true); }, - - setFirstChild : function(node){ - var of = this.firstChild; - Ext.tree.TreeNode.superclass.setFirstChild.call(this, node); - if(this.childrenRendered && of && node != of){ - of.renderIndent(true, true); - } - if(this.rendered){ - this.renderIndent(true, true); + destroySpacer: function() { + var me = this; + if (me.spacerEl) { + me.spacerEl.destroy(); + delete me.spacerEl; } }, - - setLastChild : function(node){ - var ol = this.lastChild; - Ext.tree.TreeNode.superclass.setLastChild.call(this, node); - if(this.childrenRendered && ol && node != ol){ - ol.renderIndent(true, true); - } - if(this.rendered){ - this.renderIndent(true, true); + + onLockedGridAfterRefresh: function() { + var me = this, + view = me.lockedGrid.getView(), + el = view.el, + rowEls = el.query(view.getItemSelector()), + ln = rowEls.length, + i = 0; + + + me.lockedHeights = []; + + for (; i < ln; i++) { + me.lockedHeights[i] = rowEls[i].clientHeight; } + me.syncRowHeights(); }, - - appendChild : function(n){ - if(!n.render && !Ext.isArray(n)){ - n = this.getLoader().createNode(n); - } - var node = Ext.tree.TreeNode.superclass.appendChild.call(this, n); - if(node && this.childrenRendered){ - node.render(); + onNormalGridAfterRefresh: function() { + var me = this, + view = me.normalGrid.getView(), + el = view.el, + rowEls = el.query(view.getItemSelector()), + ln = rowEls.length, + i = 0; + + + me.normalHeights = []; + + for (; i < ln; i++) { + me.normalHeights[i] = rowEls[i].clientHeight; } - this.ui.updateExpandIcon(); - return node; + me.syncRowHeights(); + }, + + + onLockedGridAfterUpdate: function(record, index, node) { + this.lockedHeights[index] = node.clientHeight; + this.syncRowHeights(); + }, + + + onNormalGridAfterUpdate: function(record, index, node) { + this.normalHeights[index] = node.clientHeight; + this.syncRowHeights(); }, - - removeChild : function(node, destroy){ - this.ownerTree.getSelectionModel().unselect(node); - Ext.tree.TreeNode.superclass.removeChild.apply(this, arguments); + + + syncRowHeights: function() { + var me = this, + lockedHeights = me.lockedHeights, + normalHeights = me.normalHeights, + calcHeights = [], + ln = lockedHeights.length, + i = 0, + lockedView, normalView, + lockedRowEls, normalRowEls, + vertScroller = me.getVerticalScroller(), + scrollTop; + - if(!destroy){ - var rendered = node.ui.rendered; + + if (lockedHeights.length && normalHeights.length) { + lockedView = me.lockedGrid.getView(); + normalView = me.normalGrid.getView(); + lockedRowEls = lockedView.el.query(lockedView.getItemSelector()); + normalRowEls = normalView.el.query(normalView.getItemSelector()); + - if(rendered){ - node.ui.remove(); - } - if(rendered && this.childNodes.length < 1){ - this.collapse(false, false); - }else{ - this.ui.updateExpandIcon(); + for (; i < ln; i++) { + + if (!isNaN(lockedHeights[i]) && !isNaN(normalHeights[i])) { + if (lockedHeights[i] > normalHeights[i]) { + Ext.fly(normalRowEls[i]).setHeight(lockedHeights[i]); + } else if (lockedHeights[i] < normalHeights[i]) { + Ext.fly(lockedRowEls[i]).setHeight(normalHeights[i]); + } + } } - if(!this.firstChild && !this.isHiddenRoot()){ - this.childrenRendered = false; + + + me.normalGrid.invalidateScroller(); + + + + if (vertScroller && vertScroller.setViewScrollTop) { + vertScroller.setViewScrollTop(me.virtualScrollTop); + } else { + + + + scrollTop = normalView.el.dom.scrollTop; + normalView.el.dom.scrollTop = scrollTop; + lockedView.el.dom.scrollTop = scrollTop; } + + + me.lockedHeights = []; + me.normalHeights = []; } - return node; }, - - insertBefore : function(node, refNode){ - if(!node.render){ - node = this.getLoader().createNode(node); - } - var newNode = Ext.tree.TreeNode.superclass.insertBefore.call(this, node, refNode); - if(newNode && refNode && this.childrenRendered){ - node.render(); - } - this.ui.updateExpandIcon(); - return newNode; - }, - - setText : function(text){ - var oldText = this.text; - this.text = this.attributes.text = text; - if(this.rendered){ - this.ui.onTextChange(this, text, oldText); + onScrollerShow: function(scroller, direction) { + if (direction === 'horizontal') { + this.spacerHidden = false; + this.spacerEl.removeCls(Ext.baseCSSPrefix + 'hidden'); } - this.fireEvent('textchange', this, text, oldText); }, - setIconCls : function(cls){ - var old = this.attributes.iconCls; - this.attributes.iconCls = cls; - if(this.rendered){ - this.ui.onIconClsChange(this, cls, old); + onScrollerHide: function(scroller, direction) { + if (direction === 'horizontal') { + this.spacerHidden = true; + this.spacerEl.addCls(Ext.baseCSSPrefix + 'hidden'); } }, + - setTooltip : function(tip, title){ - this.attributes.qtip = tip; - this.attributes.qtipTitle = title; - if(this.rendered){ - this.ui.onTipChange(this, tip, title); - } + modifyHeaderCt: function() { + var me = this; + me.lockedGrid.headerCt.getMenuItems = me.getMenuItems(true); + me.normalGrid.headerCt.getMenuItems = me.getMenuItems(false); }, - - setIcon : function(icon){ - this.attributes.icon = icon; - if(this.rendered){ - this.ui.onIconChange(this, icon); - } + onUnlockMenuClick: function() { + this.unlock(); }, + onLockMenuClick: function() { + this.lock(); + }, - setHref : function(href, target){ - this.attributes.href = href; - this.attributes.hrefTarget = target; - if(this.rendered){ - this.ui.onHrefChange(this, href, target); - } + getMenuItems: function(locked) { + var me = this, + unlockText = me.unlockText, + lockText = me.lockText, + + unlockCls = 'xg-hmenu-unlock', + lockCls = 'xg-hmenu-lock', + unlockHandler = Ext.Function.bind(me.onUnlockMenuClick, me), + lockHandler = Ext.Function.bind(me.onLockMenuClick, me); + + + return function() { + var o = Ext.grid.header.Container.prototype.getMenuItems.call(this); + o.push('-',{ + cls: unlockCls, + text: unlockText, + handler: unlockHandler, + disabled: !locked + }); + o.push({ + cls: lockCls, + text: lockText, + handler: lockHandler, + disabled: locked + }); + return o; + }; }, - setCls : function(cls){ - var old = this.attributes.cls; - this.attributes.cls = cls; - if(this.rendered){ - this.ui.onClsChange(this, cls, old); - } - }, - - select : function(){ - var t = this.getOwnerTree(); - if(t){ - t.getSelectionModel().select(this); + lock: function(activeHd, toIdx) { + var me = this, + normalGrid = me.normalGrid, + lockedGrid = me.lockedGrid, + normalHCt = normalGrid.headerCt, + lockedHCt = lockedGrid.headerCt; + + activeHd = activeHd || normalHCt.getMenu().activeHeader; + + + + if (activeHd.flex) { + activeHd.width = activeHd.getWidth(); + delete activeHd.flex; + } + + normalHCt.remove(activeHd, false); + lockedHCt.suspendLayout = true; + if (Ext.isDefined(toIdx)) { + lockedHCt.insert(toIdx, activeHd); + } else { + lockedHCt.add(activeHd); } + lockedHCt.suspendLayout = false; + me.syncLockedSection(); }, - - unselect : function(silent){ - var t = this.getOwnerTree(); - if(t){ - t.getSelectionModel().unselect(this, silent); - } + syncLockedSection: function() { + var me = this; + me.syncLockedWidth(); + me.lockedGrid.getView().refresh(); + me.normalGrid.getView().refresh(); }, - - isSelected : function(){ - var t = this.getOwnerTree(); - return t ? t.getSelectionModel().isSelected(this) : false; + + + syncLockedWidth: function() { + var me = this, + width = me.lockedGrid.headerCt.getFullWidth(true); + me.lockedGrid.setWidth(width); }, - - expand : function(deep, anim, callback, scope){ - if(!this.expanded){ - if(this.fireEvent('beforeexpand', this, deep, anim) === false){ - return; - } - if(!this.childrenRendered){ - this.renderChildren(); - } - this.expanded = true; - if(!this.isHiddenRoot() && (this.getOwnerTree().animate && anim !== false) || anim){ - this.ui.animExpand(function(){ - this.fireEvent('expand', this); - this.runCallback(callback, scope || this, [this]); - if(deep === true){ - this.expandChildNodes(true, true); - } - }.createDelegate(this)); - return; - }else{ - this.ui.expand(); - this.fireEvent('expand', this); - this.runCallback(callback, scope || this, [this]); - } - }else{ - this.runCallback(callback, scope || this, [this]); - } - if(deep === true){ - this.expandChildNodes(true); - } + onLockedHeaderResize: function() { + this.syncLockedWidth(); }, - - runCallback : function(cb, scope, args){ - if(Ext.isFunction(cb)){ - cb.apply(scope, args); - } + + onLockedHeaderHide: function() { + this.syncLockedWidth(); }, - - isHiddenRoot : function(){ - return this.isRoot && !this.getOwnerTree().rootVisible; + + onLockedHeaderShow: function() { + this.syncLockedWidth(); }, - - collapse : function(deep, anim, callback, scope){ - if(this.expanded && !this.isHiddenRoot()){ - if(this.fireEvent('beforecollapse', this, deep, anim) === false){ - return; - } - this.expanded = false; - if((this.getOwnerTree().animate && anim !== false) || anim){ - this.ui.animCollapse(function(){ - this.fireEvent('collapse', this); - this.runCallback(callback, scope || this, [this]); - if(deep === true){ - this.collapseChildNodes(true); - } - }.createDelegate(this)); - return; - }else{ - this.ui.collapse(); - this.fireEvent('collapse', this); - this.runCallback(callback, scope || this, [this]); - } - }else if(!this.expanded){ - this.runCallback(callback, scope || this, [this]); - } - if(deep === true){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].collapse(true, false); - } + onLockedHeaderSortChange: function(headerCt, header, sortState) { + if (sortState) { + + + this.normalGrid.headerCt.clearOtherSortStates(null, true); } }, - - delayedExpand : function(delay){ - if(!this.expandProcId){ - this.expandProcId = this.expand.defer(delay, this); + onNormalHeaderSortChange: function(headerCt, header, sortState) { + if (sortState) { + + + this.lockedGrid.headerCt.clearOtherSortStates(null, true); } }, - - cancelExpand : function(){ - if(this.expandProcId){ - clearTimeout(this.expandProcId); + + + unlock: function(activeHd, toIdx) { + var me = this, + normalGrid = me.normalGrid, + lockedGrid = me.lockedGrid, + normalHCt = normalGrid.headerCt, + lockedHCt = lockedGrid.headerCt; + + if (!Ext.isDefined(toIdx)) { + toIdx = 0; } - this.expandProcId = false; + activeHd = activeHd || lockedHCt.getMenu().activeHeader; + + lockedHCt.remove(activeHd, false); + me.syncLockedWidth(); + me.lockedGrid.getView().refresh(); + normalHCt.insert(toIdx, activeHd); + me.normalGrid.getView().refresh(); }, - - toggle : function(){ - if(this.expanded){ - this.collapse(); - }else{ - this.expand(); + + reconfigureLockable: function(store, columns) { + var me = this, + lockedGrid = me.lockedGrid, + normalGrid = me.normalGrid; + + if (columns) { + lockedGrid.headerCt.removeAll(); + normalGrid.headerCt.removeAll(); + + columns = me.processColumns(columns); + lockedGrid.setWidth(columns.lockedWidth); + lockedGrid.headerCt.add(columns.locked); + normalGrid.headerCt.add(columns.normal); } - }, + + if (store) { + store = Ext.data.StoreManager.lookup(store); + me.store = store; + lockedGrid.bindStore(store); + normalGrid.bindStore(store); + } else { + lockedGrid.getView().refresh(); + normalGrid.getView().refresh(); + } + } +}); - - ensureVisible : function(callback, scope){ - var tree = this.getOwnerTree(); - tree.expandPath(this.parentNode ? this.parentNode.getPath() : this.getPath(), false, function(){ - var node = tree.getNodeById(this.id); - tree.getTreeEl().scrollChildIntoView(node.ui.anchor); - this.runCallback(callback, scope || this, [this]); - }.createDelegate(this)); - }, +Ext.define('Ext.grid.Scroller', { + extend: 'Ext.Component', + alias: 'widget.gridscroller', + weight: 110, + cls: Ext.baseCSSPrefix + 'scroller', + focusable: false, - expandChildNodes : function(deep, anim) { - var cs = this.childNodes, - i, - len = cs.length; - for (i = 0; i < len; i++) { - cs[i].expand(deep, anim); + renderTpl: [''], + + initComponent: function() { + var me = this, + dock = me.dock, + cls = Ext.baseCSSPrefix + 'scroller-vertical', + sizeProp = 'width', + + + + + + scrollbarWidth = Ext.getScrollBarWidth() + (Ext.isIE ? 1 : -1); + + me.offsets = {bottom: 0}; + + if (dock === 'top' || dock === 'bottom') { + cls = Ext.baseCSSPrefix + 'scroller-horizontal'; + sizeProp = 'height'; } + me[sizeProp] = scrollbarWidth; + + me.cls += (' ' + cls); + + Ext.applyIf(me.renderSelectors, { + stretchEl: '.' + Ext.baseCSSPrefix + 'stretcher' + }); + me.callParent(); }, - - collapseChildNodes : function(deep){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].collapse(deep); - } + + afterRender: function() { + var me = this; + me.callParent(); + me.ownerCt.on('afterlayout', me.onOwnerAfterLayout, me); + me.mon(me.el, 'scroll', me.onElScroll, me); + Ext.cache[me.el.id].skipGarbageCollection = true; }, - - disable : function(){ - this.disabled = true; - this.unselect(); - if(this.rendered && this.ui.onDisableChange){ - this.ui.onDisableChange(this, true); + getSizeCalculation: function() { + var owner = this.getPanel(), + dock = this.dock, + elDom = this.el.dom, + width = 1, + height = 1, + view, tbl; + + if (dock === 'top' || dock === 'bottom') { + + + var items = owner.query('tableview'), + center = items[1] || items[0]; + + if (!center) { + return false; + } + + + + width = center.headerCt.getFullWidth(); + + if (Ext.isIEQuirks) { + width--; + } + + width--; + } else { + view = owner.down('tableview:not([lockableInjected])'); + if (!view) { + return false; + } + tbl = view.el; + if (!tbl) { + return false; + } + + + + height = tbl.dom.scrollHeight; } - this.fireEvent('disabledchange', this, true); - }, - - - enable : function(){ - this.disabled = false; - if(this.rendered && this.ui.onDisableChange){ - this.ui.onDisableChange(this, false); + if (isNaN(width)) { + width = 1; } - this.fireEvent('disabledchange', this, false); + if (isNaN(height)) { + height = 1; + } + return { + width: width, + height: height + }; }, - - renderChildren : function(suppressEvent){ - if(suppressEvent !== false){ - this.fireEvent('beforechildrenrendered', this); + invalidate: function(firstPass) { + if (!this.stretchEl || !this.ownerCt) { + return; } - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].render(true); + var size = this.getSizeCalculation(), + elDom = this.el.dom; + if (size) { + this.stretchEl.setSize(size); + + + + elDom.scrollTop = elDom.scrollTop; } - this.childrenRendered = true; }, - - sort : function(fn, scope){ - Ext.tree.TreeNode.superclass.sort.apply(this, arguments); - if(this.childrenRendered){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].render(true); - } - } + onOwnerAfterLayout: function(owner, layout) { + this.invalidate(); }, - render : function(bulkRender){ - this.ui.render(bulkRender); - if(!this.rendered){ - - this.getOwnerTree().registerNode(this); - this.rendered = true; - if(this.expanded){ - this.expanded = false; - this.expand(false, false); - } + setScrollTop: function(scrollTop) { + if (this.el) { + var elDom = this.el.dom; + return elDom.scrollTop = Ext.Number.constrain(scrollTop, 0, elDom.scrollHeight - elDom.clientHeight); } }, - renderIndent : function(deep, refresh){ - if(refresh){ - this.ui.childIndent = null; - } - this.ui.renderIndent(); - if(deep === true && this.childrenRendered){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].renderIndent(true, refresh); - } - } - }, - - beginUpdate : function(){ - this.childrenRendered = false; - }, - - endUpdate : function(){ - if(this.expanded && this.rendered){ - this.renderChildren(); + setScrollLeft: function(scrollLeft) { + if (this.el) { + var elDom = this.el.dom; + return elDom.scrollLeft = Ext.Number.constrain(scrollLeft, 0, elDom.scrollWidth - elDom.clientWidth); } }, - destroy : function(silent){ - if(silent === true){ - this.unselect(true); + scrollByDeltaY: function(delta) { + if (this.el) { + var elDom = this.el.dom; + return this.setScrollTop(elDom.scrollTop + delta); } - Ext.tree.TreeNode.superclass.destroy.call(this, silent); - Ext.destroy(this.ui, this.loader); - this.ui = this.loader = null; }, - onIdChange : function(id){ - this.ui.onIdChange(id); - } -}); - -Ext.tree.TreePanel.nodeTypes.node = Ext.tree.TreeNode; - Ext.tree.AsyncTreeNode = function(config){ - this.loaded = config && config.loaded === true; - this.loading = false; - Ext.tree.AsyncTreeNode.superclass.constructor.apply(this, arguments); - - this.addEvents('beforeload', 'load'); - - -}; -Ext.extend(Ext.tree.AsyncTreeNode, Ext.tree.TreeNode, { - expand : function(deep, anim, callback, scope){ - if(this.loading){ - var timer; - var f = function(){ - if(!this.loading){ - clearInterval(timer); - this.expand(deep, anim, callback, scope); - } - }.createDelegate(this); - timer = setInterval(f, 200); - return; - } - if(!this.loaded){ - if(this.fireEvent("beforeload", this) === false){ - return; - } - this.loading = true; - this.ui.beforeLoad(this); - var loader = this.loader || this.attributes.loader || this.getOwnerTree().getLoader(); - if(loader){ - loader.load(this, this.loadComplete.createDelegate(this, [deep, anim, callback, scope]), this); - return; - } + scrollByDeltaX: function(delta) { + if (this.el) { + var elDom = this.el.dom; + return this.setScrollLeft(elDom.scrollLeft + delta); } - Ext.tree.AsyncTreeNode.superclass.expand.call(this, deep, anim, callback, scope); }, - isLoading : function(){ - return this.loading; - }, - loadComplete : function(deep, anim, callback, scope){ - this.loading = false; - this.loaded = true; - this.ui.afterLoad(this); - this.fireEvent("load", this); - this.expand(deep, anim, callback, scope); + scrollToTop : function(){ + this.setScrollTop(0); }, - isLoaded : function(){ - return this.loaded; - }, - - hasChildNodes : function(){ - if(!this.isLeaf() && !this.loaded){ - return true; - }else{ - return Ext.tree.AsyncTreeNode.superclass.hasChildNodes.call(this); - } + onElScroll: function(event, target) { + this.fireEvent('bodyscroll', event, target); }, - - reload : function(callback, scope){ - this.collapse(false, false); - while(this.firstChild){ - this.removeChild(this.firstChild).destroy(); - } - this.childrenRendered = false; - this.loaded = false; - if(this.isHiddenRoot()){ - this.expanded = false; + getPanel: function() { + var me = this; + if (!me.panel) { + me.panel = this.up('[scrollerOwner]'); } - this.expand(false, false, callback, scope); + return me.panel; } }); -Ext.tree.TreePanel.nodeTypes.async = Ext.tree.AsyncTreeNode; -Ext.tree.TreeNodeUI = Ext.extend(Object, { - - constructor : function(node){ - Ext.apply(this, { - node: node, - rendered: false, - animating: false, - wasLeaf: true, - ecc: 'x-tree-ec-icon x-tree-elbow', - emptyIcon: Ext.BLANK_IMAGE_URL - }); - }, - - - removeChild : function(node){ - if(this.rendered){ - this.ctNode.removeChild(node.ui.getEl()); - } - }, - - beforeLoad : function(){ - this.addClass("x-tree-node-loading"); - }, +Ext.define('Ext.grid.PagingScroller', { + extend: 'Ext.grid.Scroller', + alias: 'widget.paginggridscroller', - afterLoad : function(){ - this.removeClass("x-tree-node-loading"); - }, - - onTextChange : function(node, text, oldText){ - if(this.rendered){ - this.textNode.innerHTML = text; - } - }, - onIconClsChange : function(node, cls, oldCls){ - if(this.rendered){ - Ext.fly(this.iconNode).replaceClass(oldCls, cls); - } - }, - onIconChange : function(node, icon){ - if(this.rendered){ - - var empty = Ext.isEmpty(icon); - this.iconNode.src = empty ? this.emptyIcon : icon; - Ext.fly(this.iconNode)[empty ? 'removeClass' : 'addClass']('x-tree-node-inline-icon'); - } - }, + percentageFromEdge: 0.35, - onTipChange : function(node, tip, title){ - if(this.rendered){ - var hasTitle = Ext.isDefined(title); - if(this.textNode.setAttributeNS){ - this.textNode.setAttributeNS("ext", "qtip", tip); - if(hasTitle){ - this.textNode.setAttributeNS("ext", "qtitle", title); - } - }else{ - this.textNode.setAttribute("ext:qtip", tip); - if(hasTitle){ - this.textNode.setAttribute("ext:qtitle", title); - } - } - } - }, + scrollToLoadBuffer: 200, - onHrefChange : function(node, href, target){ - if(this.rendered){ - this.anchor.href = this.getHref(href); - if(Ext.isDefined(target)){ - this.anchor.target = target; - } - } - }, + activePrefetch: true, + chunkSize: 50, + snapIncrement: 25, - onClsChange : function(node, cls, oldCls){ - if(this.rendered){ - Ext.fly(this.elNode).replaceClass(oldCls, cls); - } - }, + syncScroll: true, + + initComponent: function() { + var me = this, + ds = me.store; + ds.on('guaranteedrange', this.onGuaranteedRange, this); + this.callParent(arguments); + }, + - onDisableChange : function(node, state){ - this.disabled = state; - if (this.checkbox) { - this.checkbox.disabled = state; + onGuaranteedRange: function(range, start, end) { + var me = this, + ds = me.store, + rs; + + if (range.length && me.visibleStart < range[0].index) { + return; } - this[state ? 'addClass' : 'removeClass']('x-tree-node-disabled'); - }, + + ds.loadRecords(range); - - onSelectedChange : function(state){ - if(state){ - this.focus(); - this.addClass("x-tree-selected"); - }else{ + if (!me.firstLoad) { + if (me.rendered) { + me.invalidate(); + } else { + me.on('afterrender', this.invalidate, this, {single: true}); + } + me.firstLoad = true; + } else { - this.removeClass("x-tree-selected"); + me.syncTo(); } }, - - onMove : function(tree, node, oldParent, newParent, index, refNode){ - this.childIndent = null; - if(this.rendered){ - var targetNode = newParent.ui.getContainer(); - if(!targetNode){ - this.holder = document.createElement("div"); - this.holder.appendChild(this.wrap); - return; - } - var insertBefore = refNode ? refNode.ui.getEl() : null; - if(insertBefore){ - targetNode.insertBefore(this.wrap, insertBefore); - }else{ - targetNode.appendChild(this.wrap); - } - this.node.renderIndent(true, oldParent != newParent); + syncTo: function() { + var me = this, + pnl = me.getPanel(), + store = pnl.store, + scrollerElDom = this.el.dom, + rowOffset = me.visibleStart - store.guaranteedStart, + scrollBy = rowOffset * me.rowHeight, + scrollHeight = scrollerElDom.scrollHeight, + clientHeight = scrollerElDom.clientHeight, + scrollTop = scrollerElDom.scrollTop, + useMaximum; + + + + if (Ext.isIE9 && Ext.isStrict) { + clientHeight = scrollerElDom.offsetHeight + 2; } - }, - - addClass : function(cls){ - if(this.elNode){ - Ext.fly(this.elNode).addClass(cls); - } + + + useMaximum = (scrollHeight - clientHeight - scrollTop <= 0); + this.setViewScrollTop(scrollBy, useMaximum); }, - - - removeClass : function(cls){ - if(this.elNode){ - Ext.fly(this.elNode).removeClass(cls); - } + + getPageData : function(){ + var panel = this.getPanel(), + store = panel.store, + totalCount = store.getTotalCount(); + + return { + total : totalCount, + currentPage : store.currentPage, + pageCount: Math.ceil(totalCount / store.pageSize), + fromRecord: ((store.currentPage - 1) * store.pageSize) + 1, + toRecord: Math.min(store.currentPage * store.pageSize, totalCount) + }; }, - - remove : function(){ - if(this.rendered){ - this.holder = document.createElement("div"); - this.holder.appendChild(this.wrap); + onElScroll: function(e, t) { + var me = this, + panel = me.getPanel(), + store = panel.store, + pageSize = store.pageSize, + guaranteedStart = store.guaranteedStart, + guaranteedEnd = store.guaranteedEnd, + totalCount = store.getTotalCount(), + numFromEdge = Math.ceil(me.percentageFromEdge * store.pageSize), + position = t.scrollTop, + visibleStart = Math.floor(position / me.rowHeight), + view = panel.down('tableview'), + viewEl = view.el, + visibleHeight = viewEl.getHeight(), + visibleAhead = Math.ceil(visibleHeight / me.rowHeight), + visibleEnd = visibleStart + visibleAhead, + prevPage = Math.floor(visibleStart / store.pageSize), + nextPage = Math.floor(visibleEnd / store.pageSize) + 2, + lastPage = Math.ceil(totalCount / store.pageSize), + + requestStart = Math.floor(visibleStart / me.snapIncrement) * me.snapIncrement, + requestEnd = requestStart + pageSize - 1, + activePrefetch = me.activePrefetch; + + me.visibleStart = visibleStart; + me.visibleEnd = visibleEnd; + + + me.syncScroll = true; + if (totalCount >= pageSize) { + + if (requestEnd > totalCount - 1) { + this.cancelLoad(); + if (store.rangeSatisfied(totalCount - pageSize, totalCount - 1)) { + me.syncScroll = true; + } + store.guaranteeRange(totalCount - pageSize, totalCount - 1); + + } else if (visibleStart < guaranteedStart || visibleEnd > guaranteedEnd) { + if (store.rangeSatisfied(requestStart, requestEnd)) { + this.cancelLoad(); + store.guaranteeRange(requestStart, requestEnd); + } else { + store.mask(); + me.attemptLoad(requestStart, requestEnd); + } + + me.syncScroll = false; + } else if (activePrefetch && visibleStart < (guaranteedStart + numFromEdge) && prevPage > 0) { + me.syncScroll = true; + store.prefetchPage(prevPage); + } else if (activePrefetch && visibleEnd > (guaranteedEnd - numFromEdge) && nextPage < lastPage) { + me.syncScroll = true; + store.prefetchPage(nextPage); + } } - }, - - 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 - }); + if (me.syncScroll) { + me.syncTo(); } }, - - getDDHandles : function(){ - return [this.iconNode, this.textNode, this.elNode]; - }, - - - hide : function(){ - this.node.hidden = true; - if(this.wrap){ - this.wrap.style.display = "none"; + getSizeCalculation: function() { + + + var owner = this.ownerCt, + view = owner.getView(), + store = this.store, + dock = this.dock, + elDom = this.el.dom, + width = 1, + height = 1; + + if (!this.rowHeight) { + this.rowHeight = view.el.down(view.getItemSelector()).getHeight(false, true); } - }, + height = store.getTotalCount() * this.rowHeight; - show : function(){ - this.node.hidden = false; - if(this.wrap){ - this.wrap.style.display = ""; + if (isNaN(width)) { + width = 1; } + if (isNaN(height)) { + height = 1; + } + return { + width: width, + height: height + }; }, - - onContextMenu : function(e){ - if (this.node.hasListener("contextmenu") || this.node.getOwnerTree().hasListener("contextmenu")) { - e.preventDefault(); - this.focus(); - this.fireEvent("contextmenu", this.node, e); + attemptLoad: function(start, end) { + var me = this; + if (!me.loadTask) { + me.loadTask = Ext.create('Ext.util.DelayedTask', me.doAttemptLoad, me, []); } + me.loadTask.delay(me.scrollToLoadBuffer, me.doAttemptLoad, me, [start, end]); }, - - 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(); + cancelLoad: function() { + if (this.loadTask) { + this.loadTask.cancel(); } }, - - onDblClick : function(e){ - e.preventDefault(); - if(this.disabled){ + doAttemptLoad: function(start, end) { + var store = this.getPanel().store; + store.guaranteeRange(start, end); + }, + + setViewScrollTop: function(scrollTop, useMax) { + var owner = this.getPanel(), + items = owner.query('tableview'), + i = 0, + len = items.length, + center, + centerEl, + calcScrollTop, + maxScrollTop, + scrollerElDom = this.el.dom; + + owner.virtualScrollTop = scrollTop; + + center = items[1] || items[0]; + centerEl = center.el.dom; + + maxScrollTop = ((owner.store.pageSize * this.rowHeight) - centerEl.clientHeight); + calcScrollTop = (scrollTop % ((owner.store.pageSize * this.rowHeight) + 1)); + if (useMax) { + calcScrollTop = maxScrollTop; + } + if (calcScrollTop > maxScrollTop) { + 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); + for (; i < len; i++) { + items[i].el.dom.scrollTop = calcScrollTop; } - }, + } +}); - onOver : function(e){ - this.addClass('x-tree-node-over'); - }, - onOut : function(e){ - this.removeClass('x-tree-node-over'); - }, - - onCheckChange : function(){ - var checked = this.checkbox.checked; - - this.checkbox.defaultChecked = checked; - this.node.attributes.checked = checked; - this.fireEvent('checkchange', this.node, checked); - }, +Ext.define('Ext.panel.Table', { + extend: 'Ext.panel.Panel', - - ecClick : function(e){ - if(!this.animating && this.node.isExpandable()){ - this.node.toggle(); - } - }, + alias: 'widget.tablepanel', - - startDrop : function(){ - this.dropping = true; - }, + uses: [ + 'Ext.selection.RowModel', + 'Ext.grid.Scroller', + 'Ext.grid.header.Container', + 'Ext.grid.Lockable' + ], - - endDrop : function(){ - setTimeout(function(){ - this.dropping = false; - }.createDelegate(this), 50); - }, + cls: Ext.baseCSSPrefix + 'grid', + extraBodyCls: Ext.baseCSSPrefix + 'grid-body', + layout: 'fit', - expand : function(){ - this.updateExpandIcon(); - this.ctNode.style.display = ""; - }, + hasView: false, - focus : function(){ - if(!this.node.preventHScroll){ - try{this.anchor.focus(); - }catch(e){} - }else{ - try{ - var noscroll = this.node.getOwnerTree().getTreeEl().dom; - var l = noscroll.scrollLeft; - this.anchor.focus(); - noscroll.scrollLeft = l; - }catch(e){} - } - }, - - - toggleCheck : function(value){ - var cb = this.checkbox; - if(cb){ - cb.checked = (value === undefined ? !cb.checked : value); - this.onCheckChange(); - } - }, + viewType: null, + selType: 'rowmodel', - blur : function(){ - try{ - this.anchor.blur(); - }catch(e){} - }, + scrollDelta: 40, - animExpand : function(callback){ - var ct = Ext.get(this.ctNode); - ct.stopFx(); - if(!this.node.isExpandable()){ - this.updateExpandIcon(); - this.ctNode.style.display = ""; - Ext.callback(callback); - return; - } - this.animating = true; - this.updateExpandIcon(); - - ct.slideIn('t', { - callback : function(){ - this.animating = false; - Ext.callback(callback); - }, - scope: this, - duration: this.node.ownerTree.duration || .25 - }); - }, + scroll: true, - highlight : function(){ - var tree = this.node.getOwnerTree(); - Ext.fly(this.wrap).highlight( - tree.hlColor || "C3DAF9", - {endColor: tree.hlBaseColor} - ); - }, - collapse : function(){ - this.updateExpandIcon(); - this.ctNode.style.display = "none"; - }, - animCollapse : function(callback){ - var ct = Ext.get(this.ctNode); - ct.enableDisplayMode('block'); - ct.stopFx(); - - this.animating = true; - this.updateExpandIcon(); - - ct.slideOut('t', { - callback : function(){ - this.animating = false; - Ext.callback(callback); - }, - scope: this, - duration: this.node.ownerTree.duration || .25 - }); - }, - getContainer : function(){ - return this.ctNode; - }, + sortableColumns: true, + verticalScrollDock: 'right', + verticalScrollerType: 'gridscroller', - getEl : function(){ - return this.wrap; - }, + horizontalScrollerPresentCls: Ext.baseCSSPrefix + 'horizontal-scroller-present', + verticalScrollerPresentCls: Ext.baseCSSPrefix + 'vertical-scroller-present', - appendDDGhost : function(ghostNode){ - ghostNode.appendChild(this.elNode.cloneNode(true)); - }, - - getDDRepairXY : function(){ - return Ext.lib.Dom.getXY(this.iconNode); - }, + scrollerOwner: true, + invalidateScrollerOnRefresh: true, - onRender : function(){ - this.render(); - }, + enableColumnMove: true, + enableColumnResize: true, - - render : function(bulkRender){ - var n = this.node, a = n.attributes; - var targetNode = n.parentNode ? - n.parentNode.ui.getContainer() : n.ownerTree.innerCt.dom; - if(!this.rendered){ - this.rendered = true; + initComponent: function() { + if (!this.viewType) { + Ext.Error.raise("You must specify a viewType config."); + } + if (!this.store) { + Ext.Error.raise("You must specify a store config"); + } + if (this.headers) { + Ext.Error.raise("The headers config is not supported. Please specify columns instead."); + } - this.renderElements(n, a, targetNode, bulkRender); + var me = this, + scroll = me.scroll, + vertical = false, + horizontal = false, + headerCtCfg = me.columns || me.colModel, + i = 0, + view, + border = me.border; - if(a.qtip){ - this.onTipChange(n, a.qtip, a.qtipTitle); - }else if(a.qtipCfg){ - a.qtipCfg.target = Ext.id(this.textNode); - Ext.QuickTips.register(a.qtipCfg); - } - this.initEvents(); - if(!this.node.expanded){ - this.updateExpandIcon(true); - } - }else{ - if(bulkRender === true) { - targetNode.appendChild(this.wrap); - } + + me.determineScrollbars = Ext.Function.createBuffered(me.determineScrollbars, 30); + me.injectView = Ext.Function.createBuffered(me.injectView, 30); + + if (me.hideHeaders) { + border = false; } - }, - - renderElements : function(n, a, targetNode, bulkRender){ - this.indentMarkup = n.parentNode ? n.parentNode.ui.getChildIndent() : ''; - - var cb = Ext.isBoolean(a.checked), - nel, - href = this.getHref(a.href), - buf = ['
' : '', + errors = []; - - snapToUnits: true, + Ext.Array.forEach(me.query('>[isFormField]'), function(field) { + errors = errors.concat( + Ext.Array.map(field.getErrors(), function(e) { + return '
- ' + errors.join('') + '
' +
+ '' +
+ '{text}' +
+ '' +
+ '
',
-
- 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');
- }
- },
+
+ dataIndex: null,
-
- unregister : function(menu){
- delete menus[menu.id];
- menu.un("beforehide", onBeforeHide);
- menu.un("hide", onHide);
- menu.un("beforeshow", onBeforeShow);
- menu.un("show", onShow);
- },
+
+ text: ' ',
-
- registerCheckable : function(menuItem){
- var g = menuItem.group;
- if(g){
- if(!groups[g]){
- groups[g] = [];
- }
- groups[g].push(menuItem);
- }
- },
+
+ sortable: true,
+
+
+
+
+ hideable: true,
-
- 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;
- }
- };
-}();
+
+ menuDisabled: false,
-Ext.menu.BaseItem = Ext.extend(Ext.Component, {
+ renderer: false,
+
+ align: 'left',
+
+ draggable: true,
+
- canActivate : false,
- activeClass : "x-menu-item-active",
+ initDraggable: Ext.emptyFn,
+
- hideOnClick : true,
+
- clickHideDelay : 1,
- ctype : "Ext.menu.BaseItem",
- actionMode : "container",
+ isHeader: true,
+
+ initComponent: function() {
+ var me = this,
+ i,
+ len;
+
+ if (Ext.isDefined(me.header)) {
+ me.text = me.header;
+ delete me.header;
+ }
+
+
+
+
+ if (me.flex) {
+ me.minWidth = me.minWidth || Ext.grid.plugin.HeaderResizer.prototype.minColWidth;
+ }
+
+
+ else {
+ me.minWidth = me.width;
+ }
+
+ if (!me.triStateSort) {
+ me.possibleSortStates.length = 2;
+ }
+
+
+ if (Ext.isDefined(me.columns)) {
+ me.isGroupHeader = true;
+
+ if (me.dataIndex) {
+ Ext.Error.raise('Ext.grid.column.Column: Group header may not accept a dataIndex');
+ }
+ if ((me.width && me.width !== Ext.grid.header.Container.prototype.defaultWidth) || me.flex) {
+ Ext.Error.raise('Ext.grid.column.Column: Group header does not support setting explicit widths or flexs. The group header width is calculated by the sum of its children.');
+ }
- initComponent : function(){
- Ext.menu.BaseItem.superclass.initComponent.call(this);
- this.addEvents(
-
- 'click',
- 'activate',
+ me.items = me.columns;
+ delete me.columns;
+ delete me.flex;
+ me.width = 0;
+
- 'deactivate'
- );
- if(this.handler){
- this.on("click", this.handler, this.scope);
- }
- },
+ for (i = 0, len = me.items.length; i < len; i++) {
+ me.width += me.items[i].width || Ext.grid.header.Container.prototype.defaultWidth;
+ if (me.items[i].flex) {
+ Ext.Error.raise('Ext.grid.column.Column: items of a grouped header do not support flexed values. Each item must explicitly define its width.');
+ }
+ }
+ me.minWidth = me.width;
-
- 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
- });
+ me.cls = (me.cls||'') + ' ' + Ext.baseCSSPrefix + 'group-header';
+ me.sortable = false;
+ me.fixed = true;
+ me.align = 'center';
}
+
+ Ext.applyIf(me.renderSelectors, {
+ titleContainer: '.' + Ext.baseCSSPrefix + 'column-header-inner',
+ triggerEl: '.' + Ext.baseCSSPrefix + 'column-header-trigger',
+ textEl: '.' + Ext.baseCSSPrefix + 'column-header-text'
+ });
+
+
+ me.callParent(arguments);
},
-
- setHandler : function(handler, scope){
- if(this.handler){
- this.un("click", this.handler, this.scope);
- }
- this.on("click", this.handler = handler, this.scope = scope);
+ onAdd: function(childHeader) {
+ childHeader.isSubHeader = true;
+ childHeader.addCls(Ext.baseCSSPrefix + 'group-sub-header');
},
-
- 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();
- }
+ onRemove: function(childHeader) {
+ childHeader.isSubHeader = false;
+ childHeader.removeCls(Ext.baseCSSPrefix + 'group-sub-header');
},
-
- 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;
+ initRenderData: function() {
+ var me = this;
+
+ Ext.applyIf(me.renderData, {
+ text: me.text,
+ menuDisabled: me.menuDisabled
+ });
+ return me.callParent(arguments);
},
- deactivate : function(){
- this.container.removeClass(this.activeClass);
- this.fireEvent("deactivate", this);
+ setText: function(text) {
+ this.text = text;
+ if (this.rendered) {
+ this.textEl.update(text);
+ }
},
- shouldDeactivate : function(e){
- return !this.region || !this.region.contains(e.getPoint());
+
+ getOwnerHeaderCt: function() {
+ return this.up(':not([isHeader])');
},
- handleClick : function(e){
- var pm = this.parentMenu;
- if(this.hideOnClick){
- if(pm.floating){
- pm.hide.defer(this.clickHideDelay, pm, [true]);
- }else{
- pm.deactivateActive();
- }
- }
+ getIndex: function() {
+ return this.isGroupColumn ? false : this.getOwnerHeaderCt().getHeaderIndex(this);
},
-
- expandMenu : Ext.emptyFn,
+ afterRender: function() {
+ var me = this,
+ el = me.el;
-
- 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
- };
+ me.callParent(arguments);
+
+ el.addCls(Ext.baseCSSPrefix + 'column-header-align-' + me.align).addClsOnOver(me.overCls);
+
+ me.mon(el, {
+ click: me.onElClick,
+ dblclick: me.onElDblClick,
+ scope: me
+ });
+
+
+
+ if (!Ext.isIE8 || !Ext.isStrict) {
+ me.mon(me.getFocusEl(), {
+ focus: me.onTitleMouseOver,
+ blur: me.onTitleMouseOut,
+ scope: me
+ });
}
- Ext.menu.TextItem.superclass.constructor.call(this, config);
+
+ me.mon(me.titleContainer, {
+ mouseenter: me.onTitleMouseOver,
+ mouseleave: me.onTitleMouseOut,
+ scope: me
+ });
+
+ me.keyNav = Ext.create('Ext.util.KeyNav', el, {
+ enter: me.onEnterKey,
+ down: me.onDownKey,
+ scope: me
+ });
},
-
- 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: '',
+ setSize: function(width, height) {
+ var me = this,
+ headerCt = me.ownerCt,
+ ownerHeaderCt = me.getOwnerHeaderCt(),
+ siblings,
+ len, i,
+ oldWidth = me.getWidth(),
+ newWidth = 0;
-
- 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,
+ if (width !== oldWidth) {
+
+
+ if (headerCt.isGroupHeader) {
+
+ siblings = headerCt.items.items;
+ len = siblings.length;
+
+
+ if (siblings[len - 1].rendered) {
+
+ for (i = 0; i < len; i++) {
+ newWidth += (siblings[i] === me) ? width : siblings[i].getWidth();
+ }
+ headerCt.minWidth = newWidth;
+ headerCt.setWidth(newWidth);
+ }
+ }
+ me.callParent(arguments);
+ }
+ },
-
- ctype: 'Ext.menu.Item',
+ afterComponentLayout: function(width, height) {
+ var me = this,
+ ownerHeaderCt = this.getOwnerHeaderCt();
- initComponent : function(){
- Ext.menu.Item.superclass.initComponent.call(this);
- if(this.menu){
- this.menu = Ext.menu.MenuMgr.get(this.menu);
- this.menu.ownerCt = this;
+ me.callParent(arguments);
+
+
+
+
+ if (width && !me.isGroupHeader && ownerHeaderCt) {
+ ownerHeaderCt.onHeaderResize(me, width, true);
}
},
- onRender : function(container, position){
- if (!this.itemTpl) {
- this.itemTpl = Ext.menu.Item.prototype.itemTpl = new Ext.XTemplate(
- '',
- ' target="{hrefTarget}"',
- '',
- '>',
- '';
+ },
+ closeTableWrap: function() {
+ return '
{collapsed}' + me.groupHeaderTpl + '
'); - } - } - ts.innerHTML = v; - h = Math.min(this.growMax, Math.max(ts.offsetHeight, this.growMin)); - if(h != this.lastHeight){ - this.lastHeight = h; - this.el.setHeight(h); - this.fireEvent("autosize", this, h); - } + getFireEventArgs: function(type, view, featureTarget) { + var returnArray = [type, view, featureTarget], + groupBd = Ext.fly(featureTarget.nextSibling, '_grouping'), + groupBdId = Ext.getDom(groupBd).id, + prefix = view.id + '-gp-', + groupName = groupBdId.substr(prefix.length); + + returnArray.push(groupName); + + return returnArray; } }); -Ext.reg('textarea', Ext.form.TextArea); -Ext.form.NumberField = Ext.extend(Ext.form.TextField, { - - - - fieldClass: "x-form-field x-form-num-field", - - - allowDecimals : true, - - - decimalSeparator : ".", - + + +Ext.define('Ext.grid.feature.GroupingSummary', { - decimalPrecision : 2, - allowNegative : true, + extend: 'Ext.grid.feature.Grouping', + alias: 'feature.groupingsummary', - minValue : Number.NEGATIVE_INFINITY, + mixins: { + summary: 'Ext.grid.feature.AbstractSummary' + }, - maxValue : Number.MAX_VALUE, + + + + getFeatureTpl: function() { + var tpl = this.callParent(arguments); + + if (this.showSummaryRow) { + + tpl = tpl.replace('', ''); + tpl += '{[this.printSummaryRow(xindex)]}'; + } + return tpl; + }, - minText : "The minimum value for this field is {0}", + getFragmentTpl: function() { + var me = this, + fragments = me.callParent(); + + Ext.apply(fragments, me.getSummaryFragments()); + if (me.showSummaryRow) { + + me.summaryGroups = me.view.store.getGroups(); + me.summaryData = me.generateSummaryData(); + } + return fragments; + }, - maxText : "The maximum value for this field is {0}", + getPrintData: function(index){ + var me = this, + columns = me.view.headerCt.getColumnsForTpl(), + i = 0, + length = columns.length, + data = [], + name = me.summaryGroups[index - 1].name, + active = me.summaryData[name], + column; + + for (; i < length; ++i) { + column = columns[i]; + column.gridSummaryValue = this.getColumnValue(column, active); + data.push(column); + } + return data; + }, - nanText : "{0} is not a valid number", + generateSummaryData: function(){ + var me = this, + data = {}, + remoteData = {}, + store = me.view.store, + groupField = this.getGroupField(), + reader = store.proxy.reader, + groups = me.summaryGroups, + columns = me.view.headerCt.getColumnsForTpl(), + i, + length, + fieldData, + root, + key, + comp; + + for (i = 0, length = groups.length; i < length; ++i) { + data[groups[i].name] = {}; + } + + if (me.remoteRoot && reader.rawData) { + + root = reader.root; + reader.root = me.remoteRoot; + reader.buildExtractors(true); + Ext.Array.each(reader.getRoot(reader.rawData), function(value) { + data[value[groupField]] = value; + data[value[groupField]]._remote = true; + }); + + reader.root = root; + reader.buildExtractors(true); + } + + for (i = 0, length = columns.length; i < length; ++i) { + comp = Ext.getCmp(columns[i].id); + fieldData = me.getSummary(store, comp.summaryType, comp.dataIndex, true); + + for (key in fieldData) { + if (fieldData.hasOwnProperty(key)) { + if (!data[key]._remote) { + data[key][comp.dataIndex] = fieldData[key]; + } + } + } + } + return data; + } +}); + + +Ext.define('Ext.grid.feature.RowBody', { + extend: 'Ext.grid.feature.Feature', + alias: 'feature.rowbody', + rowBodyHiddenCls: Ext.baseCSSPrefix + 'grid-row-body-hidden', + rowBodyTrCls: Ext.baseCSSPrefix + 'grid-rowbody-tr', + rowBodyTdCls: Ext.baseCSSPrefix + 'grid-cell-rowbody', + rowBodyDivCls: Ext.baseCSSPrefix + 'grid-rowbody', + + eventPrefix: 'rowbody', + eventSelector: '.' + Ext.baseCSSPrefix + 'grid-rowbody-tr', - baseChars : "0123456789", + getRowBody: function(values) { + return [ + '
{rowBody}
',
+ '');
- if (num < this.minValue) {
- errors.push(String.format(this.minText, this.minValue));
- }
- if (num > this.maxValue) {
- errors.push(String.format(this.maxText, this.maxValue));
- }
+ metaRowTpl.push(' |
{' + this.displayField + '}
'+this.loadingText+'
' : '');
- this.restrictHeight();
- this.selectedIndex = -1;
},
-
- onLoad : function(){
- if(!this.hasFocus){
- return;
- }
- if(this.store.getCount() > 0 || this.listEmptyText){
- this.expand();
- this.restrictHeight();
- if(this.lastQuery == this.allQuery){
- if(this.editable){
- this.el.dom.select();
- }
+ afterHeaderRender: function() {
+ var headerCt = this.headerCt,
+ el = headerCt.el;
- if(this.autoSelect !== false && !this.selectByValue(this.value, true)){
- this.select(0, true);
- }
- }else{
- if(this.autoSelect !== false){
- this.selectNext();
- }
- if(this.typeAhead && this.lastKey != Ext.EventObject.BACKSPACE && this.lastKey != Ext.EventObject.DELETE){
- this.taTask.delay(this.typeAheadDelay);
- }
- }
- }else{
- this.collapse();
- }
+ headerCt.mon(el, 'mousemove', this.onHeaderCtMouseMove, this);
+ this.tracker = Ext.create('Ext.dd.DragTracker', {
+ disabled: this.disabled,
+ onBeforeStart: Ext.Function.bind(this.onBeforeStart, this),
+ onStart: Ext.Function.bind(this.onStart, this),
+ onDrag: Ext.Function.bind(this.onDrag, this),
+ onEnd: Ext.Function.bind(this.onEnd, this),
+ tolerance: 3,
+ autoStart: 300,
+ el: el
+ });
},
- onTypeAhead : function(){
- if(this.store.getCount() > 0){
- var r = this.store.getAt(0);
- var newValue = r.data[this.displayField];
- var len = newValue.length;
- var selStart = this.getRawValue().length;
- if(selStart != len){
- this.setRawValue(newValue);
- this.selectText(selStart, newValue.length);
+
+
+ onHeaderCtMouseMove: function(e, t) {
+ if (this.headerCt.dragging) {
+ if (this.activeHd) {
+ this.activeHd.el.dom.style.cursor = '';
+ delete this.activeHd;
}
- }
- },
+ } else {
+ var headerEl = e.getTarget('.' + this.colHeaderCls, 3, true),
+ overHeader, resizeHeader;
-
- assertValue : function(){
- var val = this.getRawValue(),
- rec;
+ if (headerEl){
+ overHeader = Ext.getCmp(headerEl.id);
- if(this.valueField && Ext.isDefined(this.value)){
- rec = this.findRecord(this.valueField, this.value);
- }
- if(!rec || rec.get(this.displayField) != val){
- rec = this.findRecord(this.displayField, val);
- }
- if(!rec && this.forceSelection){
- if(val.length > 0 && val != this.emptyText){
- this.el.dom.value = Ext.value(this.lastSelectionText, '');
- this.applyEmptyText();
- }else{
- this.clearValue();
- }
- }else{
- if(rec && this.valueField){
+ if (overHeader.isOnLeftEdge(e)) {
+ resizeHeader = overHeader.previousNode('gridcolumn:not([hidden]):not([isGroupHeader])');
+ }
+ else if (overHeader.isOnRightEdge(e)) {
+ resizeHeader = overHeader;
+ }
- if (this.value == val){
- return;
+ else {
+ resizeHeader = null;
+ }
+
+
+ if (resizeHeader) {
+
+
+
+ if (resizeHeader.isGroupHeader) {
+ resizeHeader = resizeHeader.getVisibleGridColumns();
+ resizeHeader = resizeHeader[resizeHeader.length - 1];
+ }
+
+ if (resizeHeader && !resizeHeader.fixed) {
+ this.activeHd = resizeHeader;
+ overHeader.el.dom.style.cursor = this.eResizeCursor;
+ }
+
+ } else {
+ overHeader.el.dom.style.cursor = '';
+ delete this.activeHd;
}
- val = rec.get(this.valueField || this.displayField);
}
- this.setValue(val);
}
},
- onSelect : function(record, index){
- if(this.fireEvent('beforeselect', this, record, index) !== false){
- this.setValue(record.data[this.valueField || this.displayField]);
- this.collapse();
- this.fireEvent('select', this, record, index);
+ onBeforeStart : function(e){
+ var t = e.getTarget();
+
+ this.dragHd = this.activeHd;
+
+ if (!!this.dragHd && !Ext.fly(t).hasCls('x-column-header-trigger') && !this.headerCt.dragging) {
+
+ this.tracker.constrainTo = this.getConstrainRegion();
+ return true;
+ } else {
+ this.headerCt.dragging = false;
+ return false;
}
},
- getName: function(){
- var hf = this.hiddenField;
- return hf && hf.name ? hf.name : this.hiddenName || Ext.form.ComboBox.superclass.getName.call(this);
- },
+ getConstrainRegion: function() {
+ var dragHdEl = this.dragHd.el,
+ region = Ext.util.Region.getRegion(dragHdEl);
-
- getValue : function(){
- if(this.valueField){
- return Ext.isDefined(this.value) ? this.value : '';
- }else{
- return Ext.form.ComboBox.superclass.getValue.call(this);
- }
+ return region.adjust(
+ 0,
+ this.maxColWidth - dragHdEl.getWidth(),
+ 0,
+ this.minColWidth
+ );
},
- clearValue : function(){
- if(this.hiddenField){
- this.hiddenField.value = '';
- }
- this.setRawValue('');
- this.lastSelectionText = '';
- this.applyEmptyText();
- this.value = '';
- },
-
- setValue : function(v){
- var text = v;
- if(this.valueField){
- var r = this.findRecord(this.valueField, v);
- if(r){
- text = r.data[this.displayField];
- }else if(Ext.isDefined(this.valueNotFoundText)){
- text = this.valueNotFoundText;
- }
- }
- this.lastSelectionText = text;
- if(this.hiddenField){
- this.hiddenField.value = Ext.value(v, '');
- }
- Ext.form.ComboBox.superclass.setValue.call(this, text);
- this.value = v;
- return this;
- },
+ onStart: function(e){
+ var me = this,
+ dragHd = me.dragHd,
+ dragHdEl = dragHd.el,
+ width = dragHdEl.getWidth(),
+ headerCt = me.headerCt,
+ t = e.getTarget();
-
- findRecord : function(prop, value){
- var record;
- if(this.store.getCount() > 0){
- this.store.each(function(r){
- if(r.data[prop] == value){
- record = r;
- return false;
- }
- });
+ if (me.dragHd && !Ext.fly(t).hasCls('x-column-header-trigger')) {
+ headerCt.dragging = true;
}
- return record;
- },
-
- onViewMove : function(e, t){
- this.inKeyMode = false;
- },
+ me.origWidth = width;
-
- onViewOver : function(e, t){
- if(this.inKeyMode){
- return;
- }
- var item = this.view.findItemFromChild(t);
- if(item){
- var index = this.view.indexOf(item);
- this.select(index, false);
- }
- },
+
+ if (!me.dynamic) {
+ var xy = dragHdEl.getXY(),
+ gridSection = headerCt.up('[scrollerOwner]'),
+ dragHct = me.dragHd.up(':not([isGroupHeader])'),
+ firstSection = dragHct.up(),
+ lhsMarker = gridSection.getLhsMarker(),
+ rhsMarker = gridSection.getRhsMarker(),
+ el = rhsMarker.parent(),
+ offsetLeft = el.getLeft(true),
+ offsetTop = el.getTop(true),
+ topLeft = el.translatePoints(xy),
+ markerHeight = firstSection.body.getHeight() + headerCt.getHeight(),
+ top = topLeft.top - offsetTop;
-
- onViewClick : function(doFocus){
- var index = this.view.getSelectedIndexes()[0],
- s = this.store,
- r = s.getAt(index);
- if(r){
- this.onSelect(r, index);
- }else {
- this.collapse();
- }
- if(doFocus !== false){
- this.el.focus();
+ lhsMarker.setTop(top);
+ rhsMarker.setTop(top);
+ lhsMarker.setHeight(markerHeight);
+ rhsMarker.setHeight(markerHeight);
+ lhsMarker.setLeft(topLeft.left - offsetLeft);
+ rhsMarker.setLeft(topLeft.left + width - offsetLeft);
}
},
-
- restrictHeight : function(){
- this.innerList.dom.style.height = '';
- var inner = this.innerList.dom,
- pad = this.list.getFrameWidth('tb') + (this.resizable ? this.handleHeight : 0) + this.assetHeight,
- h = Math.max(inner.clientHeight, inner.offsetHeight, inner.scrollHeight),
- ha = this.getPosition()[1]-Ext.getBody().getScroll().top,
- hb = Ext.lib.Dom.getViewHeight()-ha-this.getSize().height,
- space = Math.max(ha, hb, this.minHeight || 0)-this.list.shadowOffset-pad-5;
-
- h = Math.min(h, space, this.maxHeight);
+ onDrag: function(e){
+ if (!this.dynamic) {
+ var xy = this.tracker.getXY('point'),
+ gridSection = this.headerCt.up('[scrollerOwner]'),
+ rhsMarker = gridSection.getRhsMarker(),
+ el = rhsMarker.parent(),
+ topLeft = el.translatePoints(xy),
+ offsetLeft = el.getLeft(true);
- this.innerList.setHeight(h);
- this.list.beginUpdate();
- this.list.setHeight(h+pad);
- this.list.alignTo.apply(this.list, [this.el].concat(this.listAlign));
- this.list.endUpdate();
+ rhsMarker.setLeft(topLeft.left - offsetLeft);
+
+ } else {
+ this.doResize();
+ }
},
-
- isExpanded : function(){
- return this.list && this.list.isVisible();
- },
+ onEnd: function(e){
+ this.headerCt.dragging = false;
+ if (this.dragHd) {
+ if (!this.dynamic) {
+ var dragHd = this.dragHd,
+ gridSection = this.headerCt.up('[scrollerOwner]'),
+ lhsMarker = gridSection.getLhsMarker(),
+ rhsMarker = gridSection.getRhsMarker(),
+ currWidth = dragHd.getWidth(),
+ offset = this.tracker.getOffset('point'),
+ offscreen = -9999;
-
- selectByValue : function(v, scrollIntoView){
- if(!Ext.isEmpty(v, true)){
- var r = this.findRecord(this.valueField || this.displayField, v);
- if(r){
- this.select(this.store.indexOf(r), scrollIntoView);
- return true;
+
+ lhsMarker.setLeft(offscreen);
+ rhsMarker.setLeft(offscreen);
}
+ this.doResize();
}
- return false;
},
-
- select : function(index, scrollIntoView){
- this.selectedIndex = index;
- this.view.select(index);
- if(scrollIntoView !== false){
- var el = this.view.getNode(index);
- if(el){
- this.innerList.scrollChildIntoView(el, false);
+ doResize: function() {
+ if (this.dragHd) {
+ var dragHd = this.dragHd,
+ nextHd,
+ offset = this.tracker.getOffset('point');
+
+
+ if (dragHd.flex) {
+ delete dragHd.flex;
}
- }
- },
+
+
+ if (this.headerCt.forceFit) {
+ nextHd = dragHd.nextNode('gridcolumn:not([hidden]):not([isGroupHeader])');
+ if (nextHd) {
+ this.headerCt.componentLayout.layoutBusy = true;
+ }
+ }
-
- selectNext : function(){
- var ct = this.store.getCount();
- if(ct > 0){
- if(this.selectedIndex == -1){
- this.select(0);
- }else if(this.selectedIndex < ct-1){
- this.select(this.selectedIndex+1);
+
+
+ dragHd.minWidth = this.origWidth + offset[0];
+ dragHd.setWidth(dragHd.minWidth);
+
+
+
+ if (nextHd) {
+ delete nextHd.flex;
+ nextHd.setWidth(nextHd.getWidth() - offset[0]);
+ this.headerCt.componentLayout.layoutBusy = false;
+ this.headerCt.doComponentLayout();
}
}
},
-
- selectPrev : function(){
- var ct = this.store.getCount();
- if(ct > 0){
- if(this.selectedIndex == -1){
- this.select(0);
- }else if(this.selectedIndex !== 0){
- this.select(this.selectedIndex-1);
- }
+ disable: function() {
+ this.disabled = true;
+ if (this.tracker) {
+ this.tracker.disable();
}
},
-
- onKeyUp : function(e){
- var k = e.getKey();
- if(this.editable !== false && this.readOnly !== true && (k == e.BACKSPACE || !e.isSpecialKey())){
-
- this.lastKey = k;
- this.dqTask.delay(this.queryDelay);
+ enable: function() {
+ this.disabled = false;
+ if (this.tracker) {
+ this.tracker.enable();
}
- Ext.form.ComboBox.superclass.onKeyUp.call(this, e);
- },
+ }
+});
+
+Ext.define('Ext.grid.plugin.RowEditing', {
+ extend: 'Ext.grid.plugin.Editing',
+ alias: 'plugin.rowediting',
+
+ requires: [
+ 'Ext.grid.RowEditor'
+ ],
+
+ editStyle: 'row',
- validateBlur : function(){
- return !this.list || !this.list.isVisible();
- },
+ autoCancel: true,
- initQuery : function(){
- this.doQuery(this.getRawValue());
- },
- beforeBlur : function(){
- this.assertValue();
+ errorSummary: true,
+
+
+
+
+
+ constructor: function() {
+ var me = this;
+ me.callParent(arguments);
+
+ if (!me.clicksToMoveEditor) {
+ me.clicksToMoveEditor = me.clicksToEdit;
+ }
+
+ me.autoCancel = !!me.autoCancel;
},
- postBlur : function(){
- Ext.form.ComboBox.superclass.postBlur.call(this);
- this.collapse();
- this.inKeyMode = false;
+ destroy: function() {
+ var me = this;
+ Ext.destroy(me.editor);
+ me.callParent(arguments);
},
- doQuery : function(q, forceAll){
- q = Ext.isEmpty(q) ? '' : q;
- var qe = {
- query: q,
- forceAll: forceAll,
- combo: this,
- cancel:false
- };
- if(this.fireEvent('beforequery', qe)===false || qe.cancel){
+ startEdit: function(record, columnHeader) {
+ var me = this,
+ editor = me.getEditor();
+
+ if (me.callParent(arguments) === false) {
return false;
}
- q = qe.query;
- forceAll = qe.forceAll;
- if(forceAll === true || (q.length >= this.minChars)){
- if(this.lastQuery !== q){
- this.lastQuery = q;
- if(this.mode == 'local'){
- this.selectedIndex = -1;
- if(forceAll){
- this.store.clearFilter();
- }else{
- this.store.filter(this.displayField, q);
- }
- this.onLoad();
- }else{
- this.store.baseParams[this.queryParam] = q;
- this.store.load({
- params: this.getParams(q)
- });
- this.expand();
- }
- }else{
- this.selectedIndex = -1;
- this.onLoad();
- }
+
+
+ if (editor.beforeEdit() !== false) {
+ editor.startEdit(me.context.record, me.context.column);
}
},
- getParams : function(q){
- var params = {},
- paramNames = this.store.paramNames;
- if(this.pageSize){
- params[paramNames.start] = 0;
- params[paramNames.limit] = this.pageSize;
+ cancelEdit: function() {
+ var me = this;
+
+ if (me.editing) {
+ me.getEditor().cancelEdit();
+ me.callParent(arguments);
}
- return params;
},
- collapse : function(){
- if(!this.isExpanded()){
- return;
+ completeEdit: function() {
+ var me = this;
+
+ if (me.editing && me.validateEdit()) {
+ me.editing = false;
+ me.fireEvent('edit', me.context);
}
- this.list.hide();
- Ext.getDoc().un('mousewheel', this.collapseIf, this);
- Ext.getDoc().un('mousedown', this.collapseIf, this);
- this.fireEvent('collapse', this);
},
- collapseIf : function(e){
- if(!this.isDestroyed && !e.within(this.wrap) && !e.within(this.list)){
- this.collapse();
- }
+ validateEdit: function() {
+ var me = this;
+ return me.callParent(arguments) && me.getEditor().completeEdit();
},
- expand : function(){
- if(this.isExpanded() || !this.hasFocus){
- return;
- }
-
- if(this.title || this.pageSize){
- this.assetHeight = 0;
- if(this.title){
- this.assetHeight += this.header.getHeight();
- }
- if(this.pageSize){
- this.assetHeight += this.footer.getHeight();
- }
- }
-
- if(this.bufferSize){
- this.doResize(this.bufferSize);
- delete this.bufferSize;
- }
- this.list.alignTo.apply(this.list, [this.el].concat(this.listAlign));
+ getEditor: function() {
+ var me = this;
-
- this.list.setZIndex(this.getZIndex());
- this.list.show();
- if(Ext.isGecko2){
- this.innerList.setOverflow('auto');
+ if (!me.editor) {
+ me.editor = me.initEditor();
}
- this.mon(Ext.getDoc(), {
- scope: this,
- mousewheel: this.collapseIf,
- mousedown: this.collapseIf
- });
- this.fireEvent('expand', this);
+ return me.editor;
},
-
-
- onTriggerClick : function(){
- if(this.readOnly || this.disabled){
- return;
- }
- if(this.isExpanded()){
- this.collapse();
- this.el.focus();
- }else {
- this.onFocus({});
- if(this.triggerAction == 'all') {
- this.doQuery(this.allQuery, true);
- } else {
- this.doQuery(this.getRawValue());
- }
- this.el.focus();
- }
- }
+ initEditor: function() {
+ var me = this,
+ grid = me.grid,
+ view = me.view,
+ headerCt = grid.headerCt;
-
-
-
-
+ return Ext.create('Ext.grid.RowEditor', {
+ autoCancel: me.autoCancel,
+ errorSummary: me.errorSummary,
+ fields: headerCt.getGridColumns(),
+ hidden: true,
-});
-Ext.reg('combo', Ext.form.ComboBox);
+
+ editingPlugin: me,
+ renderTo: view.el
+ });
+ },
-Ext.form.Checkbox = Ext.extend(Ext.form.Field, {
-
- focusClass : undefined,
-
- fieldClass : 'x-form-field',
-
- checked : false,
-
- boxLabel: ' ',
-
- defaultAutoCreate : { tag: 'input', type: 'checkbox', autocomplete: 'off'},
-
-
+ initEditTriggers: function() {
+ var me = this,
+ grid = me.grid,
+ view = me.view,
+ headerCt = grid.headerCt,
+ moveEditorEvent = me.clicksToMoveEditor === 1 ? 'click' : 'dblclick';
-
- actionMode : 'wrap',
+ me.callParent(arguments);
-
- initComponent : function(){
- Ext.form.Checkbox.superclass.initComponent.call(this);
- this.addEvents(
+ if (me.clicksToMoveEditor !== me.clicksToEdit) {
+ me.mon(view, 'cell' + moveEditorEvent, me.moveEditorByClick, me);
+ }
+
+ view.on('render', function() {
- 'check'
- );
+ me.mon(headerCt, {
+ add: me.onColumnAdd,
+ remove: me.onColumnRemove,
+ columnresize: me.onColumnResize,
+ columnhide: me.onColumnHide,
+ columnshow: me.onColumnShow,
+ columnmove: me.onColumnMove,
+ scope: me
+ });
+ }, me, { single: true });
},
-
- onResize : function(){
- Ext.form.Checkbox.superclass.onResize.apply(this, arguments);
- if(!this.boxLabel && !this.fieldLabel){
- this.el.alignTo(this.wrap, 'c-c');
+ startEditByClick: function() {
+ var me = this;
+ if (!me.editing || me.clicksToMoveEditor === me.clicksToEdit) {
+ me.callParent(arguments);
}
},
-
- initEvents : function(){
- Ext.form.Checkbox.superclass.initEvents.call(this);
- this.mon(this.el, {
- scope: this,
- click: this.onClick,
- change: this.onClick
- });
+ moveEditorByClick: function() {
+ var me = this;
+ if (me.editing) {
+ me.superclass.startEditByClick.apply(me, arguments);
+ }
},
- markInvalid : Ext.emptyFn,
-
- clearInvalid : Ext.emptyFn,
+ onColumnAdd: function(ct, column) {
+ var me = this,
+ editor = me.getEditor();
-
- onRender : function(ct, position){
- Ext.form.Checkbox.superclass.onRender.call(this, ct, position);
- if(this.inputValue !== undefined){
- this.el.dom.value = this.inputValue;
+ me.initFieldAccessors(column);
+ if (editor && editor.onColumnAdd) {
+ editor.onColumnAdd(column);
}
- this.wrap = this.el.wrap({cls: 'x-form-check-wrap'});
- if(this.boxLabel){
- this.wrap.createChild({tag: 'label', htmlFor: this.el.id, cls: 'x-form-cb-label', html: this.boxLabel});
- }
- if(this.checked){
- this.setValue(true);
- }else{
- this.checked = this.el.dom.checked;
- }
-
- if (Ext.isIE && !Ext.isStrict) {
- this.wrap.repaint();
- }
- this.resizeEl = this.positionEl = this.wrap;
},
- onDestroy : function(){
- Ext.destroy(this.wrap);
- Ext.form.Checkbox.superclass.onDestroy.call(this);
+ onColumnRemove: function(ct, column) {
+ var me = this,
+ editor = me.getEditor();
+
+ if (editor && editor.onColumnRemove) {
+ editor.onColumnRemove(column);
+ }
+ me.removeFieldAccessors(column);
},
- initValue : function() {
- this.originalValue = this.getValue();
+ onColumnResize: function(ct, column, width) {
+ var me = this,
+ editor = me.getEditor();
+
+ if (editor && editor.onColumnResize) {
+ editor.onColumnResize(column, width);
+ }
},
- getValue : function(){
- if(this.rendered){
- return this.el.dom.checked;
+ onColumnHide: function(ct, column) {
+ var me = this,
+ editor = me.getEditor();
+
+ if (editor && editor.onColumnHide) {
+ editor.onColumnHide(column);
}
- return this.checked;
},
-
- onClick : function(){
- if(this.el.dom.checked != this.checked){
- this.setValue(this.el.dom.checked);
+
+ onColumnShow: function(ct, column) {
+ var me = this,
+ editor = me.getEditor();
+
+ if (editor && editor.onColumnShow) {
+ editor.onColumnShow(column);
}
},
- setValue : function(v){
- var checked = this.checked,
- inputVal = this.inputValue;
-
- this.checked = (v === true || v === 'true' || v == '1' || (inputVal ? v == inputVal : String(v).toLowerCase() == 'on'));
- if(this.rendered){
- this.el.dom.checked = this.checked;
- this.el.dom.defaultChecked = this.checked;
- }
- if(checked != this.checked){
- this.fireEvent('check', this, this.checked);
- if(this.handler){
- this.handler.call(this.scope || this, this, this.checked);
- }
+ onColumnMove: function(ct, column, fromIdx, toIdx) {
+ var me = this,
+ editor = me.getEditor();
+
+ if (editor && editor.onColumnMove) {
+ editor.onColumnMove(column, fromIdx, toIdx);
}
- return this;
+ },
+
+
+ setColumnField: function(column, field) {
+ var me = this;
+ me.callParent(arguments);
+ me.getEditor().setField(column.field, column);
}
});
-Ext.reg('checkbox', Ext.form.Checkbox);
-Ext.form.CheckboxGroup = Ext.extend(Ext.form.Field, {
-
-
- columns : 'auto',
-
- vertical : false,
-
- allowBlank : true,
-
- blankText : "You must select at least one item in this group",
+Ext.define('Ext.grid.property.Grid', {
-
- defaultType : 'checkbox',
+ extend: 'Ext.grid.Panel',
-
- groupCls : 'x-form-check-group',
+ alternateClassName: 'Ext.grid.PropertyGrid',
-
- initComponent: function(){
- this.addEvents(
-
- 'change'
- );
- this.on('change', this.validate, this);
- Ext.form.CheckboxGroup.superclass.initComponent.call(this);
- },
+ uses: [
+ 'Ext.grid.plugin.CellEditing',
+ 'Ext.grid.property.Store',
+ 'Ext.grid.property.HeaderContainer',
+ 'Ext.XTemplate',
+ 'Ext.grid.CellEditor',
+ 'Ext.form.field.Date',
+ 'Ext.form.field.Text',
+ 'Ext.form.field.Number'
+ ],
+
+
- onRender : function(ct, position){
- if(!this.el){
- var panelCfg = {
- autoEl: {
- id: this.id
- },
- cls: this.groupCls,
- layout: 'column',
- renderTo: ct,
- bufferResize: false
- };
- var colCfg = {
- xtype: 'container',
- defaultType: this.defaultType,
- layout: 'form',
- defaults: {
- hideLabel: true,
- anchor: '100%'
- }
- };
- if(this.items[0].items){
+
-
+
- Ext.apply(panelCfg, {
- layoutConfig: {columns: this.items.length},
- defaults: this.defaults,
- items: this.items
- });
- for(var i=0, len=this.items.length; i"); + + remove : function(prop) { + var r = this.getRec(prop); + if(r) { + this.store.remove(r); + delete this.source[prop]; + } }, - sortErrors: function() { - var fields = this.items; + getRec : function(prop) { + return this.store.getById(prop); + }, - this.fieldErrors.sort("ASC", function(a, b) { - var findByName = function(key) { - return function(field) { - return field.getName() == key; - }; - }; + + getSource : function() { + return this.source; + } +}); - var aIndex = fields.findIndexBy(findByName(a.field)), - bIndex = fields.findIndexBy(findByName(b.field)); - return aIndex < bIndex ? -1 : 1; - }); - }, +Ext.define('Ext.layout.component.Body', { - reset: function() { - this.eachItem(function(item) { - item.reset(); - }); - - - (function() { - this.clearInvalid(); - }).defer(50, this); - }, - - - clearInvalidChildren: function() { - this.eachItem(function(item) { - item.clearInvalid(); - }); - }, + alias: ['layout.body'], + + extend: 'Ext.layout.component.Component', + + uses: ['Ext.layout.container.Container'], - buildLabel: function(segments) { - return Ext.clean(segments).join(this.labelConnector); - }, + type: 'body', - isDirty: function(){ + onLayout: function(width, height) { + var me = this, + owner = me.owner; + - if (this.disabled || !this.rendered) { - return false; - } + me.setTargetSize(width, height); - var dirty = false; - this.eachItem(function(item){ - if(item.isDirty()){ - dirty = true; - return false; + + me.setBodySize.apply(me, arguments); + + + if (owner && owner.layout && owner.layout.isLayout) { + if (!Ext.isNumber(owner.height) || !Ext.isNumber(owner.width)) { + owner.layout.bindToOwnerCtComponent = true; } - }); - return dirty; + else { + owner.layout.bindToOwnerCtComponent = false; + } + } + + me.callParent(arguments); }, - eachItem: function(fn, scope) { - if(this.items && this.items.each){ - this.items.each(fn, scope || this); + setBodySize: function(width, height) { + var me = this, + owner = me.owner, + frameSize = owner.frameSize, + isNumber = Ext.isNumber; + + if (isNumber(width)) { + width -= owner.el.getFrameWidth('lr') - frameSize.left - frameSize.right; + } + if (isNumber(height)) { + height -= owner.el.getFrameWidth('tb') - frameSize.top - frameSize.bottom; } - }, - - onResize: function(adjWidth, adjHeight, rawWidth, rawHeight) { - var innerCt = this.innerCt; + me.setElementSize(owner.body, width, height); + } +}); + +Ext.define('Ext.layout.component.FieldSet', { + extend: 'Ext.layout.component.Body', + alias: ['layout.fieldset'], + + type: 'fieldset', - if (this.rendered && innerCt.rendered) { - innerCt.setSize(adjWidth, adjHeight); + doContainerLayout: function() { + + if (!this.owner.collapsed) { + this.callParent(); } + } +}); - Ext.form.CompositeField.superclass.onResize.apply(this, arguments); - }, +Ext.define('Ext.layout.component.Tab', { + + alias: ['layout.tab'], + + extend: 'Ext.layout.component.Button', - doLayout: function(shallow, force) { - if (this.rendered) { - var innerCt = this.innerCt; - innerCt.forceLayout = this.ownerCt.forceLayout; - innerCt.doLayout(shallow, force); + beforeLayout: function() { + var me = this, dirty = me.lastClosable !== me.owner.closable; + + if (dirty) { + delete me.adjWidth; } + + return this.callParent(arguments) || dirty; }, - - beforeDestroy: function(){ - Ext.destroy(this.innerCt); + onLayout: function () { + var me = this; - Ext.form.CompositeField.superclass.beforeDestroy.call(this); - }, + me.callParent(arguments); - - setReadOnly : function(readOnly) { - if (readOnly == undefined) { - readOnly = true; - } - readOnly = !!readOnly; + me.lastClosable = me.owner.closable; + } +}); - if(this.rendered){ - this.eachItem(function(item){ - item.setReadOnly(readOnly); - }); + +Ext.define('Ext.layout.component.field.File', { + alias: ['layout.filefield'], + extend: 'Ext.layout.component.field.Field', + + type: 'filefield', + + sizeBodyContents: function(width, height) { + var me = this, + owner = me.owner; + + if (!owner.buttonOnly) { + + + me.setElementSize(owner.inputEl, Ext.isNumber(width) ? width - owner.button.getWidth() - owner.buttonMargin : width); } - this.readOnly = readOnly; - }, + } +}); - onShow : function() { - Ext.form.CompositeField.superclass.onShow.call(this); - this.doLayout(); - }, + +Ext.define('Ext.layout.component.field.Slider', { - onDisable : function(){ - this.eachItem(function(item){ - item.disable(); - }); - }, + + alias: ['layout.sliderfield'], + + extend: 'Ext.layout.component.field.Field', - onEnable : function(){ - this.eachItem(function(item){ - item.enable(); - }); + + type: 'sliderfield', + + sizeBodyContents: function(width, height) { + var owner = this.owner, + thumbs = owner.thumbs, + length = thumbs.length, + inputEl = owner.inputEl, + innerEl = owner.innerEl, + endEl = owner.endEl, + i = 0; + + + for(; i < length; ++i) { + thumbs[i].el.stopAnimation(); + } + + if (owner.vertical) { + inputEl.setHeight(height); + innerEl.setHeight(Ext.isNumber(height) ? height - inputEl.getPadding('t') - endEl.getPadding('b') : height); + } + else { + inputEl.setWidth(width); + innerEl.setWidth(Ext.isNumber(width) ? width - inputEl.getPadding('l') - endEl.getPadding('r') : width); + } + owner.syncThumbs(); } }); -Ext.reg('compositefield', Ext.form.CompositeField); -Ext.form.Radio = Ext.extend(Ext.form.Checkbox, { - inputType: 'radio', + + +Ext.define('Ext.layout.container.Absolute', { - markInvalid : Ext.emptyFn, - - clearInvalid : Ext.emptyFn, + + alias: 'layout.absolute', + extend: 'Ext.layout.container.Anchor', + requires: ['Ext.chart.axis.Axis', 'Ext.fx.Anim'], + alternateClassName: 'Ext.layout.AbsoluteLayout', - getGroupValue : function(){ - var p = this.el.up('form') || Ext.getBody(); - var c = p.child('input[name='+this.el.dom.name+']:checked', true); - return c ? c.value : null; + + itemCls: Ext.baseCSSPrefix + 'abs-layout-item', + + type: 'absolute', + + onLayout: function() { + var me = this, + target = me.getTarget(), + targetIsBody = target.dom === document.body; + + + if (!targetIsBody) { + target.position(); + } + me.paddingLeft = target.getPadding('l'); + me.paddingTop = target.getPadding('t'); + me.callParent(arguments); }, - setValue : function(v){ - var checkEl, - els, - radio; - if (typeof v == 'boolean') { - Ext.form.Radio.superclass.setValue.call(this, v); - } else if (this.rendered) { - checkEl = this.getCheckEl(); - radio = checkEl.child('input[name=' + this.el.dom.name + '][value=' + v + ']', true); - if(radio){ - Ext.getCmp(radio.id).setValue(true); - } - } - if(this.rendered && this.checked){ - checkEl = checkEl || this.getCheckEl(); - els = this.getCheckEl().select('input[name=' + this.el.dom.name + ']'); - els.each(function(el){ - if(el.dom.id != this.id){ - Ext.getCmp(el.dom.id).setValue(false); - } - }, this); - } - return this; + adjustWidthAnchor: function(value, comp) { + + return value ? value - comp.getPosition(true)[0] : value; }, - getCheckEl: function(){ - if(this.inGroup){ - return this.el.up('.x-form-radio-group'); - } - return this.el.up('form') || Ext.getBody(); + adjustHeightAnchor: function(value, comp) { + + return value ? value - comp.getPosition(true)[1] : value; } }); -Ext.reg('radio', Ext.form.Radio); -Ext.form.RadioGroup = Ext.extend(Ext.form.CheckboxGroup, { +Ext.define('Ext.layout.container.Accordion', { + extend: 'Ext.layout.container.VBox', + alias: ['layout.accordion'], + alternateClassName: 'Ext.layout.AccordionLayout', + align: 'stretch', + - allowBlank : true, + fill : true, - blankText : 'You must select one item in this group', + autoWidth : true, + titleCollapse : true, - defaultType : 'radio', + hideCollapseTool : false, + collapseFirst : false, - groupCls : 'x-form-radio-group', + animate : true, + activeOnTop : false, + multi: false, + + constructor: function() { + var me = this; + + me.callParent(arguments); + + + me.initialAnimate = me.animate; + me.animate = false; + + + if (me.fill === false) { + me.itemCls = Ext.baseCSSPrefix + 'accordion-item'; + } + }, + - getValue : function(){ - var out = null; - this.eachItem(function(item){ - if(item.checked){ - out = item; + beforeLayout: function() { + var me = this; + + me.callParent(arguments); + if (me.fill) { + if (!me.owner.el.dom.style.height) { return false; } - }); - return out; + } else { + me.owner.componentLayout.monitorChildren = false; + me.autoSize = true; + me.owner.setAutoScroll(true); + } }, - - - onSetValue : function(id, value){ - if(arguments.length > 1){ - var f = this.getBox(id); - if(f){ - f.setValue(value); - if(f.checked){ - this.eachItem(function(item){ - if (item !== f){ - item.setValue(false); - } - }); + + renderItems : function(items, target) { + var me = this, + ln = items.length, + i = 0, + comp, + targetSize = me.getLayoutTargetSize(), + renderedPanels = [], + border; + + for (; i < ln; i++) { + comp = items[i]; + if (!comp.rendered) { + renderedPanels.push(comp); + + + if (me.collapseFirst) { + comp.collapseFirst = me.collapseFirst; + } + if (me.hideCollapseTool) { + comp.hideCollapseTool = me.hideCollapseTool; + comp.titleCollapse = true; + } + else if (me.titleCollapse) { + comp.titleCollapse = me.titleCollapse; + } + + delete comp.hideHeader; + comp.collapsible = true; + comp.title = comp.title || ' '; + comp.setBorder(false); + + + comp.width = targetSize.width; + if (me.fill) { + delete comp.height; + delete comp.flex; + + + if (me.expandedItem !== undefined) { + comp.collapsed = true; + } + + else if (comp.collapsed === false) { + comp.flex = 1; + me.expandedItem = i; + } else { + comp.collapsed = true; + } + } else { + delete comp.flex; + comp.animCollapse = me.initialAnimate; + comp.autoHeight = true; + comp.autoScroll = false; } } - }else{ - this.setValueForItem(id); } - }, - - setValueForItem : function(val){ - val = String(val).split(',')[0]; - this.eachItem(function(item){ - item.setValue(val == item.inputValue); - }); - }, - - - fireChecked : function(){ - if(!this.checkTask){ - this.checkTask = new Ext.util.DelayedTask(this.bufferChecked, this); + + + if (ln && me.expandedItem === undefined) { + me.expandedItem = 0; + comp = items[0]; + comp.collapsed = false; + if (me.fill) { + comp.flex = 1; + } + } + + + me.callParent(arguments); + + + ln = renderedPanels.length; + for (i = 0; i < ln; i++) { + comp = renderedPanels[i]; + + + delete comp.width; + + comp.header.addCls(Ext.baseCSSPrefix + 'accordion-hd'); + comp.body.addCls(Ext.baseCSSPrefix + 'accordion-body'); + + + if (me.fill) { + me.owner.mon(comp, { + show: me.onComponentShow, + beforeexpand: me.onComponentExpand, + beforecollapse: me.onComponentCollapse, + scope: me + }); + } } - this.checkTask.delay(10); }, - - - bufferChecked : function(){ - var out = null; - this.eachItem(function(item){ - if(item.checked){ - out = item; - return false; + + onLayout: function() { + var me = this; + + me.updatePanelClasses(); + + if (me.fill) { + me.callParent(arguments); + } else { + var targetSize = me.getLayoutTargetSize(), + items = me.getVisibleItems(), + len = items.length, + i = 0, comp; + + for (; i < len; i++) { + comp = items[i]; + if (comp.collapsed) { + items[i].setWidth(targetSize.width); + } else { + items[i].setSize(null, null); + } } - }); - this.fireEvent('change', this, out); + } + + return me; }, - onDestroy : function(){ - if(this.checkTask){ - this.checkTask.cancel(); - this.checkTask = null; + updatePanelClasses: function() { + var children = this.getLayoutItems(), + ln = children.length, + siblingCollapsed = true, + i, child; + + for (i = 0; i < ln; i++) { + child = children[i]; + if (!siblingCollapsed) { + child.header.addCls(Ext.baseCSSPrefix + 'accordion-hd-sibling-expanded'); + } + else { + child.header.removeCls(Ext.baseCSSPrefix + 'accordion-hd-sibling-expanded'); + } + if (i + 1 == ln && child.collapsed) { + child.header.addCls(Ext.baseCSSPrefix + 'accordion-hd-last-collapsed'); + } + else { + child.header.removeCls(Ext.baseCSSPrefix + 'accordion-hd-last-collapsed'); + } + siblingCollapsed = child.collapsed; } - Ext.form.RadioGroup.superclass.onDestroy.call(this); - } - -}); - -Ext.reg('radiogroup', Ext.form.RadioGroup); + }, -Ext.form.Hidden = Ext.extend(Ext.form.Field, { - inputType : 'hidden', - shouldLayout: false, - - onRender : function(){ - Ext.form.Hidden.superclass.onRender.apply(this, arguments); - }, + onComponentExpand: function(toExpand) { + var me = this, + it = me.owner.items.items, + len = it.length, + i = 0, + comp; - - initEvents : function(){ - this.originalValue = this.getValue(); + for (; i < len; i++) { + comp = it[i]; + if (comp === toExpand && comp.collapsed) { + me.setExpanded(comp); + } else if (!me.multi && (comp.rendered && comp.header.rendered && comp !== toExpand && !comp.collapsed)) { + me.setCollapsed(comp); + } + } + + me.animate = me.initialAnimate; + me.layout(); + me.animate = false; + return false; }, - - setSize : Ext.emptyFn, - setWidth : Ext.emptyFn, - setHeight : Ext.emptyFn, - setPosition : Ext.emptyFn, - setPagePosition : Ext.emptyFn, - markInvalid : Ext.emptyFn, - clearInvalid : Ext.emptyFn -}); -Ext.reg('hidden', Ext.form.Hidden); -Ext.form.BasicForm = Ext.extend(Ext.util.Observable, { + onComponentCollapse: function(comp) { + var me = this, + toExpand = comp.next() || comp.prev(), + expanded = me.multi ? me.owner.query('>panel:not([collapsed])') : []; - constructor: function(el, config){ - Ext.apply(this, config); - if(Ext.isString(this.paramOrder)){ - this.paramOrder = this.paramOrder.split(/[\s,|]/); - } - this.items = new Ext.util.MixedCollection(false, function(o){ - return o.getItemId(); - }); - this.addEvents( + + if (me.multi) { + me.setCollapsed(comp); + - 'beforeaction', - 'actionfailed', + if (expanded.length === 1 && expanded[0] === comp) { + me.setExpanded(toExpand); + } - 'actioncomplete' - ); + me.animate = me.initialAnimate; + me.layout(); + me.animate = false; + } + + else if (toExpand) { + me.onComponentExpand(toExpand); + } + return false; + }, - if(el){ - this.initEl(el); + onComponentShow: function(comp) { + + this.onComponentExpand(comp); + }, + + setCollapsed: function(comp) { + var otherDocks = comp.getDockedItems(), + dockItem, + len = otherDocks.length, + i = 0; + + + comp.hiddenDocked = []; + for (; i < len; i++) { + dockItem = otherDocks[i]; + if ((dockItem !== comp.header) && !dockItem.hidden) { + dockItem.hidden = true; + comp.hiddenDocked.push(dockItem); + } + } + comp.addCls(comp.collapsedCls); + comp.header.addCls(comp.collapsedHeaderCls); + comp.height = comp.header.getHeight(); + comp.el.setHeight(comp.height); + comp.collapsed = true; + delete comp.flex; + comp.fireEvent('collapse', comp); + if (comp.collapseTool) { + comp.collapseTool.setType('expand-' + comp.getOppositeDirection(comp.collapseDirection)); } - Ext.form.BasicForm.superclass.constructor.call(this); }, - - - - - - - - timeout: 30, + setExpanded: function(comp) { + var otherDocks = comp.hiddenDocked, + len = otherDocks ? otherDocks.length : 0, + i = 0; - + + for (; i < len; i++) { + otherDocks[i].hidden = false; + } - - paramOrder: undefined, + + if (!comp.body.isVisible()) { + comp.body.show(); + } + delete comp.collapsed; + delete comp.height; + delete comp.componentLayout.lastComponentSize; + comp.suspendLayout = false; + comp.flex = 1; + comp.removeCls(comp.collapsedCls); + comp.header.removeCls(comp.collapsedHeaderCls); + comp.fireEvent('expand', comp); + if (comp.collapseTool) { + comp.collapseTool.setType('collapse-' + comp.collapseDirection); + } + comp.setAutoScroll(comp.initialConfig.autoScroll); + } +}); - - paramsAsHash: false, +Ext.define('Ext.resizer.Splitter', { + extend: 'Ext.Component', + requires: ['Ext.XTemplate'], + uses: ['Ext.resizer.SplitterTracker'], + alias: 'widget.splitter', - - waitTitle: 'Please Wait...', + renderTpl: [ + '
' + html + '
';
- }
- }
- html = this.cleanHtml(html);
- if(this.fireEvent('beforesync', this, html) !== false){
- this.el.dom.value = html;
- this.fireEvent('sync', this, html);
+
+ if (newCard && oldCard != newCard) {
+
+ if (!newCard.rendered) {
+ me.renderItem(newCard, me.getRenderTarget(), owner.items.length);
+ me.configureItem(newCard, 0);
}
- }
- },
-
- getValue : function() {
- this[this.sourceEditMode ? 'pushValue' : 'syncValue']();
- return Ext.form.HtmlEditor.superclass.getValue.call(this);
- },
+ me.activeItem = newCard;
-
- pushValue : function(){
- if(this.initialized){
- var v = this.el.dom.value;
- if(!this.activated && v.length < 1){
- v = this.defaultValue;
+
+ if (newCard.fireEvent('beforeactivate', newCard, oldCard) === false) {
+ me.layoutBusy = false;
+ return false;
}
- if(this.fireEvent('beforepush', this, v) !== false){
- this.getEditorBody().innerHTML = v;
- if(Ext.isGecko){
-
- this.setDesignMode(false);
- this.setDesignMode(true);
+ if (oldCard && oldCard.fireEvent('beforedeactivate', oldCard, newCard) === false) {
+ me.layoutBusy = false;
+ return false;
+ }
+
+
+ if (!me.sizeAllCards) {
+ me.setItemBox(newCard, me.getTargetBox());
+ }
+ else {
+
+ me.onLayout();
+ }
+
+ if (oldCard) {
+ if (me.hideInactive) {
+ oldCard.hide();
}
- this.fireEvent('push', this, v);
+ oldCard.fireEvent('deactivate', oldCard, newCard);
}
- }
- },
+
+ if (newCard.hidden) {
+ newCard.show();
+ }
-
- deferFocus : function(){
- this.focus.defer(10, this);
- },
+ newCard.fireEvent('activate', newCard, oldCard);
-
- focus : function(){
- if(this.win && !this.sourceEditMode){
- this.win.focus();
- }else{
- this.el.focus();
+ me.layoutBusy = false;
+
+ if (!me.sizeAllCards) {
+ if (!owner.componentLayout.layoutBusy) {
+ me.onLayout();
+ }
+ }
+ return newCard;
}
- },
-
- initEditor : function(){
-
- try{
- var dbody = this.getEditorBody(),
- ss = this.el.getStyles('font-size', 'font-family', 'background-image', 'background-repeat', 'background-color', 'color'),
- doc,
- fn;
+ me.layoutBusy = false;
+ return false;
+ }
+});
- ss['background-attachment'] = 'fixed';
- dbody.bgProperties = 'fixed';
+Ext.define('Ext.layout.container.Column', {
- Ext.DomHelper.applyStyles(dbody, ss);
+ extend: 'Ext.layout.container.Auto',
+ alias: ['layout.column'],
+ alternateClassName: 'Ext.layout.ColumnLayout',
- doc = this.getDoc();
+ type: 'column',
- if(doc){
- try{
- Ext.EventManager.removeAll(doc);
- }catch(e){}
- }
+ itemCls: Ext.baseCSSPrefix + 'column',
+
+ targetCls: Ext.baseCSSPrefix + 'column-layout-ct',
+
+ scrollOffset: 0,
+
+ bindToOwnerCtComponent: false,
+
+ getRenderTarget : function() {
+ if (!this.innerCt) {
- fn = this.onEditorEvent.createDelegate(this);
- Ext.EventManager.on(doc, {
- mousedown: fn,
- dblclick: fn,
- click: fn,
- keyup: fn,
- buffer:100
+
+ this.innerCt = this.getTarget().createChild({
+ cls: Ext.baseCSSPrefix + 'column-inner'
});
- if(Ext.isGecko){
- Ext.EventManager.on(doc, 'keypress', this.applyCommand, this);
- }
- if(Ext.isIE || Ext.isWebKit || Ext.isOpera){
- Ext.EventManager.on(doc, 'keydown', this.fixKeys, this);
- }
- doc.editorInitialized = true;
- this.initialized = true;
- this.pushValue();
- this.setReadOnly(this.readOnly);
- this.fireEvent('initialize', this);
- }catch(e){}
+
+
+
+ this.clearEl = this.innerCt.createChild({
+ cls: Ext.baseCSSPrefix + 'clear',
+ role: 'presentation'
+ });
+ }
+ return this.innerCt;
},
- beforeDestroy : function(){
- if(this.monitorTask){
- Ext.TaskMgr.stop(this.monitorTask);
+ onLayout : function() {
+ var me = this,
+ target = me.getTarget(),
+ items = me.getLayoutItems(),
+ len = items.length,
+ item,
+ i,
+ parallelMargins = [],
+ itemParallelMargins,
+ size,
+ availableWidth,
+ columnWidth;
+
+ size = me.getLayoutTargetSize();
+ if (size.width < len * 10) {
+ return;
}
- if(this.rendered){
- Ext.destroy(this.tb);
- var doc = this.getDoc();
- if(doc){
- try{
- Ext.EventManager.removeAll(doc);
- for (var prop in doc){
- delete doc[prop];
- }
- }catch(e){}
+
+
+
+
+ if (me.adjustmentPass) {
+ if (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks) {
+ size.width = me.adjustedWidth;
}
- if(this.wrap){
- this.wrap.dom.innerHTML = '';
- this.wrap.remove();
+ } else {
+ i = target.getStyle('overflow');
+ if (i && i != 'hidden') {
+ me.autoScroll = true;
+ if (!(Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks)) {
+ target.setStyle('overflow', 'hidden');
+ size = me.getLayoutTargetSize();
+ }
}
}
- Ext.form.HtmlEditor.superclass.beforeDestroy.call(this);
- },
-
- onFirstFocus : function(){
- this.activated = true;
- this.disableItems(this.readOnly);
- if(Ext.isGecko){
- this.win.focus();
- var s = this.win.getSelection();
- if(!s.focusNode || s.focusNode.nodeType != 3){
- var r = s.getRangeAt(0);
- r.selectNodeContents(this.getEditorBody());
- r.collapse(true);
- this.deferFocus();
+ availableWidth = size.width - me.scrollOffset;
+ me.innerCt.setWidth(availableWidth);
+
+
+
+ for (i = 0; i < len; i++) {
+ item = items[i];
+ itemParallelMargins = parallelMargins[i] = item.getEl().getMargin('lr');
+ if (!item.columnWidth) {
+ availableWidth -= (item.getWidth() + itemParallelMargins);
}
- try{
- this.execCmd('useCSS', true);
- this.execCmd('styleWithCSS', false);
- }catch(e){}
}
- this.fireEvent('activate', this);
- },
-
- adjustFont: function(btn){
- var adjust = btn.getItemId() == 'increasefontsize' ? 1 : -1,
- doc = this.getDoc(),
- v = parseInt(doc.queryCommandValue('FontSize') || 2, 10);
- if((Ext.isSafari && !Ext.isSafari2) || Ext.isChrome || Ext.isAir){
-
+ availableWidth = availableWidth < 0 ? 0 : availableWidth;
+ for (i = 0; i < len; i++) {
+ item = items[i];
+ if (item.columnWidth) {
+ columnWidth = Math.floor(item.columnWidth * availableWidth) - parallelMargins[i];
+ if (item.getWidth() != columnWidth) {
+ me.setItemSize(item, columnWidth, item.height);
+ }
+ }
+ }
+
+
+ if (!me.adjustmentPass && me.autoScroll) {
+
- if(v <= 10){
- v = 1 + adjust;
- }else if(v <= 13){
- v = 2 + adjust;
- }else if(v <= 16){
- v = 3 + adjust;
- }else if(v <= 18){
- v = 4 + adjust;
- }else if(v <= 24){
- v = 5 + adjust;
- }else {
- v = 6 + adjust;
+ target.setStyle('overflow', 'auto');
+ me.adjustmentPass = (target.dom.scrollHeight > size.height);
+ if (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks) {
+ me.adjustedWidth = size.width - Ext.getScrollBarWidth();
+ } else {
+ target.setStyle('overflow', 'auto');
}
- v = v.constrain(1, 6);
- }else{
- if(Ext.isSafari){
- adjust *= 2;
+
+
+ if (me.adjustmentPass) {
+ me.onLayout();
}
- v = Math.max(1, v+adjust) + (Ext.isSafari ? 'px' : 0);
}
- this.execCmd('FontSize', v);
- },
+ delete me.adjustmentPass;
+ }
+});
+
+
+Ext.define('Ext.layout.container.Table', {
- onEditorEvent : function(e){
- this.updateToolbar();
- },
+ alias: ['layout.table'],
+ extend: 'Ext.layout.container.Auto',
+ alternateClassName: 'Ext.layout.TableLayout',
- updateToolbar: function(){
- if(this.readOnly){
- return;
- }
+
- if(!this.activated){
- this.onFirstFocus();
- return;
- }
+
+ monitorResize:false,
- var btns = this.tb.items.map,
- doc = this.getDoc();
+ type: 'table',
- 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'));
- }
+
+
+ autoSize: true,
- Ext.menu.MenuMgr.hideAll();
+ clearEl: true,
- this.syncValue();
- },
+ targetCls: Ext.baseCSSPrefix + 'table-layout-ct',
+ tableCls: Ext.baseCSSPrefix + 'table-layout',
+ cellCls: Ext.baseCSSPrefix + 'table-layout-cell',
- relayBtnCmd : function(btn){
- this.relayCmd(btn.getItemId());
- },
+ tableAttrs:null,
- relayCmd : function(cmd, value){
- (function(){
- this.focus();
- this.execCmd(cmd, value);
- this.updateToolbar();
- }).defer(10, this);
- },
+ renderItems: function(items) {
+ var tbody = this.getTable().tBodies[0],
+ rows = tbody.rows,
+ i = 0,
+ len = items.length,
+ cells, curCell, rowIdx, cellIdx, item, trEl, tdEl, itemCt;
-
- execCmd : function(cmd, value){
- var doc = this.getDoc();
- doc.execCommand(cmd, false, value === undefined ? null : value);
- this.syncValue();
- },
+
+ cells = this.calculateCells(items);
-
- 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();
+
+
+
+ for (; i < len; i++) {
+ curCell = cells[i];
+ rowIdx = curCell.rowIdx;
+ cellIdx = curCell.cellIdx;
+ item = items[i];
+
+
+ trEl = rows[rowIdx];
+ if (!trEl) {
+ trEl = tbody.insertRow(rowIdx);
+ }
+
+
+ itemCt = tdEl = Ext.get(trEl.cells[cellIdx] || trEl.insertCell(cellIdx));
+ if (this.needsDivWrap()) {
+ itemCt = tdEl.first() || tdEl.createChild({tag: 'div'});
+ itemCt.setWidth(null);
+ }
+
+
+ if (!item.rendered) {
+ this.renderItem(item, itemCt, 0);
+ }
+ else if (!this.isValidParent(item, itemCt, 0)) {
+ this.moveItem(item, itemCt, 0);
+ }
+
+
+ tdEl.set({
+ colSpan: item.colspan || 1,
+ rowSpan: item.rowspan || 1,
+ id: item.cellId || '',
+ cls: this.cellCls + ' ' + (item.cellCls || '')
+ });
+
+
+ if (!cells[i + 1] || cells[i + 1].rowIdx !== rowIdx) {
+ cellIdx++;
+ while (trEl.cells[cellIdx]) {
+ trEl.deleteCell(cellIdx);
}
}
}
- },
-
- insertAtCursor : function(text){
- if(!this.activated){
- return;
+
+ rowIdx++;
+ while (tbody.rows[rowIdx]) {
+ tbody.deleteRow(rowIdx);
}
- if(Ext.isIE){
- this.win.focus();
- var doc = this.getDoc(),
- r = doc.selection.createRange();
- if(r){
- r.pasteHTML(text);
- this.syncValue();
- this.deferFocus();
- }
- }else{
- this.win.focus();
- this.execCmd('InsertHTML', text);
- this.deferFocus();
+ },
+
+ afterLayout: function() {
+ this.callParent();
+
+ if (this.needsDivWrap()) {
+
+ Ext.Array.forEach(this.getLayoutItems(), function(item) {
+ Ext.fly(item.el.dom.parentNode).setWidth(item.getWidth());
+ });
}
},
- fixKeys : function(){
- if(Ext.isIE){
- return function(e){
- var k = e.getKey(),
- doc = this.getDoc(),
- r;
- if(k == e.TAB){
- e.stopEvent();
- r = doc.selection.createRange();
- if(r){
- r.collapse(true);
- r.pasteHTML(' ');
- this.deferFocus();
- }
- }else if(k == e.ENTER){
- r = doc.selection.createRange();
- if(r){
- var target = r.parentElement();
- if(!target || target.tagName.toLowerCase() != 'li'){
- e.stopEvent();
- r.pasteHTML(''); - r.collapse(false); - r.select(); + calculateCells: function(items) { + var cells = [], + rowIdx = 0, + colIdx = 0, + cellIdx = 0, + totalCols = this.columns || Infinity, + rowspans = [], + i = 0, j, + len = items.length, + item; + + for (; i < len; i++) { + item = items[i]; + + + while (colIdx >= totalCols || rowspans[colIdx] > 0) { + if (colIdx >= totalCols) { + + colIdx = 0; + cellIdx = 0; + rowIdx++; + + + for (j = 0; j < totalCols; j++) { + if (rowspans[j] > 0) { + rowspans[j]--; } } + } else { + colIdx++; } - }; - }else if(Ext.isOpera){ - return function(e){ - var k = e.getKey(); - if(k == e.TAB){ - e.stopEvent(); - this.win.focus(); - this.execCmd('InsertHTML',' '); - this.deferFocus(); - } - }; - }else if(Ext.isWebKit){ - return function(e){ - var k = e.getKey(); - if(k == e.TAB){ - e.stopEvent(); - this.execCmd('InsertText','\t'); - this.deferFocus(); - }else if(k == e.ENTER){ - e.stopEvent(); - this.execCmd('InsertHtml','
'); - this.deferFocus(); - } - }; + } + + + cells.push({ + rowIdx: rowIdx, + cellIdx: cellIdx + }); + + + rowspans[colIdx] = item.rowspan || 1; + colIdx += item.colspan || 1; + cellIdx++; } - }(), - - getToolbar : function(){ - return this.tb; + return cells; }, - buttonTips : { - bold : { - title: 'Bold (Ctrl+B)', - text: 'Make the selected text bold.', - cls: 'x-html-editor-tip' - }, - italic : { - title: 'Italic (Ctrl+I)', - text: 'Make the selected text italic.', - cls: 'x-html-editor-tip' - }, - underline : { - title: 'Underline (Ctrl+U)', - text: 'Underline the selected text.', - cls: 'x-html-editor-tip' - }, - increasefontsize : { - title: 'Grow Text', - text: 'Increase the font size.', - cls: 'x-html-editor-tip' - }, - decreasefontsize : { - title: 'Shrink Text', - text: 'Decrease the font size.', - cls: 'x-html-editor-tip' - }, - backcolor : { - title: 'Text Highlight Color', - text: 'Change the background color of the selected text.', - cls: 'x-html-editor-tip' - }, - forecolor : { - title: 'Font Color', - text: 'Change the color of the selected text.', - cls: 'x-html-editor-tip' - }, - justifyleft : { - title: 'Align Text Left', - text: 'Align text to the left.', - cls: 'x-html-editor-tip' - }, - justifycenter : { - title: 'Center Text', - text: 'Center text in the editor.', - cls: 'x-html-editor-tip' - }, - justifyright : { - title: 'Align Text Right', - text: 'Align text to the right.', - cls: 'x-html-editor-tip' - }, - insertunorderedlist : { - title: 'Bullet List', - text: 'Start a bulleted list.', - cls: 'x-html-editor-tip' - }, - insertorderedlist : { - title: 'Numbered List', - text: 'Start a numbered list.', - cls: 'x-html-editor-tip' - }, - createlink : { - title: 'Hyperlink', - text: 'Make the selected text a hyperlink.', - cls: 'x-html-editor-tip' - }, - sourceedit : { - title: 'Source Edit', - text: 'Switch to source editing mode.', - cls: 'x-html-editor-tip' + getTable: function() { + var table = this.table; + if (!table) { + table = this.table = this.getTarget().createChild( + Ext.apply({ + tag: 'table', + role: 'presentation', + cls: this.tableCls, + cellspacing: 0, + cn: {tag: 'tbody'} + }, this.tableAttrs), + null, true + ); } - } + return table; + }, + needsDivWrap: function() { + return Ext.isOpera10_5; + } +}); + +Ext.define('Ext.menu.Item', { + extend: 'Ext.Component', + alias: 'widget.menuitem', + alternateClassName: 'Ext.menu.TextItem', + + activeCls: Ext.baseCSSPrefix + 'menu-item-active', + ariaRole: 'menuitem', + canActivate: true, + clickHideDelay: 1, + destroyMenu: true, + disabledCls: Ext.baseCSSPrefix + 'menu-item-disabled', + + + hideOnClick: true, + + isMenuItem: true, + menuAlign: 'tl-tr?', + menuExpandDelay: 200, + menuHideDelay: 200, + renderTpl: [ + '
',
- '',
- ' ',
- ' ',
- '
'
- ),
-
- headerTpl: new Ext.Template(
- '{value}
',
- '{body}
',
- '' + innerText + '
'),
- 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();
- }
+ if (me.id && Ext.Array.indexOf(types, me.id) > -1) {
+ Ext.global.console.warn('When specifying a tool you should use the type option, the id can conflict now that tool is a Component');
}
+
+ me.type = me.type || me.id;
- this.templates = templates;
- this.colRe = new RegExp('x-grid3-td-([^\\s]+)', '');
+ Ext.applyIf(me.renderData, {
+ baseCls: me.baseCls,
+ blank: Ext.BLANK_IMAGE_URL,
+ type: me.type
+ });
+ me.renderSelectors.toolEl = '.' + me.baseCls + '-' + me.type;
+ me.callParent();
},
- fly : function(el) {
- if (!this._flyweight) {
- this._flyweight = new Ext.Element.Flyweight(document.body);
+ afterRender: function() {
+ var me = this;
+ me.callParent(arguments);
+ if (me.qtip) {
+ if (Ext.isObject(me.qtip)) {
+ Ext.tip.QuickTipManager.register(Ext.apply({
+ target: me.id
+ }, me.qtip));
+ }
+ else {
+ me.toolEl.dom.qtip = me.qtip;
+ }
}
- this._flyweight.dom = el;
- return this._flyweight;
- },
-
- getEditorParent : function() {
- return this.scroller.dom;
+ me.mon(me.toolEl, {
+ click: me.onClick,
+ mousedown: me.onMouseDown,
+ mouseover: me.onMouseOver,
+ mouseout: me.onMouseOut,
+ scope: me
+ });
},
- initElements : function() {
- var Element = Ext.Element,
- el = Ext.get(this.grid.getGridEl().dom.firstChild),
- mainWrap = new Element(el.child('div.x-grid3-viewport')),
- mainHd = new Element(mainWrap.child('div.x-grid3-header')),
- scroller = new Element(mainWrap.child('div.x-grid3-scroller'));
-
- if (this.grid.hideHeaders) {
- mainHd.setDisplayed(false);
- }
+ setType: function(type) {
+ var me = this;
- if (this.forceFit) {
- scroller.setStyle('overflow-x', 'hidden');
+ me.type = type;
+ if (me.rendered) {
+ me.toolEl.dom.className = me.baseCls + '-' + type;
}
-
-
-
- Ext.apply(this, {
- el : el,
- mainWrap: mainWrap,
- scroller: scroller,
- mainHd : mainHd,
- innerHd : mainHd.child('div.x-grid3-header-inner').dom,
- mainBody: new Element(Element.fly(scroller).child('div.x-grid3-body')),
- focusEl : new Element(Element.fly(scroller).child('a')),
-
- resizeMarker: new Element(el.child('div.x-grid3-resize-marker')),
- resizeProxy : new Element(el.child('div.x-grid3-resize-proxy'))
- });
-
- this.focusEl.swallowEvent('click', true);
+ return me;
},
- getRows : function() {
- return this.hasRows() ? this.mainBody.dom.childNodes : [];
+ bindTo: function(component) {
+ this.owner = component;
},
-
-
- findCell : function(el) {
- if (!el) {
+ onClick: function(e, target) {
+ var me = this,
+ owner;
+
+ if (me.disabled) {
return false;
}
- return this.fly(el).findParent(this.cellSelector, this.cellSelectorDepth);
- },
+ owner = me.owner || me.ownerCt;
-
- findCellIndex : function(el, requiredCls) {
- var cell = this.findCell(el),
- hasCls;
- if (cell) {
- hasCls = this.fly(cell).hasClass(requiredCls);
- if (!requiredCls || hasCls) {
- return this.getCellIndex(cell);
- }
- }
- return false;
- },
+ me.el.removeCls(me.toolPressedCls);
+ me.el.removeCls(me.toolOverCls);
-
- getCellIndex : function(el) {
- if (el) {
- var match = el.className.match(this.colRe);
-
- if (match && match[1]) {
- return this.cm.getIndexById(match[1]);
- }
+ if (me.stopEvent !== false) {
+ e.stopEvent();
}
- return false;
- },
-
- findHeaderCell : function(el) {
- var cell = this.findCell(el);
- return cell && this.fly(cell).hasClass(this.hdCls) ? cell : null;
+ Ext.callback(me.handler, me.scope || me, [e, target, owner, me]);
+ me.fireEvent('click', me, e);
+ return true;
},
-
- findHeaderIndex : function(el){
- return this.findCellIndex(el, this.hdCls);
+
+ onDestroy: function(){
+ if (Ext.isObject(this.tooltip)) {
+ Ext.tip.QuickTipManager.unregister(this.id);
+ }
+ this.callParent();
},
- findRow : function(el) {
- if (!el) {
+ onMouseDown: function() {
+ if (this.disabled) {
return false;
}
- return this.fly(el).findParent(this.rowSelector, this.rowSelectorDepth);
- },
-
- findRowIndex : function(el) {
- var row = this.findRow(el);
- return row ? row.rowIndex : false;
+ this.el.addCls(this.toolPressedCls);
},
- findRowBody : function(el) {
- if (!el) {
+ onMouseOver: function() {
+ if (this.disabled) {
return false;
}
-
- return this.fly(el).findParent(this.rowBodySelector, this.rowBodySelectorDepth);
+ this.el.addCls(this.toolOverCls);
},
+ onMouseOut: function() {
+ this.el.removeCls(this.toolOverCls);
+ }
+});
+Ext.define('Ext.resizer.Handle', {
+ extend: 'Ext.Component',
+ handleCls: '',
+ baseHandleCls: Ext.baseCSSPrefix + 'resizable-handle',
- getRow : function(row) {
- return this.getRows()[row];
- },
-
- getCell : function(row, col) {
- return Ext.fly(this.getRow(row)).query(this.cellSelector)[col];
- },
+ region: '',
-
- getHeaderCell : function(index) {
- return this.mainHd.dom.getElementsByTagName('td')[index];
- },
+ onRender: function() {
+ this.addCls(
+ this.baseHandleCls,
+ this.baseHandleCls + '-' + this.region,
+ this.handleCls
+ );
+ this.callParent(arguments);
+ this.el.unselectable();
+ }
+});
-
-
- addRowClass : function(rowId, cls) {
- var row = this.getRow(rowId);
- if (row) {
- this.fly(row).addClass(cls);
- }
+Ext.define('Ext.resizer.Resizer', {
+ mixins: {
+ observable: 'Ext.util.Observable'
},
+ uses: ['Ext.resizer.ResizeTracker', 'Ext.Component'],
-
- removeRowClass : function(row, cls) {
- var r = this.getRow(row);
- if(r){
- this.fly(r).removeClass(cls);
- }
- },
+ alternateClassName: 'Ext.Resizable',
-
- removeRow : function(row) {
- Ext.removeNode(this.getRow(row));
- this.syncFocusEl(row);
- },
+ handleCls: Ext.baseCSSPrefix + 'resizable-handle',
+ pinnedCls: Ext.baseCSSPrefix + 'resizable-pinned',
+ overCls: Ext.baseCSSPrefix + 'resizable-over',
+ proxyCls: Ext.baseCSSPrefix + 'resizable-proxy',
+ wrapCls: Ext.baseCSSPrefix + 'resizable-wrap',
- removeRows : function(firstRow, lastRow) {
- var bd = this.mainBody.dom,
- rowIndex;
-
- for (rowIndex = firstRow; rowIndex <= lastRow; rowIndex++){
- Ext.removeNode(bd.childNodes[firstRow]);
- }
-
- this.syncFocusEl(firstRow);
- },
+ dynamic: true,
-
-
- getScrollState : function() {
- var sb = this.scroller.dom;
-
- return {
- left: sb.scrollLeft,
- top : sb.scrollTop
- };
- },
+ handles: 's e se',
- restoreScroll : function(state) {
- var sb = this.scroller.dom;
- sb.scrollLeft = state.left;
- sb.scrollTop = state.top;
- },
+ height : null,
- scrollToTop : function() {
- var dom = this.scroller.dom;
-
- dom.scrollTop = 0;
- dom.scrollLeft = 0;
- },
+ width : null,
- syncScroll : function() {
- this.syncHeaderScroll();
- var mb = this.scroller.dom;
- this.grid.fireEvent('bodyscroll', mb.scrollLeft, mb.scrollTop);
- },
+ minHeight : 20,
- syncHeaderScroll : function() {
- var innerHd = this.innerHd,
- scrollLeft = this.scroller.dom.scrollLeft;
-
- innerHd.scrollLeft = scrollLeft;
- innerHd.scrollLeft = scrollLeft;
- },
+ minWidth : 20,
+
+ maxHeight : 10000,
+
- updateSortIcon : function(col, dir) {
- var sortClasses = this.sortClasses,
- sortClass = sortClasses[dir == "DESC" ? 1 : 0],
- headers = this.mainHd.select('td').removeClass(sortClasses);
-
- headers.item(col).addClass(sortClass);
- },
+ maxWidth : 10000,
- updateAllColumnWidths : function() {
- var totalWidth = this.getTotalWidth(),
- colCount = this.cm.getColumnCount(),
- rows = this.getRows(),
- rowCount = rows.length,
- widths = [],
- row, rowFirstChild, trow, i, j;
-
- for (i = 0; i < colCount; i++) {
- widths[i] = this.getColumnWidth(i);
- this.getHeaderCell(i).style.width = widths[i];
- }
-
- this.updateHeaderWidth();
-
- for (i = 0; i < rowCount; i++) {
- row = rows[i];
- row.style.width = totalWidth;
- rowFirstChild = row.firstChild;
-
- if (rowFirstChild) {
- rowFirstChild.style.width = totalWidth;
- trow = rowFirstChild.rows[0];
-
- for (j = 0; j < colCount; j++) {
- trow.childNodes[j].style.width = widths[j];
- }
- }
- }
-
- this.onAllColumnWidthsUpdated(widths, totalWidth);
- },
+ pinned: false,
- updateColumnWidth : function(column, width) {
- var columnWidth = this.getColumnWidth(column),
- totalWidth = this.getTotalWidth(),
- headerCell = this.getHeaderCell(column),
- nodes = this.getRows(),
- nodeCount = nodes.length,
- row, i, firstChild;
-
- this.updateHeaderWidth();
- headerCell.style.width = columnWidth;
-
- for (i = 0; i < nodeCount; i++) {
- row = nodes[i];
- firstChild = row.firstChild;
-
- row.style.width = totalWidth;
- if (firstChild) {
- firstChild.style.width = totalWidth;
- firstChild.rows[0].childNodes[column].style.width = columnWidth;
- }
- }
-
- this.onColumnWidthUpdated(column, columnWidth, totalWidth);
- },
+ preserveRatio: false,
+
+ transparent: false,
+
- updateColumnHidden : function(col, hidden) {
- var totalWidth = this.getTotalWidth(),
- display = hidden ? 'none' : '',
- headerCell = this.getHeaderCell(col),
- nodes = this.getRows(),
- nodeCount = nodes.length,
- row, rowFirstChild, i;
-
- this.updateHeaderWidth();
- headerCell.style.display = display;
-
- for (i = 0; i < nodeCount; i++) {
- row = nodes[i];
- row.style.width = totalWidth;
- rowFirstChild = row.firstChild;
-
- if (rowFirstChild) {
- rowFirstChild.style.width = totalWidth;
- rowFirstChild.rows[0].childNodes[col].style.display = display;
- }
- }
-
- this.onColumnHiddenUpdated(col, hidden, totalWidth);
- delete this.lastViewWidth;
- this.layout();
+
+ possiblePositions: {
+ n: 'north',
+ s: 'south',
+ e: 'east',
+ w: 'west',
+ se: 'southeast',
+ sw: 'southwest',
+ nw: 'northwest',
+ ne: 'northeast'
},
- doRender : function(columns, records, store, startRow, colCount, stripe) {
- var templates = this.templates,
- cellTemplate = templates.cell,
- rowTemplate = templates.row,
- last = colCount - 1,
- tstyle = 'width:' + this.getTotalWidth() + ';',
-
- rowBuffer = [],
- colBuffer = [],
- rowParams = {tstyle: tstyle},
- meta = {},
- len = records.length,
- alt,
- column,
- record, i, j, rowIndex;
-
- for (j = 0; j < len; j++) {
- record = records[j];
- colBuffer = [];
+
- rowIndex = j + startRow;
+ constructor: function(config) {
+ var me = this,
+ target,
+ tag,
+ handles = me.handles,
+ handleCls,
+ possibles,
+ len,
+ i = 0,
+ pos;
+ this.addEvents(
- for (i = 0; i < colCount; i++) {
- column = columns[i];
-
- meta.id = column.id;
- meta.css = i === 0 ? 'x-grid3-cell-first ' : (i == last ? 'x-grid3-cell-last ' : '');
- meta.attr = meta.cellAttr = '';
- meta.style = column.style;
- meta.value = column.renderer.call(column.scope, record.data[column.name], meta, record, rowIndex, i, store);
-
- if (Ext.isEmpty(meta.value)) {
- meta.value = ' ';
- }
-
- if (this.markDirty && record.dirty && typeof record.modified[column.name] != 'undefined') {
- meta.css += ' x-grid3-dirty-cell';
- }
-
- colBuffer[colBuffer.length] = cellTemplate.apply(meta);
- }
-
- alt = [];
+ 'beforeresize',
- if (stripe && ((rowIndex + 1) % 2 === 0)) {
- alt[0] = 'x-grid3-row-alt';
- }
-
- if (record.dirty) {
- alt[1] = ' x-grid3-dirty-row';
- }
-
- rowParams.cols = colCount;
-
- if (this.getRowClass) {
- alt[2] = this.getRowClass(record, rowIndex, rowParams, store);
- }
-
- rowParams.alt = alt.join(' ');
- rowParams.cells = colBuffer.join('');
-
- rowBuffer[rowBuffer.length] = rowTemplate.apply(rowParams);
- }
-
- return rowBuffer.join('');
- },
+ 'resizedrag',
+
+ 'resize'
+ );
-
- processRows : function(startRow, skipStripe) {
- if (!this.ds || this.ds.getCount() < 1) {
- return;
+ if (Ext.isString(config) || Ext.isElement(config) || config.dom) {
+ target = config;
+ config = arguments[1] || {};
+ config.target = target;
}
+
+ me.mixins.observable.constructor.call(me, config);
- var rows = this.getRows(),
- length = rows.length,
- row, i;
-
- skipStripe = skipStripe || !this.grid.stripeRows;
- startRow = startRow || 0;
-
- for (i = 0; i < length; i++) {
- row = rows[i];
- if (row) {
- row.rowIndex = i;
- if (!skipStripe) {
- row.className = row.className.replace(this.rowClsRe, ' ');
- if ((i + 1) % 2 === 0){
- row.className += ' x-grid3-row-alt';
+
+
+ target = me.target;
+ if (target) {
+ if (target.isComponent) {
+ me.el = target.getEl();
+ if (target.minWidth) {
+ me.minWidth = target.minWidth;
+ }
+ if (target.minHeight) {
+ me.minHeight = target.minHeight;
+ }
+ if (target.maxWidth) {
+ me.maxWidth = target.maxWidth;
+ }
+ if (target.maxHeight) {
+ me.maxHeight = target.maxHeight;
+ }
+ if (target.floating) {
+ if (!this.hasOwnProperty('handles')) {
+ this.handles = 'n ne e se s sw w nw';
}
}
+ } else {
+ me.el = me.target = Ext.get(target);
}
}
-
- if (startRow === 0) {
- Ext.fly(rows[0]).addClass(this.firstRowCls);
+ else {
+ me.target = me.el = Ext.get(me.el);
}
- 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);
+
+
+ tag = me.el.dom.tagName;
+ if (tag == 'TEXTAREA' || tag == 'IMG') {
+
+ me.originalTarget = me.target;
+ me.target = me.el = me.el.wrap({
+ cls: me.wrapCls,
+ id: me.el.id + '-rzwrap'
+ });
- if (this.deferEmptyText !== true) {
- this.applyEmptyText();
+
+ me.el.setPositioning(me.originalTarget.getPositioning());
+ me.originalTarget.clearPositioning();
+ var box = me.originalTarget.getBox();
+ me.el.setBox(box);
}
+
- this.grid.fireEvent('viewready', this.grid);
- },
-
-
- afterRenderUI: function() {
- var grid = this.grid;
- this.initElements();
+ me.el.position();
+ if (me.pinned) {
+ me.el.addCls(me.pinnedCls);
+ }
- Ext.fly(this.innerHd).on('click', this.handleHdDown, this);
-
- this.mainHd.on({
- scope : this,
- mouseover: this.handleHdOver,
- mouseout : this.handleHdOut,
- mousemove: this.handleHdMove
+ me.resizeTracker = Ext.create('Ext.resizer.ResizeTracker', {
+ disabled: me.disabled,
+ target: me.target,
+ constrainTo: me.constrainTo,
+ overCls: me.overCls,
+ throttle: me.throttle,
+ originalTarget: me.originalTarget,
+ delegate: '.' + me.handleCls,
+ dynamic: me.dynamic,
+ preserveRatio: me.preserveRatio,
+ minHeight: me.minHeight,
+ maxHeight: me.maxHeight,
+ minWidth: me.minWidth,
+ maxWidth: me.maxWidth
});
- 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
- });
- }
+ me.resizeTracker.on('mousedown', me.onBeforeResize, me);
+ me.resizeTracker.on('drag', me.onResize, me);
+ me.resizeTracker.on('dragend', me.onResizeEnd, me);
- if (grid.enableDragDrop || grid.enableDrag) {
- this.dragZone = new Ext.grid.GridDragZone(grid, {
- ddGroup : grid.ddGroup || 'GridDD'
- });
+ if (me.handles == 'all') {
+ me.handles = 'n s e w ne nw se sw';
}
- 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);
-
-
+ handles = me.handles = me.handles.split(/ |\s*?[,;]\s*?/);
+ possibles = me.possiblePositions;
+ len = handles.length;
+ handleCls = me.handleCls + ' ' + (this.target.isComponent ? (me.target.baseCls + '-handle ') : '') + me.handleCls + '-';
+ for(; i < len; i++){
+
+ if (handles[i] && possibles[handles[i]]) {
+ pos = possibles[handles[i]];
+
- 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);
- }
+ me[pos] = Ext.create('Ext.Component', {
+ owner: this,
+ region: pos,
+ cls: handleCls + pos,
+ renderTo: me.el
+ });
+ me[pos].el.unselectable();
+ if (me.transparent) {
+ me[pos].el.setOpacity(0);
}
- } else {
- grid.fireEvent('container' + name, grid, e);
}
}
- },
-
-
- layout : function(initial) {
- if (!this.mainBody) {
- return;
- }
- var grid = this.grid,
- gridEl = grid.getGridEl(),
- gridSize = gridEl.getSize(true),
- gridWidth = gridSize.width,
- gridHeight = gridSize.height,
- scroller = this.scroller,
- scrollStyle, headerHeight, scrollHeight;
- if (gridWidth < 20 || gridHeight < 20) {
- return;
+ if (Ext.isNumber(me.width)) {
+ me.width = Ext.Number.constrain(me.width, me.minWidth, me.maxWidth);
}
-
- if (grid.autoHeight) {
- scrollStyle = scroller.dom.style;
- scrollStyle.overflow = 'visible';
-
- if (Ext.isWebKit) {
- scrollStyle.position = 'static';
- }
- } else {
- this.el.setSize(gridWidth, gridHeight);
-
- headerHeight = this.mainHd.getHeight();
- scrollHeight = gridHeight - headerHeight;
-
- scroller.setSize(gridWidth, scrollHeight);
-
- if (this.innerHd) {
- this.innerHd.style.width = (gridWidth) + "px";
- }
+ if (Ext.isNumber(me.height)) {
+ me.height = Ext.Number.constrain(me.height, me.minHeight, me.maxHeight);
}
+
- if (this.forceFit || (initial === true && this.autoFill)) {
- if (this.lastViewWidth != gridWidth) {
- this.fitColumns(false, false);
- this.lastViewWidth = gridWidth;
+ if (me.width != null || me.height != null) {
+ if (me.originalTarget) {
+ me.originalTarget.setWidth(me.width);
+ me.originalTarget.setHeight(me.height);
}
- } else {
- this.autoExpand();
- this.syncHeaderScroll();
+ me.resizeTo(me.width, me.height);
}
-
- this.onLayout(gridWidth, scrollHeight);
- },
-
-
- onLayout : function(vw, vh) {
-
+ me.forceHandlesHeight();
},
- onColumnWidthUpdated : function(col, w, tw) {
-
+ disable: function() {
+ this.resizeTracker.disable();
},
- onAllColumnWidthsUpdated : function(ws, tw) {
-
+ enable: function() {
+ this.resizeTracker.enable();
},
- onColumnHiddenUpdated : function(col, hidden, tw) {
-
+
+ onBeforeResize: function(tracker, e) {
+ var b = this.target.getBox();
+ return this.fireEvent('beforeresize', this, b.width, b.height, e);
},
- updateColumnText : function(col, text) {
-
+
+ onResize: function(tracker, e) {
+ var me = this,
+ b = me.target.getBox();
+ me.forceHandlesHeight();
+ return me.fireEvent('resizedrag', me, b.width, b.height, e);
},
- afterMove : function(colIndex) {
-
+
+ onResizeEnd: function(tracker, e) {
+ var me = this,
+ b = me.target.getBox();
+ me.forceHandlesHeight();
+ return me.fireEvent('resize', me, b.width, b.height, e);
},
-
- init : function(grid) {
- this.grid = grid;
-
- this.initTemplates();
- this.initData(grid.store, grid.colModel);
- this.initUI(grid);
+ resizeTo : function(width, height){
+ this.target.setSize(width, height);
+ this.fireEvent('resize', this, width, height, null);
},
- getColumnId : function(index){
- return this.cm.getColumnId(index);
+ getEl : function() {
+ return this.el;
},
- getOffsetWidth : function() {
- return (this.cm.getTotalWidth() + this.getScrollOffset()) + 'px';
+ getTarget: function() {
+ return this.target;
},
-
- getScrollOffset: function() {
- return Ext.num(this.scrollOffset, Ext.getScrollBarWidth());
+ destroy: function() {
+ var h;
+ for (var i = 0, l = this.handles.length; i < l; i++) {
+ h = this[this.possiblePositions[this.handles[i]]];
+ delete h.owner;
+ Ext.destroy(h);
+ }
},
- renderHeaders : function() {
- var colModel = this.cm,
- templates = this.templates,
- headerTpl = templates.hcell,
- properties = {},
- colCount = colModel.getColumnCount(),
- last = colCount - 1,
- cells = [],
- i, cssCls;
-
- for (i = 0; i < colCount; i++) {
- if (i == 0) {
- cssCls = 'x-grid3-cell-first ';
- } else {
- cssCls = i == last ? 'x-grid3-cell-last ' : '';
+ forceHandlesHeight : function() {
+ var me = this,
+ handle;
+ if (Ext.isIE6) {
+ handle = me.east;
+ if (handle) {
+ handle.setHeight(me.el.getHeight());
}
-
- properties = {
- id : colModel.getColumnId(i),
- value : colModel.getColumnHeader(i) || '',
- style : this.getColumnStyle(i, true),
- css : cssCls,
- tooltip: this.getColumnTooltip(i)
- };
-
- if (colModel.config[i].align == 'right') {
- properties.istyle = 'padding-right: 16px;';
- } else {
- delete properties.istyle;
+ handle = me.west;
+ if (handle) {
+ handle.setHeight(me.el.getHeight());
}
-
- cells[i] = headerTpl.apply(properties);
+ me.el.repaint();
}
-
- return templates.header.apply({
- cells : cells.join(""),
- tstyle: String.format("width: {0};", this.getTotalWidth())
- });
- },
+ }
+});
+
+
+Ext.define('Ext.resizer.ResizeTracker', {
+ extend: 'Ext.dd.DragTracker',
+ dynamic: true,
+ preserveRatio: false,
- getColumnTooltip : function(i) {
- var tooltip = this.cm.getColumnTooltip(i);
- if (tooltip) {
- if (Ext.QuickTips.isEnabled()) {
- return 'ext:qtip="' + tooltip + '"';
+ constrainTo: null,
+
+ constructor: function(config) {
+ var me = this;
+
+ if (!config.el) {
+ if (config.target.isComponent) {
+ me.el = config.target.getEl();
} else {
- return 'title="' + tooltip + '"';
+ me.el = config.target;
}
}
-
- return '';
- },
-
-
- beforeUpdate : function() {
- this.grid.stopEditing(true);
- },
+ this.callParent(arguments);
-
- updateHeaders : function() {
- this.innerHd.firstChild.innerHTML = this.renderHeaders();
- this.updateHeaderWidth(false);
- },
-
-
- updateHeaderWidth: function(updateMain) {
- var innerHdChild = this.innerHd.firstChild,
- totalWidth = this.getTotalWidth();
+ if (me.preserveRatio && me.minWidth && me.minHeight) {
+ var widthRatio = me.minWidth / me.el.getWidth(),
+ heightRatio = me.minHeight / me.el.getHeight();
+
+
+
+
+ if (heightRatio > widthRatio) {
+ me.minWidth = me.el.getWidth() * heightRatio;
+ } else {
+ me.minHeight = me.el.getHeight() * widthRatio;
+ }
+ }
+
- innerHdChild.style.width = this.getOffsetWidth();
- innerHdChild.firstChild.style.width = totalWidth;
- if (updateMain !== false) {
- this.mainBody.dom.style.width = totalWidth;
+ if (me.throttle) {
+ var throttledResizeFn = Ext.Function.createThrottled(function() {
+ Ext.resizer.ResizeTracker.prototype.resize.apply(me, arguments);
+ }, me.throttle);
+
+ me.resize = function(box, direction, atEnd) {
+ if (atEnd) {
+ Ext.resizer.ResizeTracker.prototype.resize.apply(me, arguments);
+ } else {
+ throttledResizeFn.apply(null, arguments);
+ }
+ };
}
},
-
- focusRow : function(row) {
- this.focusCell(row, 0, false);
+ onBeforeStart: function(e) {
+
+ this.startBox = this.el.getBox();
},
- focusCell : function(row, col, hscroll) {
- this.syncFocusEl(this.ensureVisible(row, col, hscroll));
-
- var focusEl = this.focusEl;
-
- if (Ext.isGecko) {
- focusEl.focus();
- } else {
- focusEl.focus.defer(1, focusEl);
+ getDynamicTarget: function() {
+ var d = this.target;
+ if (this.dynamic) {
+ return d;
+ } else if (!this.proxy) {
+ this.proxy = d.isComponent ? d.getProxy().addCls(Ext.baseCSSPrefix + 'resizable-proxy') : d.createProxy({tag: 'div', cls: Ext.baseCSSPrefix + 'resizable-proxy', id: d.id + '-rzproxy'}, Ext.getBody());
+ this.proxy.removeCls(Ext.baseCSSPrefix + 'proxy-el');
}
+ this.proxy.show();
+ return this.proxy;
},
-
- resolveCell : function(row, col, hscroll) {
- if (!Ext.isNumber(row)) {
- row = row.rowIndex;
- }
+ onStart: function(e) {
- if (!this.ds) {
- return null;
- }
+ this.activeResizeHandle = Ext.getCmp(this.getDragTarget().id);
+
- if (row < 0 || row >= this.ds.getCount()) {
- return null;
+ if (!this.dynamic) {
+ this.resize(this.startBox, {
+ horizontal: 'none',
+ vertical: 'none'
+ });
}
- col = (col !== undefined ? col : 0);
+ },
- var rowEl = this.getRow(row),
- colModel = this.cm,
- colCount = colModel.getColumnCount(),
- cellEl;
-
- if (!(hscroll === false && col === 0)) {
- while (col < colCount && colModel.isHidden(col)) {
- col++;
- }
-
- cellEl = this.getCell(row, col);
+ onDrag: function(e) {
+
+ if (this.dynamic || this.proxy) {
+ this.updateDimensions(e);
}
-
- return {row: rowEl, cell: cellEl};
},
-
- getResolvedXY : function(resolved) {
- if (!resolved) {
- return null;
+ updateDimensions: function(e, atEnd) {
+ var me = this,
+ region = me.activeResizeHandle.region,
+ offset = me.getOffset(me.constrainTo ? 'dragTarget' : null),
+ box = me.startBox,
+ ratio,
+ widthAdjust = 0,
+ heightAdjust = 0,
+ adjustX = 0,
+ adjustY = 0,
+ dragRatio,
+ horizDir = offset[0] < 0 ? 'right' : 'left',
+ vertDir = offset[1] < 0 ? 'down' : 'up',
+ oppositeCorner,
+ axis;
+
+ switch (region) {
+ case 'south':
+ heightAdjust = offset[1];
+ axis = 2;
+ break;
+ case 'north':
+ heightAdjust = -offset[1];
+ adjustY = -heightAdjust;
+ axis = 2;
+ break;
+ case 'east':
+ widthAdjust = offset[0];
+ axis = 1;
+ break;
+ case 'west':
+ widthAdjust = -offset[0];
+ adjustX = -widthAdjust;
+ axis = 1;
+ break;
+ case 'northeast':
+ heightAdjust = -offset[1];
+ adjustY = -heightAdjust;
+ widthAdjust = offset[0];
+ oppositeCorner = [box.x, box.y + box.height];
+ axis = 3;
+ break;
+ case 'southeast':
+ heightAdjust = offset[1];
+ widthAdjust = offset[0];
+ oppositeCorner = [box.x, box.y];
+ axis = 3;
+ break;
+ case 'southwest':
+ widthAdjust = -offset[0];
+ adjustX = -widthAdjust;
+ heightAdjust = offset[1];
+ oppositeCorner = [box.x + box.width, box.y];
+ axis = 3;
+ break;
+ case 'northwest':
+ heightAdjust = -offset[1];
+ adjustY = -heightAdjust;
+ widthAdjust = -offset[0];
+ adjustX = -widthAdjust;
+ oppositeCorner = [box.x + box.width, box.y + box.height];
+ axis = 3;
+ break;
}
+
+ var newBox = {
+ width: box.width + widthAdjust,
+ height: box.height + heightAdjust,
+ x: box.x + adjustX,
+ y: box.y + adjustY
+ };
+
- var cell = resolved.cell,
- row = resolved.row;
-
- if (cell) {
- return Ext.fly(cell).getXY();
+ if (newBox.width < me.minWidth || newBox.width > me.maxWidth) {
+ newBox.width = Ext.Number.constrain(newBox.width, me.minWidth, me.maxWidth);
+ newBox.x = me.lastX || newBox.x;
} else {
- return [this.el.getX(), Ext.fly(row).getY()];
+ me.lastX = newBox.x;
}
- },
-
-
- syncFocusEl : function(row, col, hscroll) {
- var xy = row;
-
- if (!Ext.isArray(xy)) {
- row = Math.min(row, Math.max(0, this.getRows().length-1));
-
- if (isNaN(row)) {
- return;
- }
-
- xy = this.getResolvedXY(this.resolveCell(row, col, hscroll));
+ if (newBox.height < me.minHeight || newBox.height > me.maxHeight) {
+ newBox.height = Ext.Number.constrain(newBox.height, me.minHeight, me.maxHeight);
+ newBox.y = me.lastY || newBox.y;
+ } else {
+ me.lastY = newBox.y;
}
-
- this.focusEl.setXY(xy || this.scroller.getXY());
- },
-
- ensureVisible : function(row, col, hscroll) {
- var resolved = this.resolveCell(row, col, hscroll);
- if (!resolved || !resolved.row) {
- return null;
- }
+ if (me.preserveRatio || e.shiftKey) {
+ var newHeight,
+ newWidth;
- var rowEl = resolved.row,
- cellEl = resolved.cell,
- c = this.scroller.dom,
- p = rowEl,
- ctop = 0,
- stop = this.el.dom;
+ ratio = me.startBox.width / me.startBox.height;
- while (p && p != stop) {
- ctop += p.offsetTop;
- p = p.offsetParent;
- }
+
+ newHeight = Math.min(Math.max(me.minHeight, newBox.width / ratio), me.maxHeight);
+ newWidth = Math.min(Math.max(me.minWidth, newBox.height * ratio), me.maxWidth);
- ctop -= this.mainHd.dom.offsetHeight;
- stop = parseInt(c.scrollTop, 10);
+
+ if (axis == 1) {
+ newBox.height = newHeight;
+ }
- var cbot = ctop + rowEl.offsetHeight,
- ch = c.clientHeight,
- sbot = stop + ch;
+
+ else if (axis == 2) {
+ newBox.width = newWidth;
+ }
+
+ else {
+
+
+ dragRatio = Math.abs(oppositeCorner[0] - this.lastXY[0]) / Math.abs(oppositeCorner[1] - this.lastXY[1]);
- if (ctop < stop) {
- c.scrollTop = ctop;
- } else if(cbot > sbot) {
- c.scrollTop = cbot-ch;
- }
+
+ if (dragRatio > ratio) {
+ newBox.height = newHeight;
+ } else {
+ newBox.width = newWidth;
+ }
- if (hscroll !== false) {
- var cleft = parseInt(cellEl.offsetLeft, 10),
- cright = cleft + cellEl.offsetWidth,
- sleft = parseInt(c.scrollLeft, 10),
- sright = sleft + c.clientWidth;
- if (cleft < sleft) {
- c.scrollLeft = cleft;
- } else if(cright > sright) {
- c.scrollLeft = cright-c.clientWidth;
+ if (region == 'northeast') {
+ newBox.y = box.y - (newBox.height - box.height);
+ } else if (region == 'northwest') {
+ newBox.y = box.y - (newBox.height - box.height);
+ newBox.x = box.x - (newBox.width - box.width);
+ } else if (region == 'southwest') {
+ newBox.x = box.x - (newBox.width - box.width);
+ }
}
}
-
- return this.getResolvedXY(resolved);
+
+ if (heightAdjust === 0) {
+ vertDir = 'none';
+ }
+ if (widthAdjust === 0) {
+ horizDir = 'none';
+ }
+ me.resize(newBox, {
+ horizontal: horizDir,
+ vertical: vertDir
+ }, atEnd);
},
-
- insertRows : function(dm, firstRow, lastRow, isUpdate) {
- var last = dm.getCount() - 1;
- if( !isUpdate && firstRow === 0 && lastRow >= last) {
- this.fireEvent('beforerowsinserted', this, firstRow, lastRow);
- this.refresh();
- this.fireEvent('rowsinserted', this, firstRow, lastRow);
- } else {
- if (!isUpdate) {
- this.fireEvent('beforerowsinserted', this, firstRow, lastRow);
- }
- var html = this.renderRows(firstRow, lastRow),
- before = this.getRow(firstRow);
- if (before) {
- if(firstRow === 0){
- Ext.fly(this.getRow(0)).removeClass(this.firstRowCls);
- }
- Ext.DomHelper.insertHtml('beforeBegin', before, html);
- } else {
- var r = this.getRow(last - 1);
- if(r){
- Ext.fly(r).removeClass(this.lastRowCls);
- }
- Ext.DomHelper.insertHtml('beforeEnd', this.mainBody.dom, html);
+ getResizeTarget: function(atEnd) {
+ return atEnd ? this.target : this.getDynamicTarget();
+ },
+
+ resize: function(box, direction, atEnd) {
+ var target = this.getResizeTarget(atEnd);
+ if (target.isComponent) {
+ if (target.floating) {
+ target.setPagePosition(box.x, box.y);
}
- if (!isUpdate) {
- this.processRows(firstRow);
- this.fireEvent('rowsinserted', this, firstRow, lastRow);
- } else if (firstRow === 0 || firstRow >= last) {
-
- Ext.fly(this.getRow(firstRow)).addClass(firstRow === 0 ? this.firstRowCls : this.lastRowCls);
+ target.setSize(box.width, box.height);
+ } else {
+ target.setBox(box);
+
+ if (this.originalTarget) {
+ this.originalTarget.setBox(box);
}
}
- this.syncFocusEl(firstRow);
},
-
- deleteRows : function(dm, firstRow, lastRow) {
- if (dm.getRowCount() < 1) {
- this.refresh();
- } else {
- this.fireEvent('beforerowsdeleted', this, firstRow, lastRow);
+ onEnd: function(e) {
+ this.updateDimensions(e, true);
+ if (this.proxy) {
+ this.proxy.hide();
+ }
+ }
+});
- this.removeRows(firstRow, lastRow);
- this.processRows(firstRow);
- this.fireEvent('rowsdeleted', this, firstRow, lastRow);
- }
+Ext.define('Ext.resizer.SplitterTracker', {
+ extend: 'Ext.dd.DragTracker',
+ requires: ['Ext.util.Region'],
+ enabled: true,
+
+ getPrevCmp: function() {
+ var splitter = this.getSplitter();
+ return splitter.previousSibling();
},
-
- getColumnStyle : function(colIndex, isHeader) {
- var colModel = this.cm,
- colConfig = colModel.config,
- style = isHeader ? '' : colConfig[colIndex].css || '',
- align = colConfig[colIndex].align;
-
- style += String.format("width: {0};", this.getColumnWidth(colIndex));
-
- if (colModel.isHidden(colIndex)) {
- style += 'display: none; ';
- }
-
- if (align) {
- style += String.format("text-align: {0};", align);
- }
-
- return style;
+ getNextCmp: function() {
+ var splitter = this.getSplitter();
+ return splitter.nextSibling();
},
- getColumnWidth : function(column) {
- var columnWidth = this.cm.getColumnWidth(column),
- borderWidth = this.borderWidth;
+
+ onBeforeStart: function(e) {
+ var prevCmp = this.getPrevCmp(),
+ nextCmp = this.getNextCmp();
+
- if (Ext.isNumber(columnWidth)) {
- if (Ext.isBorderBox || (Ext.isWebKit && !Ext.isSafari2)) {
- return columnWidth + "px";
- } else {
- return Math.max(columnWidth - borderWidth, 0) + "px";
- }
- } else {
- return columnWidth;
+ if (nextCmp.collapsed || prevCmp.collapsed) {
+ return false;
}
+
+ this.prevBox = prevCmp.getEl().getBox();
+ this.nextBox = nextCmp.getEl().getBox();
+ this.constrainTo = this.calculateConstrainRegion();
},
- getTotalWidth : function() {
- return this.cm.getTotalWidth() + 'px';
+ onStart: function(e) {
+ var splitter = this.getSplitter();
+ splitter.addCls(splitter.baseCls + '-active');
},
- fitColumns : function(preventRefresh, onlyExpand, omitColumn) {
- var grid = this.grid,
- colModel = this.cm,
- totalColWidth = colModel.getTotalWidth(false),
- gridWidth = this.getGridInnerWidth(),
- extraWidth = gridWidth - totalColWidth,
- columns = [],
- extraCol = 0,
- width = 0,
- colWidth, fraction, i;
-
-
- if (gridWidth < 20 || extraWidth === 0) {
- return false;
- }
-
- var visibleColCount = colModel.getColumnCount(true),
- totalColCount = colModel.getColumnCount(false),
- adjCount = visibleColCount - (Ext.isNumber(omitColumn) ? 1 : 0);
-
- if (adjCount === 0) {
- adjCount = 1;
- omitColumn = undefined;
- }
-
+ calculateConstrainRegion: function() {
+ var splitter = this.getSplitter(),
+ topPad = 0,
+ bottomPad = 0,
+ splitWidth = splitter.getWidth(),
+ defaultMin = splitter.defaultSplitMin,
+ orient = splitter.orientation,
+ prevBox = this.prevBox,
+ prevCmp = this.getPrevCmp(),
+ nextBox = this.nextBox,
+ nextCmp = this.getNextCmp(),
+
+
+
+ prevConstrainRegion, nextConstrainRegion;
+
- for (i = 0; i < totalColCount; i++) {
- if (!colModel.isFixed(i) && i !== omitColumn) {
- colWidth = colModel.getColumnWidth(i);
- columns.push(i, colWidth);
+ if (orient === 'vertical') {
+
+
+
+ prevConstrainRegion = Ext.create('Ext.util.Region',
+ prevBox.y,
- if (!colModel.isHidden(i)) {
- extraCol = i;
- width += colWidth;
- }
- }
- }
-
- fraction = (gridWidth - colModel.getTotalWidth()) / width;
-
- while (columns.length) {
- colWidth = columns.pop();
- i = columns.pop();
+
+ (prevCmp.maxWidth ? prevBox.x + prevCmp.maxWidth : nextBox.right - (nextCmp.minWidth || defaultMin)) + splitWidth,
+ prevBox.bottom,
+ prevBox.x + (prevCmp.minWidth || defaultMin)
+ );
- colModel.setColumnWidth(i, Math.max(grid.minColumnWidth, Math.floor(colWidth + colWidth * fraction)), true);
- }
-
-
- totalColWidth = colModel.getTotalWidth(false);
-
- if (totalColWidth > gridWidth) {
- var adjustCol = (adjCount == visibleColCount) ? extraCol : omitColumn,
- newWidth = Math.max(1, colModel.getColumnWidth(adjustCol) - (totalColWidth - gridWidth));
+ nextConstrainRegion = Ext.create('Ext.util.Region',
+ nextBox.y,
+ nextBox.right - (nextCmp.minWidth || defaultMin),
+ nextBox.bottom,
+
+
+ (nextCmp.maxWidth ? nextBox.right - nextCmp.maxWidth : prevBox.x + (prevBox.minWidth || defaultMin)) - splitWidth
+ );
+ } else {
- colModel.setColumnWidth(adjustCol, newWidth, true);
- }
-
- if (preventRefresh !== true) {
- this.updateAllColumnWidths();
+ prevConstrainRegion = Ext.create('Ext.util.Region',
+ prevBox.y + (prevCmp.minHeight || defaultMin),
+ prevBox.right,
+
+
+ (prevCmp.maxHeight ? prevBox.y + prevCmp.maxHeight : nextBox.bottom - (nextCmp.minHeight || defaultMin)) + splitWidth,
+ prevBox.x
+ );
+
+ nextConstrainRegion = Ext.create('Ext.util.Region',
+
+
+ (nextCmp.maxHeight ? nextBox.bottom - nextCmp.maxHeight : prevBox.y + (prevCmp.minHeight || defaultMin)) - splitWidth,
+ nextBox.right,
+ nextBox.bottom - (nextCmp.minHeight || defaultMin),
+ nextBox.x
+ );
}
+
- return true;
+ return prevConstrainRegion.intersect(nextConstrainRegion);
},
- autoExpand : function(preventUpdate) {
- var grid = this.grid,
- colModel = this.cm,
- gridWidth = this.getGridInnerWidth(),
- totalColumnWidth = colModel.getTotalWidth(false),
- autoExpandColumn = grid.autoExpandColumn;
+ performResize: function(e) {
+ var offset = this.getOffset('dragTarget'),
+ splitter = this.getSplitter(),
+ orient = splitter.orientation,
+ prevCmp = this.getPrevCmp(),
+ nextCmp = this.getNextCmp(),
+ owner = splitter.ownerCt,
+ layout = owner.getLayout();
+
- if (!this.userResized && autoExpandColumn) {
- if (gridWidth != totalColumnWidth) {
-
- var colIndex = colModel.getIndexById(autoExpandColumn),
- currentWidth = colModel.getColumnWidth(colIndex),
- desiredWidth = gridWidth - totalColumnWidth + currentWidth,
- newWidth = Math.min(Math.max(desiredWidth, grid.autoExpandMin), grid.autoExpandMax);
-
- if (currentWidth != newWidth) {
- colModel.setColumnWidth(colIndex, newWidth, true);
-
- if (preventUpdate !== true) {
- this.updateColumnWidth(colIndex, newWidth);
- }
+ owner.suspendLayout = true;
+
+ if (orient === 'vertical') {
+ if (prevCmp) {
+ if (!prevCmp.maintainFlex) {
+ delete prevCmp.flex;
+ prevCmp.setSize(this.prevBox.width + offset[0], prevCmp.getHeight());
+ }
+ }
+ if (nextCmp) {
+ if (!nextCmp.maintainFlex) {
+ delete nextCmp.flex;
+ nextCmp.setSize(this.nextBox.width - offset[0], nextCmp.getHeight());
+ }
+ }
+
+ } else {
+ if (prevCmp) {
+ if (!prevCmp.maintainFlex) {
+ delete prevCmp.flex;
+ prevCmp.setSize(prevCmp.getWidth(), this.prevBox.height + offset[1]);
+ }
+ }
+ if (nextCmp) {
+ if (!nextCmp.maintainFlex) {
+ delete nextCmp.flex;
+ nextCmp.setSize(prevCmp.getWidth(), this.nextBox.height - offset[1]);
}
}
}
+ delete owner.suspendLayout;
+ layout.onLayout();
},
+
+
+ onEnd: function(e) {
+ var splitter = this.getSplitter();
+ splitter.removeCls(splitter.baseCls + '-active');
+ this.performResize();
+ },
+
- getGridInnerWidth: function() {
- return this.grid.getGridEl().getWidth(true) - this.getScrollOffset();
+ onDrag: function(e) {
+ var offset = this.getOffset('dragTarget'),
+ splitter = this.getSplitter(),
+ splitEl = splitter.getEl(),
+ orient = splitter.orientation;
+
+ if (orient === "vertical") {
+ splitEl.setX(this.startRegion.left + offset[0]);
+ } else {
+ splitEl.setY(this.startRegion.top + offset[1]);
+ }
},
+ getSplitter: function() {
+ return Ext.getCmp(this.getDragCt().id);
+ }
+});
+
+Ext.define('Ext.selection.CellModel', {
+ extend: 'Ext.selection.Model',
+ alias: 'selection.cellmodel',
+ requires: ['Ext.util.KeyNav'],
- getColumnData : function() {
- var columns = [],
- colModel = this.cm,
- colCount = colModel.getColumnCount(),
- fields = this.ds.fields,
- i, name;
-
- for (i = 0; i < colCount; i++) {
- name = colModel.getDataIndex(i);
+
+ enableKeyNav: true,
+
+
+ preventWrap: false,
+
+ constructor: function(){
+ this.addEvents(
- columns[i] = {
- name : Ext.isDefined(name) ? name : (fields.get(i) ? fields.get(i).name : undefined),
- renderer: colModel.getRenderer(i),
- scope : colModel.getRendererScope(i),
- id : colModel.getColumnId(i),
- style : this.getColumnStyle(i)
- };
+ 'deselect',
+
+
+ 'select'
+ );
+ this.callParent(arguments);
+ },
+
+ bindComponent: function(view) {
+ var me = this;
+ me.primaryView = view;
+ me.views = me.views || [];
+ me.views.push(view);
+ me.bind(view.getStore(), true);
+
+ view.on({
+ cellmousedown: me.onMouseDown,
+ refresh: me.onViewRefresh,
+ scope: me
+ });
+
+ if (me.enableKeyNav) {
+ me.initKeyNav(view);
}
-
- return columns;
},
-
- renderRows : function(startRow, endRow) {
- var grid = this.grid,
- store = grid.store,
- stripe = grid.stripeRows,
- colModel = grid.colModel,
- colCount = colModel.getColumnCount(),
- rowCount = store.getCount(),
- records;
+ initKeyNav: function(view) {
+ var me = this;
- if (rowCount < 1) {
- return '';
+ if (!view.rendered) {
+ view.on('render', Ext.Function.bind(me.initKeyNav, me, [view], 0), me, {single: true});
+ return;
}
+
+ view.el.set({
+ tabIndex: -1
+ });
+
- startRow = startRow || 0;
- endRow = Ext.isDefined(endRow) ? endRow : rowCount - 1;
- records = store.getRange(startRow, endRow);
- return this.doRender(this.getColumnData(), records, store, startRow, colCount, stripe);
+ me.keyNav = Ext.create('Ext.util.KeyNav', view.el, {
+ up: me.onKeyUp,
+ down: me.onKeyDown,
+ right: me.onKeyRight,
+ left: me.onKeyLeft,
+ tab: me.onKeyTab,
+ scope: me
+ });
},
-
- renderBody : function(){
- var markup = this.renderRows() || ' ';
- return this.templates.body.apply({rows: markup});
+ getHeaderCt: function() {
+ return this.primaryView.headerCt;
+ },
+
+ onKeyUp: function(e, t) {
+ this.move('up', e);
+ },
+
+ onKeyDown: function(e, t) {
+ this.move('down', e);
},
+ onKeyLeft: function(e, t) {
+ this.move('left', e);
+ },
- refreshRow: function(record) {
- var store = this.ds,
- colCount = this.cm.getColumnCount(),
- columns = this.getColumnData(),
- last = colCount - 1,
- cls = ['x-grid3-row'],
- rowParams = {
- tstyle: String.format("width: {0};", this.getTotalWidth())
- },
- colBuffer = [],
- cellTpl = this.templates.cell,
- rowIndex, row, column, meta, css, i;
-
- if (Ext.isNumber(record)) {
- rowIndex = record;
- record = store.getAt(rowIndex);
- } else {
- rowIndex = store.indexOf(record);
- }
-
-
- if (!record || rowIndex < 0) {
- return;
- }
-
-
- for (i = 0; i < colCount; i++) {
- column = columns[i];
-
- if (i == 0) {
- css = 'x-grid3-cell-first';
- } else {
- css = (i == last) ? 'x-grid3-cell-last ' : '';
- }
-
- meta = {
- id : column.id,
- style : column.style,
- css : css,
- attr : "",
- cellAttr: ""
- };
-
- meta.value = column.renderer.call(column.scope, record.data[column.name], meta, record, rowIndex, i, store);
-
- if (Ext.isEmpty(meta.value)) {
- meta.value = ' ';
- }
-
- if (this.markDirty && record.dirty && typeof record.modified[column.name] != 'undefined') {
- meta.css += ' x-grid3-dirty-cell';
- }
-
- colBuffer[i] = cellTpl.apply(meta);
+ onKeyRight: function(e, t) {
+ this.move('right', e);
+ },
+
+ move: function(dir, e) {
+ var me = this,
+ pos = me.primaryView.walkCells(me.getCurrentPosition(), dir, e, me.preventWrap);
+ if (pos) {
+ me.setCurrentPosition(pos);
}
+ return pos;
+ },
+
+
+ getCurrentPosition: function() {
+ return this.position;
+ },
+
+
+ setCurrentPosition: function(pos) {
+ var me = this;
- row = this.getRow(rowIndex);
- row.className = '';
-
- if (this.grid.stripeRows && ((rowIndex + 1) % 2 === 0)) {
- cls.push('x-grid3-row-alt');
+ if (me.position) {
+ me.onCellDeselect(me.position);
}
-
- if (this.getRowClass) {
- rowParams.cols = colCount;
- cls.push(this.getRowClass(record, rowIndex, rowParams, store));
+ if (pos) {
+ me.onCellSelect(pos);
}
-
- this.fly(row).addClass(cls).setStyle(rowParams.tstyle);
- rowParams.cells = colBuffer.join("");
- row.innerHTML = this.templates.rowInner.apply(rowParams);
-
- this.fireEvent('rowupdated', this, rowIndex, record);
+ me.position = pos;
},
- refresh : function(headersToo) {
- this.fireEvent('beforerefresh', this);
- this.grid.stopEditing(true);
-
- var result = this.renderBody();
- this.mainBody.update(result).setWidth(this.getTotalWidth());
- if (headersToo === true) {
- this.updateHeaders();
- this.updateHeaderSortState();
- }
- this.processRows(0, true);
- this.layout();
- this.applyEmptyText();
- this.fireEvent('refresh', this);
+ onMouseDown: function(view, cell, cellIndex, record, row, rowIndex, e) {
+ this.setCurrentPosition({
+ row: rowIndex,
+ column: cellIndex
+ });
},
- applyEmptyText : function() {
- if (this.emptyText && !this.hasRows()) {
- this.mainBody.update('' + this.emptyText + '
');
- }
+
+ onCellSelect: function(position) {
+ var me = this,
+ store = me.view.getStore(),
+ record = store.getAt(position.row);
+
+ me.doSelect(record);
+ me.primaryView.onCellSelect(position);
+
+ me.primaryView.onCellFocus(position);
+ me.fireEvent('select', me, record, position.row, position.column);
},
- updateHeaderSortState : function() {
- var state = this.ds.getSortState();
- if (!state) {
- return;
- }
+
+ onCellDeselect: function(position) {
+ var me = this,
+ store = me.view.getStore(),
+ record = store.getAt(position.row);
+
+ me.doDeselect(record);
+ me.primaryView.onCellDeselect(position);
+ me.fireEvent('deselect', me, record, position.row, position.column);
+ },
+
+ onKeyTab: function(e, t) {
+ var me = this,
+ direction = e.shiftKey ? 'left' : 'right',
+ editingPlugin = me.view.editingPlugin,
+ position = me.move(direction, e);
- if (!this.sortState || (this.sortState.field != state.field || this.sortState.direction != state.direction)) {
- this.grid.fireEvent('sortchange', this.grid, state);
+ if (editingPlugin && position && me.wasEditing) {
+ editingPlugin.startEditByPosition(position);
}
+ delete me.wasEditing;
+ },
- this.sortState = state;
+ onEditorTab: function(editingPlugin, e) {
+ var me = this,
+ direction = e.shiftKey ? 'left' : 'right',
+ position = me.move(direction, e);
- var sortColumn = this.cm.findColumnIndex(state.field);
- if (sortColumn != -1) {
- var sortDir = state.direction;
- this.updateSortIcon(sortColumn, sortDir);
+ if (position) {
+ editingPlugin.startEditByPosition(position);
+ me.wasEditing = true;
}
},
-
- clearHeaderSortState : function() {
- if (!this.sortState) {
- return;
+ refresh: function() {
+ var pos = this.getCurrentPosition();
+ if (pos) {
+ this.onCellSelect(pos);
}
- 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();
+ onViewRefresh: function() {
+ var pos = this.getCurrentPosition();
+ if (pos) {
+ this.onCellDeselect(pos);
+ this.setCurrentPosition(null);
}
-
- Ext.destroyMembers(me, 'colMenu', 'hmenu');
+ },
- me.initData(null, null);
- me.purgeListeners();
-
- Ext.fly(me.innerHd).un("click", me.handleHdDown, me);
+ selectByPosition: function(position) {
+ this.setCurrentPosition(position);
+ }
+});
- 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
- );
+Ext.define('Ext.selection.RowModel', {
+ extend: 'Ext.selection.Model',
+ alias: 'selection.rowmodel',
+ requires: ['Ext.util.KeyNav'],
+
+
+ deltaScroll: 5,
+
+
+ enableKeyNav: true,
+
+ constructor: function(){
+ this.addEvents(
- if (columnDragProxy.anim) {
- Ext.destroy(columnDragProxy.anim);
- }
+ 'deselect',
- 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];
- }
+ 'select'
+ );
+ this.callParent(arguments);
+ },
- Ext.fly(me.innerHd).removeAllListeners();
- Ext.removeNode(me.innerHd);
- delete me.innerHd;
+ bindComponent: function(view) {
+ var me = this;
+
+ me.views = me.views || [];
+ me.views.push(view);
+ me.bind(view.getStore(), true);
- Ext.destroy(
- me.el,
- me.mainWrap,
- me.mainHd,
- me.scroller,
- me.mainBody,
- me.focusEl,
- me.resizeMarker,
- me.resizeProxy,
- me.activeHdBtn,
- me._flyweight,
- dragZone,
- splitZone
- );
+ view.on({
+ itemmousedown: me.onRowMouseDown,
+ scope: me
+ });
- delete grid.container;
+ if (me.enableKeyNav) {
+ me.initKeyNav(view);
+ }
+ },
- if (dragZone) {
- dragZone.destroy();
+ initKeyNav: function(view) {
+ var me = this;
+
+ if (!view.rendered) {
+ view.on('render', Ext.Function.bind(me.initKeyNav, me, [view], 0), me, {single: true});
+ return;
}
- Ext.dd.DDM.currentTarget = null;
- delete Ext.dd.DDM.locationCache[gridEl.id];
+ view.el.set({
+ tabIndex: -1
+ });
- Ext.EventManager.removeResizeListener(me.onWindowResize, me);
+
+
+ me.keyNav = new Ext.util.KeyNav(view.el, {
+ up: me.onKeyUp,
+ down: me.onKeyDown,
+ right: me.onKeyRight,
+ left: me.onKeyLeft,
+ pageDown: me.onKeyPageDown,
+ pageUp: me.onKeyPageUp,
+ home: me.onKeyHome,
+ end: me.onKeyEnd,
+ scope: me
+ });
+ view.el.on(Ext.EventManager.getKeyEvent(), me.onKeyPress, me);
},
- onDenyColumnHide : function() {
+
+
+ getRowsVisible: function() {
+ var rowsVisible = false,
+ view = this.views[0],
+ row = view.getNode(0),
+ rowHeight, gridViewHeight;
+ if (row) {
+ rowHeight = Ext.fly(row).getHeight();
+ gridViewHeight = view.el.getHeight();
+ rowsVisible = Math.floor(gridViewHeight / rowHeight);
+ }
+
+ return rowsVisible;
},
- render : function() {
- if (this.autoFill) {
- var ct = this.grid.ownerCt;
+ onKeyEnd: function(e, t) {
+ var me = this,
+ last = me.store.getAt(me.store.getCount() - 1);
- if (ct && ct.getLayout()) {
- ct.on('afterlayout', function() {
- this.fitColumns(true, true);
- this.updateHeaders();
- this.updateHeaderSortState();
- }, this, {single: true});
+ if (last) {
+ if (e.shiftKey) {
+ me.selectRange(last, me.lastFocused || 0);
+ me.setLastFocused(last);
+ } else if (e.ctrlKey) {
+ me.setLastFocused(last);
+ } else {
+ me.doSelect(last);
}
- } else if (this.forceFit) {
- this.fitColumns(true, false);
- } else if (this.grid.autoExpandColumn) {
- this.autoExpand(true);
}
-
- this.grid.getGridEl().dom.innerHTML = this.renderUI();
-
- this.afterRenderUI();
},
-
-
- initData : function(newStore, newColModel) {
- var me = this;
-
- if (me.ds) {
- var oldStore = me.ds;
-
- oldStore.un('add', me.onAdd, me);
- oldStore.un('load', me.onLoad, me);
- oldStore.un('clear', me.onClear, me);
- oldStore.un('remove', me.onRemove, me);
- oldStore.un('update', me.onUpdate, me);
- oldStore.un('datachanged', me.onDataChange, me);
+ onKeyHome: function(e, t) {
+ var me = this,
+ first = me.store.getAt(0);
- if (oldStore !== newStore && oldStore.autoDestroy) {
- oldStore.destroy();
+ if (first) {
+ if (e.shiftKey) {
+ me.selectRange(first, me.lastFocused || 0);
+ me.setLastFocused(first);
+ } else if (e.ctrlKey) {
+ me.setLastFocused(first);
+ } else {
+ me.doSelect(first, false);
}
}
-
- if (newStore) {
- newStore.on({
- scope : me,
- load : me.onLoad,
- add : me.onAdd,
- remove : me.onRemove,
- update : me.onUpdate,
- clear : me.onClear,
- datachanged: me.onDataChange
- });
- }
-
- if (me.cm) {
- var oldColModel = me.cm;
-
- oldColModel.un('configchange', me.onColConfigChange, me);
- oldColModel.un('widthchange', me.onColWidthChange, me);
- oldColModel.un('headerchange', me.onHeaderChange, me);
- oldColModel.un('hiddenchange', me.onHiddenChange, me);
- oldColModel.un('columnmoved', me.onColumnMove, me);
- }
-
- if (newColModel) {
- delete me.lastViewWidth;
-
- newColModel.on({
- scope : me,
- configchange: me.onColConfigChange,
- widthchange : me.onColWidthChange,
- headerchange: me.onHeaderChange,
- hiddenchange: me.onHiddenChange,
- columnmoved : me.onColumnMove
- });
- }
-
- me.ds = newStore;
- me.cm = newColModel;
},
- onDataChange : function(){
- this.refresh(true);
- this.updateHeaderSortState();
- this.syncFocusEl(0);
- },
+ onKeyPageUp: function(e, t) {
+ var me = this,
+ rowsVisible = me.getRowsVisible(),
+ selIdx,
+ prevIdx,
+ prevRecord,
+ currRec;
+
+ if (rowsVisible) {
+ selIdx = me.lastFocused ? me.store.indexOf(me.lastFocused) : 0;
+ prevIdx = selIdx - rowsVisible;
+ if (prevIdx < 0) {
+ prevIdx = 0;
+ }
+ prevRecord = me.store.getAt(prevIdx);
+ if (e.shiftKey) {
+ currRec = me.store.getAt(selIdx);
+ me.selectRange(prevRecord, currRec, e.ctrlKey, 'up');
+ me.setLastFocused(prevRecord);
+ } else if (e.ctrlKey) {
+ e.preventDefault();
+ me.setLastFocused(prevRecord);
+ } else {
+ me.doSelect(prevRecord);
+ }
-
- onClear : function() {
- this.refresh();
- this.syncFocusEl(0);
+ }
},
- onUpdate : function(store, record) {
- this.refreshRow(record);
+ onKeyPageDown: function(e, t) {
+ var me = this,
+ rowsVisible = me.getRowsVisible(),
+ selIdx,
+ nextIdx,
+ nextRecord,
+ currRec;
+
+ if (rowsVisible) {
+ selIdx = me.lastFocused ? me.store.indexOf(me.lastFocused) : 0;
+ nextIdx = selIdx + rowsVisible;
+ if (nextIdx >= me.store.getCount()) {
+ nextIdx = me.store.getCount() - 1;
+ }
+ nextRecord = me.store.getAt(nextIdx);
+ if (e.shiftKey) {
+ currRec = me.store.getAt(selIdx);
+ me.selectRange(nextRecord, currRec, e.ctrlKey, 'down');
+ me.setLastFocused(nextRecord);
+ } else if (e.ctrlKey) {
+
+
+ e.preventDefault();
+ me.setLastFocused(nextRecord);
+ } else {
+ me.doSelect(nextRecord);
+ }
+ }
},
- onAdd : function(store, records, index) {
- this.insertRows(store, index, index + (records.length-1));
+
+ onKeyPress: function(e, t) {
+ if (e.getKey() === e.SPACE) {
+ e.stopEvent();
+ var me = this,
+ record = me.lastFocused;
+
+ if (record) {
+ if (me.isSelected(record)) {
+ me.doDeselect(record, false);
+ } else {
+ me.doSelect(record, true);
+ }
+ }
+ }
},
- onRemove : function(store, record, index, isUpdate) {
- if (isUpdate !== true) {
- this.fireEvent('beforerowremoved', this, index, record);
+
+
+ onKeyUp: function(e, t) {
+ var me = this,
+ view = me.views[0],
+ idx = me.store.indexOf(me.lastFocused),
+ record;
+
+ if (idx > 0) {
+
+
+ record = me.store.getAt(idx - 1);
+ if (e.shiftKey && me.lastFocused) {
+ if (me.isSelected(me.lastFocused) && me.isSelected(record)) {
+ me.doDeselect(me.lastFocused, true);
+ me.setLastFocused(record);
+ } else if (!me.isSelected(me.lastFocused)) {
+ me.doSelect(me.lastFocused, true);
+ me.doSelect(record, true);
+ } else {
+ me.doSelect(record, true);
+ }
+ } else if (e.ctrlKey) {
+ me.setLastFocused(record);
+ } else {
+ me.doSelect(record);
+
+ }
}
- this.removeRow(index);
- if (isUpdate !== true) {
- this.processRows(index);
- this.applyEmptyText();
- this.fireEvent('rowremoved', this, index, record);
- }
+
+
+
+
+
},
- onLoad : function() {
- if (Ext.isGecko) {
- if (!this.scrollToTopTask) {
- this.scrollToTopTask = new Ext.util.DelayedTask(this.scrollToTop, this);
+
+
+ onKeyDown: function(e, t) {
+ var me = this,
+ view = me.views[0],
+ idx = me.store.indexOf(me.lastFocused),
+ record;
+
+
+
+ if (idx + 1 < me.store.getCount()) {
+ record = me.store.getAt(idx + 1);
+ if (me.selected.getCount() === 0) {
+ me.doSelect(record);
+
+ } else if (e.shiftKey && me.lastFocused) {
+ if (me.isSelected(me.lastFocused) && me.isSelected(record)) {
+ me.doDeselect(me.lastFocused, true);
+ me.setLastFocused(record);
+ } else if (!me.isSelected(me.lastFocused)) {
+ me.doSelect(me.lastFocused, true);
+ me.doSelect(record, true);
+ } else {
+ me.doSelect(record, true);
+ }
+ } else if (e.ctrlKey) {
+ me.setLastFocused(record);
+ } else {
+ me.doSelect(record);
+
}
- this.scrollToTopTask.delay(1);
- } else {
- this.scrollToTop();
}
},
-
- onColWidthChange : function(cm, col, width) {
- this.updateColumnWidth(col, width);
+ scrollByDeltaX: function(delta) {
+ var view = this.views[0],
+ section = view.up(),
+ hScroll = section.horizontalScroller;
+
+ if (hScroll) {
+ hScroll.scrollByDeltaX(delta);
+ }
},
-
- onHeaderChange : function(cm, col, text) {
- this.updateHeaders();
+ onKeyLeft: function(e, t) {
+ this.scrollByDeltaX(-this.deltaScroll);
},
-
- onHiddenChange : function(cm, col, hidden) {
- this.updateColumnHidden(col, hidden);
+ onKeyRight: function(e, t) {
+ this.scrollByDeltaX(this.deltaScroll);
},
- onColumnMove : function(cm, oldIndex, newIndex) {
- this.indexMap = null;
- this.refresh(true);
- this.restoreScroll(this.getScrollState());
-
- this.afterMove(newIndex);
- this.grid.fireEvent('columnmove', oldIndex, newIndex);
- },
-
- onColConfigChange : function() {
- delete this.lastViewWidth;
- this.indexMap = null;
- this.refresh(true);
+ onRowMouseDown: function(view, record, item, index, e) {
+ view.el.focus();
+ this.selectWithEvent(record, e);
},
- initUI : function(grid) {
- grid.on('headerclick', this.onHeaderClick, this);
+ onSelectChange: function(record, isSelected, suppressEvent) {
+ var me = this,
+ views = me.views,
+ viewsLn = views.length,
+ store = me.store,
+ rowIdx = store.indexOf(record),
+ i = 0;
+
+ for (; i < viewsLn; i++) {
+ if (isSelected) {
+ views[i].onRowSelect(rowIdx, suppressEvent);
+ if (!suppressEvent) {
+ me.fireEvent('select', me, record, rowIdx);
+ }
+ } else {
+ views[i].onRowDeselect(rowIdx, suppressEvent);
+ if (!suppressEvent) {
+ me.fireEvent('deselect', me, record, rowIdx);
+ }
+ }
+ }
},
- initEvents : Ext.emptyFn,
-
- onHeaderClick : function(g, index) {
- if (this.headersDisabled || !this.cm.isSortable(index)) {
- return;
+ onLastFocusChanged: function(oldFocused, newFocused, supressFocus) {
+ var views = this.views,
+ viewsLn = views.length,
+ store = this.store,
+ rowIdx,
+ i = 0;
+
+ if (oldFocused) {
+ rowIdx = store.indexOf(oldFocused);
+ if (rowIdx != -1) {
+ for (; i < viewsLn; i++) {
+ views[i].onRowFocus(rowIdx, false);
+ }
+ }
}
- g.stopEditing(true);
- g.store.sort(this.cm.getDataIndex(index));
- },
-
- onRowOver : function(e, target) {
- var row = this.findRowIndex(target);
-
- if (row !== false) {
- this.addRowClass(row, this.rowOverCls);
+ if (newFocused) {
+ rowIdx = store.indexOf(newFocused);
+ if (rowIdx != -1) {
+ for (i = 0; i < viewsLn; i++) {
+ views[i].onRowFocus(rowIdx, true, supressFocus);
+ }
+ }
}
},
-
- onRowOut : function(e, target) {
- var row = this.findRowIndex(target);
-
- if (row !== false && !e.within(this.getRow(row), true)) {
- this.removeRowClass(row, this.rowOverCls);
+ onEditorTab: function(editingPlugin, e) {
+ var me = this,
+ view = me.views[0],
+ record = editingPlugin.getActiveRecord(),
+ header = editingPlugin.getActiveColumn(),
+ position = view.getPosition(record, header),
+ direction = e.shiftKey ? 'left' : 'right',
+ newPosition = view.walkCells(position, direction, e, this.preventWrap);
+
+ if (newPosition) {
+ editingPlugin.startEditByPosition(newPosition);
}
},
+
+ selectByPosition: function(position) {
+ var record = this.store.getAt(position.row);
+ this.select(record);
+ }
+});
+
+Ext.define('Ext.selection.CheckboxModel', {
+ extend: 'Ext.selection.RowModel',
- onRowSelect : function(row) {
- this.addRowClass(row, this.selectedRowClass);
- },
+ mode: 'MULTI',
+
+
+ injectCheckbox: 0,
- onRowDeselect : function(row) {
- this.removeRowClass(row, this.selectedRowClass);
+ checkOnly: false,
+
+
+ checkerOnCls: Ext.baseCSSPrefix + 'grid-hd-checker-on',
+
+ bindComponent: function() {
+ this.sortable = false;
+ this.callParent(arguments);
+
+ var view = this.views[0],
+ headerCt = view.headerCt;
+
+ if (this.injectCheckbox !== false) {
+ if (this.injectCheckbox == 'first') {
+ this.injectCheckbox = 0;
+ } else if (this.injectCheckbox == 'last') {
+ this.injectCheckbox = headerCt.getColumnCount();
+ }
+ headerCt.add(this.injectCheckbox, this.getHeaderConfig());
+ }
+ headerCt.on('headerclick', this.onHeaderClick, this);
},
- onCellSelect : function(row, col) {
- var cell = this.getCell(row, col);
- if (cell) {
- this.fly(cell).addClass('x-grid3-cell-selected');
+ toggleUiHeader: function(isChecked) {
+ var view = this.views[0],
+ headerCt = view.headerCt,
+ checkHd = headerCt.child('gridcolumn[isCheckerHd]');
+
+ if (checkHd) {
+ if (isChecked) {
+ checkHd.el.addCls(this.checkerOnCls);
+ } else {
+ checkHd.el.removeCls(this.checkerOnCls);
+ }
}
},
- onCellDeselect : function(row, col) {
- var cell = this.getCell(row, col);
- if (cell) {
- this.fly(cell).removeClass('x-grid3-cell-selected');
+ onHeaderClick: function(headerCt, header, e) {
+ if (header.isCheckerHd) {
+ e.stopEvent();
+ var isChecked = header.el.hasCls(Ext.baseCSSPrefix + 'grid-hd-checker-on');
+ if (isChecked) {
+
+ this.deselectAll(true);
+ } else {
+
+ this.selectAll(true);
+ }
}
},
- handleWheel : function(e) {
- e.stopPropagation();
+ getHeaderConfig: function() {
+ return {
+ isCheckerHd: true,
+ text : ' ',
+ width: 24,
+ sortable: false,
+ fixed: true,
+ hideable: false,
+ menuDisabled: true,
+ dataIndex: '',
+ cls: Ext.baseCSSPrefix + 'column-header-checkbox ',
+ renderer: Ext.Function.bind(this.renderer, this)
+ };
+ },
+
+
+ renderer: function(value, metaData, record, rowIndex, colIndex, store, view) {
+ metaData.tdCls = Ext.baseCSSPrefix + 'grid-cell-special';
+ return '',
- '',
- ' ',
- ' ',
- '
'
- ),
+ useTips : true,
+
+ tipText : null,
+
+ ariaRole: 'slider',
+
- initTemplates: function() {
- Ext.grid.PivotGridView.superclass.initTemplates.apply(this, arguments);
+ initValue: function() {
+ var me = this,
+ extValue = Ext.value,
+
+ values = extValue(me.values, [extValue(me.value, extValue(me.minValue, 0))]),
+ i = 0,
+ len = values.length;
+
- var templates = this.templates || {};
- if (!templates.gcell) {
- templates.gcell = new Ext.XTemplate(
- ' {baseCls}-body-{ui} {parent.baseCls}-body-{parent.ui}-{.} " style="{bodyStyle}" >
',
+ ' {baseCls}-strip-{ui} {parent.baseCls}-strip-{parent.ui}-{.} ">
'
+ ],
- getRendererScope : function(col) {
- return this.config[col].scope;
- },
+
+ minTabWidth: 30,
- setRenderer : function(col, fn) {
- this.config[col].renderer = fn;
- },
+ maxTabWidth: undefined,
- getColumnWidth : function(col) {
- var width = this.config[col].width;
- if(typeof width != 'number'){
- width = this.defaultWidth;
+ initComponent: function() {
+ var me = this,
+ keys;
+
+ if (me.plain) {
+ me.setUI(me.ui + '-plain');
}
- return width;
- },
+
+ me.addClsWithUI(me.dock);
+
+ me.addEvents(
+
+ 'change'
+ );
+
+ Ext.applyIf(this.renderSelectors, {
+ body : '.' + this.baseCls + '-body',
+ strip: '.' + this.baseCls + '-strip'
+ });
+ me.callParent(arguments);
-
- setColumnWidth : function(col, width, suppressEvent) {
- this.config[col].width = width;
- this.totalWidth = null;
- if (!suppressEvent) {
- this.fireEvent("widthchange", this, col, width);
- }
+ me.layout.align = (me.orientation == 'vertical') ? 'left' : 'top';
+ me.layout.overflowHandler = Ext.create('Ext.layout.container.boxOverflow.Scroller', me.layout);
+ me.items.removeAt(me.items.getCount() - 1);
+ me.items.removeAt(me.items.getCount() - 1);
+
+
+ keys = me.orientation == 'vertical' ? ['up', 'down'] : ['left', 'right'];
+ Ext.FocusManager.subscribe(me, {
+ keys: keys
+ });
},
- 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);
- }
- }
+ onAdd: function(tab) {
+ var me = this,
+ tabPanel = me.tabPanel,
+ hasOwner = !!tabPanel;
+
+ me.callParent(arguments);
+ tab.position = me.dock;
+ if (hasOwner) {
+ tab.minWidth = tabPanel.minTabWidth;
+ }
+ else {
+ tab.minWidth = me.minTabWidth + (tab.iconCls ? 25 : 0);
}
- return this.totalWidth;
+ tab.maxWidth = me.maxTabWidth || (hasOwner ? tabPanel.maxTabWidth : undefined);
},
- getColumnHeader : function(col) {
- return this.config[col].header;
- },
+ afterRender: function() {
+ var me = this;
-
- setColumnHeader : function(col, header) {
- this.config[col].header = header;
- this.fireEvent("headerchange", this, col, header);
+ me.mon(me.el, {
+ scope: me,
+ click: me.onClick,
+ delegate: '.' + Ext.baseCSSPrefix + 'tab'
+ });
+ me.callParent(arguments);
+
},
-
- getColumnTooltip : function(col) {
- return this.config[col].tooltip;
- },
-
- setColumnTooltip : function(col, tooltip) {
- this.config[col].tooltip = tooltip;
+ afterComponentLayout : function() {
+ var me = this;
+
+ me.callParent(arguments);
+ me.strip.setWidth(me.el.getWidth());
},
- getDataIndex : function(col) {
- return this.config[col].dataIndex;
- },
+ onClick: function(e, target) {
+
+ var tab = Ext.getCmp(target.id),
+ tabPanel = this.tabPanel;
-
- setDataIndex : function(col, dataIndex) {
- this.config[col].dataIndex = dataIndex;
- },
+ target = e.getTarget();
-
- findColumnIndex : function(dataIndex) {
- var c = this.config;
- for(var i = 0, len = c.length; i < len; i++){
- if(c[i].dataIndex == dataIndex){
- return i;
+ if (tab && tab.isDisabled && !tab.isDisabled()) {
+ if (tab.closable && target === tab.closeEl.dom) {
+ tab.onCloseClick();
+ } else {
+ this.setActiveTab(tab);
+ if (tabPanel) {
+ tabPanel.setActiveTab(tab.card);
+ }
+ tab.focus();
}
}
- return -1;
},
- isCellEditable : function(colIndex, rowIndex) {
- var c = this.config[colIndex],
- ed = c.editable;
+ closeTab: function(tab) {
+ var card = tab.card,
+ tabPanel = this.tabPanel,
+ nextTab;
+
+ if (tab.active && this.items.getCount() > 1) {
+ nextTab = tab.next('tab') || this.items.items[0];
+ this.setActiveTab(nextTab);
+ if (tabPanel) {
+ tabPanel.setActiveTab(nextTab.card);
+ }
+ }
+ this.remove(tab);
+ if (tabPanel && card) {
+ tabPanel.remove(card);
+ }
- return !!(ed || (!Ext.isDefined(ed) && c.editor));
+ if (nextTab) {
+ nextTab.focus();
+ }
},
- getCellEditor : function(colIndex, rowIndex) {
- return this.config[colIndex].getCellEditor(rowIndex);
- },
+ setActiveTab: function(tab) {
+ if (tab.disabled) {
+ return;
+ }
+ var me = this;
+ if (me.activeTab) {
+ me.activeTab.deactivate();
+ }
+ tab.activate();
+
+ if (me.rendered) {
+ me.layout.layout();
+ tab.el.scrollIntoView(me.layout.getRenderTarget());
+ }
+ me.activeTab = tab;
+ me.fireEvent('change', me, tab, tab.card);
+ }
+});
+
+Ext.define('Ext.tab.Panel', {
+ extend: 'Ext.panel.Panel',
+ alias: 'widget.tabpanel',
+ alternateClassName: ['Ext.TabPanel'],
+
+ requires: ['Ext.layout.container.Card', 'Ext.tab.Bar'],
- setEditable : function(col, editable) {
- this.config[col].editable = editable;
- },
+ tabPosition : 'top',
+
+
- isHidden : function(colIndex) {
- return !!this.config[colIndex].hidden;
- },
- isFixed : function(colIndex) {
- return !!this.config[colIndex].fixed;
- },
+ removePanelHeader: true,
- isResizable : function(colIndex) {
- return colIndex >= 0 && this.config[colIndex].resizable !== false && this.config[colIndex].fixed !== true;
- },
+ plain: false,
+
+ itemCls: 'x-tabpanel-child',
+
- setHidden : function(colIndex, hidden) {
- var c = this.config[colIndex];
- if(c.hidden !== hidden){
- c.hidden = hidden;
- this.totalWidth = null;
- this.fireEvent("hiddenchange", this, colIndex, hidden);
- }
- },
- setEditor : function(col, editor) {
- this.config[col].setEditor(editor);
- },
+ deferredRender : true,
- destroy : function() {
- var length = this.config.length,
- i = 0;
+ initComponent: function() {
+ var me = this,
+ dockedItems = me.dockedItems || [],
+ activeTab = me.activeTab || 0;
+
+ me.layout = Ext.create('Ext.layout.container.Card', Ext.apply({
+ owner: me,
+ deferredRender: me.deferredRender,
+ itemCls: me.itemCls
+ }, me.layout));
+
+
+ me.tabBar = Ext.create('Ext.tab.Bar', Ext.apply({}, me.tabBar, {
+ dock: me.tabPosition,
+ plain: me.plain,
+ border: me.border,
+ cardLayout: me.layout,
+ tabPanel: me
+ }));
- for (; i < length; i++){
- this.config[i].destroy();
+ if (dockedItems && !Ext.isArray(dockedItems)) {
+ dockedItems = [dockedItems];
}
- delete this.config;
- delete this.lookup;
- this.purgeListeners();
- },
-
- setState : function(col, state) {
- state = Ext.applyIf(state, this.defaults);
- Ext.apply(this.config[col], state);
- }
-});
+ dockedItems.push(me.tabBar);
+ me.dockedItems = dockedItems;
+ me.addEvents(
+
+ 'beforetabchange',
-Ext.grid.ColumnModel.defaultRenderer = function(value) {
- if (typeof value == "string" && value.length < 1) {
- return " ";
- }
- return value;
-};
-Ext.grid.AbstractSelectionModel = Ext.extend(Ext.util.Observable, {
-
+
+ 'tabchange'
+ );
+ me.callParent(arguments);
- constructor : function(){
- this.locked = false;
- Ext.grid.AbstractSelectionModel.superclass.constructor.call(this);
+
+ me.setActiveTab(activeTab);
+
+ me.on('afterlayout', me.afterInitialLayout, me, {single: true});
},
- init : function(grid){
- this.grid = grid;
- if(this.lockOnInit){
- delete this.lockOnInit;
- this.locked = false;
- this.lock();
+ afterInitialLayout: function() {
+ var me = this,
+ card = me.getComponent(me.activeTab);
+
+ if (card) {
+ me.layout.setActiveItem(card);
}
- this.initEvents();
},
- lock : function(){
- if(!this.locked){
- this.locked = true;
+ setActiveTab: function(card) {
+ var me = this,
+ previous;
+
+ card = me.getComponent(card);
+ if (card) {
+ previous = me.getActiveTab();
- var g = this.grid;
- if(g){
- g.getView().on({
- scope: this,
- beforerefresh: this.sortUnLock,
- refresh: this.sortLock
- });
- }else{
- this.lockOnInit = true;
+ if (previous && previous !== card && me.fireEvent('beforetabchange', me, card, previous) === false) {
+ return false;
+ }
+
+ me.tabBar.setActiveTab(card.tab);
+ me.activeTab = card;
+ if (me.rendered) {
+ me.layout.setActiveItem(card);
+ }
+
+ if (previous && previous !== card) {
+ me.fireEvent('tabchange', me, card, previous);
}
}
},
- sortLock : function() {
- this.locked = true;
+ getActiveTab: function() {
+ return this.activeTab;
},
- sortUnLock : function() {
- this.locked = false;
+ getTabBar: function() {
+ return this.tabBar;
},
- unlock : function(){
- if(this.locked){
- this.locked = false;
- var g = this.grid,
- gv;
-
-
- if(g){
- gv = g.getView();
- gv.un('beforerefresh', this.sortUnLock, this);
- gv.un('refresh', this.sortLock, this);
- }else{
- delete this.lockOnInit;
+ onAdd: function(item, index) {
+ var me = this;
+
+ item.tab = me.tabBar.insert(index, {
+ xtype: 'tab',
+ card: item,
+ disabled: item.disabled,
+ closable: item.closable,
+ hidden: item.hidden,
+ tabBar: me.tabBar
+ });
+
+ item.on({
+ scope : me,
+ enable: me.onItemEnable,
+ disable: me.onItemDisable,
+ beforeshow: me.onItemBeforeShow,
+ iconchange: me.onItemIconChange,
+ titlechange: me.onItemTitleChange
+ });
+
+ if (item.isPanel) {
+ if (me.removePanelHeader) {
+ item.preventHeader = true;
+ if (item.rendered) {
+ item.updateHeader();
+ }
+ }
+ if (item.isPanel && me.border) {
+ item.setBorder(false);
}
}
- },
+
+ if (this.rendered && me.items.getCount() === 1) {
+ me.setActiveTab(0);
+ }
+ },
- isLocked : function(){
- return this.locked;
+
+ onItemEnable: function(item){
+ item.tab.enable();
},
- destroy: function(){
- this.unlock();
- this.purgeListeners();
- }
-});
-Ext.grid.RowSelectionModel = Ext.extend(Ext.grid.AbstractSelectionModel, {
+
+ onItemDisable: function(item){
+ item.tab.disable();
+ },
- singleSelect : false,
- constructor : function(config){
- Ext.apply(this, config);
- this.selections = new Ext.util.MixedCollection(false, function(o){
- return o.id;
- });
-
- this.last = false;
- this.lastActive = false;
-
- this.addEvents(
-
- 'selectionchange',
-
- 'beforerowselect',
-
- 'rowselect',
-
- 'rowdeselect'
- );
- Ext.grid.RowSelectionModel.superclass.constructor.call(this);
+ onItemBeforeShow: function(item) {
+ if (item !== this.activeTab) {
+ this.setActiveTab(item);
+ return false;
+ }
},
-
- initEvents : function(){
-
- if(!this.grid.enableDragDrop && !this.grid.enableDrag){
- this.grid.on('rowmousedown', this.handleMouseDown, this);
- }
-
- this.rowNav = new Ext.KeyNav(this.grid.getGridEl(), {
- up: this.onKeyPress,
- down: this.onKeyPress,
- scope: this
- });
-
- this.grid.getView().on({
- scope: this,
- refresh: this.onRefresh,
- rowupdated: this.onRowUpdated,
- rowremoved: this.onRemove
- });
+ onItemIconChange: function(item, newIconCls) {
+ item.tab.setIconCls(newIconCls);
+ this.getTabBar().doLayout();
},
- onKeyPress : function(e, name){
- var up = name == 'up',
- method = up ? 'selectPrevious' : 'selectNext',
- add = up ? -1 : 1,
- last;
- if(!e.shiftKey || this.singleSelect){
- this[method](false);
- }else if(this.last !== false && this.lastActive !== false){
- last = this.last;
- this.selectRange(this.last, this.lastActive + add);
- this.grid.getView().focusRow(this.lastActive);
- if(last !== false){
- this.last = last;
- }
- }else{
- this.selectFirstRow();
- }
+
+ onItemTitleChange: function(item, newTitle) {
+ item.tab.setText(newTitle);
+ this.getTabBar().doLayout();
},
+
- onRefresh : function(){
- var ds = this.grid.store,
- s = this.getSelections(),
- i = 0,
- len = s.length,
- index, r;
+ doRemove: function(item, autoDestroy) {
+ var me = this,
+ items = me.items,
- this.silent = true;
- this.clearSelections(true);
- for(; i < len; i++){
- r = s[i];
- if((index = ds.indexOfId(r.id)) != -1){
- this.selectRow(index, true);
- }
- }
- if(s.length != this.selections.getCount()){
- this.fireEvent('selectionchange', this);
+ hasItemsLeft = items.getCount() > 1;
+
+ if (me.destroying || !hasItemsLeft) {
+ me.activeTab = null;
+ } else if (item === me.activeTab) {
+ me.setActiveTab(item.next() || items.getAt(0));
}
- this.silent = false;
+ me.callParent(arguments);
+
+
+ delete item.tab.card;
+ delete item.tab;
},
- onRemove : function(v, index, r){
- if(this.selections.remove(r) !== false){
- this.fireEvent('selectionchange', this);
+ onRemove: function(item, autoDestroy) {
+ var me = this;
+
+ item.un({
+ scope : me,
+ enable: me.onItemEnable,
+ disable: me.onItemDisable,
+ beforeshow: me.onItemBeforeShow
+ });
+ if (!me.destroying && item.tab.ownerCt == me.tabBar) {
+ me.tabBar.remove(item.tab);
}
+ }
+});
+
+
+Ext.define('Ext.toolbar.Spacer', {
+ extend: 'Ext.Component',
+ alias: 'widget.tbspacer',
+ alternateClassName: 'Ext.Toolbar.Spacer',
+ baseCls: Ext.baseCSSPrefix + 'toolbar-spacer',
+ focusable: false
+});
+
+Ext.define('Ext.tree.Column', {
+ extend: 'Ext.grid.column.Column',
+ alias: 'widget.treecolumn',
+
+ initComponent: function() {
+ var origRenderer = this.renderer || this.defaultRenderer,
+ origScope = this.scope || window;
+
+ this.renderer = function(value, metaData, record, rowIdx, colIdx, store, view) {
+ var buf = [],
+ format = Ext.String.format,
+ depth = record.getDepth(),
+ treePrefix = Ext.baseCSSPrefix + 'tree-',
+ elbowPrefix = treePrefix + 'elbow-',
+ expanderCls = treePrefix + 'expander',
+ imgText = '',
+ '',
+ thHtml,
+ '
',
+ '
',
+ '',
- '',
- '
';
+ if (me.enableDrop) {
+ me.dropZone = Ext.create('Ext.tree.ViewDropZone', {
+ view: view,
+ ddGroup: me.dropGroup || me.ddGroup,
+ allowContainerDrops: me.allowContainerDrops,
+ appendOnly: me.appendOnly,
+ allowParentInserts: me.allowParentInserts,
+ expandDelay: me.expandDelay,
+ dropHighlightColor: me.nodeHighlightColor,
+ dropHighlight: me.nodeHighlightOnDrop
+ });
}
- },
+ }
+});
+Ext.define('Ext.util.Cookies', {
+ singleton: true,
- findGroup : function(el){
- return Ext.fly(el).up('.x-grid-group', this.mainBody.dom);
- },
-
- getGroups : function(){
- return this.hasRows() ? this.mainBody.dom.childNodes : [];
+ set : function(name, value){
+ var argv = arguments,
+ argc = arguments.length,
+ expires = (argc > 2) ? argv[2] : null,
+ path = (argc > 3) ? argv[3] : '/',
+ domain = (argc > 4) ? argv[4] : null,
+ secure = (argc > 5) ? argv[5] : false;
+
+ document.cookie = name + "=" + escape(value) + ((expires === null) ? "" : ("; expires=" + expires.toGMTString())) + ((path === null) ? "" : ("; path=" + path)) + ((domain === null) ? "" : ("; domain=" + domain)) + ((secure === true) ? "; secure" : "");
},
- 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);
+ get : function(name){
+ var arg = name + "=",
+ alen = arg.length,
+ clen = document.cookie.length,
+ i = 0,
+ j = 0;
+
+ while(i < clen){
+ j = i + alen;
+ if(document.cookie.substring(i, j) == arg){
+ return this.getCookieVal(j);
+ }
+ i = document.cookie.indexOf(" ", i) + 1;
+ if(i === 0){
+ break;
+ }
}
+ return null;
},
- 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);
+ clear : function(name, path){
+ if(this.get(name)){
+ path = path || '/';
+ document.cookie = name + '=' + '; expires=Thu, 01-Jan-70 00:00:01 GMT; path=' + path;
}
- 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);
+ getCookieVal : function(offset){
+ var endstr = document.cookie.indexOf(";", offset);
+ if(endstr == -1){
+ endstr = document.cookie.length;
}
- },
+ return unescape(document.cookie.substring(offset, endstr));
+ }
+});
-
- 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
- });
+Ext.define('Ext.util.CSS', function() {
+ var rules = null;
+ var doc = document;
+
+ var camelRe = /(-[a-z])/gi;
+ var camelFn = function(m, a){ return a.charAt(1).toUpperCase(); };
+
+ return {
+
+ singleton: true,
+
+ constructor: function() {
+ this.rules = {};
+ this.initialized = false;
+ },
+
+
+ createStyleSheet : function(cssText, id) {
+ var ss,
+ head = doc.getElementsByTagName("head")[0],
+ styleEl = doc.createElement("style");
+
+ styleEl.setAttribute("type", "text/css");
+ if (id) {
+ styleEl.setAttribute("id", id);
}
- 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');
+ if (Ext.isIE) {
+ head.appendChild(styleEl);
+ ss = styleEl.styleSheet;
+ ss.cssText = cssText;
+ } else {
+ try{
+ styleEl.appendChild(doc.createTextNode(cssText));
+ } catch(e) {
+ styleEl.cssText = cssText;
+ }
+ head.appendChild(styleEl);
+ ss = styleEl.styleSheet ? styleEl.styleSheet : (styleEl.sheet || doc.styleSheets[doc.styleSheets.length-1]);
+ }
+ this.cacheStyleSheet(ss);
+ return ss;
+ },
-
- groupValue = groupValue.substr(0, groupValue.length - 3);
-
-
- if(groupValue || emptyRe.test(hd.id)){
- this.grid.fireEvent('group' + name, this.grid, field, groupValue, e);
+
+ removeStyleSheet : function(id) {
+ var existing = document.getElementById(id);
+ if (existing) {
+ existing.parentNode.removeChild(existing);
+ }
+ },
+
+
+ swapStyleSheet : function(id, url) {
+ var doc = document;
+ this.removeStyleSheet(id);
+ var ss = doc.createElement("link");
+ ss.setAttribute("rel", "stylesheet");
+ ss.setAttribute("type", "text/css");
+ ss.setAttribute("id", id);
+ ss.setAttribute("href", url);
+ doc.getElementsByTagName("head")[0].appendChild(ss);
+ },
+
+
+ refreshCache : function() {
+ return this.getRules(true);
+ },
+
+
+ cacheStyleSheet : function(ss) {
+ if(!rules){
+ rules = {};
+ }
+ try {
+ var ssRules = ss.cssRules || ss.rules,
+ selectorText,
+ i = ssRules.length - 1,
+ j,
+ selectors;
+
+ for (; i >= 0; --i) {
+ selectorText = ssRules[i].selectorText;
+ if (selectorText) {
+
+
+ selectorText = selectorText.split(',');
+ selectors = selectorText.length;
+ for (j = 0; j < selectors; j++) {
+ rules[Ext.String.trim(selectorText[j]).toLowerCase()] = ssRules[i];
+ }
+ }
+ }
+ } catch(e) {}
+ },
+
+
+ getRules : function(refreshCache) {
+ if (rules === null || refreshCache) {
+ rules = {};
+ var ds = doc.styleSheets,
+ i = 0,
+ len = ds.length;
+
+ for (; i < len; i++) {
+ try {
+ if (!ds[i].disabled) {
+ this.cacheStyleSheet(ds[i]);
+ }
+ } catch(e) {}
+ }
}
- if(name == 'mousedown' && e.button == 0){
- this.toggleGroup(hd.parentNode);
+ return rules;
+ },
+
+
+ getRule: function(selector, refreshCache) {
+ var rs = this.getRules(refreshCache);
+ if (!Ext.isArray(selector)) {
+ return rs[selector.toLowerCase()];
+ }
+ for (var i = 0; i < selector.length; i++) {
+ if (rs[selector[i]]) {
+ return rs[selector[i].toLowerCase()];
+ }
+ }
+ return null;
+ },
+
+
+ updateRule : function(selector, property, value){
+ if (!Ext.isArray(selector)) {
+ var rule = this.getRule(selector);
+ if (rule) {
+ rule.style[property.replace(camelRe, camelFn)] = value;
+ return true;
+ }
+ } else {
+ for (var i = 0; i < selector.length; i++) {
+ if (this.updateRule(selector[i], property, value)) {
+ return true;
+ }
+ }
}
+ return false;
}
+ };
+}());
+Ext.define('Ext.util.History', {
+ singleton: true,
+ alternateClassName: 'Ext.History',
+ mixins: {
+ observable: 'Ext.util.Observable'
},
-
- 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();
+ constructor: function() {
+ var me = this;
+ me.oldIEMode = Ext.isIE6 || Ext.isIE7 || !Ext.isStrict && Ext.isIE8;
+ me.iframe = null;
+ me.hiddenField = null;
+ me.ready = false;
+ me.currentToken = null;
},
-
- onShowGroupsClick : function(mi, checked){
- this.enableGrouping = checked;
- if(checked){
- this.onGroupByClick();
- }else{
- this.grid.store.clearGrouping();
- this.grid.fireEvent('groupchange', this, null);
- }
+ getHash: function() {
+ var href = window.location.href,
+ i = href.indexOf("#");
+
+ return i >= 0 ? href.substr(i + 1) : null;
},
-
- toggleRowIndex : function(rowIndex, expanded){
- if(!this.canGroup()){
- return;
- }
- var row = this.getRow(rowIndex);
- if(row){
- this.toggleGroup(this.findGroup(row), expanded);
- }
+ doSave: function() {
+ this.hiddenField.value = this.currentToken;
},
-
- 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');
- }
+
+ handleStateChange: function(token) {
+ this.currentToken = token;
+ this.fireEvent('change', token);
},
-
- toggleAllGroups : function(expanded){
- var groups = this.getGroups();
- for(var i = 0, len = groups.length; i < len; i++){
- this.toggleGroup(groups[i], expanded);
+ updateIFrame: function(token) {
+ var html = '', this.groupTextTpl ,'
'
- );
+ if (me.enableDrag) {
+ me.dragZone = Ext.create('Ext.tree.ViewDragZone', {
+ view: view,
+ ddGroup: me.dragGroup || me.ddGroup,
+ dragText: me.dragText,
+ repairHighlightColor: me.nodeHighlightColor,
+ repairHighlight: me.nodeHighlightOnRepair
+ });
}
- this.startGroup.compile();
- if (!this.endGroup) {
- this.endGroup = '
' +
+ Ext.util.Format.htmlEncode(token) +
+ '
';
+
+ try {
+ var doc = this.iframe.contentWindow.document;
+ doc.open();
+ doc.write(html);
+ doc.close();
+ return true;
+ } catch (e) {
+ return false;
}
},
-
- expandAllGroups : function(){
- this.toggleAllGroups(true);
+ checkIFrame: function () {
+ var me = this,
+ contentWindow = me.iframe.contentWindow;
+
+ if (!contentWindow || !contentWindow.document) {
+ Ext.Function.defer(this.checkIFrame, 10, this);
+ return;
+ }
+
+ var doc = contentWindow.document,
+ elem = doc.getElementById("state"),
+ oldToken = elem ? elem.innerText : null,
+ oldHash = me.getHash();
+
+ Ext.TaskManager.start({
+ run: function () {
+ var doc = contentWindow.document,
+ elem = doc.getElementById("state"),
+ newToken = elem ? elem.innerText : null,
+ newHash = me.getHash();
+
+ if (newToken !== oldToken) {
+ oldToken = newToken;
+ me.handleStateChange(newToken);
+ window.top.location.hash = newToken;
+ oldHash = newToken;
+ me.doSave();
+ } else if (newHash !== oldHash) {
+ oldHash = newHash;
+ me.updateIFrame(newHash);
+ }
+ },
+ interval: 50,
+ scope: me
+ });
+ me.ready = true;
+ me.fireEvent('ready', me);
},
-
- collapseAllGroups : function(){
- this.toggleAllGroups(false);
- },
+ startUp: function () {
+ var me = this;
+
+ me.currentToken = me.hiddenField.value || this.getHash();
-
- 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;
+ if (me.oldIEMode) {
+ me.checkIFrame();
+ } else {
+ var hash = me.getHash();
+ Ext.TaskManager.start({
+ run: function () {
+ var newHash = me.getHash();
+ if (newHash !== hash) {
+ hash = newHash;
+ me.handleStateChange(hash);
+ me.doSave();
+ }
+ },
+ interval: 50,
+ scope: me
+ });
+ me.ready = true;
+ me.fireEvent('ready', me);
}
- return g;
+
},
- getGroupField : function(){
- return this.grid.store.getGroupState();
- },
+ fieldId: Ext.baseCSSPrefix + 'history-field',
+
+ iframeId: Ext.baseCSSPrefix + 'history-frame',
- afterRender : function(){
- if(!this.ds || !this.cm){
+ init: function (onReady, scope) {
+ var me = this;
+
+ if (me.ready) {
+ Ext.callback(onReady, scope, [me]);
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 (!Ext.isReady) {
+ Ext.onReady(function() {
+ me.init(onReady, scope);
});
+ return;
+ }
+
+ me.hiddenField = Ext.getDom(me.fieldId);
+
+ if (me.oldIEMode) {
+ me.iframe = Ext.getDom(me.iframeId);
+ }
+
+ me.addEvents(
- if (this.enableNoGroups) {
- this.hmenu.add({
- itemId:'showGroups',
- text: this.showGroupsText,
- checked: true,
- checkHandler: this.onShowGroupsClick,
- scope: this
- });
- }
+ 'ready',
- this.hmenu.on('beforeshow', this.beforeMenuShow, this);
+ 'change'
+ );
+
+ if (onReady) {
+ me.on('ready', onReady, scope, {single: true});
}
+ me.startUp();
},
- renderRows : function(){
- var groupField = this.getGroupField();
- var eg = !!groupField;
+ add: function (token, preventDup) {
+ var me = this;
- 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);
+ if (preventDup !== false) {
+ if (me.getToken() === token) {
+ return true;
}
}
- return Ext.grid.GroupingView.superclass.renderRows.apply(
- this, arguments);
+
+ if (me.oldIEMode) {
+ return me.updateIFrame(token);
+ } else {
+ window.top.location.hash = token;
+ return true;
+ }
},
- 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);
-
-
- this.state[gid] = !(Ext.isDefined(this.state[gid]) ? !this.state[gid] : this.startCollapsed);
- curGroup = {
- group: g,
- gvalue: gvalue,
- text: prefix + g,
- groupId: gid,
- startRow: rowIndex,
- rs: [r],
- cls: this.state[gid] ? '' : 'x-grid-group-collapsed',
- style: gstyle
- };
- groups.push(curGroup);
- }else{
- curGroup.rs.push(r);
- }
- r._groupId = gid;
- }
-
- var buf = [];
- for(i = 0, len = groups.length; i < len; i++){
- g = groups[i];
- this.doGroupStart(buf, g, cs, ds, colCount);
- buf[buf.length] = Ext.grid.GroupingView.superclass.doRender.call(
- this, cs, g.rs, ds, g.startRow, colCount, stripe);
-
- this.doGroupEnd(buf, g, cs, ds, colCount);
- }
- return buf.join('');
+ back: function() {
+ window.history.go(-1);
},
- getGroupId : function(value){
- var field = this.getGroupField();
- return this.constructId(value, field, this.cm.findColumnIndex(field));
+ forward: function(){
+ window.history.go(1);
},
- constructId : function(value, field, idx){
- var cfg = this.cm.config[idx],
- groupRenderer = cfg.groupRenderer || cfg.renderer,
- val = (this.groupMode == 'value') ? value : this.getGroup(value, {data:{}}, groupRenderer, 0, idx, this.ds);
+ getToken: function() {
+ return this.ready ? this.currentToken : this.getHash();
+ }
+});
- return this.getPrefix(field) + Ext.util.Format.htmlEncode(val);
- },
+Ext.define('Ext.view.TableChunker', {
+ singleton: true,
+ requires: ['Ext.XTemplate'],
+ metaTableTpl: [
+ '{[this.openTableWrap()]}',
+ '| ', + ' |
|---|
{{id}}