d2coreui 23.0.15 → 23.0.16

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

@@ -1,527 +0,0 @@
-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/lib/esm/components/input/draftail.d.ts

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

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

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

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

@@ -1,101 +0,0 @@
-{
-    "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"
-}