Debian Codegraph @

js/datagrid.ts

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