Debian Codegraph @

js/datagrid.ts

raw ◀ ▶
1 Debian patch touch this file
1 // Copyright (c) NumFOCUS.
2 // Distributed under the terms of the Modified BSD License.
3
4 import * as _ from 'underscore';
5
6 import { BasicSelectionModel, TextRenderer } from '@lumino/datagrid';
7
8 import { CellRenderer } from '@lumino/datagrid';
9
10 import { JSONExt } from '@lumino/coreutils';
11
12 import { Message, MessageLoop } from '@lumino/messaging';
13
14 import { Widget } from '@lumino/widgets';
15
16 import {
17 Dict,
18 DOMWidgetModel,
19 DOMWidgetView,
20 ICallbacks,
21 ISerializers,
22 // @ts-ignore needed for ipywidgetx 8.x compatibility
23 JupyterLuminoPanelWidget,
24 // @ts-ignore needed for ipywidgetx 7.x compatibility
25 JupyterPhosphorPanelWidget,
26 resolvePromisesDict,
27 unpack_models,
28 WidgetModel,
29 WidgetView,
30 } from '@jupyter-widgets/base';
31
32 import { array_or_json_serializer } from 'bqplot';
33
34 import { deserialize_data } from './core/deserialize';
35 import { ViewBasedJSONModel } from './core/viewbasedjsonmodel';
36 import { StreamingViewBasedJSONModel } from './core/streamingviewbasedjsonmodel';
37
38 import { MODULE_NAME, MODULE_VERSION } from './version';
39
40 import { CellRendererModel, CellRendererView } from './cellrenderer';
41 import { FeatherGrid } from './feathergrid';
42 import { StreamingFeatherGrid } from './streamingfeathergrid';
43 import { Theme } from './utils';
44 import { DataSource } from './datasource';
45
46 // Import CSS
47 import '../style/jupyter-widget.css';
48
49 function serialize_data(data: DataSource, manager: any): any {
50 const serialized_data: any = {};
51 for (const column of Object.keys(data.data)) {
52 serialized_data[column] = array_or_json_serializer.serialize(
53 data.data[column],
54 manager,
55 );
56 }
57 return { data: serialized_data, fields: data.fields, schema: data.schema };
58 }
59
60 export class DataGridModel extends DOMWidgetModel {
61 defaults() {
62 return {
63 ...super.defaults(),
64 _model_module: DataGridModel.model_module,
65 _model_module_version: DataGridModel.model_module_version,
66 _view_name: DataGridModel.view_name,
67 _view_module: DataGridModel.view_module,
68 _view_module_version: DataGridModel.view_module_version,
69 _visible_rows: [],
70 _transforms: [],
71 baseRowSize: 20,
72 baseColumnSize: 64,
73 baseRowHeaderSize: 64,
74 baseColumnHeaderSize: 20,
75 headerVisibility: 'all',
76 _data: {},
77 renderers: {},
78 corner_renderer: null,
79 default_renderer: null,
80 header_renderer: null,
81 selection_mode: 'none',
82 selections: [],
83 grid_style: {},
84 editable: false,
85 column_widths: {},
86 horizontal_stripes: false,
87 vertical_stripes: false,
88 _transform_on_backend: false,
89 };
90 }
91
92 initialize(attributes: any, options: any) {
93 super.initialize(attributes, options);
94
95 this.updateDataSync = this.updateDataSync.bind(this);
96 this.syncTransformState = this.syncTransformState.bind(this);
97
•98 // @ts-ignore
99 this.on('change:_data', this.updateData.bind(this));
•100 // @ts-ignore
101 this.on('change:_transforms', this.updateTransforms.bind(this));
•102 // @ts-ignore
103 this.on('change:selection_mode', this.updateSelectionModel, this);
•104 // @ts-ignore
105 this.on('change:selections', this.updateSelections, this);
106 this.updateData();
107 this.updateTransforms();
108 this.updateSelectionModel();
109
•110 // @ts-ignore
111 this.on('msg:custom', (content) => {
112 if (content.event_type === 'cell-changed') {
113 this.data_model.setModelData(
114 'body',
115 content.row,
116 content.column_index,
117 content.value,
118 );
119 }
120
121 if (content.event_type === 'row-changed') {
122 this.data_model.setRowData(content.row, content.value);
123 }
124 });
125 }
126
127 updateDataSync(sender: any, msg: any) {
128 switch (msg.type) {
129 case 'row-indices-updated':
130 this.set('_visible_rows', msg.indices);
131 this.save_changes();
132 break;
133 case 'cell-edit-event':
134 // Update data in widget model
•135 // @ts-ignore
136 const newData = this.get('_data') as DataSource;
137 newData.data[msg.column][msg.row] = msg.value;
138 this.set('_data', newData);
139
140 this.send(
141 {
142 event_type: 'cell-changed',
143 region: msg.region,
144 row: msg.row,
145 column_index: msg.columnIndex,
146 value: msg.value,
147 },
148 { ...this._view_callbacks },
149 );
150 break;
151 default:
152 throw 'unreachable';
153 }
154 }
155
156 syncTransformState(sender: any, value: any) {
157 this.set('_transforms', value.transforms);
158 this.save_changes();
159 }
160
161 updateData() {
162 const data = this.data;
163
164 if (this.data_model) {
165 this.data_model.updateDataset({ datasource: data });
166 this.data_model.transformStateChanged.disconnect(this.syncTransformState);
167 this.data_model.dataSync.disconnect(this.updateDataSync);
168 }
169
170 this.data_model = new ViewBasedJSONModel({ datasource: data });
171
172 this.data_model.transformStateChanged.connect(this.syncTransformState);
173 this.data_model.dataSync.connect(this.updateDataSync);
174
175 this.updateTransforms();
•176 // @ts-ignore
177 this.trigger('data-model-changed');
178 this.updateSelectionModel();
179 }
180
181 updateTransforms() {
182 const transforms = this.get('_transforms');
183 if (!this.get('_transform_on_backend')) {
184 if (this.selectionModel) {
185 this.selectionModel.clear();
186 }
187 }
188 this.data_model.replaceTransforms(transforms);
189 }
190
191 updateSelectionModel() {
192 if (this.selectionModel) {
193 this.selectionModel.clear();
194 }
195
•196 // @ts-ignore
197 const selectionMode = this.get('selection_mode');
198
199 if (selectionMode === 'none') {
200 this.selectionModel = null;
201 return;
202 }
203
204 this.selectionModel = new BasicSelectionModel({
205 dataModel: this.data_model,
206 });
207 this.selectionModel.selectionMode = selectionMode;
•208 // @ts-ignore
209 this.trigger('selection-model-changed');
210
211 this.selectionModel.changed.connect(
212 (sender: BasicSelectionModel, args: void) => {
213 if (this.synchingWithKernel) {
214 return;
215 }
216
217 this.synchingWithKernel = true;
218
219 const selections: any[] = [];
220
221 let selectionIter = sender.selections();
222 // @ts-ignore
223 if (typeof selectionIter.iter === 'function') {
224 // Lumino 1 (JupyterLab 3)
225 let selection = null;
226
227 // @ts-ignore
228 selectionIter = selectionIter.iter();
229
230 while ((selection = selectionIter.next())) {
231 selections.push({
232 // @ts-ignore
233 r1: Math.min(selection.r1, selection.r2),
234 // @ts-ignore
235 r2: Math.max(selection.r1, selection.r2),
236 // @ts-ignore
237 c1: Math.min(selection.c1, selection.c2),
238 // @ts-ignore
239 c2: Math.max(selection.c1, selection.c2),
240 });
241 }
242 } else {
243 // Lumino 2 (JupyterLab 4)
244 let selectionNode = null;
245
246 while ((selectionNode = selectionIter.next())) {
247 if (selectionNode.done) {
248 break;
249 }
250
251 const selection = selectionNode.value;
252
253 selections.push({
254 r1: Math.min(selection.r1, selection.r2),
255 r2: Math.max(selection.r1, selection.r2),
256 c1: Math.min(selection.c1, selection.c2),
257 c2: Math.max(selection.c1, selection.c2),
258 });
259 }
260 }
261
262 this.set('selections', selections);
263 this.save_changes();
264
265 this.synchingWithKernel = false;
266 },
267 this,
268 );
269 }
270
271 updateSelections() {
272 if (!this.selectionModel || this.synchingWithKernel) {
273 return;
274 }
275
276 this.synchingWithKernel = true;
277
•278 // @ts-ignore
279 const selections = this.get('selections');
280 this.selectionModel.clear();
281
282 for (const selection of selections) {
283 this.selectionModel.select({
284 r1: selection.r1,
285 c1: selection.c1,
286 r2: selection.r2,
287 c2: selection.c2,
288 cursorRow: selection.r1,
289 cursorColumn: selection.c1,
290 clear: 'none',
291 });
292 }
293
294 this.synchingWithKernel = false;
295 }
296
297 get data(): DataSource {
•298 // @ts-ignore
299 return this.get('_data');
300 }
301
302 static serializers: ISerializers = {
303 ...DOMWidgetModel.serializers,
304 transforms: { deserialize: unpack_models as any },
305 renderers: { deserialize: unpack_models as any },
306 corner_renderer: { deserialize: unpack_models as any },
307 default_renderer: { deserialize: unpack_models as any },
308 header_renderer: { deserialize: unpack_models as any },
309 _data: {
310 deserialize: deserialize_data,
311 serialize: serialize_data,
312 },
313 grid_style: { deserialize: unpack_style as any },
314 };
315
316 static readonly model_name: string = 'DataGridModel';
317 static readonly model_module = MODULE_NAME;
318 static readonly model_module_version = MODULE_VERSION;
319
320 static readonly view_name: string = 'DataGridView';
321 static readonly view_module = MODULE_NAME;
322 static readonly view_module_version = MODULE_VERSION;
323
324 data_model: ViewBasedJSONModel;
325 selectionModel: BasicSelectionModel | null;
326 synchingWithKernel = false;
327 _view_callbacks: ICallbacks;
328 }
329
330 /**
331 * Helper function to convert snake_case strings to camelCase.
332 * Assumes all strings are valid snake_case (all lowercase).
333 * @param string snake_case string
334 * @returns camelCase string
335 */
336 function camelCase(string: string): string {
337 string = string.toLowerCase();
338 const charArray = [];
339 for (let i = 0; i < string.length; i++) {
340 const curChar = string.charAt(i);
341 if (curChar === '_') {
342 i++;
343 charArray.push(string.charAt(i).toUpperCase());
344 continue;
345 }
346 charArray.push(curChar);
347 }
348
349 return charArray.join('');
350 }
351
352 /**
353 * Custom deserialization function for grid styles.
354 */
355 function unpack_style(
356 value: any | Dict<unknown> | string | (Dict<unknown> | string)[],
357 manager: any,
358 ): Promise<WidgetModel | Dict<WidgetModel> | WidgetModel[] | any> {
359 if (value instanceof Object && typeof value !== 'string') {
360 const unpacked: { [key: string]: any } = {};
361 Object.keys(value).forEach((key) => {
362 unpacked[camelCase(key)] = unpack_style(value[key], manager);
363 });
364 return resolvePromisesDict(unpacked);
365 } else if (typeof value === 'string' && value.slice(0, 10) === 'IPY_MODEL_') {
366 return Promise.resolve(
367 manager.get_model(value.slice(10, value.length)),
368 ).then((model) => {
369 // returning the color formatting function from VegaExprModel.
370 return model._function;
371 });
372 } else {
373 return Promise.resolve(value);
374 }
375 }
376
377 export class DataGridView extends DOMWidgetView {
378 _createElement(tagName: string) {
379 const panelWidget = Private.getWidgetPanel();
380 this.luminoWidget = new panelWidget({ view: this });
381 this._initializeTheme();
382 return this.luminoWidget.node;
383 }
384
385 // @ts-ignore Added for ipywidgets 7.x compatibility
386 get pWidget(): any {
387 return this.luminoWidget;
388 }
389
390 _setElement(el: HTMLElement) {
391 if (this.el || el !== this.luminoWidget.node) {
392 throw new Error('Cannot reset the DOM element.');
393 }
394
395 this.el = this.luminoWidget.node;
396 }
397
398 manageResizeEvent = () => {
399 MessageLoop.postMessage(
400 this.luminoWidget,
401 Widget.ResizeMessage.UnknownSize,
402 );
403 };
404
405 // ipywidgets 7 compatibility
406 _processLuminoMessage(msg: Message, _super: any): void {
407 _super.call(this, msg);
408
409 switch (msg.type) {
410 case 'after-show':
411 if (this.luminoWidget.isVisible) {
412 this.manageResizeEvent();
413 }
414 break;
415 }
416 }
417
418 processLuminoMessage(msg: Message): void {
419 // @ts-ignore needed for ipywidgets 8.x compatibility
420 this._processLuminoMessage(msg, super.processLuminoMessage);
421 }
422
423 processPhosphorMessage(msg: Message): void {
424 // @ts-ignore needed for ipywidgets 7.x compatibility
425 this._processLuminoMessage(msg, super.processPhosphorMessage);
426 }
427
428 protected _createGrid(): FeatherGrid {
429 return new FeatherGrid({
430 defaultSizes: {
•431 // @ts-ignore
432 rowHeight: this.model.get('base_row_size'),
•433 // @ts-ignore
434 columnWidth: this.model.get('base_column_size'),
•435 // @ts-ignore
436 rowHeaderWidth: this.model.get('base_row_header_size'),
•437 // @ts-ignore
438 columnHeaderHeight: this.model.get('base_column_header_size'),
439 },
•440 // @ts-ignore
441 headerVisibility: this.model.get('header_visibility'),
•442 // @ts-ignore
443 style: this.model.get('grid_style'),
444 });
445 }
446
447 render(): Promise<void> {
448 this.el.classList.add('datagrid-container');
449 window.addEventListener('resize', this.manageResizeEvent);
•450 // @ts-ignore
451 this.once('remove', () => {
452 window.removeEventListener('resize', this.manageResizeEvent);
453 });
454
455 this.grid = this._createGrid();
456
•457 // @ts-ignore
458 this.grid.columnWidths = this.model.get('column_widths');
•459 // @ts-ignore
460 this.grid.editable = this.model.get('editable');
461 // this.default_renderer must be created after setting grid.isLightTheme
462 // for proper color variable initialization
463 this.grid.isLightTheme = this._isLightTheme;
464 this.grid.dataModel = this.model.data_model;
465 this.grid.selectionModel = this.model.selectionModel;
466 this.grid.backboneModel = this.model;
467
468 this.grid.cellClicked.connect(
469 (sender: FeatherGrid, event: FeatherGrid.ICellClickedEvent) => {
470 if (this.model.comm) {
471 this.send({
472 event_type: 'cell-click',
473 region: event.region,
474 column: event.column,
475 column_index: event.columnIndex,
476 row: event.row,
477 primary_key_row: event.primaryKeyRow,
478 cell_value: event.cellValue,
479 });
480 }
481 },
482 );
483
484 this.grid.columnsResized.connect(
485 (sender: FeatherGrid, args: void): void => {
486 this.model.set(
487 'column_widths',
488 JSONExt.deepCopy(this.grid.columnWidths),
489 );
490 this.model.save_changes();
491 },
492 );
493
494 // Attaching the view's iopub callbacks functions to
495 // the data model so we can use those as an
496 // argument to model.send() function in the model class.
497 this.model._view_callbacks = this.callbacks();
498
•499 // @ts-ignore
500 this.model.on('data-model-changed', () => {
501 this.grid.dataModel = this.model.data_model;
502 this.handleColumnAutoFit();
503 });
504
•505 // @ts-ignore
506 this.model.on('change:base_row_size', () => {
•507 // @ts-ignore
508 this.grid.baseRowSize = this.model.get('base_row_size');
509 });
510
•511 // @ts-ignore
512 this.model.on('change:base_column_size', () => {
•513 // @ts-ignore
514 this.grid.baseColumnSize = this.model.get('base_column_size');
515 });
516
•517 // @ts-ignore
518 this.model.on('change:column_widths', () => {
519 this.grid.columnWidths = this.model.get('column_widths');
520 });
521
•522 // @ts-ignore
523 this.model.on('change:base_row_header_size', () => {
•524 // @ts-ignore
525 this.grid.baseRowHeaderSize = this.model.get('base_row_header_size');
526 });
527
•528 // @ts-ignore
529 this.model.on('change:base_column_header_size', () => {
•530 // @ts-ignore
531 this.grid.baseColumnHeaderSize = this.model.get(
532 'base_column_header_size',
533 );
534 });
535
•536 // @ts-ignore
537 this.model.on('change:header_visibility', () => {
538 this.grid.headerVisibility = this.model.get('header_visibility');
539 });
540
•541 // @ts-ignore
542 this.model.on_some_change(
543 [
544 'corner_renderer',
545 'header_renderer',
546 'default_renderer',
547 'renderers',
548 'grid_style',
549 ],
550 () => {
551 this.updateRenderers()
552 .then(this.updateGridStyle.bind(this))
553 .then(this.updateGridRenderers.bind(this));
554 },
555 this,
556 );
557
•558 // @ts-ignore
559 this.model.on('selection-model-changed', () => {
560 this.grid.selectionModel = this.model.selectionModel;
561 });
•562 // @ts-ignore
563
•564 // @ts-ignore
565 this.model.on('change:editable', () => {
•566 // @ts-ignore
567 this.grid.editable = this.model.get('editable');
568 });
569
570 this.model.on_some_change(
571 ['auto_fit_columns', 'auto_fit_params'],
572 () => {
573 this.handleColumnAutoFit();
574 },
575 this,
576 );
577
•578 // @ts-ignore
579 if (this.model.get('auto_fit_columns')) {
580 this.handleColumnAutoFit();
581 }
582
583 return this.updateRenderers().then(() => {
584 this.updateGridStyle();
585 this.updateGridRenderers();
586 this.luminoWidget.addWidget(this.grid);
587 });
588 }
589
590 private handleColumnAutoFit() {
591 // Check whether we need to auto-fit or revert to base size.
•592 // @ts-ignore
593 const shouldAutoFit = this.model.get('auto_fit_columns');
594 if (!shouldAutoFit) {
•595 // @ts-ignore
596 this.grid.baseColumnSize = this.model.get('base_column_size');
597 // Terminate call here if not auto-fitting.
598 return;
599 }
600
601 // Retrieve user-defined auto-fit params
•602 // @ts-ignore
603 let { area, padding, numCols } = this.model.get('auto_fit_params');
604
605 // Data validation on params
606 area = area ?? 'all';
607 padding = padding ?? 30;
608 numCols = numCols ?? undefined;
609
610 // Call resize function
611 this.grid.grid.fitColumnNames(area, padding, numCols);
612 }
613
614 private updateRenderers() {
615 // Unlisten to previous renderers
616 if (this.default_renderer) {
•617 // @ts-ignore
618 this.stopListening(this.default_renderer, 'renderer-changed');
619 }
620 if (this.header_renderer) {
•621 // @ts-ignore
622 this.stopListening(this.header_renderer, 'renderer-changed');
623 }
624 if (this.corner_renderer) {
•625 // @ts-ignore
626 this.stopListening(this.corner_renderer, 'renderer-changed');
627 }
628 for (const key in this.renderers) {
•629 // @ts-ignore
630 this.stopListening(this.renderers[key], 'renderer-changed');
631 }
632
633 // And create views for new renderers
634 const promises = [];
635
•636 // @ts-ignore
637 const default_renderer = this.model.get('default_renderer');
638 promises.push(
639 this.create_child_view(default_renderer).then(
640 (defaultRendererView: any) => {
641 this.default_renderer = defaultRendererView;
642
•643 // @ts-ignore
644 this.listenTo(
645 this.default_renderer,
646 'renderer-changed',
647 this.updateGridRenderers.bind(this),
648 );
649 },
650 ),
651 );
652
•653 // @ts-ignore
654 const corner_renderer = this.model.get('corner_renderer');
655 if (corner_renderer) {
656 promises.push(
657 this.create_child_view(corner_renderer).then(
658 (cornerRendererView: any) => {
659 this.corner_renderer = cornerRendererView;
660
•661 // @ts-ignore
662 this.listenTo(
663 this.corner_renderer,
664 'renderer-changed',
665 this.updateGridRenderers.bind(this),
666 );
667 },
668 ),
669 );
670 }
671
•672 // @ts-ignore
673 const header_renderer = this.model.get('header_renderer');
674 if (header_renderer) {
675 promises.push(
676 this.create_child_view(header_renderer).then(
677 (headerRendererView: any) => {
678 this.header_renderer = headerRendererView;
679
•680 // @ts-ignore
681 this.listenTo(
682 this.header_renderer,
683 'renderer-changed',
684 this.updateGridRenderers.bind(this),
685 );
686 },
687 ),
688 );
689 }
690
691 const renderer_promises: Dict<Promise<any>> = {};
692 _.each(
•693 // @ts-ignore
694 this.model.get('renderers'),
695 (model: CellRendererModel, key: string) => {
696 renderer_promises[key] = this.create_child_view(model);
697 },
698 );
699 promises.push(
700 resolvePromisesDict(renderer_promises).then(
701 (rendererViews: Dict<CellRendererView>) => {
702 this.renderers = rendererViews;
703
704 for (const key in rendererViews) {
•705 // @ts-ignore
706 this.listenTo(
707 rendererViews[key],
708 'renderer-changed',
709 this.updateGridRenderers.bind(this),
710 );
711 }
712 },
713 ),
714 );
715
716 return Promise.all(promises);
717 }
718
719 public updateGridStyle() {
720 this.grid.updateGridStyle();
721 }
722
723 set isLightTheme(value: boolean) {
724 this._isLightTheme = value;
725 if (!this.grid) {
726 return;
727 }
728 this.grid.isLightTheme = value;
729 }
730
731 get isLightTheme(): boolean {
732 return this._isLightTheme;
733 }
734
735 private updateGridRenderers() {
736 let defaultRenderer = this.default_renderer.renderer;
737 if (
738 this.grid.grid.style.backgroundColor !== Theme.getBackgroundColor() ||
739 this.grid.grid.style.rowBackgroundColor ||
740 this.grid.grid.style.columnBackgroundColor
741 ) {
742 // Making sure the default renderer doesn't paint over the global
743 // grid background color, if the latter is set.
744 defaultRenderer = new TextRenderer({
745 ...this.default_renderer.renderer,
746 backgroundColor: undefined,
747 });
748 }
749
•750 // @ts-ignore
751 const hasHeaderRenderer = this.model.get('header_renderer') !== null;
752 let columnHeaderRenderer = null;
753 if (this.header_renderer && hasHeaderRenderer) {
754 columnHeaderRenderer = this.header_renderer.renderer;
755 } else {
756 columnHeaderRenderer = new TextRenderer({
757 font: '12px sans-serif',
758 textColor: Theme.getFontColor(),
759 backgroundColor: Theme.getBackgroundColor(2),
760 });
761 }
762
763 let cornerHeaderRenderer = null;
764 if (this.corner_renderer) {
765 cornerHeaderRenderer = this.corner_renderer.renderer;
766 }
767
768 const renderers: Dict<CellRenderer> = {};
769 Object.entries(this.renderers).forEach(([name, rendererView]) => {
770 renderers[name] = rendererView.renderer;
771 });
772
773 this.grid.defaultRenderer = defaultRenderer;
774 this.grid.columnHeaderRenderer = columnHeaderRenderer;
775
776 if (cornerHeaderRenderer) {
777 this.grid.cornerHeaderRenderer = cornerHeaderRenderer;
778 }
779 this.grid.renderers = renderers;
780 }
781
782 private _initializeTheme() {
783 // initialize theme unless set earlier
784 if (this._isLightTheme !== undefined) {
785 return;
786 }
787
788 // initialize theme based on application settings
789 this._isLightTheme = !(
790 (
791 document.body.classList.contains(
792 'theme-dark',
793 ) /* jupyter notebook or voila */ ||
794 document.body.dataset.jpThemeLight === 'false'
795 ) /* jupyter lab */
796 );
797 }
798
799 renderers: Dict<CellRendererView>;
800 corner_renderer: CellRendererView;
801 default_renderer: CellRendererView;
802 header_renderer: CellRendererView;
803 grid: FeatherGrid;
804 luminoWidget: JupyterLuminoPanelWidget;
805 model: DataGridModel;
806 backboneModel: DataGridModel;
807
808 horizontal_stripes: boolean;
809 vertical_stripes: boolean;
810
811 // keep undefined since widget initializes before constructor
812 private _isLightTheme: boolean;
813 }
814
815 export {
816 BarRendererModel,
817 BarRendererView,
818 ImageRendererModel,
819 ImageRendererView,
820 HyperlinkRendererModel,
821 HyperlinkRendererView,
822 TextRendererModel,
823 TextRendererView,
824 HtmlRendererModel,
825 HtmlRendererView,
826 } from './cellrenderer';
827 export { VegaExprModel, VegaExprView } from './vegaexpr';
828
829 export namespace DataGridModel {
830 export interface IData {
831 data: DataSource;
832 schema: ISchema;
833 fields: { [key: string]: null }[];
834 }
835 export interface IField {
836 readonly name: string;
837 readonly type: string;
838 readonly rows: any[];
839 }
840 export interface ISchema {
841 readonly fields: IField[];
842 readonly primaryKey: string | string[];
843 readonly primaryKeyUuid: string;
844 }
845 }
846
847 /**
848 * The namespace for the module implementation details.
849 */
850 namespace Private {
851 export function getWidgetPanel(): any {
852 // @ts-ignore needed for ipywidget 7.x compatibility
853 return JupyterLuminoPanelWidget ?? JupyterPhosphorPanelWidget;
854 }
855 }
856
857 export class StreamingDataGridModel extends DataGridModel {
858 defaults() {
859 return {
860 ...super.defaults(),
861 _model_name: StreamingDataGridModel.model_name,
862 _view_name: StreamingDataGridModel.view_name,
863 _row_count: 0,
864 _data: {},
865 _debounce_delay: 160,
866 _transform_on_backend: true,
867 };
868 }
869
870 initialize(attributes: any, options: any) {
871 super.initialize(attributes, options);
872 this.on('change:_row_count', () => {
873 const newRowCount = this.get('_row_count');
874 const oldRowCount = this.data_model.rowCount('body');
875 if (newRowCount != oldRowCount) {
876 const currentView = this.data_model.currentView;
877 currentView.setRowCount(newRowCount);
878 this.data_model.currentView = currentView;
879 }
880 });
881
882 this.on('msg:custom', (content, buffers) => {
883 if (content.event_type === 'data-reply') {
884 // Bring back buffers at their original position in the data structure
885 for (const column of Object.keys(content.value.data)) {
886 if (content.value.data[column].type !== 'raw') {
887 content.value.data[column].value =
888 buffers[content.value.data[column].value];
889 }
890 }
891
892 const deserialized = deserialize_data(content.value, null);
893 this.data_model.setModelRangeData(
894 content.r1,
895 content.r2,
896 content.c1,
897 content.c2,
898 deserialized,
899 );
900 }
901 });
902 }
903
904 updateData() {
905 const data = this.data;
906
907 if (this.data_model) {
908 this.data_model.updateDataset({
909 dataModel: this,
910 datasource: data,
911 rowCount: this.get('_row_count'),
912 });
913 this.data_model.transformStateChanged.disconnect(this.syncTransformState);
914 this.data_model.dataSync.disconnect(this.updateDataSync);
915 }
916
917 this.data_model = new StreamingViewBasedJSONModel({
918 dataModel: this,
919 datasource: this.data,
920 rowCount: this.get('_row_count'),
921 });
922
923 this.data_model.transformStateChanged.connect(this.syncTransformState);
924 this.data_model.dataSync.connect(this.updateDataSync);
925
926 this.updateTransforms();
927 this.trigger('data-model-changed');
928 this.updateSelectionModel();
929 }
930
931 requestData(r1: number, r2: number, c1: number, c2: number) {
932 this.send({ type: 'data-request', r1, r2, c1, c2 });
933 }
934
935 static readonly model_name: string = 'StreamingDataGridModel';
936 static readonly view_name: string = 'StreamingDataGridView';
937
938 data_model: StreamingViewBasedJSONModel;
939 }
940
941 export class StreamingDataGridView extends DataGridView {
942 initialize(parameters: WidgetView.IInitializeParameters<WidgetModel>): void {
943 super.initialize(parameters);
944
945 this.model.on('msg:custom', (content, _) => {
946 if (content.event_type === 'tick') {
947 this.grid.tick();
948
949 return;
950 }
951 });
952 }
953
954 protected _createGrid(): StreamingFeatherGrid {
955 return new StreamingFeatherGrid({
956 defaultSizes: {
957 rowHeight: this.model.get('base_row_size'),
958 columnWidth: this.model.get('base_column_size'),
959 rowHeaderWidth: this.model.get('base_row_header_size'),
960 columnHeaderHeight: this.model.get('base_column_header_size'),
961 },
962 headerVisibility: this.model.get('header_visibility'),
963 style: this.model.get('grid_style'),
964 debounceDelay: this.model.get('_debounce_delay'),
965 requestData: this.requestData.bind(this),
966 });
967 }
968
969 private requestData(r1: number, r2: number, c1: number, c2: number) {
970 this.model.requestData(r1, r2, c1, c2);
971 }
972
973 model: StreamingDataGridModel;
974 grid: StreamingFeatherGrid;
975 }