-
- );
- }
-
- return (
-
-// this.setDomEditor(x)} onKeyDown={this.editorKeyDown} placeholder='Search' >
-
-// {dropDownContent}
-//
;
-// }
-
-// async filterMultipleValues() {
-// let result = await ModalDialog.run(
- {grider.errors.map((err, index) => (
-
- );
- }
-
- const handleRowScroll = value => {
- setFirstVisibleRowScrollIndex(value);
- };
-
- const handleColumnScroll = value => {
- setFirstVisibleColumnScrollIndex(value);
- };
-
- const getSelectedFreeData = () => {
- const columns = getSelectedColumns();
- const rows = getSelectedRowData().map(row => _.pickBy(row, (v, col) => columns.find(x => x.columnName == col)));
- return {
- structure: {
- columns,
- },
- rows,
- };
- };
-
- const handleOpenFreeTable = () => {
- openNewTab(
- {
- title: 'Data #',
- icon: 'img free-table',
- tabComponent: 'FreeTableTab',
- props: {},
- },
- { editor: getSelectedFreeData() }
- );
- };
-
- const handleOpenChart = () => {
- openNewTab(
- {
- title: 'Chart #',
- icon: 'img chart',
- tabComponent: 'ChartTab',
- props: {},
- },
- {
- editor: {
- data: getSelectedFreeData(),
- config: { chartType: 'bar' },
- },
- }
- );
- };
-
- const handleContextMenu = event => {
- event.preventDefault();
- showMenu(
- event.pageX,
- event.pageY,
- this.domScrollContainer = x} style={this.props.containerStyle}>
-//
;
-// }
-
-// getContainerSize(): number {
-// return $(this.domScrollContainer).width();
-// }
-
-// updateContentSize() {
-// $(this.domScrollContent).width(this.contentSize);
-// }
-
-// getScrollPosition() {
-// return $(this.domScrollContainer).scrollLeft();
-// }
-
-// setScrollPosition(value: number) {
-// $(this.domScrollContainer).scrollLeft(value);
-// }
-// }
-
-// export class VerticalScrollBar extends ScrollBarBase {
-// render() {
-// this.setContentSizeField();
-
-// return this.domScrollContent = x} style={{ width: this.contentSize }}>
-//
-//
-// this.domScrollContainer = x} style={this.props.containerStyle}>
-//
;
-// }
-
-// getContainerSize(): number {
-// return $(this.domScrollContainer).height();
-// }
-
-// updateContentSize() {
-// $(this.domScrollContent).height(this.contentSize);
-// }
-
-// getScrollPosition() {
-// return $(this.domScrollContainer).scrollTop();
-// }
-
-// setScrollPosition(value: number) {
-// $(this.domScrollContainer).scrollTop(value);
-// }
-// }
diff --git a/packages/web/src/datagrid/SeriesSizes-old.js b/packages/web/src/datagrid/SeriesSizes-old.js
deleted file mode 100644
index 6c8f98d85..000000000
--- a/packages/web/src/datagrid/SeriesSizes-old.js
+++ /dev/null
@@ -1,340 +0,0 @@
-import _ from 'lodash';
-
-export class SeriesSizeItem {
- constructor() {
- this.scrollIndex = -1;
- this.frozenIndex = -1;
- this.modelIndex = 0;
- this.size = 0;
- this.position = 0;
- }
-
- // modelIndex;
- // size;
- // position;
-
- get endPosition() {
- return this.position + this.size;
- }
-}
-
-export class SeriesSizes {
- constructor() {
- this.scrollItems = [];
- this.sizeOverridesByModelIndex = {};
- this.positions = [];
- this.scrollIndexes = [];
- this.frozenItems = [];
- this.hiddenAndFrozenModelIndexes = null;
- this.frozenModelIndexes = null;
-
- this.count = 0;
- this.maxSize = 1000;
- this.defaultSize = 50;
- }
-
- // private sizeOverridesByModelIndex: { [id] } = {};
- // count;
- // defaultSize;
- // maxSize;
- // private hiddenAndFrozenModelIndexes[] = [];
- // private frozenModelIndexes[] = [];
- // private hiddenModelIndexes[] = [];
- // private scrollItems: SeriesSizeItem[] = [];
- // private positions[] = [];
- // private scrollIndexes[] = [];
- // private frozenItems: SeriesSizeItem[] = [];
-
- get scrollCount() {
- return this.count - (this.hiddenAndFrozenModelIndexes != null ? this.hiddenAndFrozenModelIndexes.length : 0);
- }
- get frozenCount() {
- return this.frozenModelIndexes != null ? this.frozenModelIndexes.length : 0;
- }
- get frozenSize() {
- return _.sumBy(this.frozenItems, x => x.size);
- }
- get realCount() {
- return this.frozenCount + this.scrollCount;
- }
-
- putSizeOverride(modelIndex, size, sizeByUser = false) {
- if (this.maxSize && size > this.maxSize && !sizeByUser) {
- size = this.maxSize;
- }
-
- let currentSize = this.sizeOverridesByModelIndex[modelIndex];
- if (sizeByUser || !currentSize || size > currentSize) {
- this.sizeOverridesByModelIndex[modelIndex] = size;
- }
- // if (!_.has(this.sizeOverridesByModelIndex, modelIndex))
- // this.sizeOverridesByModelIndex[modelIndex] = size;
- // if (size > this.sizeOverridesByModelIndex[modelIndex])
- // this.sizeOverridesByModelIndex[modelIndex] = size;
- }
- buildIndex() {
- this.scrollItems = [];
- this.scrollIndexes = _.filter(
- _.map(this.intKeys(this.sizeOverridesByModelIndex), x => this.modelToReal(x) - this.frozenCount),
- x => x >= 0
- );
- this.scrollIndexes.sort();
- let lastScrollIndex = -1;
- let lastEndPosition = 0;
- this.scrollIndexes.forEach(scrollIndex => {
- let modelIndex = this.realToModel(scrollIndex + this.frozenCount);
- let size = this.sizeOverridesByModelIndex[modelIndex];
- let item = new SeriesSizeItem();
- item.scrollIndex = scrollIndex;
- item.modelIndex = modelIndex;
- item.size = size;
- item.position = lastEndPosition + (scrollIndex - lastScrollIndex - 1) * this.defaultSize;
- this.scrollItems.push(item);
- lastScrollIndex = scrollIndex;
- lastEndPosition = item.endPosition;
- });
- this.positions = _.map(this.scrollItems, x => x.position);
- this.frozenItems = [];
- let lastpos = 0;
- for (let i = 0; i < this.frozenCount; i++) {
- let modelIndex = this.frozenModelIndexes[i];
- let size = this.getSizeByModelIndex(modelIndex);
- let item = new SeriesSizeItem();
- item.frozenIndex = i;
- item.modelIndex = modelIndex;
- item.size = size;
- item.position = lastpos;
- this.frozenItems.push(item);
- lastpos += size;
- }
- }
-
- getScrollIndexOnPosition(position) {
- let itemOrder = _.sortedIndex(this.positions, position);
- if (this.positions[itemOrder] == position) return itemOrder;
- if (itemOrder == 0) return Math.floor(position / this.defaultSize);
- if (position <= this.scrollItems[itemOrder - 1].endPosition) return this.scrollItems[itemOrder - 1].scrollIndex;
- return (
- Math.floor((position - this.scrollItems[itemOrder - 1].position) / this.defaultSize) +
- this.scrollItems[itemOrder - 1].scrollIndex
- );
- }
- getFrozenIndexOnPosition(position) {
- this.frozenItems.forEach(function (item) {
- if (position >= item.position && position <= item.endPosition) return item.frozenIndex;
- });
- return -1;
- }
- // getSizeSum(startScrollIndex, endScrollIndex) {
- // let order1 = _.sortedIndexOf(this.scrollIndexes, startScrollIndex);
- // let order2 = _.sortedIndexOf(this.scrollIndexes, endScrollIndex);
- // let count = endScrollIndex - startScrollIndex;
- // if (order1 < 0)
- // order1 = ~order1;
- // if (order2 < 0)
- // order2 = ~order2;
- // let result = 0;
- // for (let i = order1; i <= order2; i++) {
- // if (i < 0)
- // continue;
- // if (i >= this.scrollItems.length)
- // continue;
- // let item = this.scrollItems[i];
- // if (item.scrollIndex < startScrollIndex)
- // continue;
- // if (item.scrollIndex >= endScrollIndex)
- // continue;
- // result += item.size;
- // count--;
- // }
- // result += count * this.defaultSize;
- // return result;
- // }
- getSizeByModelIndex(modelIndex) {
- if (_.has(this.sizeOverridesByModelIndex, modelIndex)) return this.sizeOverridesByModelIndex[modelIndex];
- return this.defaultSize;
- }
- getSizeByScrollIndex(scrollIndex) {
- return this.getSizeByRealIndex(scrollIndex + this.frozenCount);
- }
- getSizeByRealIndex(realIndex) {
- let modelIndex = this.realToModel(realIndex);
- return this.getSizeByModelIndex(modelIndex);
- }
- removeSizeOverride(realIndex) {
- let modelIndex = this.realToModel(realIndex);
- delete this.sizeOverridesByModelIndex[modelIndex];
- }
- getScroll(sourceScrollIndex, targetScrollIndex) {
- if (sourceScrollIndex < targetScrollIndex) {
- return -_.sum(
- _.map(_.range(sourceScrollIndex, targetScrollIndex - sourceScrollIndex), x => this.getSizeByScrollIndex(x))
- );
- } else {
- return _.sum(
- _.map(_.range(targetScrollIndex, sourceScrollIndex - targetScrollIndex), x => this.getSizeByScrollIndex(x))
- );
- }
- }
- modelIndexIsInScrollArea(modelIndex) {
- let realIndex = this.modelToReal(modelIndex);
- return realIndex >= this.frozenCount;
- }
- getTotalScrollSizeSum() {
- let scrollSizeOverrides = _.map(
- _.filter(this.intKeys(this.sizeOverridesByModelIndex), x => this.modelIndexIsInScrollArea(x)),
- x => this.sizeOverridesByModelIndex[x]
- );
- return _.sum(scrollSizeOverrides) + (this.count - scrollSizeOverrides.length) * this.defaultSize;
- }
- getVisibleScrollSizeSum() {
- let scrollSizeOverrides = _.map(
- _.filter(this.intKeys(this.sizeOverridesByModelIndex), x => !_.includes(this.hiddenAndFrozenModelIndexes, x)),
- x => this.sizeOverridesByModelIndex[x]
- );
- return (
- _.sum(scrollSizeOverrides) +
- (this.count - this.hiddenModelIndexes.length - scrollSizeOverrides.length) * this.defaultSize
- );
- }
- intKeys(value) {
- return _.keys(value).map(x => _.parseInt(x));
- }
- getPositionByRealIndex(realIndex) {
- if (realIndex < 0) return 0;
- if (realIndex < this.frozenCount) return this.frozenItems[realIndex].position;
- return this.getPositionByScrollIndex(realIndex - this.frozenCount);
- }
- getPositionByScrollIndex(scrollIndex) {
- let order = _.sortedIndex(this.scrollIndexes, scrollIndex);
- if (this.scrollIndexes[order] == scrollIndex) return this.scrollItems[order].position;
- order--;
- if (order < 0) return scrollIndex * this.defaultSize;
- return (
- this.scrollItems[order].endPosition + (scrollIndex - this.scrollItems[order].scrollIndex - 1) * this.defaultSize
- );
- }
- getVisibleScrollCount(firstVisibleIndex, viewportSize) {
- let res = 0;
- let index = firstVisibleIndex;
- let count = 0;
- while (res < viewportSize && index <= this.scrollCount) {
- // console.log('this.getSizeByScrollIndex(index)', this.getSizeByScrollIndex(index));
- res += this.getSizeByScrollIndex(index);
- index++;
- count++;
- }
- // console.log('getVisibleScrollCount', firstVisibleIndex, viewportSize, count);
- return count;
- }
- getVisibleScrollCountReversed(lastVisibleIndex, viewportSize) {
- let res = 0;
- let index = lastVisibleIndex;
- let count = 0;
- while (res < viewportSize && index >= 0) {
- res += this.getSizeByScrollIndex(index);
- index--;
- count++;
- }
- return count;
- }
- invalidateAfterScroll(oldFirstVisible, newFirstVisible, invalidate, viewportSize) {
- if (newFirstVisible > oldFirstVisible) {
- let oldVisibleCount = this.getVisibleScrollCount(oldFirstVisible, viewportSize);
- let newVisibleCount = this.getVisibleScrollCount(newFirstVisible, viewportSize);
- for (let i = oldFirstVisible + oldVisibleCount - 1; i <= newFirstVisible + newVisibleCount; i++) {
- invalidate(i + this.frozenCount);
- }
- } else {
- for (let i = newFirstVisible; i <= oldFirstVisible; i++) {
- invalidate(i + this.frozenCount);
- }
- }
- }
- isWholeInView(firstVisibleIndex, index, viewportSize) {
- let res = 0;
- let testedIndex = firstVisibleIndex;
- while (res < viewportSize && testedIndex < this.count) {
- res += this.getSizeByScrollIndex(testedIndex);
- if (testedIndex == index) return res <= viewportSize;
- testedIndex++;
- }
- return false;
- }
- scrollInView(firstVisibleIndex, scrollIndex, viewportSize) {
- if (this.isWholeInView(firstVisibleIndex, scrollIndex, viewportSize)) {
- return firstVisibleIndex;
- }
- if (scrollIndex < firstVisibleIndex) {
- return scrollIndex;
- }
- let res = 0;
- let testedIndex = scrollIndex;
- while (res < viewportSize && testedIndex >= 0) {
- let size = this.getSizeByScrollIndex(testedIndex);
- if (res + size > viewportSize) return testedIndex + 1;
- testedIndex--;
- res += size;
- }
- if (res >= viewportSize && testedIndex < scrollIndex) return testedIndex + 1;
- return firstVisibleIndex;
- }
- resize(realIndex, newSize) {
- if (realIndex < 0) return;
- let modelIndex = this.realToModel(realIndex);
- if (modelIndex < 0) return;
- this.sizeOverridesByModelIndex[modelIndex] = newSize;
- this.buildIndex();
- }
- setExtraordinaryIndexes(hidden, frozen) {
- //this._hiddenAndFrozenModelIndexes = _.clone(hidden);
- hidden = hidden.filter(x => x >= 0);
- frozen = frozen.filter(x => x >= 0);
-
- hidden.sort((a, b) => a - b);
- frozen.sort((a, b) => a - b);
- this.frozenModelIndexes = _.filter(frozen, x => !_.includes(hidden, x));
- this.hiddenModelIndexes = _.filter(hidden, x => !_.includes(frozen, x));
- this.hiddenAndFrozenModelIndexes = _.concat(hidden, this.frozenModelIndexes);
- this.frozenModelIndexes.sort((a, b) => a - b);
- if (this.hiddenAndFrozenModelIndexes.length == 0) this.hiddenAndFrozenModelIndexes = null;
- if (this.frozenModelIndexes.length == 0) this.frozenModelIndexes = null;
- this.buildIndex();
- }
- realToModel(realIndex) {
- if (this.hiddenAndFrozenModelIndexes == null && this.frozenModelIndexes == null) return realIndex;
- if (realIndex < 0) return -1;
- if (realIndex < this.frozenCount && this.frozenModelIndexes != null) return this.frozenModelIndexes[realIndex];
- if (this.hiddenAndFrozenModelIndexes == null) return realIndex;
- realIndex -= this.frozenCount;
- for (let hidItem of this.hiddenAndFrozenModelIndexes) {
- if (realIndex < hidItem) return realIndex;
- realIndex++;
- }
- return realIndex;
- }
- modelToReal(modelIndex) {
- if (this.hiddenAndFrozenModelIndexes == null && this.frozenModelIndexes == null) return modelIndex;
- if (modelIndex < 0) return -1;
- let frozenIndex = this.frozenModelIndexes != null ? _.indexOf(this.frozenModelIndexes, modelIndex) : -1;
- if (frozenIndex >= 0) return frozenIndex;
- if (this.hiddenAndFrozenModelIndexes == null) return modelIndex;
- let hiddenIndex = _.sortedIndex(this.hiddenAndFrozenModelIndexes, modelIndex);
- if (this.hiddenAndFrozenModelIndexes[hiddenIndex] == modelIndex) return -1;
- if (hiddenIndex >= 0) return modelIndex - hiddenIndex + this.frozenCount;
- return modelIndex;
- }
- getFrozenPosition(frozenIndex) {
- return this.frozenItems[frozenIndex].position;
- }
- hasSizeOverride(modelIndex) {
- return _.has(this.sizeOverridesByModelIndex, modelIndex);
- }
- isVisible(testedRealIndex, firstVisibleScrollIndex, viewportSize) {
- if (testedRealIndex < 0) return false;
- if (testedRealIndex >= 0 && testedRealIndex < this.frozenCount) return true;
- let scrollIndex = testedRealIndex - this.frozenCount;
- let onPageIndex = scrollIndex - firstVisibleScrollIndex;
- return onPageIndex >= 0 && onPageIndex < this.getVisibleScrollCount(firstVisibleScrollIndex, viewportSize);
- }
-}
diff --git a/packages/web/src/datagrid/SeriesSizes.ts b/packages/web/src/datagrid/SeriesSizes.ts
deleted file mode 100644
index f221a4c56..000000000
--- a/packages/web/src/datagrid/SeriesSizes.ts
+++ /dev/null
@@ -1,341 +0,0 @@
-import _ from 'lodash';
-
-export class SeriesSizeItem {
- public scrollIndex: number = -1;
- public modelIndex: number;
- public frozenIndex: number = -1;
- public size: number;
- public position: number;
- public get endPosition(): number {
- return this.position + this.size;
- }
-}
-
-export class SeriesSizes {
- private sizeOverridesByModelIndex: { [id: number]: number } = {};
- public count: number = 0;
- public defaultSize: number = 50;
- public maxSize: number = 1000;
- private hiddenAndFrozenModelIndexes: number[] = [];
- private frozenModelIndexes: number[] = [];
- private hiddenModelIndexes: number[] = [];
- private scrollItems: SeriesSizeItem[] = [];
- private positions: number[] = [];
- private scrollIndexes: number[] = [];
- private frozenItems: SeriesSizeItem[] = [];
-
- public get scrollCount(): number {
- return this.count - (this.hiddenAndFrozenModelIndexes != null ? this.hiddenAndFrozenModelIndexes.length : 0);
- }
- public get frozenCount(): number {
- return this.frozenModelIndexes != null ? this.frozenModelIndexes.length : 0;
- }
- public get frozenSize(): number {
- return _.sumBy(this.frozenItems, x => x.size);
- }
- public get realCount(): number {
- return this.frozenCount + this.scrollCount;
- }
-
- // public clear(): void {
- // this.scrollItems = [];
- // this.sizeOverridesByModelIndex = {};
- // this.positions = [];
- // this.scrollIndexes = [];
- // this.frozenItems = [];
- // this.hiddenAndFrozenModelIndexes = null;
- // this.frozenModelIndexes = null;
- // }
- public putSizeOverride(modelIndex: number, size: number, sizeByUser = false): void {
- if (this.maxSize && size > this.maxSize && !sizeByUser) {
- size = this.maxSize;
- }
-
- let currentSize = this.sizeOverridesByModelIndex[modelIndex];
- if (sizeByUser || !currentSize || size > currentSize) {
- this.sizeOverridesByModelIndex[modelIndex] = size;
- }
- // if (!_.has(this.sizeOverridesByModelIndex, modelIndex))
- // this.sizeOverridesByModelIndex[modelIndex] = size;
- // if (size > this.sizeOverridesByModelIndex[modelIndex])
- // this.sizeOverridesByModelIndex[modelIndex] = size;
- }
- public buildIndex(): void {
- this.scrollItems = [];
- this.scrollIndexes = _.filter(
- _.map(_.range(this.count), x => this.modelToReal(x) - this.frozenCount),
- // _.map(this.intKeys(_.keys(this.sizeOverridesByModelIndex)), (x) => this.modelToReal(x) - this.frozenCount),
- x => x >= 0
- );
- this.scrollIndexes.sort();
- let lastScrollIndex: number = -1;
- let lastEndPosition: number = 0;
- this.scrollIndexes.forEach(scrollIndex => {
- let modelIndex: number = this.realToModel(scrollIndex + this.frozenCount);
- let size: number = this.sizeOverridesByModelIndex[modelIndex];
- let item = new SeriesSizeItem();
- item.scrollIndex = scrollIndex;
- item.modelIndex = modelIndex;
- item.size = size;
- item.position = lastEndPosition + (scrollIndex - lastScrollIndex - 1) * this.defaultSize;
- this.scrollItems.push(item);
- lastScrollIndex = scrollIndex;
- lastEndPosition = item.endPosition;
- });
- this.positions = _.map(this.scrollItems, x => x.position);
- this.frozenItems = [];
- let lastpos: number = 0;
- for (let i: number = 0; i < this.frozenCount; i++) {
- let modelIndex: number = this.frozenModelIndexes[i];
- let size: number = this.getSizeByModelIndex(modelIndex);
- let item = new SeriesSizeItem();
- item.frozenIndex = i;
- item.modelIndex = modelIndex;
- item.size = size;
- item.position = lastpos;
- this.frozenItems.push(item);
- lastpos += size;
- }
- }
-
- public getScrollIndexOnPosition(position: number): number {
- let itemOrder: number = _.sortedIndex(this.positions, position);
- if (this.positions[itemOrder] == position) return itemOrder;
- if (itemOrder == 0) return Math.floor(position / this.defaultSize);
- if (position <= this.scrollItems[itemOrder - 1].endPosition) return this.scrollItems[itemOrder - 1].scrollIndex;
- return (
- Math.floor((position - this.scrollItems[itemOrder - 1].position) / this.defaultSize) +
- this.scrollItems[itemOrder - 1].scrollIndex
- );
- }
- public getFrozenIndexOnPosition(position: number): number {
- this.frozenItems.forEach(function (item) {
- if (position >= item.position && position <= item.endPosition) return item.frozenIndex;
- });
- return -1;
- }
- // public getSizeSum(startScrollIndex: number, endScrollIndex: number): number {
- // let order1: number = _.sortedIndexOf(this.scrollIndexes, startScrollIndex);
- // let order2: number = _.sortedIndexOf(this.scrollIndexes, endScrollIndex);
- // let count: number = endScrollIndex - startScrollIndex;
- // if (order1 < 0)
- // order1 = ~order1;
- // if (order2 < 0)
- // order2 = ~order2;
- // let result: number = 0;
- // for (let i: number = order1; i <= order2; i++) {
- // if (i < 0)
- // continue;
- // if (i >= this.scrollItems.length)
- // continue;
- // let item = this.scrollItems[i];
- // if (item.scrollIndex < startScrollIndex)
- // continue;
- // if (item.scrollIndex >= endScrollIndex)
- // continue;
- // result += item.size;
- // count--;
- // }
- // result += count * this.defaultSize;
- // return result;
- // }
- public getSizeByModelIndex(modelIndex: number): number {
- if (_.has(this.sizeOverridesByModelIndex, modelIndex)) return this.sizeOverridesByModelIndex[modelIndex];
- return this.defaultSize;
- }
- public getSizeByScrollIndex(scrollIndex: number): number {
- return this.getSizeByRealIndex(scrollIndex + this.frozenCount);
- }
- public getSizeByRealIndex(realIndex: number): number {
- let modelIndex: number = this.realToModel(realIndex);
- return this.getSizeByModelIndex(modelIndex);
- }
- public removeSizeOverride(realIndex: number): void {
- let modelIndex: number = this.realToModel(realIndex);
- delete this.sizeOverridesByModelIndex[modelIndex];
- }
- public getScroll(sourceScrollIndex: number, targetScrollIndex: number): number {
- if (sourceScrollIndex < targetScrollIndex) {
- return -_.sum(
- _.map(_.range(sourceScrollIndex, targetScrollIndex - sourceScrollIndex), x => this.getSizeByScrollIndex(x))
- );
- } else {
- return _.sum(
- _.map(_.range(targetScrollIndex, sourceScrollIndex - targetScrollIndex), x => this.getSizeByScrollIndex(x))
- );
- }
- }
- public modelIndexIsInScrollArea(modelIndex: number): boolean {
- let realIndex = this.modelToReal(modelIndex);
- return realIndex >= this.frozenCount;
- }
- public getTotalScrollSizeSum(): number {
- let scrollSizeOverrides = _.map(
- _.filter(this.intKeys(this.sizeOverridesByModelIndex), x => this.modelIndexIsInScrollArea(x)),
- x => this.sizeOverridesByModelIndex[x]
- );
- return _.sum(scrollSizeOverrides) + (this.count - scrollSizeOverrides.length) * this.defaultSize;
- }
- public getVisibleScrollSizeSum(): number {
- let scrollSizeOverrides = _.map(
- _.filter(this.intKeys(this.sizeOverridesByModelIndex), x => !_.includes(this.hiddenAndFrozenModelIndexes, x)),
- x => this.sizeOverridesByModelIndex[x]
- );
- return (
- _.sum(scrollSizeOverrides) +
- (this.count - this.hiddenModelIndexes.length - scrollSizeOverrides.length) * this.defaultSize
- );
- }
- private intKeys(value): number[] {
- return _.keys(value).map(x => _.parseInt(x));
- }
- public getPositionByRealIndex(realIndex: number): number {
- if (realIndex < 0) return 0;
- if (realIndex < this.frozenCount) return this.frozenItems[realIndex].position;
- return this.getPositionByScrollIndex(realIndex - this.frozenCount);
- }
- public getPositionByScrollIndex(scrollIndex: number): number {
- let order: number = _.sortedIndex(this.scrollIndexes, scrollIndex);
- if (this.scrollIndexes[order] == scrollIndex) return this.scrollItems[order].position;
- order--;
- if (order < 0) return scrollIndex * this.defaultSize;
- return (
- this.scrollItems[order].endPosition + (scrollIndex - this.scrollItems[order].scrollIndex - 1) * this.defaultSize
- );
- }
- public getVisibleScrollCount(firstVisibleIndex: number, viewportSize: number): number {
- let res: number = 0;
- let index: number = firstVisibleIndex;
- let count: number = 0;
- while (res < viewportSize && index <= this.scrollCount) {
- res += this.getSizeByScrollIndex(index);
- index++;
- count++;
- }
- return count;
- }
- public getVisibleScrollCountReversed(lastVisibleIndex: number, viewportSize: number): number {
- let res: number = 0;
- let index: number = lastVisibleIndex;
- let count: number = 0;
- while (res < viewportSize && index >= 0) {
- res += this.getSizeByScrollIndex(index);
- index--;
- count++;
- }
- return count;
- }
- public invalidateAfterScroll(
- oldFirstVisible: number,
- newFirstVisible: number,
- invalidate: (_: number) => void,
- viewportSize: number
- ): void {
- if (newFirstVisible > oldFirstVisible) {
- let oldVisibleCount: number = this.getVisibleScrollCount(oldFirstVisible, viewportSize);
- let newVisibleCount: number = this.getVisibleScrollCount(newFirstVisible, viewportSize);
- for (let i: number = oldFirstVisible + oldVisibleCount - 1; i <= newFirstVisible + newVisibleCount; i++) {
- invalidate(i + this.frozenCount);
- }
- } else {
- for (let i: number = newFirstVisible; i <= oldFirstVisible; i++) {
- invalidate(i + this.frozenCount);
- }
- }
- }
- public isWholeInView(firstVisibleIndex: number, index: number, viewportSize: number): boolean {
- let res: number = 0;
- let testedIndex: number = firstVisibleIndex;
- while (res < viewportSize && testedIndex < this.count) {
- res += this.getSizeByScrollIndex(testedIndex);
- if (testedIndex == index) return res <= viewportSize;
- testedIndex++;
- }
- return false;
- }
- public scrollInView(firstVisibleIndex: number, scrollIndex: number, viewportSize: number): number {
- if (this.isWholeInView(firstVisibleIndex, scrollIndex, viewportSize)) {
- return firstVisibleIndex;
- }
- if (scrollIndex < firstVisibleIndex) {
- return scrollIndex;
- }
- let testedIndex = firstVisibleIndex + 1;
- while (testedIndex < this.scrollCount) {
- if (this.isWholeInView(testedIndex, scrollIndex, viewportSize)) {
- return testedIndex;
- }
- testedIndex++;
- }
- return this.scrollCount - 1;
-
- // let res: number = 0;
- // let testedIndex: number = scrollIndex;
- // while (res < viewportSize && testedIndex >= 0) {
- // let size: number = this.getSizeByScrollIndex(testedIndex);
- // if (res + size > viewportSize) return testedIndex + 1;
- // testedIndex--;
- // res += size;
- // }
- // if (res >= viewportSize && testedIndex < scrollIndex) return testedIndex + 1;
- // return firstVisibleIndex;
- }
- public resize(realIndex: number, newSize: number): void {
- if (realIndex < 0) return;
- let modelIndex: number = this.realToModel(realIndex);
- if (modelIndex < 0) return;
- this.sizeOverridesByModelIndex[modelIndex] = newSize;
- this.buildIndex();
- }
- public setExtraordinaryIndexes(hidden: number[], frozen: number[]): void {
- //this._hiddenAndFrozenModelIndexes = _.clone(hidden);
- hidden = hidden.filter(x => x >= 0);
- frozen = frozen.filter(x => x >= 0);
-
- hidden.sort((a, b) => a - b);
- frozen.sort((a, b) => a - b);
- this.frozenModelIndexes = _.filter(frozen, x => !_.includes(hidden, x));
- this.hiddenModelIndexes = _.filter(hidden, x => !_.includes(frozen, x));
- this.hiddenAndFrozenModelIndexes = _.concat(hidden, this.frozenModelIndexes);
- this.frozenModelIndexes.sort((a, b) => a - b);
- if (this.hiddenAndFrozenModelIndexes.length == 0) this.hiddenAndFrozenModelIndexes = null;
- if (this.frozenModelIndexes.length == 0) this.frozenModelIndexes = null;
- this.buildIndex();
- }
- public realToModel(realIndex: number): number {
- if (this.hiddenAndFrozenModelIndexes == null && this.frozenModelIndexes == null) return realIndex;
- if (realIndex < 0) return -1;
- if (realIndex < this.frozenCount && this.frozenModelIndexes != null) return this.frozenModelIndexes[realIndex];
- if (this.hiddenAndFrozenModelIndexes == null) return realIndex;
- realIndex -= this.frozenCount;
- for (let hidItem of this.hiddenAndFrozenModelIndexes) {
- if (realIndex < hidItem) return realIndex;
- realIndex++;
- }
- return realIndex;
- }
- public modelToReal(modelIndex: number): number {
- if (this.hiddenAndFrozenModelIndexes == null && this.frozenModelIndexes == null) return modelIndex;
- if (modelIndex < 0) return -1;
- let frozenIndex: number = this.frozenModelIndexes != null ? _.indexOf(this.frozenModelIndexes, modelIndex) : -1;
- if (frozenIndex >= 0) return frozenIndex;
- if (this.hiddenAndFrozenModelIndexes == null) return modelIndex;
- let hiddenIndex: number = _.sortedIndex(this.hiddenAndFrozenModelIndexes, modelIndex);
- if (this.hiddenAndFrozenModelIndexes[hiddenIndex] == modelIndex) return -1;
- if (hiddenIndex >= 0) return modelIndex - hiddenIndex + this.frozenCount;
- return modelIndex;
- }
- public getFrozenPosition(frozenIndex: number): number {
- return this.frozenItems[frozenIndex].position;
- }
- public hasSizeOverride(modelIndex: number): boolean {
- return _.has(this.sizeOverridesByModelIndex, modelIndex);
- }
- public isVisible(testedRealIndex: number, firstVisibleScrollIndex: number, viewportSize: number): boolean {
- if (testedRealIndex < 0) return false;
- if (testedRealIndex >= 0 && testedRealIndex < this.frozenCount) return true;
- let scrollIndex: number = testedRealIndex - this.frozenCount;
- let onPageIndex: number = scrollIndex - firstVisibleScrollIndex;
- return onPageIndex >= 0 && onPageIndex < this.getVisibleScrollCount(firstVisibleScrollIndex, viewportSize);
- }
-}
diff --git a/packages/web/src/datagrid/SqlDataGridCore.js b/packages/web/src/datagrid/SqlDataGridCore.js
deleted file mode 100644
index fd3fc60af..000000000
--- a/packages/web/src/datagrid/SqlDataGridCore.js
+++ /dev/null
@@ -1,177 +0,0 @@
-import React from 'react';
-import axios from '../utility/axios';
-import { useSetOpenedTabs } from '../utility/globalState';
-import DataGridCore from './DataGridCore';
-import useSocket from '../utility/SocketProvider';
-import useShowModal from '../modals/showModal';
-import ImportExportModal from '../modals/ImportExportModal';
-import { changeSetToSql, createChangeSet, getChangeSetInsertedRows } from 'dbgate-datalib';
-import LoadingDataGridCore from './LoadingDataGridCore';
-import ChangeSetGrider from './ChangeSetGrider';
-import { scriptToSql } from 'dbgate-sqltree';
-import useModalState from '../modals/useModalState';
-import ConfirmSqlModal from '../modals/ConfirmSqlModal';
-import ErrorMessageModal from '../modals/ErrorMessageModal';
-import useOpenNewTab from '../utility/useOpenNewTab';
-
-/** @param props {import('./types').DataGridProps} */
-async function loadDataPage(props, offset, limit) {
- const { display, conid, database } = props;
-
- const sql = display.getPageQuery(offset, limit);
-
- const response = await axios.request({
- url: 'database-connections/query-data',
- method: 'post',
- params: {
- conid,
- database,
- },
- data: { sql },
- });
-
- if (response.data.errorMessage) return response.data;
- return response.data.rows;
-}
-
-function dataPageAvailable(props) {
- const { display } = props;
- const sql = display.getPageQuery(0, 1);
- return !!sql;
-}
-
-async function loadRowCount(props) {
- const { display, conid, database } = props;
-
- const sql = display.getCountQuery();
-
- const response = await axios.request({
- url: 'database-connections/query-data',
- method: 'post',
- params: {
- conid,
- database,
- },
- data: { sql },
- });
-
- return parseInt(response.data.rows[0].count);
-}
-
-/** @param props {import('./types').DataGridProps} */
-export default function SqlDataGridCore(props) {
- const { conid, database, display, changeSetState, dispatchChangeSet } = props;
- const showModal = useShowModal();
- const openNewTab = useOpenNewTab();
-
- const confirmSqlModalState = useModalState();
- const [confirmSql, setConfirmSql] = React.useState('');
-
- const changeSet = changeSetState && changeSetState.value;
- const changeSetRef = React.useRef(changeSet);
- changeSetRef.current = changeSet;
-
- function exportGrid() {
- const initialValues = {};
- initialValues.sourceStorageType = 'query';
- initialValues.sourceConnectionId = conid;
- initialValues.sourceDatabaseName = database;
- initialValues.sourceSql = display.getExportQuery();
- initialValues.sourceList = display.baseTable ? [display.baseTable.pureName] : [];
- showModal(modalState => this.domScrollContent = x} style={{ height: this.contentSize }}>
-//
-//
-//
- x.columnName == column.columnName)} />
-
- {formDisplay.config.formViewKeyRequested && (
-
-
- setFieldValue(
- 'sourceList',
- _.uniq([...(values.sourceList || []), ...(dbinfo && dbinfo.tables.map(x => x.pureName))])
- )
- }
- />
-
- setFieldValue(
- 'sourceList',
- _.uniq([...(values.sourceList || []), ...(dbinfo && dbinfo.views.map(x => x.pureName))])
- )
- }
- />
- setFieldValue('sourceList', [])} />
-
-
- )}
-
- )}
- {storageType == 'query' && (
- <>
-
-
-
- setFieldValue(
- 'sourceList',
- _.uniq([...(values.sourceList || []), ...(archiveFiles && archiveFiles.map(x => x.name))])
- )
- }
- />
- setFieldValue('sourceList', [])} />
-
-
- )}
-
- {!!format && direction == 'source' && {name}
- 
-
-
- ) : (
-
-
- )}
-
- Connected:
- )}
- {!isTesting && sqlConnectResult && sqlConnectResult.msgtype == 'error' && (
-
- Connect failed:
- )}
- {isTesting && (
-
-
- )}
-
- setMode(value)}
- />
-
-
- );
-}
-
-export default function FilterMultipleValuesModal({ modalState, onFilter }) {
- const editorRef = React.useRef(null);
- const [text, setText] = React.useState('');
- const [mode, setMode] = React.useState('is');
- React.useEffect(() => {
- setTimeout(() => {
- if (editorRef.current) editorRef.current.focus();
- }, 1);
- }, []);
-
- const handleOk = () => {
- onFilter(mode, text);
- modalState.close();
- };
-
- return (
-