ext-all-debug.js
上传用户:shuoshiled
上传日期:2018-01-28
资源大小:10124k
文件大小:2341k
源码类别:

中间件编程

开发平台:

JavaScript

  1.         opacity: {to: .3, from: 1},
  2.         height: {to: 50, from: el.getHeight()},
  3.         width: {to: 300, from: el.getWidth()},
  4.         top  : {by: - 100, unit: 'px'},
  5.         points: {
  6.             to: [50, 100],  // go to this point
  7.             control: [      // optional bezier way points
  8.                 [ 600, 800],
  9.                 [-100, 200]
  10.             ]
  11.         }
  12.     },
  13.     3000,      // animation duration (milliseconds!)
  14.     null,      // callback
  15.     'easeOut', // easing method
  16.     'motion'   // animation type ('run','color','motion','scroll')    
  17. );
  18.          * </code></pre> 
  19.          * </li>
  20.          * <li><tt>'scroll'</tt>
  21.          * <p>Animate horizontal or vertical scrolling of an overflowing page element.</p>
  22.          * <pre><code>
  23. el.animate(
  24.     // animation control object
  25.     {
  26.         scroll: {to: [400, 300]}
  27.     },
  28.     0.35,      // animation duration
  29.     null,      // callback
  30.     'easeOut', // easing method
  31.     'scroll'   // animation type ('run','color','motion','scroll')    
  32. );
  33.          * </code></pre> 
  34.          * </li>
  35.          * </ul></div>
  36.          * 
  37.          * </ul></div>
  38.          * 
  39.          * @param {Object} args The animation control args
  40.          * @param {Float} duration (optional) How long the animation lasts in seconds (defaults to <tt>.35</tt>)
  41.          * @param {Function} onComplete (optional) Function to call when animation completes
  42.          * @param {String} easing (optional) {@link Ext.Fx#easing} method to use (defaults to <tt>'easeOut'</tt>)
  43.          * @param {String} animType (optional) <tt>'run'</tt> is the default. Can also be <tt>'color'</tt>,
  44.          * <tt>'motion'</tt>, or <tt>'scroll'</tt>
  45.          * @return {Ext.Element} this
  46.          */
  47.         animate : function(args, duration, onComplete, easing, animType){       
  48.             this.anim(args, {duration: duration, callback: onComplete, easing: easing}, animType);
  49.             return this;
  50.         },
  51.     
  52.         /*
  53.          * @private Internal animation call
  54.          */
  55.         anim : function(args, opt, animType, defaultDur, defaultEase, cb){
  56.             animType = animType || 'run';
  57.             opt = opt || {};
  58.             var me = this,              
  59.                 anim = Ext.lib.Anim[animType](
  60.                     me.dom, 
  61.                     args,
  62.                     (opt.duration || defaultDur) || .35,
  63.                     (opt.easing || defaultEase) || 'easeOut',
  64.                     function(){
  65.                         if(cb) cb.call(me);
  66.                         if(opt.callback) opt.callback.call(opt.scope || me, me, opt);
  67.                     },
  68.                     me
  69.                 );
  70.             opt.anim = anim;
  71.             return anim;
  72.         },
  73.     
  74.         // private legacy anim prep
  75.         preanim : function(a, i){
  76.             return !a[i] ? false : (Ext.isObject(a[i]) ? a[i]: {duration: a[i+1], callback: a[i+2], easing: a[i+3]});
  77.         },
  78.         
  79.         /**
  80.          * Checks whether the element is currently visible using both visibility and display properties.         
  81.          * @return {Boolean} True if the element is currently visible, else false
  82.          */
  83.         isVisible : function() {
  84.             return !this.isStyle(VISIBILITY, HIDDEN) && !this.isStyle(DISPLAY, NONE);
  85.         },
  86.         
  87.         /**
  88.          * Sets the visibility of the element (see details). If the visibilityMode is set to Element.DISPLAY, it will use
  89.          * the display property to hide the element, otherwise it uses visibility. The default is to hide and show using the visibility property.
  90.          * @param {Boolean} visible Whether the element is visible
  91.          * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
  92.          * @return {Ext.Element} this
  93.          */
  94.          setVisible : function(visible, animate){
  95.             var me = this,
  96.                 dom = me.dom,
  97.                 isDisplay = getVisMode(this.dom) == ELDISPLAY;
  98.                 
  99.             if (!animate || !me.anim) {
  100.                 if(isDisplay){
  101.                     me.setDisplayed(visible);
  102.                 }else{
  103.                     me.fixDisplay();
  104.                     dom.style.visibility = visible ? "visible" : HIDDEN;
  105.                 }
  106.             }else{
  107.                 // closure for composites            
  108.                 if(visible){
  109.                     me.setOpacity(.01);
  110.                     me.setVisible(true);
  111.                 }
  112.                 me.anim({opacity: { to: (visible?1:0) }},
  113.                         me.preanim(arguments, 1),
  114.                         null,
  115.                         .35,
  116.                         'easeIn',
  117.                         function(){
  118.                              if(!visible){
  119.                                  dom.style[isDisplay ? DISPLAY : VISIBILITY] = (isDisplay) ? NONE : HIDDEN;                     
  120.                                  Ext.fly(dom).setOpacity(1);
  121.                              }
  122.                         });
  123.             }
  124.             return me;
  125.         },
  126.     
  127.         /**
  128.          * Toggles the element's visibility or display, depending on visibility mode.
  129.          * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
  130.          * @return {Ext.Element} this
  131.          */
  132.         toggle : function(animate){
  133.             var me = this;
  134.             me.setVisible(!me.isVisible(), me.preanim(arguments, 0));
  135.             return me;
  136.         },
  137.     
  138.         /**
  139.          * Sets the CSS display property. Uses originalDisplay if the specified value is a boolean true.
  140.          * @param {Mixed} value Boolean value to display the element using its default display, or a string to set the display directly.
  141.          * @return {Ext.Element} this
  142.          */
  143.         setDisplayed : function(value) {            
  144.             if(typeof value == "boolean"){
  145.                value = value ? getDisplay(this.dom) : NONE;
  146.             }
  147.             this.setStyle(DISPLAY, value);
  148.             return this;
  149.         },
  150.         
  151.         // private
  152.         fixDisplay : function(){
  153.             var me = this;
  154.             if(me.isStyle(DISPLAY, NONE)){
  155.                 me.setStyle(VISIBILITY, HIDDEN);
  156.                 me.setStyle(DISPLAY, getDisplay(this.dom)); // first try reverting to default
  157.                 if(me.isStyle(DISPLAY, NONE)){ // if that fails, default to block
  158.                     me.setStyle(DISPLAY, "block");
  159.                 }
  160.             }
  161.         },
  162.     
  163.         /**
  164.          * Hide this element - Uses display mode to determine whether to use "display" or "visibility". See {@link #setVisible}.
  165.          * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
  166.          * @return {Ext.Element} this
  167.          */
  168.         hide : function(animate){
  169.             this.setVisible(false, this.preanim(arguments, 0));
  170.             return this;
  171.         },
  172.     
  173.         /**
  174.         * Show this element - Uses display mode to determine whether to use "display" or "visibility". See {@link #setVisible}.
  175.         * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
  176.          * @return {Ext.Element} this
  177.          */
  178.         show : function(animate){
  179.             this.setVisible(true, this.preanim(arguments, 0));
  180.             return this;
  181.         }
  182.     }
  183. }());/**
  184.  * @class Ext.Element
  185.  */
  186. Ext.Element.addMethods(
  187. function(){
  188.     var VISIBILITY = "visibility",
  189.         DISPLAY = "display",
  190.         HIDDEN = "hidden",
  191.         NONE = "none",
  192.     XMASKED = "x-masked",
  193. XMASKEDRELATIVE = "x-masked-relative",
  194.         data = Ext.Element.data;
  195. return {
  196. /**
  197.      * Checks whether the element is currently visible using both visibility and display properties.
  198.      * @param {Boolean} deep (optional) True to walk the dom and see if parent elements are hidden (defaults to false)
  199.      * @return {Boolean} True if the element is currently visible, else false
  200.      */
  201.     isVisible : function(deep) {
  202.         var vis = !this.isStyle(VISIBILITY,HIDDEN) && !this.isStyle(DISPLAY,NONE),
  203.          p = this.dom.parentNode;
  204.         if(deep !== true || !vis){
  205.             return vis;
  206.         }         
  207.         while(p && !/body/i.test(p.tagName)){
  208.             if(!Ext.fly(p, '_isVisible').isVisible()){
  209.                 return false;
  210.             }
  211.             p = p.parentNode;
  212.         }
  213.         return true;
  214.     },
  215.     
  216.     /**
  217.      * Returns true if display is not "none"
  218.      * @return {Boolean}
  219.      */
  220.     isDisplayed : function() {
  221.         return !this.isStyle(DISPLAY, NONE);
  222.     },
  223.     
  224. /**
  225.      * Convenience method for setVisibilityMode(Element.DISPLAY)
  226.      * @param {String} display (optional) What to set display to when visible
  227.      * @return {Ext.Element} this
  228.      */
  229.     enableDisplayMode : function(display){     
  230.         this.setVisibilityMode(Ext.Element.DISPLAY);
  231.         if(!Ext.isEmpty(display)){
  232.                 data(this.dom, 'originalDisplay', display);
  233.             }
  234.         return this;
  235.     },
  236.     
  237. /**
  238.      * Puts a mask over this element to disable user interaction. Requires core.css.
  239.      * This method can only be applied to elements which accept child nodes.
  240.      * @param {String} msg (optional) A message to display in the mask
  241.      * @param {String} msgCls (optional) A css class to apply to the msg element
  242.      * @return {Element} The mask element
  243.      */
  244.     mask : function(msg, msgCls){
  245.     var me = this,
  246.      dom = me.dom,
  247.      dh = Ext.DomHelper,
  248.      EXTELMASKMSG = "ext-el-mask-msg",
  249.                 el, 
  250.                 mask;
  251.     
  252.         if(me.getStyle("position") == "static"){
  253.             me.addClass(XMASKEDRELATIVE);
  254.         }
  255.         if((el = data(dom, 'maskMsg'))){
  256.             el.remove();
  257.         }
  258.         if((el = data(dom, 'mask'))){
  259.             el.remove();
  260.         }
  261.             mask = dh.append(dom, {cls : "ext-el-mask"}, true);
  262.         data(dom, 'mask', mask);
  263.         me.addClass(XMASKED);
  264.         mask.setDisplayed(true);
  265.         if(typeof msg == 'string'){
  266.                 var mm = dh.append(dom, {cls : EXTELMASKMSG, cn:{tag:'div'}}, true);
  267.                 data(dom, 'maskMsg', mm);
  268.             mm.dom.className = msgCls ? EXTELMASKMSG + " " + msgCls : EXTELMASKMSG;
  269.             mm.dom.firstChild.innerHTML = msg;
  270.             mm.setDisplayed(true);
  271.             mm.center(me);
  272.         }
  273.         if(Ext.isIE && !(Ext.isIE7 && Ext.isStrict) && me.getStyle('height') == 'auto'){ // ie will not expand full height automatically
  274.             mask.setSize(undefined, me.getHeight());
  275.         }
  276.         return mask;
  277.     },
  278.     /**
  279.      * Removes a previously applied mask.
  280.      */
  281.     unmask : function(){
  282.     var me = this,
  283.                 dom = me.dom,
  284.      mask = data(dom, 'mask'),
  285.      maskMsg = data(dom, 'maskMsg');
  286.         if(mask){
  287.             if(maskMsg){
  288.                 maskMsg.remove();
  289.                     data(dom, 'maskMsg', undefined);
  290.             }
  291.             mask.remove();
  292.                 data(dom, 'mask', undefined);
  293.         }
  294.         me.removeClass([XMASKED, XMASKEDRELATIVE]);
  295.     },
  296.     /**
  297.      * Returns true if this element is masked
  298.      * @return {Boolean}
  299.      */
  300.     isMasked : function(){
  301.             var m = data(this.dom, 'mask');
  302.         return m && m.isVisible();
  303.     },
  304.     
  305.     /**
  306.      * Creates an iframe shim for this element to keep selects and other windowed objects from
  307.      * showing through.
  308.      * @return {Ext.Element} The new shim element
  309.      */
  310.     createShim : function(){
  311.         var el = document.createElement('iframe'),        
  312.          shim;
  313.         el.frameBorder = '0';
  314.         el.className = 'ext-shim';
  315.         if(Ext.isIE && Ext.isSecure){
  316.             el.src = Ext.SSL_SECURE_URL;
  317.         }
  318.         shim = Ext.get(this.dom.parentNode.insertBefore(el, this.dom));
  319.         shim.autoBoxAdjust = false;
  320.         return shim;
  321.     }
  322.     };
  323. }());/**
  324.  * @class Ext.Element
  325.  */
  326. Ext.Element.addMethods({
  327.     /**
  328.      * Convenience method for constructing a KeyMap
  329.      * @param {Number/Array/Object/String} key Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options:
  330.      *                                  {key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}
  331.      * @param {Function} fn The function to call
  332.      * @param {Object} scope (optional) The scope of the function
  333.      * @return {Ext.KeyMap} The KeyMap created
  334.      */
  335.     addKeyListener : function(key, fn, scope){
  336.         var config;
  337.         if(!Ext.isObject(key) || Ext.isArray(key)){
  338.             config = {
  339.                 key: key,
  340.                 fn: fn,
  341.                 scope: scope
  342.             };
  343.         }else{
  344.             config = {
  345.                 key : key.key,
  346.                 shift : key.shift,
  347.                 ctrl : key.ctrl,
  348.                 alt : key.alt,
  349.                 fn: fn,
  350.                 scope: scope
  351.             };
  352.         }
  353.         return new Ext.KeyMap(this, config);
  354.     },
  355.     /**
  356.      * Creates a KeyMap for this element
  357.      * @param {Object} config The KeyMap config. See {@link Ext.KeyMap} for more details
  358.      * @return {Ext.KeyMap} The KeyMap created
  359.      */
  360.     addKeyMap : function(config){
  361.         return new Ext.KeyMap(this, config);
  362.     }
  363. });(function(){
  364.     // contants
  365.     var NULL = null,
  366.         UNDEFINED = undefined,
  367.         TRUE = true,
  368.         FALSE = false,
  369.         SETX = "setX",
  370.         SETY = "setY",
  371.         SETXY = "setXY",
  372.         LEFT = "left",
  373.         BOTTOM = "bottom",
  374.         TOP = "top",
  375.         RIGHT = "right",
  376.         HEIGHT = "height",
  377.         WIDTH = "width",
  378.         POINTS = "points",
  379.         HIDDEN = "hidden",
  380.         ABSOLUTE = "absolute",
  381.         VISIBLE = "visible",
  382.         MOTION = "motion",
  383.         POSITION = "position",
  384.         EASEOUT = "easeOut",
  385.         /*
  386.          * Use a light flyweight here since we are using so many callbacks and are always assured a DOM element
  387.          */
  388.         flyEl = new Ext.Element.Flyweight(),
  389.         queues = {},
  390.         getObject = function(o){
  391.             return o || {};
  392.         },
  393.         fly = function(dom){
  394.             flyEl.dom = dom;
  395.             flyEl.id = Ext.id(dom);
  396.             return flyEl;
  397.         },
  398.         /*
  399.          * Queueing now stored outside of the element due to closure issues
  400.          */
  401.         getQueue = function(id){
  402.             if(!queues[id]){
  403.                 queues[id] = [];
  404.             }
  405.             return queues[id];
  406.         },
  407.         setQueue = function(id, value){
  408.             queues[id] = value;
  409.         };
  410.         
  411. //Notifies Element that fx methods are available
  412. Ext.enableFx = TRUE;
  413. /**
  414.  * @class Ext.Fx
  415.  * <p>A class to provide basic animation and visual effects support.  <b>Note:</b> This class is automatically applied
  416.  * to the {@link Ext.Element} interface when included, so all effects calls should be performed via {@link Ext.Element}.
  417.  * Conversely, since the effects are not actually defined in {@link Ext.Element}, Ext.Fx <b>must</b> be
  418.  * {@link Ext#enableFx included} in order for the Element effects to work.</p><br/>
  419.  * 
  420.  * <p><b><u>Method Chaining</u></b></p>
  421.  * <p>It is important to note that although the Fx methods and many non-Fx Element methods support "method chaining" in that
  422.  * they return the Element object itself as the method return value, it is not always possible to mix the two in a single
  423.  * method chain.  The Fx methods use an internal effects queue so that each effect can be properly timed and sequenced.
  424.  * Non-Fx methods, on the other hand, have no such internal queueing and will always execute immediately.  For this reason,
  425.  * while it may be possible to mix certain Fx and non-Fx method calls in a single chain, it may not always provide the
  426.  * expected results and should be done with care.  Also see <tt>{@link #callback}</tt>.</p><br/>
  427.  *
  428.  * <p><b><u>Anchor Options for Motion Effects</u></b></p>
  429.  * <p>Motion effects support 8-way anchoring, meaning that you can choose one of 8 different anchor points on the Element
  430.  * that will serve as either the start or end point of the animation.  Following are all of the supported anchor positions:</p>
  431. <pre>
  432. Value  Description
  433. -----  -----------------------------
  434. tl     The top left corner
  435. t      The center of the top edge
  436. tr     The top right corner
  437. l      The center of the left edge
  438. r      The center of the right edge
  439. bl     The bottom left corner
  440. b      The center of the bottom edge
  441. br     The bottom right corner
  442. </pre>
  443.  * <b>Note</b>: some Fx methods accept specific custom config parameters.  The options shown in the Config Options
  444.  * section below are common options that can be passed to any Fx method unless otherwise noted.</b>
  445.  * 
  446.  * @cfg {Function} callback A function called when the effect is finished.  Note that effects are queued internally by the
  447.  * Fx class, so a callback is not required to specify another effect -- effects can simply be chained together
  448.  * and called in sequence (see note for <b><u>Method Chaining</u></b> above), for example:<pre><code>
  449.  * el.slideIn().highlight();
  450.  * </code></pre>
  451.  * The callback is intended for any additional code that should run once a particular effect has completed. The Element
  452.  * being operated upon is passed as the first parameter.
  453.  * 
  454.  * @cfg {Object} scope The scope of the <tt>{@link #callback}</tt> function
  455.  * 
  456.  * @cfg {String} easing A valid Ext.lib.Easing value for the effect:</p><div class="mdetail-params"><ul>
  457.  * <li><b><tt>backBoth</tt></b></li>
  458.  * <li><b><tt>backIn</tt></b></li>
  459.  * <li><b><tt>backOut</tt></b></li>
  460.  * <li><b><tt>bounceBoth</tt></b></li>
  461.  * <li><b><tt>bounceIn</tt></b></li>
  462.  * <li><b><tt>bounceOut</tt></b></li>
  463.  * <li><b><tt>easeBoth</tt></b></li>
  464.  * <li><b><tt>easeBothStrong</tt></b></li>
  465.  * <li><b><tt>easeIn</tt></b></li>
  466.  * <li><b><tt>easeInStrong</tt></b></li>
  467.  * <li><b><tt>easeNone</tt></b></li>
  468.  * <li><b><tt>easeOut</tt></b></li>
  469.  * <li><b><tt>easeOutStrong</tt></b></li>
  470.  * <li><b><tt>elasticBoth</tt></b></li>
  471.  * <li><b><tt>elasticIn</tt></b></li>
  472.  * <li><b><tt>elasticOut</tt></b></li>
  473.  * </ul></div>
  474.  *
  475.  * @cfg {String} afterCls A css class to apply after the effect
  476.  * @cfg {Number} duration The length of time (in seconds) that the effect should last
  477.  * 
  478.  * @cfg {Number} endOpacity Only applicable for {@link #fadeIn} or {@link #fadeOut}, a number between
  479.  * <tt>0</tt> and <tt>1</tt> inclusive to configure the ending opacity value.
  480.  *  
  481.  * @cfg {Boolean} remove Whether the Element should be removed from the DOM and destroyed after the effect finishes
  482.  * @cfg {Boolean} useDisplay Whether to use the <i>display</i> CSS property instead of <i>visibility</i> when hiding Elements (only applies to 
  483.  * effects that end with the element being visually hidden, ignored otherwise)
  484.  * @cfg {String/Object/Function} afterStyle A style specification string, e.g. <tt>"width:100px"</tt>, or an object
  485.  * in the form <tt>{width:"100px"}</tt>, or a function which returns such a specification that will be applied to the
  486.  * Element after the effect finishes.
  487.  * @cfg {Boolean} block Whether the effect should block other effects from queueing while it runs
  488.  * @cfg {Boolean} concurrent Whether to allow subsequently-queued effects to run at the same time as the current effect, or to ensure that they run in sequence
  489.  * @cfg {Boolean} stopFx Whether preceding effects should be stopped and removed before running current effect (only applies to non blocking effects)
  490.  */
  491. Ext.Fx = {
  492.     
  493.     // private - calls the function taking arguments from the argHash based on the key.  Returns the return value of the function.
  494.     //           this is useful for replacing switch statements (for example).
  495.     switchStatements : function(key, fn, argHash){
  496.         return fn.apply(this, argHash[key]);
  497.     },
  498.     
  499.     /**
  500.      * Slides the element into view.  An anchor point can be optionally passed to set the point of
  501.      * origin for the slide effect.  This function automatically handles wrapping the element with
  502.      * a fixed-size container if needed.  See the Fx class overview for valid anchor point options.
  503.      * Usage:
  504.      *<pre><code>
  505. // default: slide the element in from the top
  506. el.slideIn();
  507. // custom: slide the element in from the right with a 2-second duration
  508. el.slideIn('r', { duration: 2 });
  509. // common config options shown with default values
  510. el.slideIn('t', {
  511.     easing: 'easeOut',
  512.     duration: .5
  513. });
  514. </code></pre>
  515.      * @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to top: 't')
  516.      * @param {Object} options (optional) Object literal with any of the Fx config options
  517.      * @return {Ext.Element} The Element
  518.      */
  519.     slideIn : function(anchor, o){ 
  520.         o = getObject(o);
  521.         var me = this,
  522.             dom = me.dom,
  523.             st = dom.style,
  524.             xy,
  525.             r,
  526.             b,              
  527.             wrap,               
  528.             after,
  529.             st,
  530.             args, 
  531.             pt,
  532.             bw,
  533.             bh;
  534.             
  535.         anchor = anchor || "t";
  536.         me.queueFx(o, function(){            
  537.             xy = fly(dom).getXY();
  538.             // fix display to visibility
  539.             fly(dom).fixDisplay();            
  540.             
  541.             // restore values after effect
  542.             r = fly(dom).getFxRestore();      
  543.             b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
  544.             b.right = b.x + b.width;
  545.             b.bottom = b.y + b.height;
  546.             
  547.             // fixed size for slide
  548.             fly(dom).setWidth(b.width).setHeight(b.height);            
  549.             
  550.             // wrap if needed
  551.             wrap = fly(dom).fxWrap(r.pos, o, HIDDEN);
  552.             
  553.             st.visibility = VISIBLE;
  554.             st.position = ABSOLUTE;
  555.             
  556.             // clear out temp styles after slide and unwrap
  557.             function after(){
  558.                  fly(dom).fxUnwrap(wrap, r.pos, o);
  559.                  st.width = r.width;
  560.                  st.height = r.height;
  561.                  fly(dom).afterFx(o);
  562.             }
  563.             
  564.             // time to calculate the positions        
  565.             pt = {to: [b.x, b.y]}; 
  566.             bw = {to: b.width};
  567.             bh = {to: b.height};
  568.                 
  569.             function argCalc(wrap, style, ww, wh, sXY, sXYval, s1, s2, w, h, p){                    
  570.                 var ret = {};
  571.                 fly(wrap).setWidth(ww).setHeight(wh);
  572.                 if(fly(wrap)[sXY]){
  573.                     fly(wrap)[sXY](sXYval);                  
  574.                 }
  575.                 style[s1] = style[s2] = "0";                    
  576.                 if(w){
  577.                     ret.width = w
  578.                 };
  579.                 if(h){
  580.                     ret.height = h;
  581.                 }
  582.                 if(p){
  583.                     ret.points = p;
  584.                 }
  585.                 return ret;
  586.             };
  587.             args = fly(dom).switchStatements(anchor.toLowerCase(), argCalc, {
  588.                     t  : [wrap, st, b.width, 0, NULL, NULL, LEFT, BOTTOM, NULL, bh, NULL],
  589.                     l  : [wrap, st, 0, b.height, NULL, NULL, RIGHT, TOP, bw, NULL, NULL],
  590.                     r  : [wrap, st, b.width, b.height, SETX, b.right, LEFT, TOP, NULL, NULL, pt],
  591.                     b  : [wrap, st, b.width, b.height, SETY, b.bottom, LEFT, TOP, NULL, bh, pt],
  592.                     tl : [wrap, st, 0, 0, NULL, NULL, RIGHT, BOTTOM, bw, bh, pt],
  593.                     bl : [wrap, st, 0, 0, SETY, b.y + b.height, RIGHT, TOP, bw, bh, pt],
  594.                     br : [wrap, st, 0, 0, SETXY, [b.right, b.bottom], LEFT, TOP, bw, bh, pt],
  595.                     tr : [wrap, st, 0, 0, SETX, b.x + b.width, LEFT, BOTTOM, bw, bh, pt]
  596.                 });
  597.             
  598.             st.visibility = VISIBLE;
  599.             fly(wrap).show();
  600.             arguments.callee.anim = fly(wrap).fxanim(args,
  601.                 o,
  602.                 MOTION,
  603.                 .5,
  604.                 EASEOUT, 
  605.                 after);
  606.         });
  607.         return me;
  608.     },
  609.     
  610.     /**
  611.      * Slides the element out of view.  An anchor point can be optionally passed to set the end point
  612.      * for the slide effect.  When the effect is completed, the element will be hidden (visibility = 
  613.      * 'hidden') but block elements will still take up space in the document.  The element must be removed
  614.      * from the DOM using the 'remove' config option if desired.  This function automatically handles 
  615.      * wrapping the element with a fixed-size container if needed.  See the Fx class overview for valid anchor point options.
  616.      * Usage:
  617.      *<pre><code>
  618. // default: slide the element out to the top
  619. el.slideOut();
  620. // custom: slide the element out to the right with a 2-second duration
  621. el.slideOut('r', { duration: 2 });
  622. // common config options shown with default values
  623. el.slideOut('t', {
  624.     easing: 'easeOut',
  625.     duration: .5,
  626.     remove: false,
  627.     useDisplay: false
  628. });
  629. </code></pre>
  630.      * @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to top: 't')
  631.      * @param {Object} options (optional) Object literal with any of the Fx config options
  632.      * @return {Ext.Element} The Element
  633.      */
  634.     slideOut : function(anchor, o){
  635.         o = getObject(o);
  636.         var me = this,
  637.             dom = me.dom,
  638.             st = dom.style,
  639.             xy = me.getXY(),
  640.             wrap,
  641.             r,
  642.             b,
  643.             a,
  644.             zero = {to: 0}; 
  645.                     
  646.         anchor = anchor || "t";
  647.         me.queueFx(o, function(){
  648.             
  649.             // restore values after effect
  650.             r = fly(dom).getFxRestore(); 
  651.             b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
  652.             b.right = b.x + b.width;
  653.             b.bottom = b.y + b.height;
  654.                 
  655.             // fixed size for slide   
  656.             fly(dom).setWidth(b.width).setHeight(b.height);
  657.             // wrap if needed
  658.             wrap = fly(dom).fxWrap(r.pos, o, VISIBLE);
  659.                 
  660.             st.visibility = VISIBLE;
  661.             st.position = ABSOLUTE;
  662.             fly(wrap).setWidth(b.width).setHeight(b.height);            
  663.             function after(){
  664.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();                
  665.                 fly(dom).fxUnwrap(wrap, r.pos, o);
  666.                 st.width = r.width;
  667.                 st.height = r.height;
  668.                 fly(dom).afterFx(o);
  669.             }            
  670.             
  671.             function argCalc(style, s1, s2, p1, v1, p2, v2, p3, v3){                    
  672.                 var ret = {};
  673.                 
  674.                 style[s1] = style[s2] = "0";
  675.                 ret[p1] = v1;               
  676.                 if(p2){
  677.                     ret[p2] = v2;               
  678.                 }
  679.                 if(p3){
  680.                     ret[p3] = v3;
  681.                 }
  682.                 
  683.                 return ret;
  684.             };
  685.             
  686.             a = fly(dom).switchStatements(anchor.toLowerCase(), argCalc, {
  687.                 t  : [st, LEFT, BOTTOM, HEIGHT, zero],
  688.                 l  : [st, RIGHT, TOP, WIDTH, zero],
  689.                 r  : [st, LEFT, TOP, WIDTH, zero, POINTS, {to : [b.right, b.y]}],
  690.                 b  : [st, LEFT, TOP, HEIGHT, zero, POINTS, {to : [b.x, b.bottom]}],
  691.                 tl : [st, RIGHT, BOTTOM, WIDTH, zero, HEIGHT, zero],
  692.                 bl : [st, RIGHT, TOP, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.x, b.bottom]}],
  693.                 br : [st, LEFT, TOP, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.x + b.width, b.bottom]}],
  694.                 tr : [st, LEFT, BOTTOM, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.right, b.y]}]
  695.             });
  696.             
  697.             arguments.callee.anim = fly(wrap).fxanim(a,
  698.                 o,
  699.                 MOTION,
  700.                 .5,
  701.                 EASEOUT, 
  702.                 after);
  703.         });
  704.         return me;
  705.     },
  706.     /**
  707.      * Fades the element out while slowly expanding it in all directions.  When the effect is completed, the 
  708.      * element will be hidden (visibility = 'hidden') but block elements will still take up space in the document. 
  709.      * The element must be removed from the DOM using the 'remove' config option if desired.
  710.      * Usage:
  711.      *<pre><code>
  712. // default
  713. el.puff();
  714. // common config options shown with default values
  715. el.puff({
  716.     easing: 'easeOut',
  717.     duration: .5,
  718.     remove: false,
  719.     useDisplay: false
  720. });
  721. </code></pre>
  722.      * @param {Object} options (optional) Object literal with any of the Fx config options
  723.      * @return {Ext.Element} The Element
  724.      */
  725.     puff : function(o){
  726.         o = getObject(o);
  727.         var me = this,
  728.             dom = me.dom,
  729.             st = dom.style,
  730.             width,
  731.             height,
  732.             r;
  733.         me.queueFx(o, function(){
  734.             width = fly(dom).getWidth();
  735.             height = fly(dom).getHeight();
  736.             fly(dom).clearOpacity();
  737.             fly(dom).show();
  738.             // restore values after effect
  739.             r = fly(dom).getFxRestore();                   
  740.             
  741.             function after(){
  742.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();                  
  743.                 fly(dom).clearOpacity();  
  744.                 fly(dom).setPositioning(r.pos);
  745.                 st.width = r.width;
  746.                 st.height = r.height;
  747.                 st.fontSize = '';
  748.                 fly(dom).afterFx(o);
  749.             }   
  750.             arguments.callee.anim = fly(dom).fxanim({
  751.                     width : {to : fly(dom).adjustWidth(width * 2)},
  752.                     height : {to : fly(dom).adjustHeight(height * 2)},
  753.                     points : {by : [-width * .5, -height * .5]},
  754.                     opacity : {to : 0},
  755.                     fontSize: {to : 200, unit: "%"}
  756.                 },
  757.                 o,
  758.                 MOTION,
  759.                 .5,
  760.                 EASEOUT,
  761.                  after);
  762.         });
  763.         return me;
  764.     },
  765.     /**
  766.      * Blinks the element as if it was clicked and then collapses on its center (similar to switching off a television).
  767.      * When the effect is completed, the element will be hidden (visibility = 'hidden') but block elements will still 
  768.      * take up space in the document. The element must be removed from the DOM using the 'remove' config option if desired.
  769.      * Usage:
  770.      *<pre><code>
  771. // default
  772. el.switchOff();
  773. // all config options shown with default values
  774. el.switchOff({
  775.     easing: 'easeIn',
  776.     duration: .3,
  777.     remove: false,
  778.     useDisplay: false
  779. });
  780. </code></pre>
  781.      * @param {Object} options (optional) Object literal with any of the Fx config options
  782.      * @return {Ext.Element} The Element
  783.      */
  784.     switchOff : function(o){
  785.         o = getObject(o);
  786.         var me = this,
  787.             dom = me.dom,
  788.             st = dom.style,
  789.             r;
  790.         me.queueFx(o, function(){
  791.             fly(dom).clearOpacity();
  792.             fly(dom).clip();
  793.             // restore values after effect
  794.             r = fly(dom).getFxRestore();
  795.                 
  796.             function after(){
  797.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();  
  798.                 fly(dom).clearOpacity();
  799.                 fly(dom).setPositioning(r.pos);
  800.                 st.width = r.width;
  801.                 st.height = r.height;   
  802.                 fly(dom).afterFx(o);
  803.             };
  804.             fly(dom).fxanim({opacity : {to : 0.3}}, 
  805.                 NULL, 
  806.                 NULL, 
  807.                 .1, 
  808.                 NULL, 
  809.                 function(){                                 
  810.                     fly(dom).clearOpacity();
  811.                         (function(){                            
  812.                             fly(dom).fxanim({
  813.                                 height : {to : 1},
  814.                                 points : {by : [0, fly(dom).getHeight() * .5]}
  815.                             }, 
  816.                             o, 
  817.                             MOTION, 
  818.                             0.3, 
  819.                             'easeIn', 
  820.                             after);
  821.                         }).defer(100);
  822.                 });
  823.         });
  824.         return me;
  825.     },
  826.     /**
  827.      * Highlights the Element by setting a color (applies to the background-color by default, but can be
  828.      * changed using the "attr" config option) and then fading back to the original color. If no original
  829.      * color is available, you should provide the "endColor" config option which will be cleared after the animation.
  830.      * Usage:
  831. <pre><code>
  832. // default: highlight background to yellow
  833. el.highlight();
  834. // custom: highlight foreground text to blue for 2 seconds
  835. el.highlight("0000ff", { attr: 'color', duration: 2 });
  836. // common config options shown with default values
  837. el.highlight("ffff9c", {
  838.     attr: "background-color", //can be any valid CSS property (attribute) that supports a color value
  839.     endColor: (current color) or "ffffff",
  840.     easing: 'easeIn',
  841.     duration: 1
  842. });
  843. </code></pre>
  844.      * @param {String} color (optional) The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c')
  845.      * @param {Object} options (optional) Object literal with any of the Fx config options
  846.      * @return {Ext.Element} The Element
  847.      */ 
  848.     highlight : function(color, o){
  849.         o = getObject(o);
  850.         var me = this,
  851.             dom = me.dom,
  852.             attr = o.attr || "backgroundColor",
  853.             a = {},
  854.             restore;
  855.         me.queueFx(o, function(){
  856.             fly(dom).clearOpacity();
  857.             fly(dom).show();
  858.             function after(){
  859.                 dom.style[attr] = restore;
  860.                 fly(dom).afterFx(o);
  861.             }            
  862.             restore = dom.style[attr];
  863.             a[attr] = {from: color || "ffff9c", to: o.endColor || fly(dom).getColor(attr) || "ffffff"};
  864.             arguments.callee.anim = fly(dom).fxanim(a,
  865.                 o,
  866.                 'color',
  867.                 1,
  868.                 'easeIn', 
  869.                 after);
  870.         });
  871.         return me;
  872.     },
  873.    /**
  874.     * Shows a ripple of exploding, attenuating borders to draw attention to an Element.
  875.     * Usage:
  876. <pre><code>
  877. // default: a single light blue ripple
  878. el.frame();
  879. // custom: 3 red ripples lasting 3 seconds total
  880. el.frame("ff0000", 3, { duration: 3 });
  881. // common config options shown with default values
  882. el.frame("C3DAF9", 1, {
  883.     duration: 1 //duration of each individual ripple.
  884.     // Note: Easing is not configurable and will be ignored if included
  885. });
  886. </code></pre>
  887.     * @param {String} color (optional) The color of the border.  Should be a 6 char hex color without the leading # (defaults to light blue: 'C3DAF9').
  888.     * @param {Number} count (optional) The number of ripples to display (defaults to 1)
  889.     * @param {Object} options (optional) Object literal with any of the Fx config options
  890.     * @return {Ext.Element} The Element
  891.     */
  892.     frame : function(color, count, o){
  893.         o = getObject(o);
  894.         var me = this,
  895.             dom = me.dom,
  896.             proxy,
  897.             active;
  898.         me.queueFx(o, function(){
  899.             color = color || "#C3DAF9"
  900.             if(color.length == 6){
  901.                 color = "#" + color;
  902.             }            
  903.             count = count || 1;
  904.             fly(dom).show();
  905.             var xy = fly(dom).getXY(),
  906.                 b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight},
  907.                 queue = function(){
  908.                     proxy = fly(document.body || document.documentElement).createChild({
  909.                         style:{
  910.                             visbility: HIDDEN,
  911.                             position : ABSOLUTE,
  912.                             "z-index": 35000, // yee haw
  913.                             border : "0px solid " + color
  914.                         }
  915.                     });
  916.                     return proxy.queueFx({}, animFn);
  917.                 };
  918.             
  919.             
  920.             arguments.callee.anim = {
  921.                 isAnimated: true,
  922.                 stop: function() {
  923.                     count = 0;
  924.                     proxy.stopFx();
  925.                 }
  926.             };
  927.             
  928.             function animFn(){
  929.                 var scale = Ext.isBorderBox ? 2 : 1;
  930.                 active = proxy.anim({
  931.                     top : {from : b.y, to : b.y - 20},
  932.                     left : {from : b.x, to : b.x - 20},
  933.                     borderWidth : {from : 0, to : 10},
  934.                     opacity : {from : 1, to : 0},
  935.                     height : {from : b.height, to : b.height + 20 * scale},
  936.                     width : {from : b.width, to : b.width + 20 * scale}
  937.                 },{
  938.                     duration: o.duration || 1,
  939.                     callback: function() {
  940.                         proxy.remove();
  941.                         --count > 0 ? queue() : fly(dom).afterFx(o);
  942.                     }
  943.                 });
  944.                 arguments.callee.anim = {
  945.                     isAnimated: true,
  946.                     stop: function(){
  947.                         active.stop();
  948.                     }
  949.                 };
  950.             };
  951.             queue();
  952.         });
  953.         return me;
  954.     },
  955.    /**
  956.     * Creates a pause before any subsequent queued effects begin.  If there are
  957.     * no effects queued after the pause it will have no effect.
  958.     * Usage:
  959. <pre><code>
  960. el.pause(1);
  961. </code></pre>
  962.     * @param {Number} seconds The length of time to pause (in seconds)
  963.     * @return {Ext.Element} The Element
  964.     */
  965.     pause : function(seconds){        
  966.         var dom = this.dom,
  967.             t;
  968.         this.queueFx({}, function(){
  969.             t = setTimeout(function(){
  970.                 fly(dom).afterFx({});
  971.             }, seconds * 1000);
  972.             arguments.callee.anim = {
  973.                 isAnimated: true,
  974.                 stop: function(){
  975.                     clearTimeout(t);
  976.                     fly(dom).afterFx({});
  977.                 }
  978.             };
  979.         });
  980.         return this;
  981.     },
  982.    /**
  983.     * Fade an element in (from transparent to opaque).  The ending opacity can be specified
  984.     * using the <tt>{@link #endOpacity}</tt> config option.
  985.     * Usage:
  986. <pre><code>
  987. // default: fade in from opacity 0 to 100%
  988. el.fadeIn();
  989. // custom: fade in from opacity 0 to 75% over 2 seconds
  990. el.fadeIn({ endOpacity: .75, duration: 2});
  991. // common config options shown with default values
  992. el.fadeIn({
  993.     endOpacity: 1, //can be any value between 0 and 1 (e.g. .5)
  994.     easing: 'easeOut',
  995.     duration: .5
  996. });
  997. </code></pre>
  998.     * @param {Object} options (optional) Object literal with any of the Fx config options
  999.     * @return {Ext.Element} The Element
  1000.     */
  1001.     fadeIn : function(o){
  1002.         o = getObject(o);
  1003.         var me = this,
  1004.             dom = me.dom,
  1005.             to = o.endOpacity || 1;
  1006.         
  1007.         me.queueFx(o, function(){
  1008.             fly(dom).setOpacity(0);
  1009.             fly(dom).fixDisplay();
  1010.             dom.style.visibility = VISIBLE;
  1011.             arguments.callee.anim = fly(dom).fxanim({opacity:{to:to}},
  1012.                 o, NULL, .5, EASEOUT, function(){
  1013.                 if(to == 1){
  1014.                     fly(dom).clearOpacity();
  1015.                 }
  1016.                 fly(dom).afterFx(o);
  1017.             });
  1018.         });
  1019.         return me;
  1020.     },
  1021.    /**
  1022.     * Fade an element out (from opaque to transparent).  The ending opacity can be specified
  1023.     * using the <tt>{@link #endOpacity}</tt> config option.  Note that IE may require
  1024.     * <tt>{@link #useDisplay}:true</tt> in order to redisplay correctly.
  1025.     * Usage:
  1026. <pre><code>
  1027. // default: fade out from the element's current opacity to 0
  1028. el.fadeOut();
  1029. // custom: fade out from the element's current opacity to 25% over 2 seconds
  1030. el.fadeOut({ endOpacity: .25, duration: 2});
  1031. // common config options shown with default values
  1032. el.fadeOut({
  1033.     endOpacity: 0, //can be any value between 0 and 1 (e.g. .5)
  1034.     easing: 'easeOut',
  1035.     duration: .5,
  1036.     remove: false,
  1037.     useDisplay: false
  1038. });
  1039. </code></pre>
  1040.     * @param {Object} options (optional) Object literal with any of the Fx config options
  1041.     * @return {Ext.Element} The Element
  1042.     */
  1043.     fadeOut : function(o){
  1044.         o = getObject(o);
  1045.         var me = this,
  1046.             dom = me.dom,
  1047.             style = dom.style,
  1048.             to = o.endOpacity || 0;         
  1049.         
  1050.         me.queueFx(o, function(){  
  1051.             arguments.callee.anim = fly(dom).fxanim({ 
  1052.                 opacity : {to : to}},
  1053.                 o, 
  1054.                 NULL, 
  1055.                 .5, 
  1056.                 EASEOUT, 
  1057.                 function(){
  1058.                     if(to == 0){
  1059.                         Ext.Element.data(dom, 'visibilityMode') == Ext.Element.DISPLAY || o.useDisplay ? 
  1060.                             style.display = "none" :
  1061.                             style.visibility = HIDDEN;
  1062.                             
  1063.                         fly(dom).clearOpacity();
  1064.                     }
  1065.                     fly(dom).afterFx(o);
  1066.             });
  1067.         });
  1068.         return me;
  1069.     },
  1070.    /**
  1071.     * Animates the transition of an element's dimensions from a starting height/width
  1072.     * to an ending height/width.  This method is a convenience implementation of {@link shift}.
  1073.     * Usage:
  1074. <pre><code>
  1075. // change height and width to 100x100 pixels
  1076. el.scale(100, 100);
  1077. // common config options shown with default values.  The height and width will default to
  1078. // the element&#39;s existing values if passed as null.
  1079. el.scale(
  1080.     [element&#39;s width],
  1081.     [element&#39;s height], {
  1082.         easing: 'easeOut',
  1083.         duration: .35
  1084.     }
  1085. );
  1086. </code></pre>
  1087.     * @param {Number} width  The new width (pass undefined to keep the original width)
  1088.     * @param {Number} height  The new height (pass undefined to keep the original height)
  1089.     * @param {Object} options (optional) Object literal with any of the Fx config options
  1090.     * @return {Ext.Element} The Element
  1091.     */
  1092.     scale : function(w, h, o){
  1093.         this.shift(Ext.apply({}, o, {
  1094.             width: w,
  1095.             height: h
  1096.         }));
  1097.         return this;
  1098.     },
  1099.    /**
  1100.     * Animates the transition of any combination of an element's dimensions, xy position and/or opacity.
  1101.     * Any of these properties not specified in the config object will not be changed.  This effect 
  1102.     * requires that at least one new dimension, position or opacity setting must be passed in on
  1103.     * the config object in order for the function to have any effect.
  1104.     * Usage:
  1105. <pre><code>
  1106. // slide the element horizontally to x position 200 while changing the height and opacity
  1107. el.shift({ x: 200, height: 50, opacity: .8 });
  1108. // common config options shown with default values.
  1109. el.shift({
  1110.     width: [element&#39;s width],
  1111.     height: [element&#39;s height],
  1112.     x: [element&#39;s x position],
  1113.     y: [element&#39;s y position],
  1114.     opacity: [element&#39;s opacity],
  1115.     easing: 'easeOut',
  1116.     duration: .35
  1117. });
  1118. </code></pre>
  1119.     * @param {Object} options  Object literal with any of the Fx config options
  1120.     * @return {Ext.Element} The Element
  1121.     */
  1122.     shift : function(o){
  1123.         o = getObject(o);
  1124.         var dom = this.dom,
  1125.             a = {};
  1126.                 
  1127.         this.queueFx(o, function(){
  1128.             for (var prop in o) {
  1129.                 if (o[prop] != UNDEFINED) {                                                 
  1130.                     a[prop] = {to : o[prop]};                   
  1131.                 }
  1132.             } 
  1133.             
  1134.             a.width ? a.width.to = fly(dom).adjustWidth(o.width) : a;
  1135.             a.height ? a.height.to = fly(dom).adjustWidth(o.height) : a;   
  1136.             
  1137.             if (a.x || a.y || a.xy) {
  1138.                 a.points = a.xy || 
  1139.                            {to : [ a.x ? a.x.to : fly(dom).getX(),
  1140.                                    a.y ? a.y.to : fly(dom).getY()]};                  
  1141.             }
  1142.             arguments.callee.anim = fly(dom).fxanim(a,
  1143.                 o, 
  1144.                 MOTION, 
  1145.                 .35, 
  1146.                 EASEOUT, 
  1147.                 function(){
  1148.                     fly(dom).afterFx(o);
  1149.                 });
  1150.         });
  1151.         return this;
  1152.     },
  1153.     /**
  1154.      * Slides the element while fading it out of view.  An anchor point can be optionally passed to set the 
  1155.      * ending point of the effect.
  1156.      * Usage:
  1157.      *<pre><code>
  1158. // default: slide the element downward while fading out
  1159. el.ghost();
  1160. // custom: slide the element out to the right with a 2-second duration
  1161. el.ghost('r', { duration: 2 });
  1162. // common config options shown with default values
  1163. el.ghost('b', {
  1164.     easing: 'easeOut',
  1165.     duration: .5,
  1166.     remove: false,
  1167.     useDisplay: false
  1168. });
  1169. </code></pre>
  1170.      * @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to bottom: 'b')
  1171.      * @param {Object} options (optional) Object literal with any of the Fx config options
  1172.      * @return {Ext.Element} The Element
  1173.      */
  1174.     ghost : function(anchor, o){
  1175.         o = getObject(o);
  1176.         var me = this,
  1177.             dom = me.dom,
  1178.             st = dom.style,
  1179.             a = {opacity: {to: 0}, points: {}},
  1180.             pt = a.points,
  1181.             r,
  1182.             w,
  1183.             h;
  1184.             
  1185.         anchor = anchor || "b";
  1186.         me.queueFx(o, function(){
  1187.             // restore values after effect
  1188.             r = fly(dom).getFxRestore();
  1189.             w = fly(dom).getWidth();
  1190.             h = fly(dom).getHeight();
  1191.             
  1192.             function after(){
  1193.                 o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();   
  1194.                 fly(dom).clearOpacity();
  1195.                 fly(dom).setPositioning(r.pos);
  1196.                 st.width = r.width;
  1197.                 st.height = r.height;
  1198.                 fly(dom).afterFx(o);
  1199.             }
  1200.                 
  1201.             pt.by = fly(dom).switchStatements(anchor.toLowerCase(), function(v1,v2){ return [v1, v2];}, {
  1202.                t  : [0, -h],
  1203.                l  : [-w, 0],
  1204.                r  : [w, 0],
  1205.                b  : [0, h],
  1206.                tl : [-w, -h],
  1207.                bl : [-w, h],
  1208.                br : [w, h],
  1209.                tr : [w, -h] 
  1210.             });
  1211.                 
  1212.             arguments.callee.anim = fly(dom).fxanim(a,
  1213.                 o,
  1214.                 MOTION,
  1215.                 .5,
  1216.                 EASEOUT, after);
  1217.         });
  1218.         return me;
  1219.     },
  1220.     /**
  1221.      * Ensures that all effects queued after syncFx is called on the element are
  1222.      * run concurrently.  This is the opposite of {@link #sequenceFx}.
  1223.      * @return {Ext.Element} The Element
  1224.      */
  1225.     syncFx : function(){
  1226.         var me = this;
  1227.         me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
  1228.             block : FALSE,
  1229.             concurrent : TRUE,
  1230.             stopFx : FALSE
  1231.         });
  1232.         return me;
  1233.     },
  1234.     /**
  1235.      * Ensures that all effects queued after sequenceFx is called on the element are
  1236.      * run in sequence.  This is the opposite of {@link #syncFx}.
  1237.      * @return {Ext.Element} The Element
  1238.      */
  1239.     sequenceFx : function(){
  1240.         var me = this;
  1241.         me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
  1242.             block : FALSE,
  1243.             concurrent : FALSE,
  1244.             stopFx : FALSE
  1245.         });
  1246.         return me;
  1247.     },
  1248.     /* @private */
  1249.     nextFx : function(){        
  1250.         var ef = getQueue(this.dom.id)[0];
  1251.         if(ef){
  1252.             ef.call(this);
  1253.         }
  1254.     },
  1255.     /**
  1256.      * Returns true if the element has any effects actively running or queued, else returns false.
  1257.      * @return {Boolean} True if element has active effects, else false
  1258.      */
  1259.     hasActiveFx : function(){
  1260.         return getQueue(this.dom.id)[0];
  1261.     },
  1262.     /**
  1263.      * Stops any running effects and clears the element's internal effects queue if it contains
  1264.      * any additional effects that haven't started yet.
  1265.      * @return {Ext.Element} The Element
  1266.      */
  1267.     stopFx : function(finish){
  1268.         var me = this,
  1269.             id = me.dom.id;
  1270.         if(me.hasActiveFx()){
  1271.             var cur = getQueue(id)[0];
  1272.             if(cur && cur.anim){
  1273.                 if(cur.anim.isAnimated){
  1274.                     setQueue(id, [cur]); //clear
  1275.                     cur.anim.stop(finish !== undefined ? finish : TRUE);
  1276.                 }else{
  1277.                     setQueue(id, []);
  1278.                 }
  1279.             }
  1280.         }
  1281.         return me;
  1282.     },
  1283.     /* @private */
  1284.     beforeFx : function(o){
  1285.         if(this.hasActiveFx() && !o.concurrent){
  1286.            if(o.stopFx){
  1287.                this.stopFx();
  1288.                return TRUE;
  1289.            }
  1290.            return FALSE;
  1291.         }
  1292.         return TRUE;
  1293.     },
  1294.     /**
  1295.      * Returns true if the element is currently blocking so that no other effect can be queued
  1296.      * until this effect is finished, else returns false if blocking is not set.  This is commonly
  1297.      * used to ensure that an effect initiated by a user action runs to completion prior to the
  1298.      * same effect being restarted (e.g., firing only one effect even if the user clicks several times).
  1299.      * @return {Boolean} True if blocking, else false
  1300.      */
  1301.     hasFxBlock : function(){
  1302.         var q = getQueue(this.dom.id);
  1303.         return q && q[0] && q[0].block;
  1304.     },
  1305.     /* @private */
  1306.     queueFx : function(o, fn){
  1307.         var me = this;
  1308.         if(!me.hasFxBlock()){
  1309.             Ext.applyIf(o, me.fxDefaults);
  1310.             if(!o.concurrent){
  1311.                 var run = me.beforeFx(o);
  1312.                 fn.block = o.block;
  1313.                 getQueue(me.dom.id).push(fn);
  1314.                 if(run){
  1315.                     me.nextFx();
  1316.                 }
  1317.             }else{
  1318.                 fn.call(me);
  1319.             }
  1320.         }
  1321.         return me;
  1322.     },
  1323.     /* @private */
  1324.     fxWrap : function(pos, o, vis){ 
  1325.         var dom = this.dom,
  1326.             wrap,
  1327.             wrapXY;
  1328.         if(!o.wrap || !(wrap = Ext.getDom(o.wrap))){            
  1329.             if(o.fixPosition){
  1330.                 wrapXY = fly(dom).getXY();
  1331.             }
  1332.             var div = document.createElement("div");
  1333.             div.style.visibility = vis;
  1334.             wrap = dom.parentNode.insertBefore(div, dom);
  1335.             fly(wrap).setPositioning(pos);
  1336.             if(fly(wrap).isStyle(POSITION, "static")){
  1337.                 fly(wrap).position("relative");
  1338.             }
  1339.             fly(dom).clearPositioning('auto');
  1340.             fly(wrap).clip();
  1341.             wrap.appendChild(dom);
  1342.             if(wrapXY){
  1343.                 fly(wrap).setXY(wrapXY);
  1344.             }
  1345.         }
  1346.         return wrap;
  1347.     },
  1348.     /* @private */
  1349.     fxUnwrap : function(wrap, pos, o){      
  1350.         var dom = this.dom;
  1351.         fly(dom).clearPositioning();
  1352.         fly(dom).setPositioning(pos);
  1353.         if(!o.wrap){
  1354.             wrap.parentNode.insertBefore(dom, wrap);
  1355.             fly(wrap).remove();
  1356.         }
  1357.     },
  1358.     /* @private */
  1359.     getFxRestore : function(){
  1360.         var st = this.dom.style;
  1361.         return {pos: this.getPositioning(), width: st.width, height : st.height};
  1362.     },
  1363.     /* @private */
  1364.     afterFx : function(o){
  1365.         var dom = this.dom,
  1366.             id = dom.id,
  1367.             notConcurrent = !o.concurrent;
  1368.         if(o.afterStyle){
  1369.             fly(dom).setStyle(o.afterStyle);            
  1370.         }
  1371.         if(o.afterCls){
  1372.             fly(dom).addClass(o.afterCls);
  1373.         }
  1374.         if(o.remove == TRUE){
  1375.             fly(dom).remove();
  1376.         }
  1377.         if(notConcurrent){
  1378.             getQueue(id).shift();
  1379.         }
  1380.         if(o.callback){
  1381.             o.callback.call(o.scope, fly(dom));
  1382.         }
  1383.         if(notConcurrent){
  1384.             fly(dom).nextFx();
  1385.         }
  1386.     },
  1387.     /* @private */
  1388.     fxanim : function(args, opt, animType, defaultDur, defaultEase, cb){
  1389.         animType = animType || 'run';
  1390.         opt = opt || {};
  1391.         var anim = Ext.lib.Anim[animType](
  1392.                 this.dom, 
  1393.                 args,
  1394.                 (opt.duration || defaultDur) || .35,
  1395.                 (opt.easing || defaultEase) || EASEOUT,
  1396.                 cb,            
  1397.                 this
  1398.             );
  1399.         opt.anim = anim;
  1400.         return anim;
  1401.     }
  1402. };
  1403. // backwards compat
  1404. Ext.Fx.resize = Ext.Fx.scale;
  1405. //When included, Ext.Fx is automatically applied to Element so that all basic
  1406. //effects are available directly via the Element API
  1407. Ext.Element.addMethods(Ext.Fx);
  1408. })();/**
  1409.  * @class Ext.CompositeElementLite
  1410.  * Flyweight composite class. Reuses the same Ext.Element for element operations.
  1411.  <pre><code>
  1412.  var els = Ext.select("#some-el div.some-class");
  1413.  // or select directly from an existing element
  1414.  var el = Ext.get('some-el');
  1415.  el.select('div.some-class');
  1416.  els.setWidth(100); // all elements become 100 width
  1417.  els.hide(true); // all elements fade out and hide
  1418.  // or
  1419.  els.setWidth(100).hide(true);
  1420.  </code></pre><br><br>
  1421.  * <b>NOTE: Although they are not listed, this class supports all of the set/update methods of Ext.Element. All Ext.Element
  1422.  * actions will be performed on all the elements in this collection.</b>
  1423.  */
  1424. Ext.CompositeElementLite = function(els, root){
  1425.     this.elements = [];
  1426.     this.add(els, root);
  1427.     this.el = new Ext.Element.Flyweight();
  1428. };
  1429. Ext.CompositeElementLite.prototype = {
  1430. isComposite: true,
  1431. /**
  1432.      * Returns the number of elements in this composite
  1433.      * @return Number
  1434.      */
  1435.     getCount : function(){
  1436.         return this.elements.length;
  1437.     },    
  1438. add : function(els){
  1439.         if(els){
  1440.             if (Ext.isArray(els)) {
  1441.                 this.elements = this.elements.concat(els);
  1442.             } else {
  1443.                 var yels = this.elements;                                 
  1444.             Ext.each(els, function(e) {
  1445.                     yels.push(e);
  1446.                 });
  1447.             }
  1448.         }
  1449.         return this;
  1450.     },
  1451.     invoke : function(fn, args){
  1452.         var els = this.elements,
  1453.          el = this.el;        
  1454.     Ext.each(els, function(e) {    
  1455.             el.dom = e;
  1456.          Ext.Element.prototype[fn].apply(el, args);
  1457.         });
  1458.         return this;
  1459.     },
  1460.     /**
  1461.      * Returns a flyweight Element of the dom element object at the specified index
  1462.      * @param {Number} index
  1463.      * @return {Ext.Element}
  1464.      */
  1465.     item : function(index){
  1466.     var me = this;
  1467.         if(!me.elements[index]){
  1468.             return null;
  1469.         }
  1470.         me.el.dom = me.elements[index];
  1471.         return me.el;
  1472.     },
  1473.     // fixes scope with flyweight
  1474.     addListener : function(eventName, handler, scope, opt){
  1475.         Ext.each(this.elements, function(e) {
  1476.         Ext.EventManager.on(e, eventName, handler, scope || e, opt);
  1477.         });
  1478.         return this;
  1479.     },
  1480.     /**
  1481.     * Calls the passed function passing (el, this, index) for each element in this composite. <b>The element
  1482.     * passed is the flyweight (shared) Ext.Element instance, so if you require a
  1483.     * a reference to the dom node, use el.dom.</b>
  1484.     * @param {Function} fn The function to call
  1485.     * @param {Object} scope (optional) The <i>this</i> object (defaults to the element)
  1486.     * @return {CompositeElement} this
  1487.     */
  1488.     each : function(fn, scope){       
  1489.         var me = this,
  1490.          el = me.el;
  1491.        
  1492.     Ext.each(me.elements, function(e,i) {    
  1493.             el.dom = e;
  1494.          return fn.call(scope || el, el, me, i);
  1495.         });
  1496.         return me;
  1497.     },
  1498.     
  1499.     /**
  1500.      * Find the index of the passed element within the composite collection.
  1501.      * @param el {Mixed} The id of an element, or an Ext.Element, or an HtmlElement to find within the composite collection.
  1502.      * @return Number The index of the passed Ext.Element in the composite collection, or -1 if not found.
  1503.      */
  1504.     indexOf : function(el){
  1505.         return this.elements.indexOf(Ext.getDom(el));
  1506.     },
  1507.     
  1508.     /**
  1509.     * Replaces the specified element with the passed element.
  1510.     * @param {Mixed} el The id of an element, the Element itself, the index of the element in this composite
  1511.     * to replace.
  1512.     * @param {Mixed} replacement The id of an element or the Element itself.
  1513.     * @param {Boolean} domReplace (Optional) True to remove and replace the element in the document too.
  1514.     * @return {CompositeElement} this
  1515.     */    
  1516.     replaceElement : function(el, replacement, domReplace){
  1517.         var index = !isNaN(el) ? el : this.indexOf(el),
  1518.          d;
  1519.         if(index > -1){
  1520.             replacement = Ext.getDom(replacement);
  1521.             if(domReplace){
  1522.                 d = this.elements[index];
  1523.                 d.parentNode.insertBefore(replacement, d);
  1524.                 Ext.removeNode(d);
  1525.             }
  1526.             this.elements.splice(index, 1, replacement);
  1527.         }
  1528.         return this;
  1529.     },
  1530.     
  1531.     /**
  1532.      * Removes all elements.
  1533.      */
  1534.     clear : function(){
  1535.         this.elements = [];
  1536.     }
  1537. };
  1538. Ext.CompositeElementLite.prototype.on = Ext.CompositeElementLite.prototype.addListener;
  1539. (function(){
  1540. var fnName,
  1541. ElProto = Ext.Element.prototype,
  1542. CelProto = Ext.CompositeElementLite.prototype;
  1543. for(fnName in ElProto){
  1544.     if(Ext.isFunction(ElProto[fnName])){
  1545.     (function(fnName){ 
  1546.     CelProto[fnName] = CelProto[fnName] || function(){
  1547.      return this.invoke(fnName, arguments);
  1548.      };
  1549.      }).call(CelProto, fnName);
  1550.         
  1551.     }
  1552. }
  1553. })();
  1554. if(Ext.DomQuery){
  1555.     Ext.Element.selectorFunction = Ext.DomQuery.select;
  1556. /**
  1557.  * Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
  1558.  * to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
  1559.  * {@link Ext.CompositeElementLite CompositeElementLite} object.
  1560.  * @param {String/Array} selector The CSS selector or an array of elements
  1561.  * @param {Boolean} unique (optional) true to create a unique Ext.Element for each element (defaults to a shared flyweight object) <b>Not supported in core</b>
  1562.  * @param {HTMLElement/String} root (optional) The root element of the query or id of the root
  1563.  * @return {CompositeElementLite/CompositeElement}
  1564.  * @member Ext.Element