Debian Codegraph @

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