Debian Codegraph @

packages/widgets/tests/src/splitpanel.spec.ts

raw
1 // Copyright (c) Jupyter Development Team.
2 // Distributed under the terms of the Modified BSD License.
3 /*-----------------------------------------------------------------------------
4 | Copyright (c) 2014-2017, PhosphorJS Contributors
5 |
6 | Distributed under the terms of the BSD 3-Clause License.
7 |
8 | The full license is in the file LICENSE, distributed with this software.
9 |----------------------------------------------------------------------------*/
10 import { expect } from 'chai';
11
12 import { every } from '@lumino/algorithm';
13
14 import { MessageLoop } from '@lumino/messaging';
15
16 import { SplitLayout, SplitPanel, Widget } from '@lumino/widgets';
17
18 const bubbles = true;
19 const renderer: SplitPanel.IRenderer = {
20 createHandle: () => document.createElement('div')
21 };
22
23 function dragHandle(panel: LogSplitPanel): void {
24 MessageLoop.sendMessage(panel, Widget.Msg.UpdateRequest);
25 let handle = panel.handles[0];
26 let rect = handle.getBoundingClientRect();
27 let args = { bubbles, clientX: rect.left + 1, clientY: rect.top + 1 };
28 handle.dispatchEvent(new PointerEvent('pointerdown', args));
29 args = { bubbles, clientX: rect.left + 10, clientY: rect.top + 1 };
30 document.body.dispatchEvent(new PointerEvent('pointermove', args));
31 document.body.dispatchEvent(new PointerEvent('pointerup', { bubbles }));
32 }
33
34 class LogSplitPanel extends SplitPanel {
35 events: string[] = [];
36
37 handleEvent(event: Event): void {
38 super.handleEvent(event);
39 this.events.push(event.type);
40 }
41 }
42
43 describe('@lumino/widgets', () => {
44 describe('SplitPanel', () => {
45 describe('#constructor()', () => {
46 it('should accept no arguments', () => {
47 let panel = new SplitPanel();
48 expect(panel).to.be.an.instanceof(SplitPanel);
49 });
50
51 it('should accept options', () => {
52 let panel = new SplitPanel({
53 orientation: 'vertical',
54 spacing: 5,
55 renderer
56 });
57 expect(panel.orientation).to.equal('vertical');
58 expect(panel.spacing).to.equal(5);
59 expect(panel.renderer).to.equal(renderer);
60 });
61
62 it('should accept a layout option', () => {
63 let layout = new SplitLayout({ renderer });
64 let panel = new SplitPanel({ layout });
65 expect(panel.layout).to.equal(layout);
66 });
67
68 it('should ignore other options if a layout is given', () => {
69 let ignored = Object.create(renderer);
70 let layout = new SplitLayout({ renderer });
71 let panel = new SplitPanel({
72 layout,
73 orientation: 'vertical',
74 spacing: 5,
75 renderer: ignored
76 });
77 expect(panel.layout).to.equal(layout);
78 expect(panel.orientation).to.equal('horizontal');
79 expect(panel.spacing).to.equal(4);
80 expect(panel.renderer).to.equal(renderer);
81 });
82
83 it('should add the `lm-SplitPanel` class', () => {
84 let panel = new SplitPanel();
85 expect(panel.hasClass('lm-SplitPanel')).to.equal(true);
86 });
87 });
88
89 describe('#dispose()', () => {
90 it('should dispose of the resources held by the panel', () => {
91 let panel = new LogSplitPanel();
92 let layout = panel.layout as SplitLayout;
93 let widgets = [new Widget(), new Widget(), new Widget()];
94 widgets.forEach(w => {
95 panel.addWidget(w);
96 });
97 Widget.attach(panel, document.body);
98 let handle = layout.handles[0];
99 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
100 expect(panel.events).to.contain('pointerdown');
101 panel.node.dispatchEvent(new KeyboardEvent('keydown', { bubbles }));
102 expect(panel.events).to.contain('keydown');
103 let node = panel.node;
104 panel.dispose();
105 expect(every(widgets, w => w.isDisposed));
106 node.dispatchEvent(new MouseEvent('contextmenu', { bubbles }));
107 expect(panel.events).to.not.contain('contextmenu');
108 });
109 });
110
111 describe('#orientation', () => {
112 it('should get the layout orientation for the split panel', () => {
113 let panel = new SplitPanel();
114 expect(panel.orientation).to.equal('horizontal');
115 });
116
117 it('should set the layout orientation for the split panel', () => {
118 let panel = new SplitPanel();
119 panel.orientation = 'vertical';
120 expect(panel.orientation).to.equal('vertical');
121 });
122 });
123
124 describe('#spacing', () => {
125 it('should default to `4`', () => {
126 let panel = new SplitPanel();
127 expect(panel.spacing).to.equal(4);
128 });
129
130 it('should set the spacing for the panel', () => {
131 let panel = new SplitPanel();
132 panel.spacing = 10;
133 expect(panel.spacing).to.equal(10);
134 });
135 });
136
137 describe('#renderer', () => {
138 it('should get the renderer for the panel', () => {
139 let panel = new SplitPanel({ renderer });
140 expect(panel.renderer).to.equal(renderer);
141 });
142 });
143
144 describe('#handleMoved', () => {
145 it('should be emitted when a handle is moved by the user', done => {
146 let panel = new LogSplitPanel();
147 let widgets = [new Widget(), new Widget()];
148 panel.orientation = 'horizontal';
149 widgets.forEach(w => {
150 w.node.style.minHeight = '40px';
151 w.node.style.minWidth = '40px';
152 panel.addWidget(w);
153 });
154 panel.setRelativeSizes([40, 80]);
155 Widget.attach(panel, document.body);
156 panel.handleMoved.connect((sender, _) => {
157 expect(sender).to.equal(panel);
158 done();
159 });
160 dragHandle(panel);
161 });
162 });
163
164 describe('#handles', () => {
165 it('should get the read-only sequence of the split handles in the panel', () => {
166 let panel = new SplitPanel();
167 let widgets = [new Widget(), new Widget(), new Widget()];
168 widgets.forEach(w => {
169 panel.addWidget(w);
170 });
171 expect(panel.handles.length).to.equal(3);
172 });
173 });
174
175 describe('#relativeSizes()', () => {
176 it('should get the current sizes of the widgets in the panel', () => {
177 let panel = new SplitPanel();
178 let widgets = [new Widget(), new Widget(), new Widget()];
179 widgets.forEach(w => {
180 panel.addWidget(w);
181 });
182 let sizes = panel.relativeSizes();
183 expect(sizes).to.deep.equal([1 / 3, 1 / 3, 1 / 3]);
184 });
185 });
186
187 describe('#setRelativeSizes()', () => {
188 it('should set the desired sizes for the widgets in the panel', () => {
189 let panel = new SplitPanel();
190 let widgets = [new Widget(), new Widget(), new Widget()];
191 widgets.forEach(w => {
192 panel.addWidget(w);
193 });
194 panel.setRelativeSizes([10, 20, 30]);
195 let sizes = panel.relativeSizes();
196 expect(sizes).to.deep.equal([10 / 60, 20 / 60, 30 / 60]);
197 });
198
199 it('should ignore extra values', () => {
200 let panel = new SplitPanel();
201 let widgets = [new Widget(), new Widget(), new Widget()];
202 widgets.forEach(w => {
203 panel.addWidget(w);
204 });
205 panel.setRelativeSizes([10, 30, 40, 20]);
206 let sizes = panel.relativeSizes();
207 expect(sizes).to.deep.equal([10 / 80, 30 / 80, 40 / 80]);
208 });
209 });
210
211 describe('#handleEvent()', () => {
212 let panel: LogSplitPanel;
213 let layout: SplitLayout;
214
215 beforeEach(() => {
216 panel = new LogSplitPanel();
217 layout = panel.layout as SplitLayout;
218 let widgets = [new Widget(), new Widget(), new Widget()];
219 widgets.forEach(w => {
220 panel.addWidget(w);
221 });
222 panel.setRelativeSizes([10, 10, 10, 20]);
223 Widget.attach(panel, document.body);
224 MessageLoop.flush();
225 });
226
227 afterEach(() => {
228 panel.dispose();
229 });
230
231 context('pointerdown', () => {
232 it('should attach other event listeners', () => {
233 let handle = layout.handles[0];
234 let body = document.body;
235 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
236 expect(panel.events).to.contain('pointerdown');
237 body.dispatchEvent(new PointerEvent('pointermove', { bubbles }));
238 expect(panel.events).to.contain('pointermove');
239 body.dispatchEvent(new KeyboardEvent('keydown', { bubbles }));
240 expect(panel.events).to.contain('keydown');
241 body.dispatchEvent(new MouseEvent('contextmenu', { bubbles }));
242 expect(panel.events).to.contain('contextmenu');
243 body.dispatchEvent(new PointerEvent('pointerup', { bubbles }));
244 expect(panel.events).to.contain('pointerup');
245 });
246
247 it('should be a no-op if it is not the left button', () => {
248 layout.handles[0].dispatchEvent(
249 new PointerEvent('pointerdown', {
250 bubbles,
251 button: 1
252 })
253 );
254 expect(panel.events).to.contain('pointerdown');
255 document.body.dispatchEvent(
256 new PointerEvent('pointermove', { bubbles })
257 );
258 expect(panel.events).to.not.contain('pointermove');
259 });
260 });
261
262 context('pointermove', () => {
263 it('should move the handle right', done => {
264 let handle = layout.handles[1];
265 let rect = handle.getBoundingClientRect();
266 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
267 document.body.dispatchEvent(
268 new PointerEvent('pointermove', {
269 bubbles,
270 clientX: rect.left + 10,
271 clientY: rect.top
272 })
273 );
274 requestAnimationFrame(() => {
275 let newRect = handle.getBoundingClientRect();
276 expect(newRect.left).to.not.equal(rect.left);
277 done();
278 });
279 });
280
281 it('should move the handle down', done => {
282 panel.orientation = 'vertical';
283 panel.widgets.forEach(w => {
284 w.node.style.minHeight = '20px';
285 });
286 let handle = layout.handles[1];
287 let rect = handle.getBoundingClientRect();
288 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
289 document.body.dispatchEvent(
290 new PointerEvent('pointermove', {
291 bubbles,
292 clientX: rect.left,
293 clientY: rect.top - 2
294 })
295 );
296 requestAnimationFrame(() => {
297 let newRect = handle.getBoundingClientRect();
298 expect(newRect.top).to.not.equal(rect.top);
299 done();
300 });
301 });
302 });
303
304 context('pointerup', () => {
305 it('should remove the event listeners', () => {
306 let handle = layout.handles[0];
307 let body = document.body;
308 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
309 expect(panel.events).to.contain('pointerdown');
310 body.dispatchEvent(new PointerEvent('pointerup', { bubbles }));
311 expect(panel.events).to.contain('pointerup');
312 body.dispatchEvent(new PointerEvent('pointermove', { bubbles }));
313 expect(panel.events).to.not.contain('pointermove');
314 body.dispatchEvent(new KeyboardEvent('keydown', { bubbles }));
315 expect(panel.events).to.not.contain('keydown');
316 body.dispatchEvent(new MouseEvent('contextmenu', { bubbles }));
317 expect(panel.events).to.not.contain('contextmenu');
318 });
319
320 it('should be a no-op if not the left button', () => {
321 let handle = layout.handles[0];
322 let body = document.body;
323 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
324 expect(panel.events).to.contain('pointerdown');
325 body.dispatchEvent(
326 new PointerEvent('pointerup', {
327 bubbles,
328 button: 1
329 })
330 );
331 expect(panel.events).to.contain('pointerup');
332 body.dispatchEvent(new PointerEvent('pointermove', { bubbles }));
333 expect(panel.events).to.contain('pointermove');
334 });
335 });
336
337 context('keydown', () => {
338 it('should release the mouse if `Escape` is pressed', () => {
339 let handle = layout.handles[0];
340 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
341 panel.node.dispatchEvent(
342 new KeyboardEvent('keydown', {
343 bubbles,
344 keyCode: 27
345 })
346 );
347 expect(panel.events).to.contain('keydown');
348 panel.node.dispatchEvent(
349 new PointerEvent('pointermove', { bubbles })
350 );
351 expect(panel.events).to.not.contain('pointermove');
352 });
353 });
354
355 context('contextmenu', () => {
356 it('should prevent events during drag', () => {
357 let handle = layout.handles[0];
358 handle.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
359 let event = new MouseEvent('contextmenu', {
360 bubbles,
361 cancelable: true
362 });
363 let cancelled = !document.body.dispatchEvent(event);
364 expect(cancelled).to.equal(true);
365 expect(panel.events).to.contain('contextmenu');
366 });
367 });
368 });
369
370 describe('#onAfterAttach()', () => {
371 it('should attach a pointerdown listener to the node', () => {
372 let panel = new LogSplitPanel();
373 Widget.attach(panel, document.body);
374 panel.node.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
375 expect(panel.events).to.contain('pointerdown');
376 panel.dispose();
377 });
378 });
379
380 describe('#onBeforeDetach()', () => {
381 it('should remove all listeners', () => {
382 let panel = new LogSplitPanel();
383 Widget.attach(panel, document.body);
384 panel.node.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
385 expect(panel.events).to.contain('pointerdown');
386 Widget.detach(panel);
387 panel.events = [];
388 panel.node.dispatchEvent(new PointerEvent('pointerdown', { bubbles }));
389 expect(panel.events).to.not.contain('pointerdown');
390 document.body.dispatchEvent(new KeyboardEvent('keyup', { bubbles }));
391 expect(panel.events).to.not.contain('keyup');
392 });
393 });
394
395 describe('#onChildAdded()', () => {
396 it('should add a class to the child widget', () => {
397 let panel = new SplitPanel();
398 let widget = new Widget();
399 panel.addWidget(widget);
400 expect(widget.hasClass('lm-SplitPanel-child')).to.equal(true);
401 });
402 });
403
404 describe('#onChildRemoved()', () => {
405 it('should remove a class to the child widget', () => {
406 let panel = new SplitPanel();
407 let widget = new Widget();
408 panel.addWidget(widget);
409 widget.parent = null;
410 expect(widget.hasClass('lm-SplitPanel-child')).to.equal(false);
411 });
412 });
413
414 describe('.Renderer()', () => {
415 describe('#createHandle()', () => {
416 it('should create a new handle node', () => {
417 let renderer = new SplitPanel.Renderer();
418 let node1 = renderer.createHandle();
419 let node2 = renderer.createHandle();
420 expect(node1).to.be.an.instanceof(HTMLElement);
421 expect(node2).to.be.an.instanceof(HTMLElement);
422 expect(node1).to.not.equal(node2);
423 });
424
425 it('should add the "lm-SplitPanel-handle" class', () => {
426 let renderer = new SplitPanel.Renderer();
427 let node = renderer.createHandle();
428 expect(node.classList.contains('lm-SplitPanel-handle')).to.equal(
429 true
430 );
431 });
432 });
433 });
434
435 describe('.defaultRenderer', () => {
436 it('should be an instance of `Renderer`', () => {
437 expect(SplitPanel.defaultRenderer).to.be.an.instanceof(
438 SplitPanel.Renderer
439 );
440 });
441 });
442
443 describe('.getStretch()', () => {
444 it('should get the split panel stretch factor for the given widget', () => {
445 let widget = new Widget();
446 expect(SplitPanel.getStretch(widget)).to.equal(0);
447 });
448 });
449
450 describe('.setStretch()', () => {
451 it('should set the split panel stretch factor for the given widget', () => {
452 let widget = new Widget();
453 SplitPanel.setStretch(widget, 10);
454 expect(SplitPanel.getStretch(widget)).to.equal(10);
455 });
456 });
457 });
458 });