← Back to branch summary

~ubuntu-branches/ubuntu/saucy/whoopsie-daisy/saucy

« back to all changes in this revision

Viewing changes to backend/stats/static/js/yui/build/dd-scroll/dd-scroll.js

  • Committer: Package Import Robot
  • Author(s): Evan Dandrea
  • Date: 2012-04-18 13:04:36 UTC
  • Revision ID: package-import@ubuntu.com-20120418130436-vmt93p8fds516lws
Tags: 0.1.32
Fix failing tests on powerpc and ARM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/stats/static/js/yui/build/dd-scroll/dd-scroll.js
 
1
/*
 
2
YUI 3.5.0 (build 5089)
 
3
Copyright 2012 Yahoo! Inc. All rights reserved.
 
4
Licensed under the BSD License.
 
5
http://yuilibrary.com/license/
 
6
*/
 
7
YUI.add('dd-scroll', function(Y) {
 
8
 
 
9
 
 
10
    /**
 
11
     * Base scroller class used to create the Plugin.DDNodeScroll and Plugin.DDWinScroll.
 
12
     * This class should not be called on it's own, it's designed to be a plugin.
 
13
     * @module dd
 
14
     * @submodule dd-scroll
 
15
     */
 
16
    /**
 
17
     * Base scroller class used to create the Plugin.DDNodeScroll and Plugin.DDWinScroll.
 
18
     * This class should not be called on it's own, it's designed to be a plugin.
 
19
     * @class Scroll
 
20
     * @extends Base
 
21
     * @namespace DD
 
22
     * @constructor
 
23
     */
 
24
 
 
25
    var S = function() {
 
26
        S.superclass.constructor.apply(this, arguments);
 
27
 
 
28
    },
 
29
    WS, NS,
 
30
    HOST = 'host',
 
31
    BUFFER = 'buffer',
 
32
    PARENT_SCROLL = 'parentScroll',
 
33
    WINDOW_SCROLL = 'windowScroll',
 
34
    SCROLL_TOP = 'scrollTop',
 
35
    SCROLL_LEFT = 'scrollLeft',
 
36
    OFFSET_WIDTH = 'offsetWidth',
 
37
    OFFSET_HEIGHT = 'offsetHeight';
 
38
 
 
39
 
 
40
    S.ATTRS = {
 
41
        /**
 
42
        * @attribute parentScroll
 
43
        * @description Internal config option to hold the node that we are scrolling. Should not be set by the developer.
 
44
        * @type Node
 
45
        */
 
46
        parentScroll: {
 
47
            value: false,
 
48
            setter: function(node) {
 
49
                if (node) {
 
50
                    return node;
 
51
                }
 
52
                return false;
 
53
            }
 
54
        },
 
55
        /**
 
56
        * @attribute buffer
 
57
        * @description The number of pixels from the edge of the screen to turn on scrolling. Default: 30
 
58
        * @type Number
 
59
        */
 
60
        buffer: {
 
61
            value: 30,
 
62
            validator: Y.Lang.isNumber
 
63
        },
 
64
        /**
 
65
        * @attribute scrollDelay
 
66
        * @description The number of milliseconds delay to pass to the auto scroller. Default: 235
 
67
        * @type Number
 
68
        */
 
69
        scrollDelay: {
 
70
            value: 235,
 
71
            validator: Y.Lang.isNumber
 
72
        },
 
73
        /**
 
74
        * @attribute host
 
75
        * @description The host we are plugged into.
 
76
        * @type Object
 
77
        */
 
78
        host: {
 
79
            value: null
 
80
        },
 
81
        /**
 
82
        * @attribute windowScroll
 
83
        * @description Turn on window scroll support, default: false
 
84
        * @type Boolean
 
85
        */
 
86
        windowScroll: {
 
87
            value: false,
 
88
            validator: Y.Lang.isBoolean
 
89
        },
 
90
        /**
 
91
        * @attribute vertical
 
92
        * @description Allow vertical scrolling, default: true.
 
93
        * @type Boolean
 
94
        */
 
95
        vertical: {
 
96
            value: true,
 
97
            validator: Y.Lang.isBoolean
 
98
        },
 
99
        /**
 
100
        * @attribute horizontal
 
101
        * @description Allow horizontal scrolling, default: true.
 
102
        * @type Boolean
 
103
        */
 
104
        horizontal: {
 
105
            value: true,
 
106
            validator: Y.Lang.isBoolean
 
107
        }
 
108
    };
 
109
 
 
110
    Y.extend(S, Y.Base, {
 
111
        /**
 
112
        * @private
 
113
        * @property _scrolling
 
114
        * @description Tells if we are actively scrolling or not.
 
115
        * @type Boolean
 
116
        */
 
117
        _scrolling: null,
 
118
        /**
 
119
        * @private
 
120
        * @property _vpRegionCache
 
121
        * @description Cache of the Viewport dims.
 
122
        * @type Object
 
123
        */
 
124
        _vpRegionCache: null,
 
125
        /**
 
126
        * @private
 
127
        * @property _dimCache
 
128
        * @description Cache of the dragNode dims.
 
129
        * @type Object
 
130
        */
 
131
        _dimCache: null,
 
132
        /**
 
133
        * @private
 
134
        * @property _scrollTimer
 
135
        * @description Holder for the Timer object returned from Y.later.
 
136
        * @type {Y.later}
 
137
        */
 
138
        _scrollTimer: null,
 
139
        /**
 
140
        * @private
 
141
        * @method _getVPRegion
 
142
        * @description Sets the _vpRegionCache property with an Object containing the dims from the viewport.
 
143
        */        
 
144
        _getVPRegion: function() {
 
145
            var r = {},
 
146
                n = this.get(PARENT_SCROLL),
 
147
            b = this.get(BUFFER),
 
148
            ws = this.get(WINDOW_SCROLL),
 
149
            xy = ((ws) ? [] : n.getXY()),
 
150
            w = ((ws) ? 'winWidth' : OFFSET_WIDTH),
 
151
            h = ((ws) ? 'winHeight' : OFFSET_HEIGHT),
 
152
            t = ((ws) ? n.get(SCROLL_TOP) : xy[1]),
 
153
            l = ((ws) ? n.get(SCROLL_LEFT) : xy[0]);
 
154
 
 
155
            r = {
 
156
                top: t + b,
 
157
                right: (n.get(w) + l) - b,
 
158
                bottom: (n.get(h) + t) - b,
 
159
                left: l + b
 
160
            };
 
161
            this._vpRegionCache = r;
 
162
            return r;
 
163
        },
 
164
        initializer: function() {
 
165
            var h = this.get(HOST);
 
166
            h.after('drag:start', Y.bind(this.start, this));
 
167
            h.after('drag:end', Y.bind(this.end, this));
 
168
            h.on('drag:align', Y.bind(this.align, this));
 
169
 
 
170
            //TODO - This doesn't work yet??
 
171
            Y.one('win').on('scroll', Y.bind(function() {
 
172
                this._vpRegionCache = null;
 
173
            }, this));
 
174
        },
 
175
        /**
 
176
        * @private
 
177
        * @method _checkWinScroll
 
178
        * @description Check to see if we need to fire the scroll timer. If scroll timer is running this will scroll the window.
 
179
        * @param {Boolean} move Should we move the window. From Y.later
 
180
        */        
 
181
        _checkWinScroll: function(move) {
 
182
            var r = this._getVPRegion(),
 
183
                ho = this.get(HOST),
 
184
                ws = this.get(WINDOW_SCROLL),
 
185
                xy = ho.lastXY,
 
186
                scroll = false,
 
187
                b = this.get(BUFFER),
 
188
                win = this.get(PARENT_SCROLL),
 
189
                sTop = win.get(SCROLL_TOP),
 
190
                sLeft = win.get(SCROLL_LEFT),
 
191
                w = this._dimCache.w,
 
192
                h = this._dimCache.h,
 
193
                bottom = xy[1] + h,
 
194
                top = xy[1],
 
195
                right = xy[0] + w,
 
196
                left = xy[0],
 
197
                nt = top,
 
198
                nl = left,
 
199
                st = sTop,
 
200
                sl = sLeft;
 
201
            
 
202
            if (this.get('horizontal')) {
 
203
                if (left <= r.left) {
 
204
                    scroll = true;
 
205
                    nl = xy[0] - ((ws) ? b : 0);
 
206
                    sl = sLeft - b;
 
207
                }
 
208
                if (right >= r.right) {
 
209
                    scroll = true;
 
210
                    nl = xy[0] + ((ws) ? b : 0);
 
211
                    sl = sLeft + b;
 
212
                }
 
213
            }
 
214
            if (this.get('vertical')) {
 
215
                if (bottom >= r.bottom) {
 
216
                    scroll = true;
 
217
                    nt = xy[1] + ((ws) ? b : 0);
 
218
                    st = sTop + b;
 
219
 
 
220
                }
 
221
                if (top <= r.top) {
 
222
                    scroll = true;
 
223
                    nt = xy[1] - ((ws) ? b : 0);
 
224
                    st = sTop - b;
 
225
                }
 
226
            }
 
227
 
 
228
            if (st < 0) {
 
229
                st = 0;
 
230
                nt = xy[1];
 
231
            }
 
232
 
 
233
            if (sl < 0) {
 
234
                sl = 0;
 
235
                nl = xy[0];
 
236
            }
 
237
 
 
238
            if (nt < 0) {
 
239
                nt = xy[1];
 
240
            }
 
241
            if (nl < 0) {
 
242
                nl = xy[0];
 
243
            }
 
244
            if (move) {
 
245
                ho.actXY = [nl, nt];
 
246
                ho._moveNode({ node: win, top: st, left: sl});
 
247
                if (!st && !sl) {
 
248
                    this._cancelScroll();
 
249
                }
 
250
            } else {
 
251
                if (scroll) {
 
252
                    this._initScroll();
 
253
                } else {
 
254
                    this._cancelScroll();
 
255
                }
 
256
            }
 
257
        },
 
258
        /**
 
259
        * @private
 
260
        * @method _initScroll
 
261
        * @description Cancel a previous scroll timer and init a new one.
 
262
        */        
 
263
        _initScroll: function() {
 
264
            this._cancelScroll();
 
265
            this._scrollTimer = Y.Lang.later(this.get('scrollDelay'), this, this._checkWinScroll, [true], true);
 
266
 
 
267
        },
 
268
        /**
 
269
        * @private
 
270
        * @method _cancelScroll
 
271
        * @description Cancel a currently running scroll timer.
 
272
        */        
 
273
        _cancelScroll: function() {
 
274
            this._scrolling = false;
 
275
            if (this._scrollTimer) {
 
276
                this._scrollTimer.cancel();
 
277
                delete this._scrollTimer;
 
278
            }
 
279
        },
 
280
        /**
 
281
        * @method align
 
282
        * @description Called from the drag:align event to determine if we need to scroll.
 
283
        */        
 
284
        align: function(e) {
 
285
            if (this._scrolling) {
 
286
                this._cancelScroll();
 
287
                e.preventDefault();
 
288
            }
 
289
            if (!this._scrolling) {
 
290
                this._checkWinScroll();
 
291
            }
 
292
        },
 
293
        /**
 
294
        * @private
 
295
        * @method _setDimCache
 
296
        * @description Set the cache of the dragNode dims.
 
297
        */        
 
298
        _setDimCache: function() {
 
299
            var node = this.get(HOST).get('dragNode');
 
300
            this._dimCache = {
 
301
                h: node.get(OFFSET_HEIGHT),
 
302
                w: node.get(OFFSET_WIDTH)
 
303
            };
 
304
        },
 
305
        /**
 
306
        * @method start
 
307
        * @description Called from the drag:start event
 
308
        */
 
309
        start: function() {
 
310
            this._setDimCache();
 
311
        },
 
312
        /**
 
313
        * @method end
 
314
        * @description Called from the drag:end event
 
315
        */
 
316
        end: function(xy) {
 
317
            this._dimCache = null;
 
318
            this._cancelScroll();
 
319
        }
 
320
    });
 
321
 
 
322
    Y.namespace('Plugin');
 
323
 
 
324
    
 
325
    /**
 
326
     * Extends the Scroll class to make the window scroll while dragging.
 
327
     * @class DDWindowScroll
 
328
     * @extends Scroll
 
329
     * @namespace Plugin
 
330
     * @constructor
 
331
     */
 
332
    WS = function() {
 
333
        WS.superclass.constructor.apply(this, arguments);
 
334
    };
 
335
    WS.ATTRS = Y.merge(S.ATTRS, {
 
336
        /**
 
337
        * @attribute windowScroll
 
338
        * @description Turn on window scroll support, default: true
 
339
        * @type Boolean
 
340
        */
 
341
        windowScroll: {
 
342
            value: true,
 
343
            setter: function(scroll) {
 
344
                if (scroll) {
 
345
                    this.set(PARENT_SCROLL, Y.one('win'));
 
346
                }
 
347
                return scroll;
 
348
            }
 
349
        }
 
350
    });
 
351
    Y.extend(WS, S, {
 
352
        //Shouldn't have to do this..
 
353
        initializer: function() {
 
354
            this.set('windowScroll', this.get('windowScroll'));
 
355
        }
 
356
    });
 
357
    /**
 
358
    * @property NS
 
359
    * @default winscroll
 
360
    * @readonly
 
361
    * @protected
 
362
    * @static
 
363
    * @description The Scroll instance will be placed on the Drag instance under the winscroll namespace.
 
364
    * @type {String}
 
365
    */
 
366
    WS.NAME = WS.NS = 'winscroll';
 
367
    Y.Plugin.DDWinScroll = WS;
 
368
    
 
369
 
 
370
    /**
 
371
     * Extends the Scroll class to make a parent node scroll while dragging.
 
372
     * @class DDNodeScroll
 
373
     * @extends Scroll
 
374
     * @namespace Plugin
 
375
     * @constructor
 
376
     */
 
377
    NS = function() {
 
378
        NS.superclass.constructor.apply(this, arguments);
 
379
 
 
380
    };
 
381
    NS.ATTRS = Y.merge(S.ATTRS, {
 
382
        /**
 
383
        * @attribute node
 
384
        * @description The node we want to scroll. Used to set the internal parentScroll attribute.
 
385
        * @type Node
 
386
        */
 
387
        node: {
 
388
            value: false,
 
389
            setter: function(node) {
 
390
                var n = Y.one(node);
 
391
                if (!n) {
 
392
                    if (node !== false) {
 
393
                        Y.error('DDNodeScroll: Invalid Node Given: ' + node);
 
394
                    }
 
395
                } else {
 
396
                    this.set(PARENT_SCROLL, n);
 
397
                }
 
398
                return n;
 
399
            }
 
400
        }
 
401
    });
 
402
    Y.extend(NS, S, {
 
403
        //Shouldn't have to do this..
 
404
        initializer: function() {
 
405
            this.set('node', this.get('node'));
 
406
        }
 
407
    });
 
408
    /**
 
409
    * @property NS
 
410
    * @default nodescroll
 
411
    * @readonly
 
412
    * @protected
 
413
    * @static
 
414
    * @description The NodeScroll instance will be placed on the Drag instance under the nodescroll namespace.
 
415
    * @type {String}
 
416
    */
 
417
    NS.NAME = NS.NS = 'nodescroll';
 
418
    Y.Plugin.DDNodeScroll = NS;
 
419
 
 
420
    Y.DD.Scroll = S;    
 
421
 
 
422
 
 
423
 
 
424
 
 
425
}, '3.5.0' ,{skinnable:false, optional:['dd-proxy'], requires:['dd-drag']});