examples/docs/source/CalendarScrollManager.html

   1 <html>
   2 <head>
   3   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
   4   <title>The source code</title>
   5     <link href="../resources/prettify/prettify.css" type="text/css" rel="stylesheet" />
   6     <script type="text/javascript" src="../resources/prettify/prettify.js"></script>
   7 </head>
   8 <body  onload="prettyPrint();">
   9     <pre class="prettyprint lang-js">/*!
  10  * Ext JS Library 3.3.1
  11  * Copyright(c) 2006-2010 Sencha Inc.
  12  * licensing@sencha.com
  13  * http://www.sencha.com/license
  14  */
  15 <div id="cls-Ext.dd.ScrollManager"></div>/**
  16  * @class Ext.dd.ScrollManager
  17  * <p>Provides automatic scrolling of overflow regions in the page during drag operations.</p>
  18  * <p>The ScrollManager configs will be used as the defaults for any scroll container registered with it,
  19  * but you can also override most of the configs per scroll container by adding a
  20  * <tt>ddScrollConfig</tt> object to the target element that contains these properties: {@link #hthresh},
  21  * {@link #vthresh}, {@link #increment} and {@link #frequency}.  Example usage:
  22  * <pre><code>
  23 var el = Ext.get('scroll-ct');
  24 el.ddScrollConfig = {
  25     vthresh: 50,
  26     hthresh: -1,
  27     frequency: 100,
  28     increment: 200
  29 };
  30 Ext.dd.ScrollManager.register(el);
  31 </code></pre>
  32  * <b>Note: This class uses "Point Mode" and is untested in "Intersect Mode".</b>
  33  * @singleton
  34  */
  35 Ext.dd.ScrollManager = function() {
  36     var ddm = Ext.dd.DragDropMgr,
  37         els = {},
  38         dragEl = null,
  39         proc = {},
  40         onStop = function(e) {
  41             dragEl = null;
  42             clearProc();
  43         },
  44         triggerRefresh = function() {
  45             if (ddm.dragCurrent) {
  46                 ddm.refreshCache(ddm.dragCurrent.groups);
  47             }
  48         },
  49         doScroll = function() {
  50             if (ddm.dragCurrent) {
  51                 var dds = Ext.dd.ScrollManager,
  52                     inc = proc.el.ddScrollConfig ? proc.el.ddScrollConfig.increment: dds.increment;
  53                 if (!dds.animate) {
  54                     if (proc.el.scroll(proc.dir, inc)) {
  55                         triggerRefresh();
  56                     }
  57                 } else {
  58                     proc.el.scroll(proc.dir, inc, true, dds.animDuration, triggerRefresh);
  59                 }
  60             }
  61         },
  62         clearProc = function() {
  63             if (proc.id) {
  64                 clearInterval(proc.id);
  65             }
  66             proc.id = 0;
  67             proc.el = null;
  68             proc.dir = "";
  69         },
  70         startProc = function(el, dir) {
  71             clearProc();
  72             proc.el = el;
  73             proc.dir = dir;
  74             var freq = (el.ddScrollConfig && el.ddScrollConfig.frequency) ?
  75                             el.ddScrollConfig.frequency: Ext.dd.ScrollManager.frequency,
  76                 group = el.ddScrollConfig ? el.ddScrollConfig.ddGroup: undefined;
  77
  78             if (group === undefined || ddm.dragCurrent.ddGroup == group) {
  79                 proc.id = setInterval(doScroll, freq);
  80             }
  81         },
  82         onFire = function(e, isDrop) {
  83             if (isDrop || !ddm.dragCurrent) {
  84                 return;
  85             }
  86             var dds = Ext.dd.ScrollManager;
  87             if (!dragEl || dragEl != ddm.dragCurrent) {
  88                 dragEl = ddm.dragCurrent;
  89                 // refresh regions on drag start
  90                 dds.refreshCache();
  91             }
  92
  93             var xy = Ext.lib.Event.getXY(e),
  94                 pt = new Ext.lib.Point(xy[0], xy[1]),
  95                 id,
  96                 el,
  97                 r,
  98                 c;
  99             for (id in els) {
 100                 if (els.hasOwnProperty(id)) {
 101                     el = els[id];
 102                     r = el._region;
 103                     c = el.ddScrollConfig ? el.ddScrollConfig: dds;
 104                     if (r && r.contains(pt) && el.isScrollable()) {
 105                         if (r.bottom - pt.y <= c.vthresh) {
 106                             if (proc.el != el) {
 107                                 startProc(el, "down");
 108                             }
 109                             return;
 110                         } else if (r.right - pt.x <= c.hthresh) {
 111                             if (proc.el != el) {
 112                                 startProc(el, "left");
 113                             }
 114                             return;
 115                         } else if (pt.y - r.top <= c.vthresh) {
 116                             if (proc.el != el) {
 117                                 startProc(el, "up");
 118                             }
 119                             return;
 120                         } else if (pt.x - r.left <= c.hthresh) {
 121                             if (proc.el != el) {
 122                                 startProc(el, "right");
 123                             }
 124                             return;
 125                         }
 126                     }
 127                 }
 128             }
 129             clearProc();
 130         };
 131
 132     ddm.fireEvents = ddm.fireEvents.createSequence(onFire, ddm);
 133     ddm.stopDrag = ddm.stopDrag.createSequence(onStop, ddm);
 134
 135     return {
 136         <div id="method-Ext.dd.ScrollManager-register"></div>/**
 137          * Registers new overflow element(s) to auto scroll
 138          * @param {Mixed/Array} el The id of or the element to be scrolled or an array of either
 139          */
 140         register: function(el) {
 141             if (Ext.isArray(el)) {
 142                 var i = 0,
 143                     len = el.length;
 144                 for (; i < len; i++) {
 145                     this.register(el[i]);
 146                 }
 147             } else {
 148                 el = Ext.get(el);
 149                 els[el.id] = el;
 150             }
 151         },
 152
 153         <div id="method-Ext.dd.ScrollManager-unregister"></div>/**
 154          * Unregisters overflow element(s) so they are no longer scrolled
 155          * @param {Mixed/Array} el The id of or the element to be removed or an array of either
 156          */
 157         unregister: function(el) {
 158             if (Ext.isArray(el)) {
 159                 var i = 0,
 160                     len = el.length;
 161                 for (; i < len; i++) {
 162                     this.unregister(el[i]);
 163                 }
 164             } else {
 165                 el = Ext.get(el);
 166                 delete els[el.id];
 167             }
 168         },
 169
 170         <div id="prop-Ext.dd.ScrollManager-vthresh"></div>/**
 171          * The number of pixels from the top or bottom edge of a container the pointer needs to be to
 172          * trigger scrolling (defaults to 25)
 173          * @type Number
 174          */
 175         vthresh: 25,
 176         <div id="prop-Ext.dd.ScrollManager-hthresh"></div>/**
 177          * The number of pixels from the right or left edge of a container the pointer needs to be to
 178          * trigger scrolling (defaults to 25)
 179          * @type Number
 180          */
 181         hthresh: 25,
 182
 183         <div id="prop-Ext.dd.ScrollManager-increment"></div>/**
 184          * The number of pixels to scroll in each scroll increment (defaults to 50)
 185          * @type Number
 186          */
 187         increment: 100,
 188
 189         <div id="prop-Ext.dd.ScrollManager-frequency"></div>/**
 190          * The frequency of scrolls in milliseconds (defaults to 500)
 191          * @type Number
 192          */
 193         frequency: 500,
 194
 195         <div id="prop-Ext.dd.ScrollManager-animate"></div>/**
 196          * True to animate the scroll (defaults to true)
 197          * @type Boolean
 198          */
 199         animate: true,
 200
 201         <div id="prop-Ext.dd.ScrollManager-animDuration"></div>/**
 202          * The animation duration in seconds -
 203          * MUST BE less than Ext.dd.ScrollManager.frequency! (defaults to .4)
 204          * @type Number
 205          */
 206         animDuration: 0.4,
 207
 208         <div id="method-Ext.dd.ScrollManager-refreshCache"></div>/**
 209          * Manually trigger a cache refresh.
 210          */
 211         refreshCache: function() {
 212             var id;
 213             for (id in els) {
 214                 if (els.hasOwnProperty(id)) {
 215                     if (typeof els[id] == 'object') {
 216                         // for people extending the object prototype
 217                         els[id]._region = els[id].getRegion();
 218                     }
 219                 }
 220             }
 221         }
 222     };
 223 }();</pre>
 224 </body>
 225 </html>