git.ithinksw.org / extjs.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Upgrade to ExtJS 4.0.2 - Released 06/09/2011
[extjs.git] / docs / source / Element.scroll.html
diff --git a/docs/source/Element.scroll.html b/docs/source/Element.scroll.html
index 9e25785..6a411cd 100644 (file)
--- a/docs/source/Element.scroll.html
+++ b/docs/source/Element.scroll.html
@@ -1,46 +1,38 @@
+<!DOCTYPE html>
 <html>
 <head>
 <html>
 <head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />    
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   <title>The source code</title>
   <title>The source code</title>
-    <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
-    <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
+  <link href="../prettify/prettify.css" type="text/css" rel="stylesheet" />
+  <script type="text/javascript" src="../prettify/prettify.js"></script>
+  <style type="text/css">
+    .highlight { display: block; background-color: #ddd; }
+  </style>
+  <script type="text/javascript">
+    function highlight() {
+      document.getElementById(location.hash.replace(/#/, "")).className = "highlight";
+    }
+  </script>
 </head>
 </head>
-<body  onload="prettyPrint();">
-    <pre class="prettyprint lang-js">/*!
- * Ext JS Library 3.2.2
- * Copyright(c) 2006-2010 Ext JS, Inc.
- * licensing@extjs.com
- * http://www.extjs.com/license
- */
-/**
- * @class Ext.Element
+<body onload="prettyPrint(); highlight();">
+  <pre class="prettyprint lang-js"><span id='Ext-core-Element'>/**
+</span> * @class Ext.core.Element
  */
  */
-Ext.Element.addMethods({
-    <div id="method-Ext.Element-isScrollable"></div>/**
-     * Returns true if this element is scrollable.
+Ext.override(Ext.core.Element, {
+<span id='Ext-core-Element-method-isScrollable'>    /**
+</span>     * Returns true if this element is scrollable.
      * @return {Boolean}
      */
     isScrollable : function(){
         var dom = this.dom;
      * @return {Boolean}
      */
     isScrollable : function(){
         var dom = this.dom;
-        return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth;
-    },
-
-    <div id="method-Ext.Element-scrollTo"></div>/**
-     * Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use scroll().
-     * @param {String} side Either "left" for scrollLeft values or "top" for scrollTop values.
-     * @param {Number} value The new scroll value.
-     * @return {Element} this
-     */
-    scrollTo : function(side, value){
-        this.dom["scroll" + (/top/i.test(side) ? "Top" : "Left")] = value;
-        return this;
+        return dom.scrollHeight &gt; dom.clientHeight || dom.scrollWidth &gt; dom.clientWidth;
     },
 
     },
 
-    <div id="method-Ext.Element-getScroll"></div>/**
-     * Returns the current scroll position of the element.
+<span id='Ext-core-Element-method-getScroll'>    /**
+</span>     * Returns the current scroll position of the element.
      * @return {Object} An object containing the scroll position in the format {left: (scrollLeft), top: (scrollTop)}
      */
      * @return {Object} An object containing the scroll position in the format {left: (scrollLeft), top: (scrollTop)}
      */
-    getScroll : function(){
+    getScroll : function() {
         var d = this.dom, 
             doc = document,
             body = doc.body,
         var d = this.dom, 
             doc = document,
             body = doc.body,
@@ -49,20 +41,141 @@ Ext.Element.addMethods({
             t,
             ret;
 
             t,
             ret;
 
-        if(d == doc || d == body){
-            if(Ext.isIE && Ext.isStrict){
+        if (d == doc || d == body) {
+            if (Ext.isIE &amp;&amp; Ext.isStrict) {
                 l = docElement.scrollLeft; 
                 t = docElement.scrollTop;
                 l = docElement.scrollLeft; 
                 t = docElement.scrollTop;
-            }else{
+            } else {
                 l = window.pageXOffset;
                 t = window.pageYOffset;
             }
                 l = window.pageXOffset;
                 t = window.pageYOffset;
             }
-            ret = {left: l || (body ? body.scrollLeft : 0), top: t || (body ? body.scrollTop : 0)};
-        }else{
-            ret = {left: d.scrollLeft, top: d.scrollTop};
+            ret = {
+                left: l || (body ? body.scrollLeft : 0), 
+                top : t || (body ? body.scrollTop : 0)
+            };
+        } else {
+            ret = {
+                left: d.scrollLeft, 
+                top : d.scrollTop
+            };
         }
         }
+        
         return ret;
         return ret;
+    },
+    
+<span id='Ext-core-Element-method-scrollTo'>    /**
+</span>     * Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use scroll().
+     * @param {String} side Either &quot;left&quot; for scrollLeft values or &quot;top&quot; for scrollTop values.
+     * @param {Number} value The new scroll value
+     * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
+     * @return {Element} this
+     */
+    scrollTo : function(side, value, animate) {
+        //check if we're scrolling top or left
+        var top = /top/i.test(side),
+            me = this,
+            dom = me.dom,
+            obj = {},
+            prop;
+        if (!animate || !me.anim) {
+            // just setting the value, so grab the direction
+            prop = 'scroll' + (top ? 'Top' : 'Left');
+            dom[prop] = value;
+        }
+        else {
+            if (!Ext.isObject(animate)) {
+                animate = {};
+            }
+            obj['scroll' + (top ? 'Top' : 'Left')] = value;
+            me.animate(Ext.applyIf({
+                to: obj
+            }, animate));
+        }
+        return me;
+    },
+
+<span id='Ext-core-Element-method-scrollIntoView'>    /**
+</span>     * Scrolls this element into view within the passed container.
+     * @param {Mixed} container (optional) The container element to scroll (defaults to document.body).  Should be a
+     * string (id), dom node, or Ext.core.Element.
+     * @param {Boolean} hscroll (optional) False to disable horizontal scroll (defaults to true)
+     * @return {Ext.core.Element} this
+     */
+    scrollIntoView : function(container, hscroll) {
+        container = Ext.getDom(container) || Ext.getBody().dom;
+        var el = this.dom,
+            offsets = this.getOffsetsTo(container),
+            // el's box
+            left = offsets[0] + container.scrollLeft,
+            top = offsets[1] + container.scrollTop,
+            bottom = top + el.offsetHeight,
+            right = left + el.offsetWidth,
+            // ct's box
+            ctClientHeight = container.clientHeight,
+            ctScrollTop = parseInt(container.scrollTop, 10),
+            ctScrollLeft = parseInt(container.scrollLeft, 10),
+            ctBottom = ctScrollTop + ctClientHeight,
+            ctRight = ctScrollLeft + container.clientWidth;
+
+        if (el.offsetHeight &gt; ctClientHeight || top &lt; ctScrollTop) {
+            container.scrollTop = top;
+        } else if (bottom &gt; ctBottom) {
+            container.scrollTop = bottom - ctClientHeight;
+        }
+        // corrects IE, other browsers will ignore
+        container.scrollTop = container.scrollTop;
+
+        if (hscroll !== false) {
+            if (el.offsetWidth &gt; container.clientWidth || left &lt; ctScrollLeft) {
+                container.scrollLeft = left;
+            }
+            else if (right &gt; ctRight) {
+                container.scrollLeft = right - container.clientWidth;
+            }
+            container.scrollLeft = container.scrollLeft;
+        }
+        return this;
+    },
+
+    // private
+    scrollChildIntoView : function(child, hscroll) {
+        Ext.fly(child, '_scrollChildIntoView').scrollIntoView(this, hscroll);
+    },
+
+<span id='Ext-core-Element-method-scroll'>    /**
+</span>     * Scrolls this element the specified direction. Does bounds checking to make sure the scroll is
+     * within this element's scrollable range.
+     * @param {String} direction Possible values are: &quot;l&quot; (or &quot;left&quot;), &quot;r&quot; (or &quot;right&quot;), &quot;t&quot; (or &quot;top&quot;, or &quot;up&quot;), &quot;b&quot; (or &quot;bottom&quot;, or &quot;down&quot;).
+     * @param {Number} distance How far to scroll the element in pixels
+     * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
+     * @return {Boolean} Returns true if a scroll was triggered or false if the element
+     * was scrolled as far as it could go.
+     */
+     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;
+
+        direction = direction.substr(0, 1);
+        if ((v = hash[direction]) &gt; -1) {
+            scrolled = true;
+            this.scrollTo(direction == 'l' || direction == 'r' ? 'left' : 'top', v, this.anim(animate));
+        }
+        return scrolled;
     }
     }
-});</pre>    
+});</pre>
 </body>
 </body>
-</html>
\ No newline at end of file
+</html>
Mirror of ExtJS by Sencha Inc. <http://www.sencha.com/>.