Debian Codegraph @

closure-library/closure/goog/fx/abstractdragdrop_test.js

raw
1 // Copyright 2008 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.fx.AbstractDragDropTest');
16 goog.setTestOnly('goog.fx.AbstractDragDropTest');
17
18 goog.require('goog.array');
19 goog.require('goog.dom');
20 goog.require('goog.dom.TagName');
21 goog.require('goog.events');
22 goog.require('goog.events.EventType');
23 goog.require('goog.functions');
24 goog.require('goog.fx.AbstractDragDrop');
25 goog.require('goog.fx.DragDropItem');
26 goog.require('goog.math.Box');
27 goog.require('goog.math.Coordinate');
28 goog.require('goog.style');
29 goog.require('goog.testing.events');
30 goog.require('goog.testing.events.Event');
31 goog.require('goog.testing.jsunit');
32
33 var targets = [
34 {box_: new goog.math.Box(0, 3, 1, 1)}, {box_: new goog.math.Box(0, 7, 2, 6)},
35 {box_: new goog.math.Box(2, 2, 3, 1)}, {box_: new goog.math.Box(4, 1, 6, 1)},
36 {box_: new goog.math.Box(4, 9, 7, 6)},
37 {box_: new goog.math.Box(9, 9, 10, 1)}
38 ];
39
40 var targets2 = [
41 {box_: new goog.math.Box(10, 50, 20, 10)},
42 {box_: new goog.math.Box(20, 50, 30, 10)},
43 {box_: new goog.math.Box(60, 50, 70, 10)},
44 {box_: new goog.math.Box(70, 50, 80, 10)}
45 ];
46
47 var targets3 = [
48 {box_: new goog.math.Box(0, 4, 1, 1)}, {box_: new goog.math.Box(1, 6, 4, 5)},
49 {box_: new goog.math.Box(5, 5, 6, 2)}, {box_: new goog.math.Box(2, 1, 5, 0)}
50 ];
51
52
53 /**
54 * Test the utility function which tells how two one dimensional ranges
55 * overlap.
56 */
57 function testRangeOverlap() {
58 assertEquals(RangeOverlap.LEFT, rangeOverlap(1, 2, 3, 4));
59 assertEquals(RangeOverlap.LEFT, rangeOverlap(2, 3, 3, 4));
60 assertEquals(RangeOverlap.LEFT_IN, rangeOverlap(1, 3, 2, 4));
61 assertEquals(RangeOverlap.IN, rangeOverlap(1, 3, 1, 4));
62 assertEquals(RangeOverlap.IN, rangeOverlap(2, 3, 1, 4));
63 assertEquals(RangeOverlap.IN, rangeOverlap(3, 4, 1, 4));
64 assertEquals(RangeOverlap.RIGHT_IN, rangeOverlap(2, 4, 1, 3));
65 assertEquals(RangeOverlap.RIGHT, rangeOverlap(2, 3, 1, 2));
66 assertEquals(RangeOverlap.RIGHT, rangeOverlap(3, 4, 1, 2));
67 assertEquals(RangeOverlap.CONTAINS, rangeOverlap(1, 4, 2, 3));
68 }
69
70
71 /**
72 * An enum describing how two ranges overlap (non-symmetrical relation).
73 * @enum {number}
74 */
75 RangeOverlap = {
76 LEFT: 1, // First range is placed to the left of the second.
77 LEFT_IN: 2, // First range overlaps on the left side of the second.
78 IN: 3, // First range is completely contained in the second.
79 RIGHT_IN: 4, // First range overlaps on the right side of the second.
80 RIGHT: 5, // First range is placed to the right side of the second.
81 CONTAINS: 6 // First range contains the second.
82 };
83
84
85 /**
86 * Computes how two one dimensional ranges overlap.
87 *
88 * @param {number} left1 Left inclusive bound of the first range.
89 * @param {number} right1 Right exclusive bound of the first range.
90 * @param {number} left2 Left inclusive bound of the second range.
91 * @param {number} right2 Right exclusive bound of the second range.
92 * @return {RangeOverlap} The enum value describing the type of the overlap.
93 */
94 function rangeOverlap(left1, right1, left2, right2) {
95 if (right1 <= left2) return RangeOverlap.LEFT;
96 if (left1 >= right2) return RangeOverlap.RIGHT;
97 var leftIn = left1 >= left2;
98 var rightIn = right1 <= right2;
99 if (leftIn && rightIn) return RangeOverlap.IN;
100 if (leftIn) return RangeOverlap.RIGHT_IN;
101 if (rightIn) return RangeOverlap.LEFT_IN;
102 return RangeOverlap.CONTAINS;
103 }
104
105
106 /**
107 * Tells whether two boxes overlap.
108 *
109 * @param {goog.math.Box} box1 First box in question.
110 * @param {goog.math.Box} box2 Second box in question.
111 * @return {boolean} Whether boxes overlap in any way.
112 */
113 function boxOverlaps(box1, box2) {
114 var horizontalOverlap =
115 rangeOverlap(box1.left, box1.right, box2.left, box2.right);
116 var verticalOverlap =
117 rangeOverlap(box1.top, box1.bottom, box2.top, box2.bottom);
118 return horizontalOverlap != RangeOverlap.LEFT &&
119 horizontalOverlap != RangeOverlap.RIGHT &&
120 verticalOverlap != RangeOverlap.LEFT &&
121 verticalOverlap != RangeOverlap.RIGHT;
122 }
123
124
125 /**
126 * Tests if the utility function to compute box overlapping functions properly.
127 */
128 function testBoxOverlaps() {
129 // Overlapping tests.
130 var box2 = new goog.math.Box(1, 4, 4, 1);
131
132 // Corner overlaps.
133 assertTrue('NW overlap', boxOverlaps(new goog.math.Box(0, 2, 2, 0), box2));
134 assertTrue('NE overlap', boxOverlaps(new goog.math.Box(0, 5, 2, 3), box2));
135 assertTrue('SE overlap', boxOverlaps(new goog.math.Box(3, 5, 5, 3), box2));
136 assertTrue('SW overlap', boxOverlaps(new goog.math.Box(3, 2, 5, 0), box2));
137
138 // Inside.
139 assertTrue(
140 'Inside overlap', boxOverlaps(new goog.math.Box(2, 3, 3, 2), box2));
141
142 // Around.
143 assertTrue(
144 'Outside overlap', boxOverlaps(new goog.math.Box(0, 5, 5, 0), box2));
145
146 // Edge overlaps.
147 assertTrue('N overlap', boxOverlaps(new goog.math.Box(0, 3, 2, 2), box2));
148 assertTrue('E overlap', boxOverlaps(new goog.math.Box(2, 5, 3, 3), box2));
149 assertTrue('S overlap', boxOverlaps(new goog.math.Box(3, 3, 5, 2), box2));
150 assertTrue('W overlap', boxOverlaps(new goog.math.Box(2, 2, 3, 0), box2));
151
152 assertTrue('N-in overlap', boxOverlaps(new goog.math.Box(0, 5, 2, 0), box2));
153 assertTrue('E-in overlap', boxOverlaps(new goog.math.Box(0, 5, 5, 3), box2));
154 assertTrue('S-in overlap', boxOverlaps(new goog.math.Box(3, 5, 5, 0), box2));
155 assertTrue('W-in overlap', boxOverlaps(new goog.math.Box(0, 2, 5, 0), box2));
156
157 // Does not overlap.
158 var box2 = new goog.math.Box(3, 6, 6, 3);
159
160 // Along the edge - shorter.
161 assertFalse(
162 'N-in no overlap', boxOverlaps(new goog.math.Box(1, 5, 2, 4), box2));
163 assertFalse(
164 'E-in no overlap', boxOverlaps(new goog.math.Box(4, 8, 5, 7), box2));
165 assertFalse(
166 'S-in no overlap', boxOverlaps(new goog.math.Box(7, 5, 8, 4), box2));
167 assertFalse(
168 'N-in no overlap', boxOverlaps(new goog.math.Box(4, 2, 5, 1), box2));
169
170 // By the corner.
171 assertFalse(
172 'NE no overlap', boxOverlaps(new goog.math.Box(1, 8, 2, 7), box2));
173 assertFalse(
174 'SE no overlap', boxOverlaps(new goog.math.Box(7, 8, 8, 7), box2));
175 assertFalse(
176 'SW no overlap', boxOverlaps(new goog.math.Box(7, 2, 8, 1), box2));
177 assertFalse(
178 'NW no overlap', boxOverlaps(new goog.math.Box(1, 2, 2, 1), box2));
179
180 // Perpendicular to an edge.
181 assertFalse(
182 'NNE no overlap', boxOverlaps(new goog.math.Box(1, 7, 2, 5), box2));
183 assertFalse(
184 'NEE no overlap', boxOverlaps(new goog.math.Box(2, 8, 4, 7), box2));
185 assertFalse(
186 'SEE no overlap', boxOverlaps(new goog.math.Box(5, 8, 7, 7), box2));
187 assertFalse(
188 'SSE no overlap', boxOverlaps(new goog.math.Box(7, 7, 8, 5), box2));
189 assertFalse(
190 'SSW no overlap', boxOverlaps(new goog.math.Box(7, 4, 8, 2), box2));
191 assertFalse(
192 'SWW no overlap', boxOverlaps(new goog.math.Box(5, 2, 7, 1), box2));
193 assertFalse(
194 'NWW no overlap', boxOverlaps(new goog.math.Box(2, 2, 4, 1), box2));
195 assertFalse(
196 'NNW no overlap', boxOverlaps(new goog.math.Box(1, 4, 2, 2), box2));
197
198 // Along the edge - longer.
199 assertFalse('N no overlap', boxOverlaps(new goog.math.Box(0, 7, 1, 2), box2));
200 assertFalse('E no overlap', boxOverlaps(new goog.math.Box(2, 9, 7, 8), box2));
201 assertFalse('S no overlap', boxOverlaps(new goog.math.Box(8, 7, 9, 2), box2));
202 assertFalse('W no overlap', boxOverlaps(new goog.math.Box(2, 1, 7, 0), box2));
203 }
204
205
206 /**
207 * Checks whether a given box overlaps any of given DnD target boxes.
208 *
209 * @param {goog.math.Box} box The box to check.
210 * @param {Array<Object>} targets The array of targets with boxes to check
211 * if they overlap with the given box.
212 * @return {boolean} Whether the box overlaps any of the target boxes.
213 */
214 function boxOverlapsTargets(box, targets) {
215 return goog.array.some(
216 targets, function(target) { return boxOverlaps(box, target.box_); });
217 }
218
219
220 function testMaybeCreateDummyTargetForPosition() {
221 var testGroup = new goog.fx.AbstractDragDrop();
222 testGroup.targetList_ = targets;
223 testGroup.targetBox_ = new goog.math.Box(0, 9, 10, 1);
224
225 var target = testGroup.maybeCreateDummyTargetForPosition_(3, 3);
226 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
227 assertTrue(testGroup.isInside(3, 3, target.box_));
228
229 target = testGroup.maybeCreateDummyTargetForPosition_(2, 4);
230 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
231 assertTrue(testGroup.isInside(2, 4, target.box_));
232
233 target = testGroup.maybeCreateDummyTargetForPosition_(2, 7);
234 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
235 assertTrue(testGroup.isInside(2, 7, target.box_));
236
237 testGroup.targetList_.push({box_: new goog.math.Box(5, 6, 6, 0)});
238
239 target = testGroup.maybeCreateDummyTargetForPosition_(3, 3);
240 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
241 assertTrue(testGroup.isInside(3, 3, target.box_));
242
243 target = testGroup.maybeCreateDummyTargetForPosition_(2, 7);
244 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
245 assertTrue(testGroup.isInside(2, 7, target.box_));
246
247 target = testGroup.maybeCreateDummyTargetForPosition_(6, 3);
248 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
249 assertTrue(testGroup.isInside(6, 3, target.box_));
250
251 target = testGroup.maybeCreateDummyTargetForPosition_(0, 3);
252 assertNull(target);
253 target = testGroup.maybeCreateDummyTargetForPosition_(9, 0);
254 assertNull(target);
255 }
256
257
258 function testMaybeCreateDummyTargetForPosition2() {
259 var testGroup = new goog.fx.AbstractDragDrop();
260 testGroup.targetList_ = targets2;
261 testGroup.targetBox_ = new goog.math.Box(10, 50, 80, 10);
262
263 var target = testGroup.maybeCreateDummyTargetForPosition_(30, 40);
264 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
265 assertTrue(testGroup.isInside(30, 40, target.box_));
266
267 target = testGroup.maybeCreateDummyTargetForPosition_(45, 40);
268 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
269 assertTrue(testGroup.isInside(45, 40, target.box_));
270
271 testGroup.targetList_.push({box_: new goog.math.Box(40, 50, 50, 40)});
272
273 target = testGroup.maybeCreateDummyTargetForPosition_(30, 40);
274 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
275 target = testGroup.maybeCreateDummyTargetForPosition_(45, 35);
276 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
277 }
278
279
280 function testMaybeCreateDummyTargetForPosition3BoxHasDecentSize() {
281 var testGroup = new goog.fx.AbstractDragDrop();
282 testGroup.targetList_ = targets3;
283 testGroup.targetBox_ = new goog.math.Box(0, 6, 6, 0);
284
285 var target = testGroup.maybeCreateDummyTargetForPosition_(3, 3);
286 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
287 assertTrue(testGroup.isInside(3, 3, target.box_));
288 assertEquals('(1t, 5r, 5b, 1l)', target.box_.toString());
289 }
290
291
292 function testMaybeCreateDummyTargetForPosition4() {
293 var testGroup = new goog.fx.AbstractDragDrop();
294 testGroup.targetList_ = targets;
295 testGroup.targetBox_ = new goog.math.Box(0, 9, 10, 1);
296
297 for (var x = testGroup.targetBox_.left; x < testGroup.targetBox_.right; x++) {
298 for (var y = testGroup.targetBox_.top; y < testGroup.targetBox_.bottom;
299 y++) {
300 var inRealTarget = false;
301 for (var i = 0; i < testGroup.targetList_.length; i++) {
302 if (testGroup.isInside(x, y, testGroup.targetList_[i].box_)) {
303 inRealTarget = true;
304 break;
305 }
306 }
307 if (!inRealTarget) {
308 var target = testGroup.maybeCreateDummyTargetForPosition_(x, y);
309 if (target) {
310 assertFalse(
311 'Fake target for point(' + x + ',' + y + ') should ' +
312 'not overlap any real targets.',
313 boxOverlapsTargets(target.box_, testGroup.targetList_));
314 assertTrue(testGroup.isInside(x, y, target.box_));
315 }
316 }
317 }
318 }
319 }
320
321 function testMaybeCreateDummyTargetForPosition_NegativePositions() {
322 var negTargets = [
323 {box_: new goog.math.Box(-20, 10, -5, 1)},
324 {box_: new goog.math.Box(20, 10, 30, 1)}
325 ];
326
327 var testGroup = new goog.fx.AbstractDragDrop();
328 testGroup.targetList_ = negTargets;
329 testGroup.targetBox_ = new goog.math.Box(-20, 10, 30, 1);
330
331 var target = testGroup.maybeCreateDummyTargetForPosition_(1, 5);
332 assertFalse(boxOverlapsTargets(target.box_, testGroup.targetList_));
333 assertTrue(testGroup.isInside(1, 5, target.box_));
334 }
335
336 function testMaybeCreateDummyTargetOutsideScrollableContainer() {
337 var targets = [
338 {box_: new goog.math.Box(0, 3, 10, 1)},
339 {box_: new goog.math.Box(20, 3, 30, 1)}
340 ];
341 var target = targets[0];
342
343 var testGroup = new goog.fx.AbstractDragDrop();
344 testGroup.targetList_ = targets;
345 testGroup.targetBox_ = new goog.math.Box(0, 3, 30, 1);
346
347 testGroup.addScrollableContainer(document.getElementById('container1'));
348 var container = testGroup.scrollableContainers_[0];
349 container.containedTargets_.push(target);
350 container.box_ = new goog.math.Box(0, 3, 5, 1); // shorter than target
351 target.scrollableContainer_ = container;
352
353 // mouse cursor is below scrollable target but not the actual target
354 var dummyTarget = testGroup.maybeCreateDummyTargetForPosition_(2, 7);
355 // dummy target should not overlap the scrollable container
356 assertFalse(boxOverlaps(dummyTarget.box_, container.box_));
357 // but should overlap the actual target, since not all of it is visible
358 assertTrue(boxOverlaps(dummyTarget.box_, target.box_));
359 }
360
361 function testMaybeCreateDummyTargetInsideScrollableContainer() {
362 var targets = [
363 {box_: new goog.math.Box(0, 3, 10, 1)},
364 {box_: new goog.math.Box(20, 3, 30, 1)}
365 ];
366 var target = targets[0];
367
368 var testGroup = new goog.fx.AbstractDragDrop();
369 testGroup.targetList_ = targets;
370 testGroup.targetBox_ = new goog.math.Box(0, 3, 30, 1);
371
372 testGroup.addScrollableContainer(document.getElementById('container1'));
373 var container = testGroup.scrollableContainers_[0];
374 container.containedTargets_.push(target);
375 container.box_ = new goog.math.Box(0, 3, 20, 1); // longer than target
376 target.scrollableContainer_ = container;
377
378 // mouse cursor is below both the scrollable and the actual target
379 var dummyTarget = testGroup.maybeCreateDummyTargetForPosition_(2, 15);
380 // dummy target should overlap the scrollable container
381 assertTrue(boxOverlaps(dummyTarget.box_, container.box_));
382 // but not overlap the actual target
383 assertFalse(boxOverlaps(dummyTarget.box_, target.box_));
384 }
385
386 function testCalculateTargetBox() {
387 var testGroup = new goog.fx.AbstractDragDrop();
388 testGroup.targetList_ = [];
389 goog.array.forEach(targets, function(target) {
390 testGroup.targetList_.push(target);
391 testGroup.calculateTargetBox_(target.box_);
392 });
393 assertTrue(
394 goog.math.Box.equals(
395 testGroup.targetBox_, new goog.math.Box(0, 9, 10, 1)));
396
397 testGroup = new goog.fx.AbstractDragDrop();
398 testGroup.targetList_ = [];
399 goog.array.forEach(targets2, function(target) {
400 testGroup.targetList_.push(target);
401 testGroup.calculateTargetBox_(target.box_);
402 });
403 assertTrue(
404 goog.math.Box.equals(
405 testGroup.targetBox_, new goog.math.Box(10, 50, 80, 10)));
406
407 testGroup = new goog.fx.AbstractDragDrop();
408 testGroup.targetList_ = [];
409 goog.array.forEach(targets3, function(target) {
410 testGroup.targetList_.push(target);
411 testGroup.calculateTargetBox_(target.box_);
412 });
413 assertTrue(
414 goog.math.Box.equals(
415 testGroup.targetBox_, new goog.math.Box(0, 6, 6, 0)));
416 }
417
418
419 function testIsInside() {
420 var add = new goog.fx.AbstractDragDrop();
421 // The box in question.
422 // 10,20+++++20,20
423 // + |
424 // 10,30-----20,30
425 var box = new goog.math.Box(20, 20, 30, 10);
426
427 assertTrue(
428 'A point somewhere in the middle of the box should be inside.',
429 add.isInside(15, 25, box));
430
431 assertTrue(
432 'A point in top-left corner should be inside the box.',
433 add.isInside(10, 20, box));
434
435 assertTrue(
436 'A point on top border should be inside the box.',
437 add.isInside(15, 20, box));
438
439 assertFalse(
440 'A point in top-right corner should be outside the box.',
441 add.isInside(20, 20, box));
442
443 assertFalse(
444 'A point on right border should be outside the box.',
445 add.isInside(20, 25, box));
446
447 assertFalse(
448 'A point in bottom-right corner should be outside the box.',
449 add.isInside(20, 30, box));
450
451 assertFalse(
452 'A point on bottom border should be outside the box.',
453 add.isInside(15, 30, box));
454
455 assertFalse(
456 'A point in bottom-left corner should be outside the box.',
457 add.isInside(10, 30, box));
458
459 assertTrue(
460 'A point on left border should be inside the box.',
461 add.isInside(10, 25, box));
462
463 add.dispose();
464 }
465
466
467 function testAddingRemovingScrollableContainers() {
468 var group = new goog.fx.AbstractDragDrop();
469 var el1 = goog.dom.createElement(goog.dom.TagName.DIV);
470 var el2 = goog.dom.createElement(goog.dom.TagName.DIV);
471
472 assertEquals(0, group.scrollableContainers_.length);
473
474 group.addScrollableContainer(el1);
475 assertEquals(1, group.scrollableContainers_.length);
476
477 group.addScrollableContainer(el2);
478 assertEquals(2, group.scrollableContainers_.length);
479
480 group.removeAllScrollableContainers();
481 assertEquals(0, group.scrollableContainers_.length);
482 }
483
484
485 function testScrollableContainersCalculation() {
486 var group = new goog.fx.AbstractDragDrop();
487 var target = new goog.fx.AbstractDragDrop();
488
489 group.addTarget(target);
490 group.addScrollableContainer(document.getElementById('container1'));
491 var container = group.scrollableContainers_[0];
492
493 var item1 = new goog.fx.DragDropItem(document.getElementById('child1'));
494 var item2 = new goog.fx.DragDropItem(document.getElementById('child2'));
495
496 target.items_.push(item1);
497 group.recalculateDragTargets();
498 group.recalculateScrollableContainers();
499
500 assertEquals(1, container.containedTargets_.length);
501 assertEquals(container, group.targetList_[0].scrollableContainer_);
502
503 target.items_.push(item2);
504 group.recalculateDragTargets();
505 assertEquals(1, container.containedTargets_.length);
506 assertNull(group.targetList_[0].scrollableContainer_);
507
508 group.recalculateScrollableContainers();
509 assertEquals(2, container.containedTargets_.length);
510 assertEquals(container, group.targetList_[1].scrollableContainer_);
511 }
512
513 function testMouseDownEventDefaultAction() {
514 var group = new goog.fx.AbstractDragDrop();
515 var target = new goog.fx.AbstractDragDrop();
516 group.addTarget(target);
517 var item1 = new goog.fx.DragDropItem(document.getElementById('child1'));
518 group.items_.push(item1);
519 item1.setParent(group);
520 group.init();
521
522 var mousedownDefaultPrevented =
523 !goog.testing.events.fireMouseDownEvent(item1.element);
524
525 assertFalse(
526 'Default action of mousedown event should not be cancelled.',
527 mousedownDefaultPrevented);
528 }
529
530 // See http://b/7494613.
531 function testMouseUpOutsideElement() {
532 var group = new goog.fx.AbstractDragDrop();
533 var target = new goog.fx.AbstractDragDrop();
534 group.addTarget(target);
535 var item1 = new goog.fx.DragDropItem(document.getElementById('child1'));
536 group.items_.push(item1);
537 item1.setParent(group);
538 group.init();
539
540 group.startDrag = goog.functions.error('startDrag should not be called.');
541
542 goog.testing.events.fireMouseDownEvent(item1.element);
543 goog.testing.events.fireMouseUpEvent(item1.element.parentNode);
544 // This should have no effect (not start a drag) since the previous event
545 // should have cleared the listeners.
546 goog.testing.events.fireMouseOutEvent(item1.element);
547
548 group.dispose();
549 target.dispose();
550 }
551
552 function testScrollBeforeMoveDrag() {
553 var group = new goog.fx.AbstractDragDrop();
554 var target = new goog.fx.AbstractDragDrop();
555
556 group.addTarget(target);
557 var container = document.getElementById('container1');
558 group.addScrollableContainer(container);
559
560 var childEl = document.getElementById('child1');
561 var item = new goog.fx.DragDropItem(childEl);
562 item.currentDragElement_ = childEl;
563
564 target.items_.push(item);
565 group.recalculateDragTargets();
566 group.recalculateScrollableContainers();
567
568 // Simulare starting a drag.
569 var moveEvent = {
570 'clientX': 8,
571 'clientY': 10,
572 'type': goog.events.EventType.MOUSEMOVE,
573 'relatedTarget': childEl,
574 'preventDefault': function() {}
575 };
576 group.startDrag(moveEvent, item);
577
578 // Simulate scrolling before the first move drag event.
579 var scrollEvent = {'target': container};
580 assertNotThrows(goog.bind(group.containerScrollHandler_, group, scrollEvent));
581 }
582
583
584 function testMouseMove_mouseOutBeforeThreshold() {
585 // Setup dragdrop and item
586 var itemEl = goog.dom.createElement(goog.dom.TagName.DIV);
587 var childEl = goog.dom.createElement(goog.dom.TagName.DIV);
588 itemEl.appendChild(childEl);
589 var add = new goog.fx.AbstractDragDrop();
590 var item = new goog.fx.DragDropItem(itemEl);
591 item.setParent(add);
592 add.items_.push(item);
593
594 // Simulate maybeStartDrag
595 item.startPosition_ = new goog.math.Coordinate(10, 10);
596 item.currentDragElement_ = itemEl;
597
598 // Test
599 var draggedItem = null;
600 add.startDrag = function(event, item) { draggedItem = item; };
601
602 var event =
603 new goog.testing.events.Event(goog.events.EventType.MOUSEOUT, childEl);
604 // Drag distance is only 2.
605 event.clientX = 8;
606 event.clientY = 10;
607 item.mouseMove_(event);
608 assertEquals(
609 'DragStart should not be fired for mouseout on child element.', null,
610 draggedItem);
611
612 var event =
613 new goog.testing.events.Event(goog.events.EventType.MOUSEOUT, itemEl);
614 // Drag distance is only 2.
615 event.clientX = 8;
616 event.clientY = 10;
617 item.mouseMove_(event);
618 assertEquals(
619 'DragStart should be fired for mouseout on main element.', item,
620 draggedItem);
621 }
622
623
624 function testGetDragElementPosition() {
625 var testGroup = new goog.fx.AbstractDragDrop();
626 var sourceEl = goog.dom.createElement(goog.dom.TagName.DIV);
627 document.body.appendChild(sourceEl);
628
629 var pageOffset = goog.style.getPageOffset(sourceEl);
630 var pos = testGroup.getDragElementPosition(sourceEl);
631 assertEquals(
632 'Drag element position should be source element page offset',
633 pageOffset.x, pos.x);
634 assertEquals(
635 'Drag element position should be source element page offset',
636 pageOffset.y, pos.y);
637
638 sourceEl.style.marginLeft = '5px';
639 sourceEl.style.marginTop = '7px';
640 pageOffset = goog.style.getPageOffset(sourceEl);
641 pos = testGroup.getDragElementPosition(sourceEl);
642 assertEquals(
643 'Drag element position should be adjusted for source element ' +
644 'margins',
645 pageOffset.x - 10, pos.x);
646 assertEquals(
647 'Drag element position should be adjusted for source element ' +
648 'margins',
649 pageOffset.y - 14, pos.y);
650 }
651
652 function testDragEndEvent() {
653 function testDragEndEventInternal(shouldContainItemData) {
654 var testGroup = new goog.fx.AbstractDragDrop();
655
656 var childEl = document.getElementById('child1');
657 var item = new goog.fx.DragDropItem(childEl);
658 item.currentDragElement_ = childEl;
659
660 testGroup.items_.push(item);
661 testGroup.recalculateDragTargets();
662
663 // Simulate starting a drag
664 var startEvent = {
665 'clientX': 0,
666 'clientY': 0,
667 'type': goog.events.EventType.MOUSEMOVE,
668 'relatedTarget': childEl,
669 'preventDefault': function() {}
670 };
671 testGroup.startDrag(startEvent, item);
672
673 testGroup.activeTarget_ = new goog.fx.ActiveDropTarget_(
674 new goog.math.Box(0, 0, 0, 0), testGroup, item, childEl);
675
676 goog.events.listen(
677 testGroup, goog.fx.AbstractDragDrop.EventType.DRAGEND, function(event) {
678 if (shouldContainItemData) {
679 assertEquals(
680 'The drag end event should contain a drop target', testGroup,
681 event.dropTarget);
682 assertEquals(
683 'The drag end event should contain a drop target item', item,
684 event.dropTargetItem);
685 assertEquals(
686 'The drag end event should contain a drop target element',
687 childEl, event.dropTargetElement);
688 } else {
689 assertUndefined(
690 'The drag end event shouldn\'t contain a drop target',
691 event.dropTarget);
692 assertUndefined(
693 'The drag end event shouldn\'t contain a drop target item',
694 event.dropTargetItem);
695 assertUndefined(
696 'The drag end event shouldn\'t contain a drop target element',
697 event.dropTargetElement);
698 }
699 });
700
701 testGroup.endDrag(
702 {'clientX': 0, 'clientY': 0, 'dragCanceled': !shouldContainItemData});
703
704 testGroup.dispose();
705 item.dispose();
706 }
707
708 testDragEndEventInternal(false);
709 testDragEndEventInternal(true);
710 }
711
712 function testDropEventHasBrowserEvent() {
713 var testGroup = new goog.fx.AbstractDragDrop();
714
715 var childEl = document.getElementById('child1');
716 var item = new goog.fx.DragDropItem(childEl);
717 item.currentDragElement_ = childEl;
718
719 testGroup.items_.push(item);
720 testGroup.recalculateDragTargets();
721
722 // Simulate starting a drag
723 var startBrowserEvent = {
724 'clientX': 0,
725 'clientY': 0,
726 'type': goog.events.EventType.MOUSEMOVE,
727 'relatedTarget': childEl,
728 'preventDefault': function() {},
729 };
730 testGroup.startDrag(startBrowserEvent, item);
731
732 testGroup.activeTarget_ = new goog.fx.ActiveDropTarget_(
733 new goog.math.Box(0, 0, 0, 0), testGroup, item, childEl);
734
735 var endBrowserEvent = {
736 'clientX': 0,
737 'clientY': 0,
738 'type': goog.events.EventType.MOUSEUP,
739 'ctrlKey': false,
740 'altKey': true
741 };
742
743 goog.events.listen(
744 testGroup, goog.fx.AbstractDragDrop.EventType.DROP, function(event) {
745 var browserEvent = event.browserEvent;
746 assertEquals(
747 'The drop event should contain the browser event', endBrowserEvent,
748 browserEvent);
749 });
750
751 testGroup.endDrag({
752 'clientX': 0,
753 'clientY': 0,
754 'dragCanceled': false,
755 'browserEvent': endBrowserEvent
756 });
757
758 testGroup.dispose();
759 item.dispose();
760 }
761
762 // Helper function for manual debugging.
763 function drawTargets(targets, multiplier) {
764 var colors = ['green', 'blue', 'red', 'lime', 'pink', 'silver', 'orange'];
765 var cont = document.getElementById('cont');
766 cont.innerHTML = '';
767 for (var i = 0; i < targets.length; i++) {
768 var box = targets[i].box_;
769 var el = goog.dom.createElement(goog.dom.TagName.DIV);
770 el.style.top = (box.top * multiplier) + 'px';
771 el.style.left = (box.left * multiplier) + 'px';
772 el.style.width = ((box.right - box.left) * multiplier) + 'px';
773 el.style.height = ((box.bottom - box.top) * multiplier) + 'px';
774 el.style.backgroundColor = colors[i];
775 cont.appendChild(el);
776 }
777 }