d2coreui 23.0.14 → 23.0.15

package/lib/esm/components/grid/cell/rangeSelector.js

@@ -0,0 +1,527 @@
+import { _areEqual, _exists, _includes, _isDomLayout, _last, _makeNull, _missing, _removeFromArray, _shallowCompare, AutoScrollService, BeanStub } from "ag-grid-community";
+export class RangeSelector extends BeanStub {
+    constructor() {
+        super(...arguments);
+        this.beanName = "RangeSelector";
+    }
+    wireBeans(beans) {
+        this.rowModel = beans.rowModel;
+        this.dragService = beans.dragService;
+        this.columnModel = beans.columnModel;
+        this.visibleColsService = beans.visibleColsService;
+        this.cellNavigationService = beans.cellNavigationService;
+        this.pinnedRowModel = beans.pinnedRowModel;
+        this.rowPositionUtils = beans.rowPositionUtils;
+        this.cellPositionUtils = beans.cellPositionUtils;
+        this.ctrlsService = beans.ctrlsService;
+        this.valueService = beans.valueService;
+        this.eventService = beans.eventService;
+        this.mouseEventService = beans.mouseEventService;
+        this.gridApi = beans.gridApi;
+        this.eGridDiv = beans.eGridDiv;
+        this.focusService = beans.focusService;
+        this.gos = beans.gos;
+    }
+    postConstruct() {
+        this.cellRanges = [];
+        this.bodyScrollListener = this.onBodyScroll.bind(this);
+        this.dragging = false;
+        this.eventService.addEventListener("newColumnsLoaded", () => this.removeAllCellRanges());
+        this.eventService.addEventListener("columnPivotModeChanged", () => this.removeAllCellRanges());
+        this.eventService.addEventListener("columnRowGroupChanged", () => this.removeAllCellRanges());
+        this.eventService.addEventListener("columnPivotChanged", () => this.removeAllCellRanges());
+        this.eventService.addEventListener("columnGroupOpened", this.refreshLastRangeStart.bind(this));
+        this.eventService.addEventListener("columnMoved", this.refreshLastRangeStart.bind(this));
+        this.eventService.addEventListener("columnPinned", this.refreshLastRangeStart.bind(this));
+        this.eventService.addEventListener("columnVisible", this.onColumnVisibleChange.bind(this));
+        this.ctrlsService.whenReady(this, () => {
+            const gridBodyCon = this.ctrlsService.getGridBodyCtrl();
+            this.autoScrollService = new AutoScrollService({
+                scrollContainer: gridBodyCon.getBodyViewportElement(),
+                scrollAxis: 'xy',
+                getVerticalPosition: () => gridBodyCon.getScrollFeature().getVScrollPosition().top,
+                setVerticalPosition: (position) => gridBodyCon.getScrollFeature().setVerticalScrollPosition(position),
+                getHorizontalPosition: () => gridBodyCon.getScrollFeature().getHScrollPosition().left,
+                setHorizontalPosition: (position) => gridBodyCon.getScrollFeature().setHorizontalScrollPosition(position),
+                shouldSkipVerticalScroll: () => !_isDomLayout(this.gos, 'normal'),
+                shouldSkipHorizontalScroll: () => !gridBodyCon.getScrollFeature().isHorizontalScrollShowing()
+            });
+        });
+        const params = {
+            eElement: this.eGridDiv,
+            onDragStart: this.onDragStart.bind(this),
+            onDragStop: this.onDragStop.bind(this),
+            onDragging: this.onDragging.bind(this)
+        };
+        this.dragService.addDragSource(params);
+        this.dragService.addDestroyFunc(() => this.dragService.removeDragSource(params));
+    }
+    cellPositionEquals(cellA, cellB) {
+        const colsMatch = cellA.column === cellB.column;
+        const floatingMatch = cellA.rowPinned === cellB.rowPinned;
+        const indexMatch = cellA.rowIndex === cellB.rowIndex;
+        return colsMatch && floatingMatch && indexMatch;
+    }
+    onColumnVisibleChange() {
+        this.refreshLastRangeStart();
+        this.cellRanges.forEach(cellRange => {
+            const beforeCols = cellRange.columns;
+            cellRange.columns = cellRange.columns.filter(col => col.isVisible());
+            const colsInRangeChanged = !_areEqual(beforeCols, cellRange.columns);
+            if (colsInRangeChanged) {
+                this.dispatchChangedEvent(false, true, cellRange.id);
+            }
+        });
+    }
+    refreshLastRangeStart() {
+        const lastRange = _last(this.cellRanges);
+        if (!lastRange) {
+            return;
+        }
+        this.refreshRangeStart(lastRange);
+    }
+    isContiguousRange(cellRange) {
+        const rangeColumns = cellRange.columns;
+        if (!rangeColumns.length) {
+            return false;
+        }
+        const allColumns = this.visibleColsService.getAllCols();
+        const allPositions = rangeColumns.map(c => allColumns.indexOf(c)).sort((a, b) => a - b);
+        return _last(allPositions) - allPositions[0] + 1 === rangeColumns.length;
+    }
+    getRangeStartRow(cellRange) {
+        if (cellRange.startRow && cellRange.endRow) {
+            return this.rowPositionUtils.before(cellRange.startRow, cellRange.endRow) ?
+                cellRange.startRow : cellRange.endRow;
+        }
+        const rowPinned = this.pinnedRowModel.getPinnedTopRowCount() > 0 ? 'top' : null;
+        return { rowIndex: 0, rowPinned };
+    }
+    getRangeEndRow(cellRange) {
+        if (cellRange.startRow && cellRange.endRow) {
+            return this.rowPositionUtils.before(cellRange.startRow, cellRange.endRow) ?
+                cellRange.endRow : cellRange.startRow;
+        }
+        const pinnedBottomRowCount = this.pinnedRowModel.getPinnedBottomRowCount();
+        const pinnedBottom = pinnedBottomRowCount > 0;
+        if (pinnedBottom) {
+            return {
+                rowIndex: pinnedBottomRowCount - 1,
+                rowPinned: 'bottom'
+            };
+        }
+        return {
+            rowIndex: this.rowModel.getRowCount() - 1,
+            rowPinned: null
+        };
+    }
+    setRangeToCell(cell, appendRange = false) {
+        const columns = this.calculateColumnsBetween(cell.column, cell.column);
+        if (!columns) {
+            return;
+        }
+        this.removeAllCellRanges(true);
+        const rowForCell = {
+            rowIndex: cell.rowIndex,
+            rowPinned: cell.rowPinned
+        };
+        let cellRange;
+        for (let i = 0; i < this.cellRanges.length; i++) {
+            const range = this.cellRanges[i];
+            const matches = (range.columns && range.columns.length === 1 && range.columns[0] === cell.column) &&
+                this.rowPositionUtils.sameRow(rowForCell, range.startRow) &&
+                this.rowPositionUtils.sameRow(rowForCell, range.endRow);
+            if (matches) {
+                cellRange = range;
+                break;
+            }
+        }
+        if (cellRange) {
+            const atEndOfList = _last(this.cellRanges) === cellRange;
+            if (!atEndOfList) {
+                _removeFromArray(this.cellRanges, cellRange);
+                this.cellRanges.push(cellRange);
+            }
+        }
+        else {
+            cellRange = {
+                startRow: rowForCell,
+                endRow: rowForCell,
+                columns: columns,
+                startColumn: cell.column
+            };
+            this.cellRanges.push(cellRange);
+        }
+        this.newestRangeStartCell = cell;
+        this.onDragStop();
+        this.dispatchChangedEvent(true, true, cellRange.id);
+    }
+    extendLatestRangeToCell(cellPosition) {
+        if (this.isEmpty() || !this.newestRangeStartCell) {
+            return;
+        }
+        const cellRange = _last(this.cellRanges);
+        this.updateRangeEnd(cellRange, cellPosition);
+    }
+    updateRangeEnd(cellRange, cellPosition, silent) {
+        silent = !!silent;
+        const endColumn = cellPosition.column;
+        const colsToAdd = this.calculateColumnsBetween(cellRange.startColumn, endColumn);
+        if (!colsToAdd || this.isLastCellOfRange(cellRange, cellPosition)) {
+            return;
+        }
+        cellRange.columns = colsToAdd;
+        cellRange.endRow = { rowIndex: cellPosition.rowIndex, rowPinned: cellPosition.rowPinned };
+        if (!silent) {
+            this.dispatchChangedEvent(true, true, cellRange.id);
+        }
+    }
+    refreshRangeStart(cellRange) {
+        const { startColumn, columns } = cellRange;
+        const moveColInCellRange = (colToMove, moveToFront) => {
+            const otherCols = cellRange.columns.filter(col => col !== colToMove);
+            if (colToMove) {
+                cellRange.startColumn = colToMove;
+                cellRange.columns = moveToFront ? [colToMove, ...otherCols] : [...otherCols, colToMove];
+            }
+            else {
+                cellRange.columns = otherCols;
+            }
+        };
+        const { left, right } = this.getRangeEdgeColumns(cellRange);
+        const shouldMoveLeftCol = startColumn === columns[0] && startColumn !== left;
+        if (shouldMoveLeftCol) {
+            moveColInCellRange(left, true);
+            return;
+        }
+        const shouldMoveRightCol = startColumn === _last(columns) && startColumn === right;
+        if (shouldMoveRightCol) {
+            moveColInCellRange(right, false);
+            return;
+        }
+    }
+    getRangeEdgeColumns(cellRange) {
+        const allColumns = this.visibleColsService.getAllCols();
+        const allIndices = cellRange.columns
+            .map(c => allColumns.indexOf(c))
+            .filter(i => i > -1)
+            .sort((a, b) => a - b);
+        return {
+            left: allColumns[allIndices[0]],
+            right: allColumns[_last(allIndices)]
+        };
+    }
+    extendLatestRangeInDirection(key) {
+        if (this.isEmpty() || !this.newestRangeStartCell) {
+            return;
+        }
+        const lastRange = _last(this.cellRanges);
+        const startCell = this.newestRangeStartCell;
+        const firstCol = lastRange.columns[0];
+        const lastCol = _last(lastRange.columns);
+        const endCellIndex = lastRange.endRow.rowIndex;
+        const endCellFloating = lastRange.endRow.rowPinned;
+        const endCellColumn = startCell.column === firstCol ? lastCol : firstCol;
+        const endCell = { column: endCellColumn, rowIndex: endCellIndex, rowPinned: endCellFloating };
+        const newEndCell = this.cellNavigationService.getNextCellToFocus(key, endCell);
+        if (!newEndCell) {
+            return;
+        }
+        this.setCellRange({
+            rowStartIndex: startCell.rowIndex,
+            rowStartPinned: startCell.rowPinned,
+            rowEndIndex: newEndCell.rowIndex,
+            rowEndPinned: newEndCell.rowPinned,
+            columnStart: startCell.column,
+            columnEnd: newEndCell.column
+        });
+        return newEndCell;
+    }
+    setCellRange(params) {
+        this.removeAllCellRanges(true);
+        this.addCellRange(params);
+    }
+    setCellRanges(cellRanges) {
+        if (_shallowCompare(this.cellRanges, cellRanges)) {
+            return;
+        }
+        this.removeAllCellRanges(true);
+        cellRanges.forEach(newRange => {
+            if (newRange.columns && newRange.startRow) {
+                this.newestRangeStartCell = {
+                    rowIndex: newRange.startRow.rowIndex,
+                    rowPinned: newRange.startRow.rowPinned,
+                    column: newRange.columns[0]
+                };
+            }
+            this.cellRanges.push(newRange);
+        });
+        this.dispatchChangedEvent(false, true);
+    }
+    createCellRangeFromCellRangeParams(params) {
+        let columns;
+        if (params.columns) {
+            columns = params.columns.map(c => this.columnModel.getColumnWithValidation(c)).filter(c => c);
+        }
+        else {
+            const columnStart = this.columnModel.getColumnWithValidation(params.columnStart);
+            const columnEnd = this.columnModel.getColumnWithValidation(params.columnEnd);
+            if (!columnStart || !columnEnd) {
+                return;
+            }
+            columns = this.calculateColumnsBetween(columnStart, columnEnd);
+        }
+        if (!columns) {
+            return;
+        }
+        const startRow = params.rowStartIndex != null ? {
+            rowIndex: params.rowStartIndex,
+            rowPinned: params.rowStartPinned
+        } : undefined;
+        const endRow = params.rowEndIndex != null ? {
+            rowIndex: params.rowEndIndex,
+            rowPinned: params.rowEndPinned
+        } : undefined;
+        return {
+            startRow: startRow,
+            endRow: endRow,
+            columns: columns,
+            startColumn: columns[0]
+        };
+    }
+    addCellRange(params) {
+        const newRange = this.createCellRangeFromCellRangeParams(params);
+        if (newRange) {
+            this.cellRanges.push(newRange);
+            this.dispatchChangedEvent(false, true, newRange.id);
+        }
+    }
+    getCellRanges() {
+        return this.cellRanges;
+    }
+    isEmpty() {
+        return this.cellRanges.length === 0;
+    }
+    isMoreThanOneCell() {
+        if (this.cellRanges.length === 0) {
+            return false;
+        }
+        else if (this.cellRanges.length > 1) {
+            return true;
+        }
+        const range = this.cellRanges[0];
+        const startRow = this.getRangeStartRow(range);
+        const endRow = this.getRangeEndRow(range);
+        return startRow.rowPinned !== endRow.rowPinned ||
+            startRow.rowIndex !== endRow.rowIndex ||
+            range.columns.length !== 1;
+    }
+    removeAllCellRanges(silent) {
+        if (this.isEmpty()) {
+            return;
+        }
+        this.onDragStop();
+        this.cellRanges.length = 0;
+        if (!silent) {
+            this.dispatchChangedEvent(false, true);
+        }
+    }
+    onBodyScroll() {
+        this.onDragging(this.lastMouseEvent);
+    }
+    isCellInAnyRange(cell) {
+        return this.getCellRangeCount(cell) > 0;
+    }
+    isCellInSpecificRange(cell, range) {
+        const columnInRange = range.columns !== null && _includes(range.columns, cell.column);
+        const rowInRange = this.isRowInRange(cell.rowIndex, cell.rowPinned, range);
+        return columnInRange && rowInRange;
+    }
+    isLastCellOfRange(cellRange, cell) {
+        const { startRow, endRow } = cellRange;
+        const lastRow = this.rowPositionUtils.before(startRow, endRow) ? endRow : startRow;
+        const isLastRow = cell.rowIndex === lastRow.rowIndex && cell.rowPinned === lastRow.rowPinned;
+        const rangeFirstIndexColumn = cellRange.columns[0];
+        const rangeLastIndexColumn = _last(cellRange.columns);
+        const lastRangeColumn = cellRange.startColumn === rangeFirstIndexColumn ? rangeLastIndexColumn : rangeFirstIndexColumn;
+        const isLastColumn = cell.column === lastRangeColumn;
+        return isLastColumn && isLastRow;
+    }
+    isBottomRightCell(cellRange, cell) {
+        const allColumns = this.visibleColsService.getAllCols();
+        const allPositions = cellRange.columns.map(c => allColumns.indexOf(c)).sort((a, b) => a - b);
+        const { startRow, endRow } = cellRange;
+        const lastRow = this.rowPositionUtils.before(startRow, endRow) ? endRow : startRow;
+        const isRightColumn = allColumns.indexOf(cell.column) === _last(allPositions);
+        const isLastRow = cell.rowIndex === lastRow.rowIndex && _makeNull(cell.rowPinned) === _makeNull(lastRow.rowPinned);
+        return isRightColumn && isLastRow;
+    }
+    getCellRangeCount(cell) {
+        if (this.isEmpty()) {
+            return 0;
+        }
+        return this.cellRanges.filter(cellRange => this.isCellInSpecificRange(cell, cellRange)).length;
+    }
+    isRowInRange(rowIndex, floating, cellRange) {
+        const firstRow = this.getRangeStartRow(cellRange);
+        const lastRow = this.getRangeEndRow(cellRange);
+        const thisRow = { rowIndex: rowIndex, rowPinned: floating };
+        const equalsFirstRow = thisRow.rowIndex === firstRow.rowIndex && thisRow.rowPinned == firstRow.rowPinned;
+        const equalsLastRow = thisRow.rowIndex === lastRow.rowIndex && thisRow.rowPinned == lastRow.rowPinned;
+        if (equalsFirstRow || equalsLastRow) {
+            return true;
+        }
+        const afterFirstRow = !this.rowPositionUtils.before(thisRow, firstRow);
+        const beforeLastRow = this.rowPositionUtils.before(thisRow, lastRow);
+        return afterFirstRow && beforeLastRow;
+    }
+    getDraggingRange() {
+        return this.draggingRange;
+    }
+    onDragStart(mouseEvent) {
+        const { shiftKey } = mouseEvent;
+        const mouseCell = this.mouseEventService.getCellPositionForEvent(mouseEvent);
+        if (_missing(mouseCell)) {
+            return;
+        }
+        if (!shiftKey || _exists(_last(this.cellRanges).type)) {
+            this.removeAllCellRanges(true);
+        }
+        this.dragging = true;
+        this.draggingCell = mouseCell;
+        this.lastMouseEvent = mouseEvent;
+        if (!shiftKey) {
+            this.newestRangeStartCell = mouseCell;
+        }
+        if (this.cellRanges.length > 0) {
+            this.draggingRange = _last(this.cellRanges);
+        }
+        else {
+            const mouseRowPosition = {
+                rowIndex: mouseCell.rowIndex,
+                rowPinned: mouseCell.rowPinned
+            };
+            this.draggingRange = {
+                startRow: mouseRowPosition,
+                endRow: mouseRowPosition,
+                columns: [mouseCell.column],
+                startColumn: this.newestRangeStartCell.column
+            };
+            this.cellRanges.push(this.draggingRange);
+        }
+        this.ctrlsService.getGridBodyCtrl().addScrollEventListener(this.bodyScrollListener);
+        this.dispatchChangedEvent(true, false, this.draggingRange.id);
+    }
+    onDragging(mouseEvent) {
+        if (!this.dragging || !mouseEvent) {
+            return;
+        }
+        this.lastMouseEvent = mouseEvent;
+        const cellPosition = this.mouseEventService.getCellPositionForEvent(mouseEvent);
+        const isMouseAndStartInPinned = (position) => cellPosition && cellPosition.rowPinned === position && this.newestRangeStartCell.rowPinned === position;
+        const skipVerticalScroll = isMouseAndStartInPinned('top') || isMouseAndStartInPinned('bottom');
+        this.autoScrollService.check(mouseEvent, skipVerticalScroll);
+        if (!cellPosition ||
+            !this.draggingCell ||
+            this.cellPositionEquals(this.draggingCell, cellPosition)) {
+            return;
+        }
+        const columns = this.calculateColumnsBetween(this.newestRangeStartCell.column, cellPosition.column);
+        if (!columns) {
+            return;
+        }
+        this.draggingCell = cellPosition;
+        this.draggingRange.endRow = {
+            rowIndex: cellPosition.rowIndex,
+            rowPinned: cellPosition.rowPinned
+        };
+        this.draggingRange.columns = columns;
+        this.dispatchChangedEvent(false, false, this.draggingRange.id);
+        this.focusCell(cellPosition);
+    }
+    focusCell(cellPosition) {
+        const cellFocused = this.focusService.isCellFocused(cellPosition);
+        if (!cellFocused) {
+            this.focusService.setFocusedCell(cellPosition.rowIndex, cellPosition.column, cellPosition.rowPinned, true);
+        }
+    }
+    onDragStop() {
+        if (!this.dragging) {
+            return;
+        }
+        const { id } = this.draggingRange;
+        this.autoScrollService.ensureCleared();
+        this.ctrlsService.getGridBodyCtrl().removeScrollEventListener(this.bodyScrollListener);
+        this.lastMouseEvent = null;
+        this.dragging = false;
+        this.draggingRange = undefined;
+        this.draggingCell = undefined;
+        this.dispatchChangedEvent(false, true, id);
+    }
+    dispatchChangedEvent(started, finished, id) {
+        this.cellRanges.map((cellRange) => {
+            let currentRow = this.getRangeStartRow(cellRange);
+            const lastRow = this.getRangeEndRow(cellRange);
+            const nodesToBeSelected = [];
+            while (true) {
+                const finishedAllRows = _missing(currentRow) || !currentRow || this.rowPositionUtils.before(lastRow, currentRow);
+                if (finishedAllRows || !currentRow || !cellRange.columns) {
+                    break;
+                }
+                const rowNode = this.rowPositionUtils.getRowNode(currentRow);
+                if (!rowNode) {
+                    break;
+                }
+                if (!rowNode.isSelected()) {
+                    rowNode.setSelected(true);
+                }
+                nodesToBeSelected.push(rowNode.data);
+                currentRow = this.cellNavigationService.getRowBelow(currentRow);
+            }
+            this.gridApi.getSelectedNodes().forEach((node) => {
+                if (!nodesToBeSelected.some(nodeToBeSelected => node.data === nodeToBeSelected)) {
+                    node.setSelected(false);
+                }
+            });
+        });
+        const eventCellSelection = {
+            type: "cellSelectionChanged",
+            started: started,
+            finished: finished,
+            id: id,
+        };
+        this.eventService.dispatchEvent(eventCellSelection);
+        const eventRangeSelection = {
+            type: "rangeSelectionChanged",
+            started: started,
+            finished: finished,
+            id: id,
+        };
+        this.eventService.dispatchEvent(eventRangeSelection);
+    }
+    calculateColumnsBetween(columnFrom, columnTo) {
+        const allColumns = this.visibleColsService.getAllCols();
+        const isSameColumn = columnFrom === columnTo;
+        const fromIndex = allColumns.indexOf(columnFrom);
+        if (fromIndex < 0) {
+            console.warn(`ag-Grid: column ${columnFrom.getId()} is not visible`);
+            return undefined;
+        }
+        const toIndex = isSameColumn ? fromIndex : allColumns.indexOf(columnTo);
+        if (toIndex < 0) {
+            console.warn(`ag-Grid: column ${columnTo.getId()} is not visible`);
+            return undefined;
+        }
+        if (isSameColumn) {
+            return [columnFrom];
+        }
+        const firstIndex = Math.min(fromIndex, toIndex);
+        const lastIndex = firstIndex === fromIndex ? toIndex : fromIndex;
+        const columns = [];
+        for (let i = firstIndex; i <= lastIndex; i++) {
+            columns.push(allColumns[i]);
+        }
+        return columns;
+    }
+}
+//# sourceMappingURL=rangeSelector.js.map

