Debian Codegraph @

js/cellrenderer.ts

raw ◀ ▶
1 Debian patch touch this file
1 // Copyright (c) NumFOCUS.
2 // Distributed under the terms of the Modified BSD License.
3
4 const d3Format: any = require('d3-format');
5 const d3TimeFormat: any = require('d3-time-format');
6
7 import {
8 AsyncCellRenderer,
9 CellRenderer,
10 HyperlinkRenderer,
11 ImageRenderer,
12 TextRenderer,
13 } from '@lumino/datagrid';
14
15 import {
16 Dict,
17 ISerializers,
18 WidgetModel,
19 WidgetView,
20 resolvePromisesDict,
21 unpack_models,
22 } from '@jupyter-widgets/base';
23
24 import { MODULE_NAME, MODULE_VERSION } from './version';
25
26 import { BarRenderer } from './core/barrenderer';
27
28 import { VegaExprView } from './vegaexpr';
29
30 import { HtmlRenderer, exportedClass } from './core/htmlRenderer';
31 import { Scalar, Theme } from './utils';
32
33 // Temporary, will be removed when the scales are exported from bqplot
34 type Scale = any;
35
36 type Processor = Scalar | VegaExprView | Scale;
37
38 interface ICellRendererAttribute {
39 // The name of the widget attribute
40 name: string;
41
42 // The name of the equivalent phosphor attribute, if null the CellRenderer attribute has no equivalent in phosphor
43 phosphorName: string | null;
44
45 // The default value for this attribute
46 defaultValue: Scalar;
47 }
48
49 export abstract class CellRendererModel extends WidgetModel {
50 defaults() {
51 return {
52 ...super.defaults(),
53 _model_name: CellRendererModel.model_name,
54 _model_module: CellRendererModel.model_module,
55 _model_module_version: CellRendererModel.model_module_version,
56 _view_name: CellRendererModel.view_name,
57 _view_module: CellRendererModel.view_module,
58 _view_module_version: CellRendererModel.view_module_version,
59 };
60 }
61
62 abstract get_attrs(): ICellRendererAttribute[];
63
64 static model_name = 'CellRendererModel';
65 static model_module = MODULE_NAME;
66 static model_module_version = MODULE_VERSION;
67 static view_name = 'CellRendererView';
68 static view_module = MODULE_NAME;
69 static view_module_version = MODULE_VERSION;
70 }
71
72 export abstract class CellRendererView extends WidgetView {
73 async render() {
74 await this.initializeRenderer();
75
76 this.updateRenderer();
77
•78 // @ts-ignore
79 this.on('renderer-needs-update', this.updateRenderer.bind(this));
80 }
81
82 /**
83 * Method that should be called when the theme has changed.
84 */
85 async onThemeChanged() {
86 await this.initializeRenderer();
87 return this.updateRenderer();
88 }
89
90 /**
91 * Initialize the CellRenderer widget.
92 *
93 * @return The promise to initialize the renderer
94 */
95 protected async initializeRenderer(): Promise<any> {
96 const promises: Dict<PromiseLike<Processor>> = {};
97 const attr_names = this.model
98 .get_attrs()
99 .map((attr: ICellRendererAttribute) => {
100 return attr.name;
101 });
102
103 this.model.on_some_change(
104 attr_names,
105 this._on_some_processors_change,
106 this,
107 );
108
109 for (const name of attr_names) {
110 promises[name] = this.updateProcessor(name);
111 }
112
113 this.processors = await resolvePromisesDict(promises);
114 }
115
116 private _on_some_processors_change(event: any) {
117 const promises: Dict<PromiseLike<Processor>> = {};
118
119 for (const name in event.changed) {
120 promises[name] = this.updateProcessor(name);
121 }
122
123 resolvePromisesDict(promises).then((processors: Dict<Processor>) => {
124 this.processors = {
125 ...this.processors,
126 ...processors,
127 };
128
•129 // @ts-ignore
130 this.trigger('renderer-needs-update');
131 });
132 }
133
134 /**
135 * Update the phosphor renderer value, and trigger an event so that the DataGrid widget knows it has
136 * changed.
137 */
138 private updateRenderer() {
139 const options: any = {};
140 for (const attr of this.model.get_attrs()) {
141 if (attr.phosphorName) {
142 options[attr.phosphorName] = (config: CellRenderer.CellConfig) => {
143 return this.process(attr.name, config, attr.defaultValue);
144 };
145 }
146 }
147
148 this.renderer = this.createRenderer(options);
149
•150 // @ts-ignore
151 this.trigger('renderer-changed');
152 }
153
154 /**
155 * Update the processor associated with the given name.
156 *
157 * @param name - The name of the attribute to process.
158 *
159 * @return The PromiseLike to update the processor view.
160 */
161 protected updateProcessor(name: string): any {
•162 // @ts-ignore
163 const processor: any = this.model.get(name);
164
165 if (Scalar.isScalar(processor)) {
166 return processor;
167 }
168
169 // Assuming it is an VegaExprModel or a Scale model
•170 // @ts-ignore
171 this.listenTo(processor, 'change', () => {
•172 // @ts-ignore
173 this.trigger('renderer-needs-update');
174 });
175
176 return this.create_child_view(processor);
177 }
178
179 /**
180 * Process a cell attribute given the cell config.
181 *
182 * @param name - The name of the attribute to process.
183 *
184 * @param config - The configuration data for the cell.
185 *
186 * @param defaultValue - The default attribute value.
187 */
188 protected process(
189 name: string,
190 config: CellRenderer.CellConfig,
191 defaultValue: Scalar,
192 ): any {
193 const processor = this.processors[name];
194
195 if (Scalar.isScalar(processor)) {
196 if (
197 name === 'font' &&
198 typeof processor === 'string' &&
199 ((typeof config.value === 'number' && !Number.isFinite(config.value)) ||
200 (config.value instanceof Date &&
201 Number.isNaN(config.value.getTime())))
202 ) {
203 return `italic ${processor}`;
204 }
205 return processor;
206 }
207
208 if (processor instanceof VegaExprView) {
209 return processor.process(config, defaultValue);
210 }
211
212 // If it's a DateScale, convert the value to a Date object
213 if (
214 processor.model.type == 'date' ||
215 processor.model.type == 'date_color_linear'
216 ) {
217 return processor.scale(new Date(config.value));
218 }
219
220 // Assuming it is a Scale view
221 return processor.scale(config.value);
222 }
223
224 protected abstract createRenderer(
225 options: TextRenderer.IOptions,
226 ): CellRenderer;
227
228 model: CellRendererModel;
229
230 renderer: CellRenderer;
231
232 processors: Dict<Processor> = {};
233 }
234
235 export class TextRendererModel extends CellRendererModel {
236 defaults() {
237 return {
238 ...super.defaults(),
239 _model_name: TextRendererModel.model_name,
240 _view_name: TextRendererModel.view_name,
241 font: '12px sans-serif',
242 text_color: null,
243 text_wrap: false,
244 text_elide_direction: 'right',
245 text_value: null,
246 background_color: null,
247 vertical_alignment: 'center',
248 horizontal_alignment: 'left',
249 format: null,
250 format_type: 'number',
251 missing: '',
252 };
253 }
254
255 get_attrs(): ICellRendererAttribute[] {
256 return [
257 { name: 'font', phosphorName: 'font', defaultValue: '12px sans-serif' },
258 { name: 'text_wrap', phosphorName: 'wrapText', defaultValue: false },
259 {
260 name: 'text_elide_direction',
261 phosphorName: 'elideDirection',
262 defaultValue: 'right',
263 },
264 {
265 name: 'text_color',
266 phosphorName: 'textColor',
267 defaultValue: Theme.getFontColor(),
268 },
269 { name: 'text_value', phosphorName: null, defaultValue: null },
270 {
271 name: 'background_color',
272 phosphorName: 'backgroundColor',
273 defaultValue: Theme.getBackgroundColor(),
274 },
275 {
276 name: 'vertical_alignment',
277 phosphorName: 'verticalAlignment',
278 defaultValue: 'center',
279 },
280 {
281 name: 'horizontal_alignment',
282 phosphorName: 'horizontalAlignment',
283 defaultValue: 'left',
284 },
285 { name: 'format', phosphorName: null, defaultValue: null },
286 ];
287 }
288
289 static serializers: ISerializers = {
290 ...CellRendererModel.serializers,
291 font: { deserialize: unpack_models as any },
292 text_color: { deserialize: unpack_models as any },
293 text_wrap: { deserialize: unpack_models as any },
294 text_elide_direction: { deserialize: unpack_models as any },
295 text_value: { deserialize: unpack_models as any },
296 background_color: { deserialize: unpack_models as any },
297 vertical_alignment: { deserialize: unpack_models as any },
298 horizontal_alignment: { deserialize: unpack_models as any },
299 format: { deserialize: unpack_models as any },
300 };
301
302 static model_name = 'TextRendererModel';
303 static view_name = 'TextRendererView';
304 }
305
306 export class TextRendererView extends CellRendererView {
307 render() {
308 return super.render().then(() => {
309 this.model.on_some_change(
310 ['missing', 'format_type'],
311 () => {
•312 // @ts-ignore
313 this.trigger('renderer-needs-update');
314 },
315 this,
316 );
317 });
318 }
319
320 createRenderer(options: TextRenderer.IOptions) {
321 return new TextRenderer({
322 ...options,
323 format: this.getFormatter(),
324 });
325 }
326
327 getFormatter(
328 options: TextRenderer.formatGeneric.IOptions = {},
329 ): TextRenderer.FormatFunc {
330 return (config: CellRenderer.CellConfig) => {
331 let formattedValue: string;
332
333 if (config.value === null) {
•334 // @ts-ignore
335 formattedValue = this.model.get('missing');
336 } else {
337 const formattingRule = this.process('format', config, null);
338
339 if (formattingRule === null) {
340 formattedValue = String(config.value);
341 } else {
•342 // @ts-ignore
343 if (this.model.get('format_type') == 'time') {
344 formattedValue = String(
345 d3TimeFormat.timeFormat(formattingRule)(new Date(config.value)),
346 );
347 } else {
348 formattedValue = String(
349 d3Format.format(formattingRule)(config.value),
350 );
351 }
352 }
353 }
354
355 return (
356 this.process('text_value', config, formattedValue) || formattedValue
357 );
358 };
359 }
360
361 renderer: TextRenderer;
362
363 model: TextRendererModel;
364 }
365
366 export class BarRendererModel extends TextRendererModel {
367 defaults() {
368 return {
369 ...super.defaults(),
370 _model_name: BarRendererModel.model_name,
371 _view_name: BarRendererModel.view_name,
372 bar_color: '#4682b4',
373 bar_value: 0,
374 orientation: 'horizontal',
375 bar_vertical_alignment: 'bottom',
376 bar_horizontal_alignment: 'left',
377 show_text: true,
378 };
379 }
380
381 get_attrs(): ICellRendererAttribute[] {
382 return super.get_attrs().concat([
383 { name: 'bar_color', phosphorName: 'barColor', defaultValue: '#4682b4' },
384 { name: 'bar_value', phosphorName: 'barValue', defaultValue: 0 },
385 {
386 name: 'orientation',
387 phosphorName: 'orientation',
388 defaultValue: 'horizontal',
389 },
390 {
391 name: 'bar_vertical_alignment',
392 phosphorName: 'barVerticalAlignment',
393 defaultValue: 'bottom',
394 },
395 {
396 name: 'bar_horizontal_alignment',
397 phosphorName: 'barHorizontalAlignment',
398 defaultValue: 'left',
399 },
400 { name: 'show_text', phosphorName: 'showText', defaultValue: true },
401 ]);
402 }
403
404 static serializers: ISerializers = {
405 ...TextRendererModel.serializers,
406 bar_color: { deserialize: unpack_models as any },
407 bar_value: { deserialize: unpack_models as any },
408 orientation: { deserialize: unpack_models as any },
409 bar_vertical_alignment: { deserialize: unpack_models as any },
410 bar_horizontal_alignment: { deserialize: unpack_models as any },
411 show_text: { deserialize: unpack_models as any },
412 };
413
414 static model_name = 'BarRendererModel';
415 static view_name = 'BarRendererView';
416 }
417
418 export class BarRendererView extends TextRendererView {
419 createRenderer(options: BarRenderer.IOptions) {
420 return new BarRenderer({
421 ...options,
422 format: this.getFormatter(),
423 });
424 }
425
426 renderer: BarRenderer;
427
428 model: BarRendererModel;
429 }
430
431 export class HyperlinkRendererModel extends TextRendererModel {
432 defaults() {
433 return {
434 ...super.defaults(),
435 _model_name: BarRendererModel.model_name,
436 _view_name: BarRendererModel.view_name,
437 url: {},
438 url_name: {},
439 };
440 }
441
442 get_attrs(): ICellRendererAttribute[] {
443 return super.get_attrs().concat([
444 { name: 'url', phosphorName: 'url', defaultValue: null },
445 { name: 'url_name', phosphorName: 'urlName', defaultValue: null },
446 ]);
447 }
448
449 static serializers: ISerializers = {
450 ...TextRendererModel.serializers,
451 url: { deserialize: unpack_models as any },
452 url_name: { deserialize: unpack_models as any },
453 };
454
455 static model_name = 'HyperlinkRendererModel';
456 static view_name = 'HyperlinkRendererView';
457 }
458
459 export class HyperlinkRendererView extends TextRendererView {
460 createRenderer(options: HyperlinkRenderer.IOptions) {
461 return new HyperlinkRenderer({
462 ...options,
463 format: this.getFormatter(),
464 });
465 }
466
467 renderer: HyperlinkRenderer;
468
469 model: HyperlinkRendererModel;
470 }
471
472 export class ImageRendererModel extends CellRendererModel {
473 defaults() {
474 return {
475 ...super.defaults(),
476 _model_name: ImageRendererModel.model_name,
477 _view_name: ImageRendererModel.view_name,
478 background_color: {},
479 placeholder: {},
480 text_color: {},
481 width: {},
482 height: {},
483 };
484 }
485
486 get_attrs(): ICellRendererAttribute[] {
487 return [
488 {
489 name: 'background_color',
490 phosphorName: 'backgroundColor',
491 defaultValue: '',
492 },
493 { name: 'placeholder', phosphorName: 'placeholder', defaultValue: '...' },
494 {
495 name: 'text_color',
496 phosphorName: 'textColor',
497 defaultValue: '#000000',
498 },
499 { name: 'width', phosphorName: 'width', defaultValue: '' },
500 { name: 'height', phosphorName: 'height', defaultValue: '100%' },
501 ];
502 }
503
504 static serializers: ISerializers = {
505 ...TextRendererModel.serializers,
506 background_color: { deserialize: unpack_models as any },
507 placeholder: { deserialize: unpack_models as any },
508 text_color: { deserialize: unpack_models as any },
509 width: { deserialize: unpack_models as any },
510 height: { deserialize: unpack_models as any },
511 };
512
513 static model_name = 'ImageRendererModel';
514 static view_name = 'ImageRendererView';
515 }
516
517 export class ImageRendererView extends CellRendererView {
518 createRenderer(options: ImageRenderer.IOptions) {
519 if (!ImageRenderer) {
520 return new TextRenderer({
521 format: (config) => {
522 return 'ImageRenderer not available. Check that you are using JupyterLab>=4.1.';
523 },
524 wrapText: true,
525 });
526 }
527 return new ImageRenderer({
528 ...options,
529 });
530 }
531
532 renderer: ImageRenderer;
533
534 model: ImageRendererModel;
535 }
536
537 export class HtmlRendererModel extends CellRendererModel {
538 defaults() {
539 return {
540 ...super.defaults(),
541 _model_name: HtmlRendererModel.model_name,
542 _view_name: HtmlRendererModel.view_name,
543 font: '12px sans-serif',
544 placeholder: '...',
545 text_color: null,
546 background_color: null,
547 vertical_alignment: 'center',
548 horizontal_alignment: 'left',
549 };
550 }
551
552 get_attrs(): ICellRendererAttribute[] {
553 return [
554 { name: 'font', phosphorName: 'font', defaultValue: '12px sans-serif' },
555 { name: 'placeholder', phosphorName: 'placeholder', defaultValue: '...' },
556 {
557 name: 'text_color',
558 phosphorName: 'textColor',
559 defaultValue: Theme.getFontColor(),
560 },
561 {
562 name: 'background_color',
563 phosphorName: 'backgroundColor',
564 defaultValue: Theme.getBackgroundColor(),
565 },
566 {
567 name: 'vertical_alignment',
568 phosphorName: 'verticalAlignment',
569 defaultValue: 'center',
570 },
571 {
572 name: 'horizontal_alignment',
573 phosphorName: 'horizontalAlignment',
574 defaultValue: 'left',
575 },
576 ];
577 }
578
579 static serializers: ISerializers = {
580 ...CellRendererModel.serializers,
581 font: { deserialize: unpack_models as any },
582 placeholder: { deserialize: unpack_models as any },
583 text_color: { deserialize: unpack_models as any },
584 background_color: { deserialize: unpack_models as any },
585 vertical_alignment: { deserialize: unpack_models as any },
586 horizontal_alignment: { deserialize: unpack_models as any },
587 };
588
589 static model_name = 'HtmlRendererModel';
590 static view_name = 'HtmlRendererView';
591 }
592
593 export class HtmlRendererView extends CellRendererView {
594 createRenderer(options: HtmlRenderer.IOptions) {
595 // Workaround for Jupyter Lab 3 / ipywidget 7 compatibility
596 let htmRenderer: any;
597
598 if (!AsyncCellRenderer) {
599 htmRenderer = new TextRenderer({
600 format: (config) => {
601 return 'AsyncCellRenderer not available. Check that you are using JupyterLab>=4.1.';
602 },
603 wrapText: true,
604 });
605 } else {
606 htmRenderer = new exportedClass({
607 ...options,
608 });
609 htmRenderer.imageLoaded.connect(() => {
610 setTimeout(() => {
611 this.trigger('renderer-needs-update');
612 }, 0);
613 });
614 }
615
616 return htmRenderer;
617 }
618
619 // Workaround for Jupyter Lab 3 / ipywidget 7 compatibility
620 renderer: any;
621
622 model: HtmlRendererModel;
623 }