@jupyterlab/ui-components 4.1.0-alpha.4 → 4.1.0-beta.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/components/form.js +1 -1
- package/lib/components/form.js.map +1 -1
- package/lib/components/toolbar.d.ts +1 -0
- package/lib/components/toolbar.js +31 -0
- package/lib/components/toolbar.js.map +1 -1
- package/lib/components/windowedlist.d.ts +109 -7
- package/lib/components/windowedlist.js +215 -28
- package/lib/components/windowedlist.js.map +1 -1
- package/package.json +8 -8
- package/src/components/form.tsx +1 -1
- package/src/components/toolbar.tsx +32 -0
- package/src/components/windowedlist.ts +289 -34
- package/style/toolbar.css +33 -0
- package/style/windowedlist.css +38 -2
|
@@ -721,7 +721,8 @@ export abstract class WindowedListModel implements WindowedList.IModel {
|
|
|
721
721
|
* Windowed list widget
|
|
722
722
|
*/
|
|
723
723
|
export class WindowedList<
|
|
724
|
-
T extends WindowedList.IModel = WindowedList.IModel
|
|
724
|
+
T extends WindowedList.IModel = WindowedList.IModel,
|
|
725
|
+
U = any
|
|
725
726
|
> extends Widget {
|
|
726
727
|
/**
|
|
727
728
|
* Default widget size
|
|
@@ -733,29 +734,50 @@ export class WindowedList<
|
|
|
733
734
|
*
|
|
734
735
|
* @param options Constructor options
|
|
735
736
|
*/
|
|
736
|
-
constructor(options: WindowedList.IOptions<T>) {
|
|
737
|
-
|
|
737
|
+
constructor(options: WindowedList.IOptions<T, U>) {
|
|
738
|
+
const renderer = options.renderer ?? WindowedList.defaultRenderer;
|
|
739
|
+
|
|
738
740
|
const node = document.createElement('div');
|
|
739
|
-
node.className = 'jp-WindowedPanel
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
741
|
+
node.className = 'jp-WindowedPanel';
|
|
742
|
+
|
|
743
|
+
const scrollbarElement = node.appendChild(document.createElement('div'));
|
|
744
|
+
scrollbarElement.classList.add('jp-WindowedPanel-scrollbar');
|
|
745
|
+
|
|
746
|
+
const list = scrollbarElement.appendChild(renderer.createScrollbar());
|
|
747
|
+
list.classList.add('jp-WindowedPanel-scrollbar-content');
|
|
748
|
+
|
|
749
|
+
const outerElement = node.appendChild(renderer.createOuter());
|
|
750
|
+
outerElement.classList.add('jp-WindowedPanel-outer');
|
|
751
|
+
|
|
752
|
+
const innerElement = outerElement.appendChild(
|
|
743
753
|
document.createElement('div')
|
|
744
754
|
);
|
|
745
|
-
|
|
755
|
+
innerElement.className = 'jp-WindowedPanel-inner';
|
|
756
|
+
|
|
757
|
+
const viewport = innerElement.appendChild(renderer.createViewport());
|
|
758
|
+
viewport.classList.add('jp-WindowedPanel-viewport');
|
|
759
|
+
|
|
746
760
|
super({ node });
|
|
747
761
|
super.layout = options.layout ?? new WindowedLayout();
|
|
748
|
-
this.
|
|
762
|
+
this.renderer = renderer;
|
|
763
|
+
|
|
749
764
|
this._innerElement = innerElement;
|
|
750
765
|
this._isScrolling = null;
|
|
751
|
-
this.
|
|
766
|
+
this._outerElement = outerElement;
|
|
767
|
+
this._resizeObserver = null;
|
|
768
|
+
this._scrollbarElement = scrollbarElement;
|
|
752
769
|
this._scrollToItem = null;
|
|
753
770
|
this._scrollRepaint = null;
|
|
754
771
|
this._scrollUpdateWasRequested = false;
|
|
755
772
|
this._updater = new Throttler(() => this.update(), 50);
|
|
756
|
-
this.
|
|
773
|
+
this._viewModel = options.model;
|
|
774
|
+
this._viewport = viewport;
|
|
775
|
+
|
|
776
|
+
if (options.scrollbar) {
|
|
777
|
+
node.classList.add('jp-mod-virtual-scrollbar');
|
|
778
|
+
}
|
|
757
779
|
|
|
758
|
-
this.
|
|
780
|
+
this.viewModel.stateChanged.connect(this.onStateChanged, this);
|
|
759
781
|
}
|
|
760
782
|
|
|
761
783
|
/**
|
|
@@ -778,13 +800,41 @@ export class WindowedList<
|
|
|
778
800
|
return super.layout as WindowedLayout;
|
|
779
801
|
}
|
|
780
802
|
|
|
803
|
+
/**
|
|
804
|
+
* The outer container of the windowed list.
|
|
805
|
+
*/
|
|
806
|
+
get outerNode(): HTMLElement {
|
|
807
|
+
return this._outerElement;
|
|
808
|
+
}
|
|
809
|
+
|
|
781
810
|
/**
|
|
782
811
|
* Viewport
|
|
783
812
|
*/
|
|
784
|
-
get viewportNode():
|
|
785
|
-
return this.
|
|
813
|
+
get viewportNode(): HTMLElement {
|
|
814
|
+
return this._viewport;
|
|
786
815
|
}
|
|
787
816
|
|
|
817
|
+
/**
|
|
818
|
+
* Flag to enable virtual scrollbar.
|
|
819
|
+
*/
|
|
820
|
+
get scrollbar(): boolean {
|
|
821
|
+
return this.node.classList.contains('jp-mod-virtual-scrollbar');
|
|
822
|
+
}
|
|
823
|
+
set scrollbar(enabled: boolean) {
|
|
824
|
+
if (enabled) {
|
|
825
|
+
this.node.classList.add('jp-mod-virtual-scrollbar');
|
|
826
|
+
} else {
|
|
827
|
+
this.node.classList.remove('jp-mod-virtual-scrollbar');
|
|
828
|
+
}
|
|
829
|
+
this._adjustDimensionsForScrollbar();
|
|
830
|
+
this.update();
|
|
831
|
+
}
|
|
832
|
+
|
|
833
|
+
/**
|
|
834
|
+
* The renderer for this windowed list. Set at instantiation.
|
|
835
|
+
*/
|
|
836
|
+
protected renderer: WindowedList.IRenderer<U>;
|
|
837
|
+
|
|
788
838
|
/**
|
|
789
839
|
* Windowed list view model
|
|
790
840
|
*/
|
|
@@ -807,6 +857,11 @@ export class WindowedList<
|
|
|
807
857
|
*/
|
|
808
858
|
handleEvent(event: Event): void {
|
|
809
859
|
switch (event.type) {
|
|
860
|
+
case 'pointerdown':
|
|
861
|
+
event.preventDefault();
|
|
862
|
+
event.stopPropagation();
|
|
863
|
+
this._evtPointerDown(event as PointerEvent);
|
|
864
|
+
break;
|
|
810
865
|
case 'scroll':
|
|
811
866
|
this.onScroll(event);
|
|
812
867
|
break;
|
|
@@ -885,7 +940,7 @@ export class WindowedList<
|
|
|
885
940
|
this._resetScrollToItem();
|
|
886
941
|
this.scrollTo(
|
|
887
942
|
this.viewModel.getOffsetForIndexAndAlignment(
|
|
888
|
-
Math.max(0, Math.min(index, this.
|
|
943
|
+
Math.max(0, Math.min(index, this.viewModel.widgetCount - 1)),
|
|
889
944
|
align,
|
|
890
945
|
margin
|
|
891
946
|
)
|
|
@@ -899,7 +954,7 @@ export class WindowedList<
|
|
|
899
954
|
*/
|
|
900
955
|
protected onAfterAttach(msg: Message): void {
|
|
901
956
|
super.onAfterAttach(msg);
|
|
902
|
-
if (this.
|
|
957
|
+
if (this.viewModel.windowingActive) {
|
|
903
958
|
this._addListeners();
|
|
904
959
|
} else {
|
|
905
960
|
this._applyNoWindowingStyles();
|
|
@@ -907,15 +962,18 @@ export class WindowedList<
|
|
|
907
962
|
this.viewModel.height = this.node.getBoundingClientRect().height;
|
|
908
963
|
const style = window.getComputedStyle(this.node);
|
|
909
964
|
this.viewModel.paddingTop = parseFloat(style.paddingTop);
|
|
965
|
+
this._scrollbarElement.addEventListener('pointerdown', this);
|
|
910
966
|
}
|
|
911
967
|
|
|
912
968
|
/**
|
|
913
969
|
* A message handler invoked on an `'before-detach'` message.
|
|
914
970
|
*/
|
|
915
971
|
protected onBeforeDetach(msg: Message): void {
|
|
916
|
-
if (this.
|
|
972
|
+
if (this.viewModel.windowingActive) {
|
|
917
973
|
this._removeListeners();
|
|
918
974
|
}
|
|
975
|
+
this._scrollbarElement.removeEventListener('pointerdown', this);
|
|
976
|
+
super.onBeforeDetach(msg);
|
|
919
977
|
}
|
|
920
978
|
|
|
921
979
|
/**
|
|
@@ -962,6 +1020,7 @@ export class WindowedList<
|
|
|
962
1020
|
void this._updater.invoke();
|
|
963
1021
|
}
|
|
964
1022
|
super.onResize(msg);
|
|
1023
|
+
void this._updater.invoke();
|
|
965
1024
|
}
|
|
966
1025
|
|
|
967
1026
|
/**
|
|
@@ -996,6 +1055,9 @@ export class WindowedList<
|
|
|
996
1055
|
* The default implementation of this handler is a no-op.
|
|
997
1056
|
*/
|
|
998
1057
|
protected onUpdateRequest(msg: Message): void {
|
|
1058
|
+
if (this.scrollbar) {
|
|
1059
|
+
this._renderScrollbar();
|
|
1060
|
+
}
|
|
999
1061
|
if (this.viewModel.windowingActive) {
|
|
1000
1062
|
// Throttle update request
|
|
1001
1063
|
if (this._scrollRepaint === null) {
|
|
@@ -1016,6 +1078,52 @@ export class WindowedList<
|
|
|
1016
1078
|
}
|
|
1017
1079
|
}
|
|
1018
1080
|
|
|
1081
|
+
/**
|
|
1082
|
+
* A signal that emits the index when the virtual scrollbar jumps to an item.
|
|
1083
|
+
*/
|
|
1084
|
+
protected jumped = new Signal<this, number>(this);
|
|
1085
|
+
|
|
1086
|
+
/*
|
|
1087
|
+
* Hide the native scrollbar if necessary and update dimensions
|
|
1088
|
+
*/
|
|
1089
|
+
private _adjustDimensionsForScrollbar() {
|
|
1090
|
+
const outer = this._outerElement;
|
|
1091
|
+
const scrollbar = this._scrollbarElement;
|
|
1092
|
+
if (this.scrollbar) {
|
|
1093
|
+
// Query DOM
|
|
1094
|
+
let outerScrollbarWidth = outer.offsetWidth - outer.clientWidth;
|
|
1095
|
+
// Update DOM
|
|
1096
|
+
|
|
1097
|
+
// 1) The native scrollbar is hidden by shifting it out of view.
|
|
1098
|
+
if (outerScrollbarWidth == 0) {
|
|
1099
|
+
// If the scrollbar width is zero, one of the following is true:
|
|
1100
|
+
// - (a) the content is not overflowing
|
|
1101
|
+
// - (b) the browser uses overlay scrollbars
|
|
1102
|
+
// In (b) the overlay scrollbars could show up even even if
|
|
1103
|
+
// occluded by a child element; to prevent this resulting in
|
|
1104
|
+
// double scrollbar we shift the content by an arbitrary offset.
|
|
1105
|
+
outerScrollbarWidth = 1000;
|
|
1106
|
+
outer.style.paddingRight = `${outerScrollbarWidth}px`;
|
|
1107
|
+
outer.style.boxSizing = 'border-box';
|
|
1108
|
+
} else {
|
|
1109
|
+
outer.style.paddingRight = '0';
|
|
1110
|
+
}
|
|
1111
|
+
outer.style.width = `calc(100% + ${outerScrollbarWidth}px)`;
|
|
1112
|
+
|
|
1113
|
+
// 2) The inner window is shrank to accommodate the virtual scrollbar
|
|
1114
|
+
this._innerElement.style.marginRight = `${scrollbar.offsetWidth}px`;
|
|
1115
|
+
} else {
|
|
1116
|
+
// Reset all styles that may have been touched.
|
|
1117
|
+
outer.style.width = '100%';
|
|
1118
|
+
this._innerElement.style.marginRight = '0';
|
|
1119
|
+
outer.style.paddingRight = '0';
|
|
1120
|
+
outer.style.boxSizing = '';
|
|
1121
|
+
}
|
|
1122
|
+
}
|
|
1123
|
+
|
|
1124
|
+
/**
|
|
1125
|
+
* Add listeners for viewport, contents and the virtual scrollbar.
|
|
1126
|
+
*/
|
|
1019
1127
|
private _addListeners() {
|
|
1020
1128
|
if (!this._resizeObserver) {
|
|
1021
1129
|
this._resizeObserver = new ResizeObserver(
|
|
@@ -1028,22 +1136,39 @@ export class WindowedList<
|
|
|
1028
1136
|
() => this._resizeObserver?.unobserve(widget.node)
|
|
1029
1137
|
);
|
|
1030
1138
|
}
|
|
1031
|
-
this.
|
|
1032
|
-
this.
|
|
1139
|
+
this._outerElement.addEventListener('scroll', this, passiveIfSupported);
|
|
1140
|
+
this._viewport.style.position = 'absolute';
|
|
1141
|
+
|
|
1142
|
+
this._scrollbarResizeObserver = new ResizeObserver(
|
|
1143
|
+
this._adjustDimensionsForScrollbar.bind(this)
|
|
1144
|
+
);
|
|
1145
|
+
this._scrollbarResizeObserver.observe(this._outerElement);
|
|
1146
|
+
this._scrollbarResizeObserver.observe(this._scrollbarElement);
|
|
1033
1147
|
}
|
|
1034
1148
|
|
|
1149
|
+
/**
|
|
1150
|
+
* Turn off windowing related styles in the viewport.
|
|
1151
|
+
*/
|
|
1035
1152
|
private _applyNoWindowingStyles() {
|
|
1036
|
-
this.
|
|
1037
|
-
this.
|
|
1153
|
+
this._viewport.style.position = 'relative';
|
|
1154
|
+
this._viewport.style.top = '0px';
|
|
1038
1155
|
}
|
|
1039
1156
|
|
|
1157
|
+
/**
|
|
1158
|
+
* Remove listeners for viewport and contents (but not the virtual scrollbar).
|
|
1159
|
+
*/
|
|
1040
1160
|
private _removeListeners() {
|
|
1041
|
-
this.
|
|
1161
|
+
this._outerElement.removeEventListener('scroll', this);
|
|
1042
1162
|
this._resizeObserver?.disconnect();
|
|
1043
1163
|
this._resizeObserver = null;
|
|
1164
|
+
this._scrollbarResizeObserver?.disconnect();
|
|
1165
|
+
this._scrollbarResizeObserver = null;
|
|
1044
1166
|
this._applyNoWindowingStyles();
|
|
1045
1167
|
}
|
|
1046
1168
|
|
|
1169
|
+
/**
|
|
1170
|
+
* Update viewport and DOM state.
|
|
1171
|
+
*/
|
|
1047
1172
|
private _update(): void {
|
|
1048
1173
|
if (this.isDisposed || !this.layout) {
|
|
1049
1174
|
return;
|
|
@@ -1097,27 +1222,27 @@ export class WindowedList<
|
|
|
1097
1222
|
startIndex,
|
|
1098
1223
|
stopIndex
|
|
1099
1224
|
);
|
|
1100
|
-
this.
|
|
1101
|
-
this.
|
|
1225
|
+
this._viewport.style.top = `${top}px`;
|
|
1226
|
+
this._viewport.style.minHeight = `${minHeight}px`;
|
|
1102
1227
|
} else {
|
|
1103
1228
|
// Update inner container height
|
|
1104
1229
|
this._innerElement.style.height = `0px`;
|
|
1105
1230
|
|
|
1106
|
-
// Update position of
|
|
1107
|
-
this.
|
|
1108
|
-
this.
|
|
1231
|
+
// Update position of viewport node
|
|
1232
|
+
this._viewport.style.top = `0px`;
|
|
1233
|
+
this._viewport.style.minHeight = `0px`;
|
|
1109
1234
|
}
|
|
1110
1235
|
|
|
1111
1236
|
// Update scroll
|
|
1112
1237
|
if (this._scrollUpdateWasRequested) {
|
|
1113
|
-
this.
|
|
1238
|
+
this._outerElement.scrollTop = this.viewModel.scrollOffset;
|
|
1114
1239
|
this._scrollUpdateWasRequested = false;
|
|
1115
1240
|
}
|
|
1116
1241
|
}
|
|
1117
1242
|
}
|
|
1118
1243
|
|
|
1119
1244
|
let index2 = -1;
|
|
1120
|
-
for (const w of this.
|
|
1245
|
+
for (const w of this._viewport.children) {
|
|
1121
1246
|
const currentIdx = parseInt(
|
|
1122
1247
|
(w as HTMLElement).dataset.windowedListIndex!,
|
|
1123
1248
|
10
|
|
@@ -1130,6 +1255,9 @@ export class WindowedList<
|
|
|
1130
1255
|
}
|
|
1131
1256
|
}
|
|
1132
1257
|
|
|
1258
|
+
/**
|
|
1259
|
+
* Handle viewport content (e.g. widgets) resize.
|
|
1260
|
+
*/
|
|
1133
1261
|
private _onWidgetResize(entries: ResizeObserverEntry[]): void {
|
|
1134
1262
|
this._resetScrollToItem();
|
|
1135
1263
|
|
|
@@ -1166,6 +1294,9 @@ export class WindowedList<
|
|
|
1166
1294
|
}
|
|
1167
1295
|
}
|
|
1168
1296
|
|
|
1297
|
+
/**
|
|
1298
|
+
* Clear any outstanding timeout and enqueue scrolling to a new item.
|
|
1299
|
+
*/
|
|
1169
1300
|
private _resetScrollToItem(): void {
|
|
1170
1301
|
if (this._resetScrollToItemTimeout) {
|
|
1171
1302
|
clearTimeout(this._resetScrollToItemTimeout);
|
|
@@ -1182,18 +1313,60 @@ export class WindowedList<
|
|
|
1182
1313
|
}
|
|
1183
1314
|
}
|
|
1184
1315
|
|
|
1185
|
-
|
|
1186
|
-
|
|
1316
|
+
/**
|
|
1317
|
+
* Render virtual scrollbar.
|
|
1318
|
+
*/
|
|
1319
|
+
private _renderScrollbar(): void {
|
|
1320
|
+
const { node, renderer, viewModel } = this;
|
|
1321
|
+
const content = node.querySelector('.jp-WindowedPanel-scrollbar-content')!;
|
|
1322
|
+
|
|
1323
|
+
while (content.firstChild) {
|
|
1324
|
+
content.removeChild(content.firstChild);
|
|
1325
|
+
}
|
|
1326
|
+
|
|
1327
|
+
const list = viewModel.itemsList;
|
|
1328
|
+
const count = list?.length ?? viewModel.widgetCount;
|
|
1329
|
+
for (let index = 0; index < count; index += 1) {
|
|
1330
|
+
const item = list?.get?.(index);
|
|
1331
|
+
const element = renderer.createScrollbarItem(this, index, item);
|
|
1332
|
+
element.classList.add('jp-WindowedPanel-scrollbar-item');
|
|
1333
|
+
element.dataset.index = `${index}`;
|
|
1334
|
+
content.appendChild(element);
|
|
1335
|
+
}
|
|
1336
|
+
}
|
|
1337
|
+
|
|
1338
|
+
/**
|
|
1339
|
+
* Handle `pointerdown` events on the virtual scrollbar.
|
|
1340
|
+
*/
|
|
1341
|
+
private _evtPointerDown(event: PointerEvent): void {
|
|
1342
|
+
let target = event.target as HTMLElement;
|
|
1343
|
+
while (target && target.parentElement) {
|
|
1344
|
+
if (target.hasAttribute('data-index')) {
|
|
1345
|
+
const index = parseInt(target.getAttribute('data-index')!, 10);
|
|
1346
|
+
return void (async () => {
|
|
1347
|
+
await this.scrollToItem(index);
|
|
1348
|
+
this.jumped.emit(index);
|
|
1349
|
+
})();
|
|
1350
|
+
}
|
|
1351
|
+
target = target.parentElement;
|
|
1352
|
+
}
|
|
1353
|
+
}
|
|
1354
|
+
|
|
1355
|
+
private _innerElement: HTMLElement;
|
|
1187
1356
|
private _isParentHidden: boolean;
|
|
1188
1357
|
private _isScrolling: PromiseDelegate<void> | null;
|
|
1189
1358
|
private _needsUpdate = false;
|
|
1190
|
-
private
|
|
1359
|
+
private _outerElement: HTMLElement;
|
|
1191
1360
|
private _resetScrollToItemTimeout: number | null;
|
|
1192
1361
|
private _resizeObserver: ResizeObserver | null;
|
|
1362
|
+
private _scrollbarElement: HTMLElement;
|
|
1363
|
+
private _scrollbarResizeObserver: ResizeObserver | null;
|
|
1193
1364
|
private _scrollRepaint: number | null;
|
|
1194
1365
|
private _scrollToItem: [number, WindowedList.ScrollToAlign] | null;
|
|
1195
1366
|
private _scrollUpdateWasRequested: boolean;
|
|
1196
1367
|
private _updater: Throttler;
|
|
1368
|
+
private _viewModel: T;
|
|
1369
|
+
private _viewport: HTMLElement;
|
|
1197
1370
|
}
|
|
1198
1371
|
|
|
1199
1372
|
/**
|
|
@@ -1340,10 +1513,50 @@ export class WindowedLayout extends PanelLayout {
|
|
|
1340
1513
|
* A namespace for windowed list
|
|
1341
1514
|
*/
|
|
1342
1515
|
export namespace WindowedList {
|
|
1516
|
+
/**
|
|
1517
|
+
* The default renderer class for windowed lists.
|
|
1518
|
+
*/
|
|
1519
|
+
export class Renderer<T = any> implements IRenderer<T> {
|
|
1520
|
+
/**
|
|
1521
|
+
* Create the outer, root element of the windowed list.
|
|
1522
|
+
*/
|
|
1523
|
+
createOuter(): HTMLElement {
|
|
1524
|
+
return document.createElement('div');
|
|
1525
|
+
}
|
|
1526
|
+
|
|
1527
|
+
/**
|
|
1528
|
+
* Create the virtual scrollbar element.
|
|
1529
|
+
*/
|
|
1530
|
+
createScrollbar(): HTMLOListElement {
|
|
1531
|
+
return document.createElement('ol');
|
|
1532
|
+
}
|
|
1533
|
+
|
|
1534
|
+
/**
|
|
1535
|
+
* Create an individual item rendered in the scrollbar.
|
|
1536
|
+
*/
|
|
1537
|
+
createScrollbarItem(_: WindowedList, index: number): HTMLLIElement {
|
|
1538
|
+
const li = document.createElement('li');
|
|
1539
|
+
li.appendChild(document.createTextNode(`${index}`));
|
|
1540
|
+
return li;
|
|
1541
|
+
}
|
|
1542
|
+
|
|
1543
|
+
/**
|
|
1544
|
+
* Create the viewport element into which virtualized children are added.
|
|
1545
|
+
*/
|
|
1546
|
+
createViewport(): HTMLElement {
|
|
1547
|
+
return document.createElement('div');
|
|
1548
|
+
}
|
|
1549
|
+
}
|
|
1550
|
+
|
|
1551
|
+
/**
|
|
1552
|
+
* The default renderer for windowed lists.
|
|
1553
|
+
*/
|
|
1554
|
+
export const defaultRenderer = new Renderer();
|
|
1555
|
+
|
|
1343
1556
|
/**
|
|
1344
1557
|
* Windowed list model interface
|
|
1345
1558
|
*/
|
|
1346
|
-
export interface IModel extends IDisposable {
|
|
1559
|
+
export interface IModel<T = any> extends IDisposable {
|
|
1347
1560
|
/**
|
|
1348
1561
|
* Provide a best guess for the widget size at position index
|
|
1349
1562
|
*
|
|
@@ -1387,6 +1600,7 @@ export namespace WindowedList {
|
|
|
1387
1600
|
align?: ScrollToAlign,
|
|
1388
1601
|
margin?: number
|
|
1389
1602
|
): number;
|
|
1603
|
+
|
|
1390
1604
|
/**
|
|
1391
1605
|
* Compute the items range to display.
|
|
1392
1606
|
*
|
|
@@ -1420,6 +1634,7 @@ export namespace WindowedList {
|
|
|
1420
1634
|
* Items list to be rendered
|
|
1421
1635
|
*/
|
|
1422
1636
|
itemsList: {
|
|
1637
|
+
get?: (index: number) => T;
|
|
1423
1638
|
length: number;
|
|
1424
1639
|
changed: ISignal<any, IObservableList.IChangedArgs<any>>;
|
|
1425
1640
|
} | null;
|
|
@@ -1524,7 +1739,8 @@ export namespace WindowedList {
|
|
|
1524
1739
|
* Windowed list view constructor options
|
|
1525
1740
|
*/
|
|
1526
1741
|
export interface IOptions<
|
|
1527
|
-
T extends WindowedList.IModel = WindowedList.IModel
|
|
1742
|
+
T extends WindowedList.IModel = WindowedList.IModel,
|
|
1743
|
+
U = any
|
|
1528
1744
|
> {
|
|
1529
1745
|
/**
|
|
1530
1746
|
* Windowed list model to display
|
|
@@ -1534,6 +1750,45 @@ export namespace WindowedList {
|
|
|
1534
1750
|
* Windowed list layout
|
|
1535
1751
|
*/
|
|
1536
1752
|
layout?: WindowedLayout;
|
|
1753
|
+
|
|
1754
|
+
/**
|
|
1755
|
+
* A renderer for the elements of the windowed list.
|
|
1756
|
+
*/
|
|
1757
|
+
renderer?: IRenderer<U>;
|
|
1758
|
+
|
|
1759
|
+
/**
|
|
1760
|
+
* Whether the windowed list should display a scrollbar UI.
|
|
1761
|
+
*/
|
|
1762
|
+
scrollbar?: boolean;
|
|
1763
|
+
}
|
|
1764
|
+
|
|
1765
|
+
/**
|
|
1766
|
+
* A windowed list element renderer.
|
|
1767
|
+
*/
|
|
1768
|
+
export interface IRenderer<T = any> {
|
|
1769
|
+
/**
|
|
1770
|
+
* Create the outer, root element of the windowed list.
|
|
1771
|
+
*/
|
|
1772
|
+
createOuter(): HTMLElement;
|
|
1773
|
+
|
|
1774
|
+
/**
|
|
1775
|
+
* Create the virtual scrollbar element.
|
|
1776
|
+
*/
|
|
1777
|
+
createScrollbar(): HTMLElement;
|
|
1778
|
+
|
|
1779
|
+
/**
|
|
1780
|
+
* Create an individual item rendered in the scrollbar.
|
|
1781
|
+
*/
|
|
1782
|
+
createScrollbarItem(
|
|
1783
|
+
list: WindowedList,
|
|
1784
|
+
index: number,
|
|
1785
|
+
item: T | undefined
|
|
1786
|
+
): HTMLElement;
|
|
1787
|
+
|
|
1788
|
+
/**
|
|
1789
|
+
* Create the viewport element into which virtualized children are added.
|
|
1790
|
+
*/
|
|
1791
|
+
createViewport(): HTMLElement;
|
|
1537
1792
|
}
|
|
1538
1793
|
|
|
1539
1794
|
/**
|
package/style/toolbar.css
CHANGED
|
@@ -108,3 +108,36 @@ button.jp-ToolbarButtonComponent .jp-ToolbarButtonComponent-label {
|
|
|
108
108
|
border: none;
|
|
109
109
|
box-shadow: none;
|
|
110
110
|
}
|
|
111
|
+
|
|
112
|
+
/* @deprecated dead code to be removed in JupyterLab 5
|
|
113
|
+
Button in toolbar should use the ui-toolkit
|
|
114
|
+
https://github.com/jupyterlab-contrib/jupyter-ui-toolkit.
|
|
115
|
+
*/
|
|
116
|
+
button.jp-ToolbarButtonComponent {
|
|
117
|
+
background: var(--jp-layout-color1);
|
|
118
|
+
border: none;
|
|
119
|
+
box-sizing: border-box;
|
|
120
|
+
outline: none;
|
|
121
|
+
appearance: none;
|
|
122
|
+
-webkit-appearance: none;
|
|
123
|
+
-moz-appearance: none;
|
|
124
|
+
padding: 0 6px;
|
|
125
|
+
margin: 0;
|
|
126
|
+
height: 24px;
|
|
127
|
+
border-radius: var(--jp-border-radius);
|
|
128
|
+
display: flex;
|
|
129
|
+
align-items: center;
|
|
130
|
+
text-align: center;
|
|
131
|
+
font-size: var(--jp-ui-font-size0);
|
|
132
|
+
min-width: unset;
|
|
133
|
+
min-height: unset;
|
|
134
|
+
}
|
|
135
|
+
|
|
136
|
+
button.jp-ToolbarButtonComponent:disabled {
|
|
137
|
+
opacity: 0.4;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
button.jp-ToolbarButtonComponent > span {
|
|
141
|
+
padding: 0;
|
|
142
|
+
flex: 0 0 auto;
|
|
143
|
+
}
|
package/style/windowedlist.css
CHANGED
|
@@ -4,17 +4,53 @@
|
|
|
4
4
|
*/
|
|
5
5
|
|
|
6
6
|
.jp-WindowedPanel-outer {
|
|
7
|
+
height: 100%;
|
|
7
8
|
position: relative;
|
|
8
|
-
overflow
|
|
9
|
+
overflow: auto;
|
|
9
10
|
}
|
|
10
11
|
|
|
11
12
|
.jp-WindowedPanel-inner {
|
|
12
13
|
position: relative;
|
|
13
14
|
}
|
|
14
15
|
|
|
15
|
-
.jp-WindowedPanel-
|
|
16
|
+
.jp-WindowedPanel-viewport {
|
|
16
17
|
position: absolute;
|
|
17
18
|
left: 0;
|
|
18
19
|
right: 0;
|
|
19
20
|
overflow: visible;
|
|
20
21
|
}
|
|
22
|
+
|
|
23
|
+
.jp-WindowedPanel-scrollbar {
|
|
24
|
+
display: none;
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
.jp-WindowedPanel.jp-mod-virtual-scrollbar > .jp-WindowedPanel-scrollbar {
|
|
28
|
+
background-color: inherit;
|
|
29
|
+
border-left: 1px solid var(--jp-layout-color3);
|
|
30
|
+
display: block;
|
|
31
|
+
position: fixed;
|
|
32
|
+
overflow-y: auto;
|
|
33
|
+
top: 0;
|
|
34
|
+
bottom: 0;
|
|
35
|
+
right: 0;
|
|
36
|
+
min-width: 35px;
|
|
37
|
+
z-index: 1;
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
.jp-WindowedPanel-scrollbar-content {
|
|
41
|
+
background-color: var(--jp-layout-color1);
|
|
42
|
+
list-style-type: none;
|
|
43
|
+
margin: 0;
|
|
44
|
+
padding: 0;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
.jp-WindowedPanel-scrollbar-content > .jp-WindowedPanel-scrollbar-item {
|
|
48
|
+
border-bottom: 1px solid var(--jp-layout-color3);
|
|
49
|
+
padding: 2px;
|
|
50
|
+
text-align: left;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
.jp-WindowedPanel-scrollbar-content > .jp-WindowedPanel-scrollbar-item:hover {
|
|
54
|
+
cursor: pointer;
|
|
55
|
+
background-color: var(--jp-layout-color2);
|
|
56
|
+
}
|