← Back to branch summary

~jstys-z/helioviewer.org/timeline

« back to all changes in this revision

Viewing changes to lib/jquery/jquery.ui-1.6rc2/tests/draggable.js

  • Committer: V. Keith Hughitt
  • Date: 2009-03-26 19:20:57 UTC
  • Revision ID: hughitt1@kore-20090326192057-u0x8rf8sf5lmmnwh
nightly build 03-26-2009: Using alpha-channel JPEG 2000 dataset

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/jquery/jquery.ui-1.6rc2/tests/draggable.js
1
 
/*
2
 
 * draggable unit tests
3
 
 */
4
 
(function($) {
5
 
//
6
 
// Draggable Test Helper Functions
7
 
//
8
 
var el, offsetBefore, offsetAfter, dragged;
9
 
 
10
 
var drag = function(handle, dx, dy) {
11
 
        var element = el.data("draggable").element;
12
 
        offsetBefore = el.offset();
13
 
        $(handle).simulate("drag", {
14
 
                dx: dx || 0,
15
 
                dy: dy || 0
16
 
        });
17
 
        dragged = { dx: dx, dy: dy };
18
 
        offsetAfter = el.offset();
19
 
}
20
 
 
21
 
var moved = function (dx, dy, msg) {
22
 
        msg = msg ? msg + "." : "";
23
 
        var actual = { left: offsetAfter.left, top: offsetAfter.top };
24
 
        var expected = { left: offsetBefore.left + dx, top: offsetBefore.top + dy };
25
 
        compare2(actual, expected, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ' + msg);
26
 
}
27
 
 
28
 
function shouldmove(why) {
29
 
        drag(el, 50, 50);
30
 
        moved(50, 50, why);
31
 
}
32
 
 
33
 
function shouldnotmove(why) {
34
 
        drag(el, 50, 50);
35
 
        moved(0, 0, why);
36
 
}
37
 
 
38
 
var border = function(el, side) { return parseInt(el.css('border-' + side + '-width')); }
39
 
 
40
 
var margin = function(el, side) { return parseInt(el.css('margin-' + side)); }
41
 
 
42
 
// Draggable Tests
43
 
module("draggable");
44
 
 
45
 
test("init", function() {
46
 
        expect(6);
47
 
 
48
 
        el = $("#draggable1").draggable();
49
 
        ok(true, '.draggable() called on element');
50
 
 
51
 
        $([]).draggable();
52
 
        ok(true, '.draggable() called on empty collection');
53
 
 
54
 
        $("<div/>").draggable();
55
 
        ok(true, '.draggable() called on disconnected DOMElement');
56
 
 
57
 
        $("<div/>").draggable().draggable("foo");
58
 
        ok(true, 'arbitrary method called after init');
59
 
 
60
 
        $("<div/>").draggable().data("foo.draggable");
61
 
        ok(true, 'arbitrary option getter after init');
62
 
 
63
 
        $("<div/>").draggable().data("foo.draggable", "bar");
64
 
        ok(true, 'arbitrary option setter after init');
65
 
});
66
 
 
67
 
test("destroy", function() {
68
 
        expect(6);
69
 
 
70
 
        $("#draggable1").draggable().draggable("destroy");      
71
 
        ok(true, '.draggable("destroy") called on element');
72
 
 
73
 
        $([]).draggable().draggable("destroy");
74
 
        ok(true, '.draggable("destroy") called on empty collection');
75
 
 
76
 
        $("<div/>").draggable().draggable("destroy");
77
 
        ok(true, '.draggable("destroy") called on disconnected DOMElement');
78
 
 
79
 
        $("<div/>").draggable().draggable("destroy").draggable("foo");
80
 
        ok(true, 'arbitrary method called after destroy');
81
 
 
82
 
        $("<div/>").draggable().draggable("destroy").data("foo.draggable");
83
 
        ok(true, 'arbitrary option getter after destroy');
84
 
 
85
 
        $("<div/>").draggable().draggable("destroy").data("foo.draggable", "bar");
86
 
        ok(true, 'arbitrary option setter after destroy');
87
 
});
88
 
 
89
 
test("enable", function() {
90
 
        expect(6);
91
 
        el = $("#draggable2").draggable({ disabled: true });
92
 
        shouldnotmove('.draggable({ disabled: true })');
93
 
        el.draggable("enable");
94
 
        shouldmove('.draggable("enable")');
95
 
        equals(el.data("disabled.draggable"), false, "disabled.draggable getter");
96
 
 
97
 
        el.draggable("destroy");
98
 
        el.draggable({ disabled: true });
99
 
        shouldnotmove('.draggable({ disabled: true })');
100
 
        el.data("disabled.draggable", false);
101
 
        equals(el.data("disabled.draggable"), false, "disabled.draggable setter");
102
 
        shouldmove('.data("disabled.draggable", false)');
103
 
});
104
 
 
105
 
test("disable", function() {
106
 
        expect(6);
107
 
        el = $("#draggable2").draggable({ disabled: false });
108
 
        shouldmove('.draggable({ disabled: false })');
109
 
        el.draggable("disable");
110
 
        shouldnotmove('.draggable("disable")');
111
 
        equals(el.data("disabled.draggable"), true, "disabled.draggable getter");
112
 
 
113
 
        el.draggable("destroy");
114
 
 
115
 
        el.draggable({ disabled: false });
116
 
        shouldmove('.draggable({ disabled: false })');
117
 
        el.data("disabled.draggable", true);
118
 
        equals(el.data("disabled.draggable"), true, "disabled.draggable setter");
119
 
        shouldnotmove('.data("disabled.draggable", true)');
120
 
});
121
 
 
122
 
test("element types", function() {
123
 
        var typeNames = ('p,h1,h2,h3,h4,h5,h6,blockquote,ol,ul,dl,div,form'
124
 
                + ',table,fieldset,address,ins,del,em,strong,q,cite,dfn,abbr'
125
 
                + ',acronym,code,samp,kbd,var,img,object,hr'
126
 
                + ',input,button,label,select,iframe').split(',');
127
 
 
128
 
        $.each(typeNames, function(i) {
129
 
                var typeName = typeNames[i];
130
 
                el = $(document.createElement(typeName)).appendTo('body');
131
 
                (typeName == 'table' && el.append("<tr><td>content</td></tr>"));
132
 
                el.draggable({ cancel: '' });
133
 
                drag(el, 50, 50);
134
 
                moved(50, 50, "&lt;" + typeName + "&gt;");
135
 
                el.draggable("destroy");
136
 
                el.remove();
137
 
        });
138
 
});
139
 
 
140
 
test("defaults", function() {
141
 
        el = $("#draggable1").draggable();
142
 
        equals(el.data("appendTo.draggable"), "parent", "appendTo");
143
 
        equals(el.data("axis.draggable"), false, "axis");
144
 
        equals(el.data("cancel.draggable"), ":input", "cancel");
145
 
        equals(el.data("delay.draggable"), 0, "delay");
146
 
        equals(el.data("disabled.draggable"), false, "disabled");
147
 
        equals(el.data("distance.draggable"), 1, "distance");
148
 
        equals(el.data("helper.draggable"), "original", "helper");
149
 
});
150
 
 
151
 
test("No options, relative", function() {
152
 
        el = $("#draggable1").draggable();
153
 
        drag(el, 50, 50);
154
 
        moved(50, 50);
155
 
});
156
 
 
157
 
test("No options, absolute", function() {
158
 
        el = $("#draggable2").draggable();
159
 
        drag(el, 50, 50);
160
 
        moved(50, 50);  
161
 
});
162
 
 
163
 
module("draggable: Options");
164
 
 
165
 
test("{ axis: false }, default", function() {
166
 
        el = $("#draggable2").draggable({ axis: false });
167
 
        drag(el, 50, 50);
168
 
        moved(50, 50);
169
 
});
170
 
 
171
 
test("{ axis: 'x' }", function() {
172
 
        el = $("#draggable2").draggable({ axis: "x" });
173
 
        drag(el, 50, 50);
174
 
        moved(50, 0);
175
 
});
176
 
 
177
 
test("{ axis: 'y' }", function() {
178
 
        el = $("#draggable2").draggable({ axis: "y" });
179
 
        drag(el, 50, 50);
180
 
        moved(0, 50);
181
 
});
182
 
 
183
 
test("{ axis: ? }, unexpected", function() {
184
 
        var unexpected = {
185
 
                "true": true,
186
 
                "{}": {},
187
 
                "[]": [],
188
 
                "null": null,
189
 
                "undefined": undefined,
190
 
                "function() {}": function() {}
191
 
        };
192
 
        $.each(unexpected, function(key, val) {
193
 
                el = $("#draggable2").draggable({ axis: val });
194
 
                drag(el, 50, 50);
195
 
                moved(50, 50, "axis: " + key);
196
 
                el.draggable("destroy");
197
 
        })
198
 
});
199
 
 
200
 
test("{ cancel: 'span' }", function() {
201
 
        el = $("#draggable2").draggable();
202
 
        drag("#draggable2 span", 50, 50);
203
 
        moved(50, 50);
204
 
        
205
 
        el.draggable("destroy");
206
 
 
207
 
        el = $("#draggable2").draggable({ cancel: 'span' });
208
 
        drag("#draggable2 span", 50, 50);
209
 
        moved(0, 0);
210
 
});
211
 
 
212
 
test("{ cancel: ? }, unexpected", function() {
213
 
        var unexpected = {
214
 
                "true": true,
215
 
                "false": false,
216
 
                "{}": {},
217
 
                "[]": [],
218
 
                "null": null,
219
 
                "undefined": undefined,
220
 
                "function() {return '';}": function() {return '';},
221
 
                "function() {return true;}": function() {return true;},
222
 
                "function() {return false;}": function() {return false;}
223
 
        };
224
 
        $.each(unexpected, function(key, val) {
225
 
                el = $("#draggable2").draggable({ cancel: val });
226
 
                drag(el, 50, 50);
227
 
                var expected = [50, 50];
228
 
                moved(expected[0], expected[1], "cancel: " + key);
229
 
                el.draggable("destroy");
230
 
        })
231
 
});
232
 
 
233
 
test("{ containment: 'parent' }, relative", function() {
234
 
        el = $("#draggable1").draggable({ containment: 'parent' });
235
 
        var p = el.parent(), po = p.offset();
236
 
        drag(el, -100, -100);
237
 
        var expected = {
238
 
                left: po.left + border(p, 'left') + margin(el, 'left'),
239
 
                top: po.top + border(p, 'top') + margin(el, 'top')
240
 
        }
241
 
        compare2(offsetAfter, expected, 'compare offset to parent');
242
 
});
243
 
 
244
 
test("{ containment: 'parent' }, absolute", function() {
245
 
        el = $("#draggable2").draggable({ containment: 'parent' });
246
 
        var p = el.parent(), po = p.offset();
247
 
        drag(el, -100, -100);
248
 
        var expected = {
249
 
                left: po.left + border(p, 'left') + margin(el, 'left'),
250
 
                top: po.top + border(p, 'top') + margin(el, 'top')
251
 
        }
252
 
        compare2(offsetAfter, expected, 'compare offset to parent');
253
 
});
254
 
 
255
 
test("{ cursor: 'move' }", function() {
256
 
        
257
 
        function getCursor() { return $("body").css("cursor"); }
258
 
        
259
 
        expect(2);
260
 
        
261
 
        var expected = "move", actual, before, after;
262
 
        
263
 
        el = $("#draggable2").draggable({
264
 
                cursor: expected,
265
 
                start: function(e, ui) {
266
 
                        actual = getCursor();
267
 
                }
268
 
        });
269
 
        
270
 
        before = getCursor();
271
 
        drag("#draggable2", -1, -1);
272
 
        after = getCursor();
273
 
        
274
 
        equals(actual, expected, "start callback: cursor '" + expected + "'");
275
 
        equals(after, before, "after drag: cursor restored");
276
 
        
277
 
});
278
 
 
279
 
test("{ cursorAt: { left: -5, top: -5 } }", function() {
280
 
        
281
 
        expect(4);
282
 
        
283
 
        var dx = -3, dy = -3;
284
 
        var ox = 5, oy = 5;
285
 
        var cax = -5, cay = -5;
286
 
        
287
 
        var actual = null;
288
 
        $("#draggable2").draggable({
289
 
                cursorAt: { left: cax, top: cay },
290
 
                drag: function(e, ui) {
291
 
                        actual = ui.absolutePosition;
292
 
                }
293
 
        });
294
 
        var el = $("#draggable2").data("draggable").element;
295
 
        
296
 
        var before = el.offset();
297
 
        var pos = { clientX: before.left + ox, clientY: before.top + oy };
298
 
        $("#draggable2").simulate("mousedown", pos);
299
 
        pos = { clientX: pos.clientX + dx, clientY: pos.clientY + dy };
300
 
        $(document).simulate("mousemove", pos);
301
 
        $(document).simulate("mousemove", pos);
302
 
        $("#draggable2").simulate("mouseup", pos);
303
 
        var expected = {
304
 
                left: before.left + ox - cax + dx,
305
 
                top: before.top + oy - cay + dy
306
 
        };
307
 
        
308
 
        equals(actual.left, expected.left, "Absolute: -1px left");
309
 
        equals(actual.top, expected.top, "Absolute: -1px top");
310
 
        
311
 
        var actual = null;
312
 
        $("#draggable1").draggable({
313
 
                cursorAt: { left: cax, top: cay },
314
 
                drag: function(e, ui) {
315
 
                        actual = ui.absolutePosition;
316
 
                }
317
 
        });
318
 
        var el = $("#draggable2").data("draggable").element;
319
 
        
320
 
        var before = el.offset();
321
 
        var pos = { clientX: before.left + ox, clientY: before.top + oy };
322
 
        $("#draggable2").simulate("mousedown", pos);
323
 
        pos = { clientX: pos.clientX + dx, clientY: pos.clientY + dy };
324
 
        $(document).simulate("mousemove", pos);
325
 
        $(document).simulate("mousemove", pos);
326
 
        $("#draggable2").simulate("mouseup", pos);
327
 
        var expected = {
328
 
                left: before.left + ox - cax + dx,
329
 
                top: before.top + oy - cay + dy
330
 
        };
331
 
        
332
 
        equals(actual.left, expected.left, "Relative: -1px left");
333
 
        equals(actual.top, expected.top, "Relative: -1px top");
334
 
        
335
 
});
336
 
 
337
 
test("{ distance: 10 }", function() {
338
 
 
339
 
        el = $("#draggable2").draggable({ distance: 10 });
340
 
        drag(el, -9, -9);
341
 
        moved(0, 0, 'distance not met');
342
 
 
343
 
        drag(el, -10, -10);
344
 
        moved(-10, -10, 'distance met');
345
 
 
346
 
        drag(el, 9, 9);
347
 
        moved(0, 0, 'distance not met');
348
 
        
349
 
});
350
 
 
351
 
test("{ grid: [50, 50] }, relative", function() {
352
 
        el = $("#draggable1").draggable({ grid: [50, 50] });
353
 
        drag(el, 24, 24);
354
 
        moved(0, 0);
355
 
        drag(el, 26, 25);
356
 
        moved(50, 50);
357
 
});
358
 
 
359
 
test("{ grid: [50, 50] }, absolute", function() {
360
 
        el = $("#draggable2").draggable({ grid: [50, 50] });
361
 
        drag(el, 24, 24);
362
 
        moved(0, 0);
363
 
        drag(el, 26, 25);
364
 
        moved(50, 50);
365
 
});
366
 
 
367
 
test("{ handle: 'span' }", function() {
368
 
        el = $("#draggable2").draggable({ handle: 'span' });
369
 
 
370
 
        drag("#draggable2 span", 50, 50);
371
 
        moved(50, 50, "drag span");
372
 
 
373
 
        drag("#draggable2", 50, 50);
374
 
        moved(0, 0, "drag element");
375
 
});
376
 
 
377
 
test("{ helper: 'clone' }, relative", function() {
378
 
        el = $("#draggable1").draggable({ helper: "clone" });
379
 
        drag(el, 50, 50);
380
 
        moved(0, 0);
381
 
});
382
 
 
383
 
test("{ helper: 'clone' }, absolute", function() {
384
 
        el = $("#draggable2").draggable({ helper: "clone" });
385
 
        drag(el, 50, 50);
386
 
        moved(0, 0);    
387
 
});
388
 
 
389
 
test("{ opacity: 0.5 }", function() {
390
 
        
391
 
        expect(1);
392
 
        
393
 
        var opacity = null;
394
 
        el = $("#draggable2").draggable({
395
 
                opacity: 0.5,
396
 
                start: function(e, ui) {
397
 
                        opacity = $(this).css("opacity");
398
 
                }
399
 
        });
400
 
        
401
 
        drag("#draggable2", -1, -1);
402
 
        
403
 
        equals(opacity, 0.5, "start callback: opacity is");
404
 
        
405
 
});
406
 
 
407
 
test("{ zIndex: 10 }", function() {
408
 
        
409
 
        expect(1);
410
 
 
411
 
        var expected = 10, actual;
412
 
        
413
 
        var zIndex = null;
414
 
        el = $("#draggable2").draggable({
415
 
                zIndex: expected,
416
 
                start: function(e, ui) {
417
 
                        actual = $(this).css("zIndex");
418
 
                }
419
 
        });
420
 
        
421
 
        drag("#draggable2", -1, -1);
422
 
        
423
 
        equals(actual, expected, "start callback: zIndex is");
424
 
        
425
 
});
426
 
 
427
 
module("draggable: Callbacks");
428
 
 
429
 
test("callbacks occurance count", function() {
430
 
        
431
 
        expect(3);
432
 
        
433
 
        var start = 0, stop = 0, dragc = 0;
434
 
        el = $("#draggable2").draggable({
435
 
                start: function() { start++; },
436
 
                drag: function() { dragc++; },
437
 
                stop: function() { stop++; }
438
 
        });
439
 
        
440
 
        drag(el, 10, 10);
441
 
        
442
 
        equals(start, 1, "start callback should happen exactly once");
443
 
        equals(dragc, 3 + 1, "drag callback should happen exactly once per mousemove + 1");
444
 
        equals(stop, 1, "stop callback should happen exactly once");
445
 
        
446
 
});
447
 
 
448
 
module("draggable: Scroll offsets");
449
 
 
450
 
test("{ helper: 'original' }, relative, with scroll offset on parent", function() {
451
 
        el = $("#draggable1").draggable({ helper: "original" });
452
 
        $("#main")[0].scrollTop = 100;
453
 
        drag(el, 50, 50);
454
 
        moved(50, 50);
455
 
        $("#main")[0].scrollTop = 0;
456
 
});
457
 
 
458
 
test("{ helper: 'original' }, relative, with scroll offset on root", function() {
459
 
        el = $("#draggable1").draggable({ helper: "original" });
460
 
        $(document).scrollTop(100);
461
 
        drag(el, 50, 50);
462
 
        moved(50, 50);
463
 
        $(document).scrollTop(0);
464
 
});
465
 
 
466
 
test("{ helper: 'original' }, relative, with scroll offset on root and parent", function() {
467
 
        el = $("#draggable1").draggable({ helper: "original" });
468
 
        $(document).scrollTop(100);
469
 
        $("#main")[0].scrollTop = 100;
470
 
        drag(el, 50, 50);
471
 
        moved(50, 50);
472
 
        $(document).scrollTop(0);
473
 
        $("#main")[0].scrollTop = 0;
474
 
});
475
 
 
476
 
test("{ helper: 'original' }, absolute, with scroll offset on parent", function() {
477
 
        el = $("#draggable1").css({ position: 'absolute', top: 0, left: 0 }).draggable({ helper: "original" });
478
 
        $("#main")[0].scrollTop = 100;
479
 
        drag(el, 50, 50);
480
 
        moved(50, 50);
481
 
        $("#main")[0].scrollTop = 0;
482
 
});
483
 
 
484
 
test("{ helper: 'original' }, absolute, with scroll offset on root", function() {
485
 
        el = $("#draggable1").css({ position: 'absolute', top: 0, left: 0 }).draggable({ helper: "original" });
486
 
        $(document).scrollTop(100);
487
 
        drag(el, 50, 50);
488
 
        moved(50, 50);
489
 
        $(document).scrollTop(0);
490
 
});
491
 
 
492
 
test("{ helper: 'original' }, absolute, with scroll offset on root and parent", function() {
493
 
        el = $("#draggable1").css({ position: 'absolute', top: 0, left: 0 }).draggable({ helper: "original" });
494
 
        $(document).scrollTop(100);
495
 
        $("#main")[0].scrollTop = 100;
496
 
        drag(el, 50, 50);
497
 
        moved(50, 50);
498
 
        $(document).scrollTop(0);
499
 
        $("#main")[0].scrollTop = 0;
500
 
});
501
 
 
502
 
//Fixed not for IE < 7
503
 
if(!($.browser.msie && $.browser.version < 7)) {
504
 
 
505
 
        test("{ helper: 'original' }, fixed, with scroll offset on parent", function() {
506
 
                el = $("#draggable1").css({ position: 'fixed', top: 0, left: 0 }).draggable({ helper: "original" });
507
 
                $("#main")[0].scrollTop = 100;
508
 
                drag(el, 50, 50);
509
 
                moved(50, 50);
510
 
                $("#main")[0].scrollTop = 0;
511
 
        });
512
 
        
513
 
        test("{ helper: 'original' }, fixed, with scroll offset on root", function() {
514
 
                el = $("#draggable1").css({ position: 'fixed', top: 0, left: 0 }).draggable({ helper: "original" });
515
 
                $(document).scrollTop(100);
516
 
                drag(el, 50, 50);
517
 
                moved(50, 50);
518
 
                $(document).scrollTop(0);
519
 
        });
520
 
        
521
 
        test("{ helper: 'original' }, fixed, with scroll offset on root and parent", function() {
522
 
                el = $("#draggable1").css({ position: 'fixed', top: 0, left: 0 }).draggable({ helper: "original" });
523
 
                $(document).scrollTop(100);
524
 
                $("#main")[0].scrollTop = 100;
525
 
                drag(el, 50, 50);
526
 
                moved(50, 50);
527
 
                $(document).scrollTop(0);
528
 
                $("#main")[0].scrollTop = 0;
529
 
        });
530
 
 
531
 
}
532
 
 
533
 
 
534
 
 
535
 
test("{ helper: 'clone' }, absolute", function() {
536
 
        
537
 
        var helperOffset = null;
538
 
        var origOffset = $("#draggable1").offset();
539
 
        
540
 
        el = $("#draggable1").draggable({ helper: "clone", drag: function(e, ui) {
541
 
                helperOffset = ui.helper.offset();
542
 
        } });
543
 
 
544
 
        drag(el, 1, 1);
545
 
        
546
 
        compare2({ top: helperOffset.top-1, left: helperOffset.left-1 }, origOffset, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ');
547
 
 
548
 
});
549
 
 
550
 
test("{ helper: 'clone' }, absolute with scroll offset on parent", function() {
551
 
        
552
 
        $("#main")[0].scrollTop = 100;
553
 
        var helperOffset = null;
554
 
        var origOffset = $("#draggable1").offset();
555
 
        
556
 
        el = $("#draggable1").draggable({ helper: "clone", drag: function(e, ui) {
557
 
                helperOffset = ui.helper.offset();
558
 
        } });
559
 
 
560
 
        drag(el, 1, 1);
561
 
        
562
 
        compare2({ top: helperOffset.top-1, left: helperOffset.left-1 }, origOffset, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ');
563
 
        $("#main")[0].scrollTop = 0;
564
 
 
565
 
});
566
 
 
567
 
test("{ helper: 'clone' }, absolute with scroll offset on root", function() {
568
 
        
569
 
        $(document).scrollTop(100);
570
 
        var helperOffset = null;
571
 
        var origOffset = $("#draggable1").offset();
572
 
        
573
 
        el = $("#draggable1").draggable({ helper: "clone", drag: function(e, ui) {
574
 
                helperOffset = ui.helper.offset();
575
 
        } });
576
 
 
577
 
        drag(el, 1, 1);
578
 
        
579
 
        compare2({ top: helperOffset.top-1, left: helperOffset.left-1 }, origOffset, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ');
580
 
        $(document).scrollTop(0);
581
 
 
582
 
});
583
 
 
584
 
test("{ helper: 'clone' }, absolute with scroll offset on root and parent", function() {
585
 
        
586
 
        $(document).scrollTop(100);
587
 
        $("#main")[0].scrollTop = 100;
588
 
        var helperOffset = null;
589
 
        var origOffset = $("#draggable1").offset();
590
 
        
591
 
        el = $("#draggable1").draggable({ helper: "clone", drag: function(e, ui) {
592
 
                helperOffset = ui.helper.offset();
593
 
        } });
594
 
 
595
 
        drag(el, 1, 1);
596
 
        
597
 
        compare2({ top: helperOffset.top-1, left: helperOffset.left-1 }, origOffset, 'dragged[' + dragged.dx + ', ' + dragged.dy + '] ');
598
 
        $(document).scrollTop(0);
599
 
        $("#main")[0].scrollTop = 0;
600
 
 
601
 
});
602
 
 
603
 
 
604
 
module("draggable: Tickets");
605
 
 
606
 
/* This needs to be rewritten
607
 
 
608
 
test("#2965 cursorAt with margin", function() {
609
 
        
610
 
        expect(2);
611
 
        
612
 
        var ox = 0, oy = 0;
613
 
 
614
 
        var actual, expected;
615
 
        $("#draggable2").draggable({
616
 
                cursorAt: { left: ox, top: oy },
617
 
                drag: function(e, ui) {
618
 
                        actual = ui.absolutePosition;
619
 
                }
620
 
        });
621
 
        var el = $("#draggable2").data("draggable").element;
622
 
        
623
 
        $("#draggable2").css('margin', '0px !important');
624
 
 
625
 
        var before = el.offset();
626
 
        var pos = { clientX: before.left + ox, clientY: before.top + oy };
627
 
        $("#draggable2").simulate("mousedown", pos);
628
 
        $(document).simulate("mousemove", { clientX: pos.clientX + 1, clientY: pos.clientY + 1});
629
 
        $(document).simulate("mousemove", pos);
630
 
        $("#draggable2").simulate("mouseup", pos);
631
 
        var expected = actual;
632
 
        actual = undefined;
633
 
 
634
 
        var marg = 13;
635
 
 
636
 
        $("#draggable2").css('margin', marg + 'px !important');
637
 
        var before = el.offset();
638
 
        var pos = { clientX: before.left + ox - marg, clientY: before.top + oy - marg };
639
 
        $("#draggable2").simulate("mousedown", pos);
640
 
        $(document).simulate("mousemove", { clientX: pos.clientX + 1, clientY: pos.clientY + 1});
641
 
        $(document).simulate("mousemove", pos);
642
 
        $("#draggable2").simulate("mouseup", pos);
643
 
        
644
 
        equals(actual.left, expected.left, "10px margin. left");
645
 
        equals(actual.top, expected.top, "10px margin. top");
646
 
        
647
 
});
648
 
*/
649
 
 
650
 
})(jQuery);