package/{components → lib/esm/components}/grid/export/contextMenu.js

@@ -6,10 +6,10 @@ import { spawn, Thread, Worker } from "threads";
 import dayjs from "dayjs";
 import ProgressPopup from "./progressPopup";
 import { ClipboardUtils } from "d2coreui/components/clipboard/clipboardUtils";
-import txtExportUrl from 'threads-plugin/dist/loader?name=txtExport!d2coreui/components/grid/export/worker/txtExport.js';
-import csvExportUrl from "threads-plugin/dist/loader?name=csvExport!d2coreui/components/grid/export/worker/csvExport.js";
-import clipboardExportUrl from "threads-plugin/dist/loader?name=clipboardExport!d2coreui/components/grid/export/worker/clipboardExport.js";
-import pdfExportUrl from "threads-plugin/dist/loader?name=pdfExport!d2coreui/components/grid/export/worker/pdfExport.js";
+import txtExportUrl from 'threads-plugin/dist/loader?name=txtExport!d2coreui/components/grid/export/worker/txtExport.ts';
+import csvExportUrl from "threads-plugin/dist/loader?name=csvExport!d2coreui/components/grid/export/worker/csvExport.ts";
+import clipboardExportUrl from "threads-plugin/dist/loader?name=clipboardExport!d2coreui/components/grid/export/worker/clipboardExport.ts";
+import pdfExportUrl from "threads-plugin/dist/loader?name=pdfExport!d2coreui/components/grid/export/worker/pdfExport.ts";
 import PlatformSpecific from "d2coreui/components/platformSpecific";
 export default function getContextMenu(props) {
     const { hideNotificationOnClipboardCopy, getExportContent, renderer, onClick } = props;

package/lib/esm/components/input/draftail.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/components/input/draftail.js

@@ -0,0 +1,2 @@
+export * from "draftail";
+//# sourceMappingURL=draftail.js.map

package/lib/esm/i18n/components.cs.json

@@ -0,0 +1,101 @@
+{
+    "langCode": "cs",
+    " (%{n} records)": " (%{n} záznamů)",
+    "%{n} records exported": "Bylo exportováno %{n} záznamů",
+    "Advanced Settings": "Rozšířená nastavení",
+    "Apply": "Nastavit",
+    "All Rows": "Všechny řádky",
+    "Automatic": "Automatická",
+    "Autosize All Columns": "Nastavit šířku všech sloupců",
+    "Autosize Column": "Nastavit šířku sloupce",
+    "Background Color": "Barva pozadí",
+    "Cancel": "Zrušit",
+    "Clipboard": "schránky",
+    "Close": "Zavřít",
+    "Column Filter": "Filtr nad sloupci",
+    "Column Name": "Jméno sloupce",
+    "Column": "Sloupec",
+    "Columns Configuration": "Konfigurace sloupců",
+    "Copy to Clipboard": "Kopírovat do schránky",
+    "Copying to Clipboard": "Kopírování do schránky",
+    "Disabled": "Vypnuto",
+    "Enabled": "Zapnuto",
+    "Export List to": "Export seznamu do",
+    "Export Window Configuration": "Exportovat nastavení okna",
+    "Export current window configuration to file": "Exportovat současnou konfiguraci okna do souboru",
+    "Export": "Export",
+    "Exporting to": "Exportování do",
+    "Extended table features": "Rozšířené možnosti tabulky",
+    "Fixed": "Fixní",
+    "Font Size": "Velikost písma",
+    "Line Indentation": "Odsazení řádku",
+    "Goto Page": "Jdi na stranu",
+    "Hidden Columns": "Skryté sloupce",
+    "Hide Column": "Skrýt sloupec",
+    "Landscape": "Na šířku",
+    "No records found.": "Nebyly nalezeny žádné záznamy.",
+    "No": "Ne",
+    "OK": "Potvrdit",
+    "Page Orientation": "Orientace stránky",
+    "Page Size": "Velikost stránky",
+    "Pagination": "Stránkování",
+    "Pin Column": "Připnout sloupec",
+    "Pin Left": "Připnout vlevo",
+    "Pin Right": "Připnout vpravo",
+    "Portrait": "Na výšku",
+    "Records has been added or removed, table need to be reloaded in order to see actual records": "Záznamy byly přidány nebo odstraněny, prosím znovu načtěte tabulku abyste viděli aktualne záznamy",
+    "Refresh": "Obnovit",
+    "Reset Columns": "Resetovat sloupce",
+    "Reset": "Resetovat",
+    "Revert": "Vrátit změny",
+    "Revert configuration to predefined state": "Vrátit konfiguraci do výchozího nastavení",
+    "Revert filter to original state": "Vrátit filtr do původního nastavení",
+    "Revert to factory configuration": "Vrátit do továrního nastavení",
+    "Save Window Configuration": "Uložit nastavení okna",
+    "Save current window configuration for current user": "Uložit nastavení okna pro aktuálního uživatele",
+    "Search": "Vyhledat",
+    "Set No Color": "Nastavit žádnou barvu",
+    "Show time with milliseconds": "Zobrazit čas s milisekundami",
+    "Show time with year": "Zobrazit čas s rokem",
+    "Show/Hide filter panel": "Zobrazit/skrýt panel s filtrem",
+    "Show/Hide panel with modified filter": "Zobrazit/skrýt panel s modifikovaným filtrem",
+    "Shown Columns": "Zobrazené sloupce",
+    "Table - Columns": "Tabulka - sloupce",
+    "Table - General Settings": "Tabulka - všeobecná nastavení",
+    "Table - Rows Styling": "Tabulka - stylování řádků",
+    "Text Color": "Barva textu",
+    "The column list is empty": "Seznam sloupců je prázdný",
+    "Simple Mode": "Jednoduchý mód",
+    "Advanced Mode": "Pokročilý mód",
+    "Interval Begin": "Začátek intervalu",
+    "Interval End": "Konec intervalu",
+    "Now": "Nyní",
+    "Today": "Dnes",
+    "This Day": "Tento den",
+    "This Month": "Tento měsíc",
+    "This Week": "Tento týden",
+    "This Quarter": "Toto čtvrtletí",
+    "This Year": "Letos",
+    "Interval Duration": "Trvání intervalu",
+    "Time Shift": "Časový posun",
+    "Hour": "Hodina",
+    "Day": "Den",
+    "Week": "Týden",
+    "Month": "Měsíc",
+    "Quarter": "Čtvrtletí",
+    "Year": "Rok",
+    "Years": "Roky",
+    "Track last added record to table": "Sledovat naposledy přidaný záznam do tabulky",
+    "Turn on/off column filter": "Zapnout/vypnout filtr nad sloupci",
+    "Turn on/off filter panel": "Zapnout/vypnout panel filtrování",
+    "Window configuration saved successfully": "Nastavení okna byla uložena",
+    "Window": "Okno",
+    "Yes": "Ano",
+    "column": "sloupec",
+    "columns": "sloupců",
+    "of": "z",
+    "First Page": "První strana",
+    "Previous Page": "Předchozí strana",
+    "Next Page": "Následující strana",
+    "Last Page": "Poslední strana"
+}