docs/source/Element.static-more.html

   1 <!DOCTYPE html>
   2 <html>
   3 <head>
   4   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   5   <title>The source code</title>
   6   <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
   7   <script type="text/javascript" src="../prettify/prettify.js"></script>
   8   <style type="text/css">
   9     .highlight { display: block; background-color: #ddd; }
  10   </style>
  11   <script type="text/javascript">
  12     function highlight() {
  13       document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
  14     }
  15   </script>
  16 </head>
  17 <body onload="prettyPrint(); highlight();">
  18   <pre class="prettyprint lang-js"><span id='Ext-core-Element'>/**
  19 </span> * @class Ext.core.Element
  20  */
  21 (function(){
  22     var doc = document,
  23         activeElement = null,
  24         isCSS1 = doc.compatMode == &quot;CSS1Compat&quot;,
  25         ELEMENT = Ext.core.Element,
  26         fly = function(el){
  27             if (!_fly) {
  28                 _fly = new Ext.core.Element.Flyweight();
  29             }
  30             _fly.dom = el;
  31             return _fly;
  32         }, _fly;
  33
  34     // If the browser does not support document.activeElement we need some assistance.
  35     // This covers old Safari 3.2 (4.0 added activeElement along with just about all
  36     // other browsers). We need this support to handle issues with old Safari.
  37     if (!('activeElement' in doc) &amp;&amp; doc.addEventListener) {
  38         doc.addEventListener('focus',
  39             function (ev) {
  40                 if (ev &amp;&amp; ev.target) {
  41                     activeElement = (ev.target == doc) ? null : ev.target;
  42                 }
  43             }, true);
  44     }
  45
  46     /*
  47      * Helper function to create the function that will restore the selection.
  48      */
  49     function makeSelectionRestoreFn (activeEl, start, end) {
  50         return function () {
  51             activeEl.selectionStart = start;
  52             activeEl.selectionEnd = end;
  53         };
  54     }
  55
  56     Ext.apply(ELEMENT, {
  57         isAncestor : function(p, c) {
  58             var ret = false;
  59
  60             p = Ext.getDom(p);
  61             c = Ext.getDom(c);
  62             if (p &amp;&amp; c) {
  63                 if (p.contains) {
  64                     return p.contains(c);
  65                 } else if (p.compareDocumentPosition) {
  66                     return !!(p.compareDocumentPosition(c) &amp; 16);
  67                 } else {
  68                     while ((c = c.parentNode)) {
  69                         ret = c == p || ret;
  70                     }
  71                 }
  72             }
  73             return ret;
  74         },
  75
  76 <span id='Ext-core-Element-method-getActiveElement'>        /**
  77 </span>         * Returns the active element in the DOM. If the browser supports activeElement
  78          * on the document, this is returned. If not, the focus is tracked and the active
  79          * element is maintained internally.
  80          * @return {HTMLElement} The active (focused) element in the document.
  81          */
  82         getActiveElement: function () {
  83             return doc.activeElement || activeElement;
  84         },
  85
  86 <span id='Ext-core-Element-method-getRightMarginFixCleaner'>        /**
  87 </span>         * Creates a function to call to clean up problems with the work-around for the
  88          * WebKit RightMargin bug. The work-around is to add &quot;display: 'inline-block'&quot; to
  89          * the element before calling getComputedStyle and then to restore its original
  90          * display value. The problem with this is that it corrupts the selection of an
  91          * INPUT or TEXTAREA element (as in the &quot;I-beam&quot; goes away but ths focus remains).
  92          * To cleanup after this, we need to capture the selection of any such element and
  93          * then restore it after we have restored the display style.
  94          *
  95          * @param target {Element} The top-most element being adjusted.
  96          * @private
  97          */
  98         getRightMarginFixCleaner: function (target) {
  99             var supports = Ext.supports,
 100                 hasInputBug = supports.DisplayChangeInputSelectionBug,
 101                 hasTextAreaBug = supports.DisplayChangeTextAreaSelectionBug;
 102
 103             if (hasInputBug || hasTextAreaBug) {
 104                 var activeEl = doc.activeElement || activeElement, // save a call
 105                     tag = activeEl &amp;&amp; activeEl.tagName,
 106                     start,
 107                     end;
 108
 109                 if ((hasTextAreaBug &amp;&amp; tag == 'TEXTAREA') ||
 110                     (hasInputBug &amp;&amp; tag == 'INPUT' &amp;&amp; activeEl.type == 'text')) {
 111                     if (ELEMENT.isAncestor(target, activeEl)) {
 112                         start = activeEl.selectionStart;
 113                         end = activeEl.selectionEnd;
 114
 115                         if (Ext.isNumber(start) &amp;&amp; Ext.isNumber(end)) { // to be safe...
 116                             // We don't create the raw closure here inline because that
 117                             // will be costly even if we don't want to return it (nested
 118                             // function decls and exprs are often instantiated on entry
 119                             // regardless of whether execution ever reaches them):
 120                             return makeSelectionRestoreFn(activeEl, start, end);
 121                         }
 122                     }
 123                 }
 124             }
 125
 126             return Ext.emptyFn; // avoid special cases, just return a nop
 127         },
 128
 129         getViewWidth : function(full) {
 130             return full ? ELEMENT.getDocumentWidth() : ELEMENT.getViewportWidth();
 131         },
 132
 133         getViewHeight : function(full) {
 134             return full ? ELEMENT.getDocumentHeight() : ELEMENT.getViewportHeight();
 135         },
 136
 137         getDocumentHeight: function() {
 138             return Math.max(!isCSS1 ? doc.body.scrollHeight : doc.documentElement.scrollHeight, ELEMENT.getViewportHeight());
 139         },
 140
 141         getDocumentWidth: function() {
 142             return Math.max(!isCSS1 ? doc.body.scrollWidth : doc.documentElement.scrollWidth, ELEMENT.getViewportWidth());
 143         },
 144
 145         getViewportHeight: function(){
 146             return Ext.isIE ?
 147                    (Ext.isStrict ? doc.documentElement.clientHeight : doc.body.clientHeight) :
 148                    self.innerHeight;
 149         },
 150
 151         getViewportWidth : function() {
 152             return (!Ext.isStrict &amp;&amp; !Ext.isOpera) ? doc.body.clientWidth :
 153                    Ext.isIE ? doc.documentElement.clientWidth : self.innerWidth;
 154         },
 155
 156         getY : function(el) {
 157             return ELEMENT.getXY(el)[1];
 158         },
 159
 160         getX : function(el) {
 161             return ELEMENT.getXY(el)[0];
 162         },
 163
 164         getXY : function(el) {
 165             var p,
 166                 pe,
 167                 b,
 168                 bt,
 169                 bl,
 170                 dbd,
 171                 x = 0,
 172                 y = 0,
 173                 scroll,
 174                 hasAbsolute,
 175                 bd = (doc.body || doc.documentElement),
 176                 ret = [0,0];
 177
 178             el = Ext.getDom(el);
 179
 180             if(el != bd){
 181                 hasAbsolute = fly(el).isStyle(&quot;position&quot;, &quot;absolute&quot;);
 182
 183                 if (el.getBoundingClientRect) {
 184                     b = el.getBoundingClientRect();
 185                     scroll = fly(document).getScroll();
 186                     ret = [Math.round(b.left + scroll.left), Math.round(b.top + scroll.top)];
 187                 } else {
 188                     p = el;
 189
 190                     while (p) {
 191                         pe = fly(p);
 192                         x += p.offsetLeft;
 193                         y += p.offsetTop;
 194
 195                         hasAbsolute = hasAbsolute || pe.isStyle(&quot;position&quot;, &quot;absolute&quot;);
 196
 197                         if (Ext.isGecko) {
 198                             y += bt = parseInt(pe.getStyle(&quot;borderTopWidth&quot;), 10) || 0;
 199                             x += bl = parseInt(pe.getStyle(&quot;borderLeftWidth&quot;), 10) || 0;
 200
 201                             if (p != el &amp;&amp; !pe.isStyle('overflow','visible')) {
 202                                 x += bl;
 203                                 y += bt;
 204                             }
 205                         }
 206                         p = p.offsetParent;
 207                     }
 208
 209                     if (Ext.isSafari &amp;&amp; hasAbsolute) {
 210                         x -= bd.offsetLeft;
 211                         y -= bd.offsetTop;
 212                     }
 213
 214                     if (Ext.isGecko &amp;&amp; !hasAbsolute) {
 215                         dbd = fly(bd);
 216                         x += parseInt(dbd.getStyle(&quot;borderLeftWidth&quot;), 10) || 0;
 217                         y += parseInt(dbd.getStyle(&quot;borderTopWidth&quot;), 10) || 0;
 218                     }
 219
 220                     p = el.parentNode;
 221                     while (p &amp;&amp; p != bd) {
 222                         if (!Ext.isOpera || (p.tagName != 'TR' &amp;&amp; !fly(p).isStyle(&quot;display&quot;, &quot;inline&quot;))) {
 223                             x -= p.scrollLeft;
 224                             y -= p.scrollTop;
 225                         }
 226                         p = p.parentNode;
 227                     }
 228                     ret = [x,y];
 229                 }
 230             }
 231             return ret;
 232         },
 233
 234         setXY : function(el, xy) {
 235             (el = Ext.fly(el, '_setXY')).position();
 236
 237             var pts = el.translatePoints(xy),
 238                 style = el.dom.style,
 239                 pos;
 240
 241             for (pos in pts) {
 242                 if (!isNaN(pts[pos])) {
 243                     style[pos] = pts[pos] + &quot;px&quot;;
 244                 }
 245             }
 246         },
 247
 248         setX : function(el, x) {
 249             ELEMENT.setXY(el, [x, false]);
 250         },
 251
 252         setY : function(el, y) {
 253             ELEMENT.setXY(el, [false, y]);
 254         },
 255
 256 <span id='Ext-core-Element-method-serializeForm'>        /**
 257 </span>         * Serializes a DOM form into a url encoded string
 258          * @param {Object} form The form
 259          * @return {String} The url encoded form
 260          */
 261         serializeForm: function(form) {
 262             var fElements = form.elements || (document.forms[form] || Ext.getDom(form)).elements,
 263                 hasSubmit = false,
 264                 encoder = encodeURIComponent,
 265                 name,
 266                 data = '',
 267                 type,
 268                 hasValue;
 269
 270             Ext.each(fElements, function(element){
 271                 name = element.name;
 272                 type = element.type;
 273
 274                 if (!element.disabled &amp;&amp; name) {
 275                     if (/select-(one|multiple)/i.test(type)) {
 276                         Ext.each(element.options, function(opt){
 277                             if (opt.selected) {
 278                                 hasValue = opt.hasAttribute ? opt.hasAttribute('value') : opt.getAttributeNode('value').specified;
 279                                 data += Ext.String.format(&quot;{0}={1}&amp;&quot;, encoder(name), encoder(hasValue ? opt.value : opt.text));
 280                             }
 281                         });
 282                     } else if (!(/file|undefined|reset|button/i.test(type))) {
 283                         if (!(/radio|checkbox/i.test(type) &amp;&amp; !element.checked) &amp;&amp; !(type == 'submit' &amp;&amp; hasSubmit)) {
 284                             data += encoder(name) + '=' + encoder(element.value) + '&amp;';
 285                             hasSubmit = /submit/i.test(type);
 286                         }
 287                     }
 288                 }
 289             });
 290             return data.substr(0, data.length - 1);
 291         }
 292     });
 293 })();
 294 </pre>
 295 </body>
 296 </html>