mirror of
https://github.com/pgadmin-org/pgadmin4.git
synced 2025-02-25 18:55:31 -06:00
Nikhil Mohite
committed by
Akshay Joshi
Akshay Joshi
parent
ad59380676
commit
e1942d8c9e
@@ -1,203 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin 4 - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2013 - 2022, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
define([
|
||||
'jquery',
|
||||
'sources/selection/range_selection_helper',
|
||||
], function ($, RangeSelectionHelper) {
|
||||
|
||||
return function () {
|
||||
var KEY_RIGHT = 39;
|
||||
var KEY_LEFT = 37;
|
||||
var KEY_UP = 38;
|
||||
var KEY_DOWN = 40;
|
||||
|
||||
var bypassDefaultActiveCellRangeChange = false;
|
||||
var isColumnsResized = false;
|
||||
var isMouseInHeader = false;
|
||||
var grid;
|
||||
|
||||
var init = function (slickGrid) {
|
||||
grid = slickGrid;
|
||||
grid.onDragEnd.subscribe(onDragEndHandler);
|
||||
grid.onHeaderClick.subscribe(onHeaderClickHandler);
|
||||
grid.onClick.subscribe(onClickHandler);
|
||||
grid.onActiveCellChanged.subscribe(onActiveCellChangedHandler);
|
||||
grid.onKeyDown.subscribe(onKeyDownHandler);
|
||||
grid.onHeaderMouseEnter.subscribe(onHeaderMouseEnterHandler);
|
||||
grid.onHeaderMouseLeave.subscribe(onHeaderMouseLeaveHandler);
|
||||
grid.onColumnsResized.subscribe(onColumnsResizedHandler);
|
||||
};
|
||||
|
||||
var destroy = function () {
|
||||
grid.onDragEnd.unsubscribe(onDragEndHandler);
|
||||
grid.onHeaderClick.unsubscribe(onHeaderClickHandler);
|
||||
grid.onActiveCellChanged.unsubscribe(onActiveCellChangedHandler);
|
||||
grid.onKeyDown.unsubscribe(onKeyDownHandler);
|
||||
grid.onHeaderMouseEnter.unsubscribe(onHeaderMouseEnterHandler);
|
||||
grid.onHeaderMouseLeave.unsubscribe(onHeaderMouseLeaveHandler);
|
||||
grid.onColumnsResized.unsubscribe(onColumnsResizedHandler);
|
||||
};
|
||||
|
||||
$.extend(this, {
|
||||
'init': init,
|
||||
'destroy': destroy,
|
||||
});
|
||||
|
||||
function onDragEndHandler(event, dragData) {
|
||||
bypassDefaultActiveCellRangeChange = true;
|
||||
grid.setActiveCell(dragData.range.start.row, dragData.range.start.cell);
|
||||
}
|
||||
|
||||
function onHeaderClickHandler(event, args) {
|
||||
if (isColumnsResizedAndCurrentlyInHeader()) {
|
||||
isColumnsResized = false;
|
||||
event.stopPropagation();
|
||||
return;
|
||||
}
|
||||
|
||||
/* Skip if clicked on resize handler */
|
||||
if($(event.target).hasClass('slick-resizable-handle')) {
|
||||
return;
|
||||
}
|
||||
|
||||
bypassDefaultActiveCellRangeChange = true;
|
||||
|
||||
var clickedColumn = args.column.pos + 1;
|
||||
if (isClickingLastClickedHeader(0, clickedColumn)) {
|
||||
if (isSingleRangeSelected()) {
|
||||
grid.resetActiveCell();
|
||||
} else {
|
||||
grid.setActiveCell(0, retrievePreviousSelectedRange().fromCell);
|
||||
}
|
||||
} else if (!isClickingInSelectedColumn(clickedColumn)) {
|
||||
grid.setActiveCell(0, clickedColumn);
|
||||
}
|
||||
}
|
||||
|
||||
function isEditableNewRow(row) {
|
||||
return row >= grid.getDataLength();
|
||||
}
|
||||
|
||||
function onHeaderMouseLeaveHandler() {
|
||||
isMouseInHeader = false;
|
||||
}
|
||||
|
||||
function onHeaderMouseEnterHandler() {
|
||||
isMouseInHeader = true;
|
||||
isColumnsResized = false;
|
||||
}
|
||||
|
||||
function onColumnsResizedHandler() {
|
||||
isColumnsResized = true;
|
||||
}
|
||||
|
||||
function onClickHandler(event, args) {
|
||||
if (isRowHeader(args.cell)) {
|
||||
bypassDefaultActiveCellRangeChange = true;
|
||||
var rowClicked = args.row;
|
||||
|
||||
if (isEditableNewRow(rowClicked)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (isClickingLastClickedHeader(rowClicked, 1)) {
|
||||
if (isSingleRangeSelected() || grid.getSelectionModel().getSelectedRanges().length === 0) {
|
||||
grid.resetActiveCell();
|
||||
} else {
|
||||
grid.setActiveCell(retrievePreviousSelectedRange().fromRow, 1);
|
||||
}
|
||||
} else if (!isClickingInSelectedRow(rowClicked)) {
|
||||
grid.setActiveCell(rowClicked, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function onActiveCellChangedHandler(event) {
|
||||
if (bypassDefaultActiveCellRangeChange) {
|
||||
bypassDefaultActiveCellRangeChange = false;
|
||||
event.stopPropagation();
|
||||
}
|
||||
}
|
||||
|
||||
function onKeyDownHandler(event) {
|
||||
if (hasActiveCell() && isShiftArrowKey(event)) {
|
||||
selectOnlyRangeOfActiveCell();
|
||||
}
|
||||
}
|
||||
|
||||
function isColumnsResizedAndCurrentlyInHeader() {
|
||||
return isMouseInHeader && isColumnsResized;
|
||||
}
|
||||
|
||||
function isClickingLastClickedHeader(clickedRow, clickedColumn) {
|
||||
return hasActiveCell() && grid.getActiveCell().row === clickedRow && grid.getActiveCell().cell === clickedColumn;
|
||||
}
|
||||
|
||||
function isClickingInSelectedColumn(clickedColumn) {
|
||||
var column = RangeSelectionHelper.rangeForColumn(grid, clickedColumn);
|
||||
var cellSelectionModel = grid.getSelectionModel();
|
||||
var ranges = cellSelectionModel.getSelectedRanges();
|
||||
return RangeSelectionHelper.isRangeSelected(ranges, column);
|
||||
}
|
||||
|
||||
function isRowHeader(cellClicked) {
|
||||
return grid.getColumns()[cellClicked].id === 'row-header-column';
|
||||
}
|
||||
|
||||
function isClickingInSelectedRow(rowClicked) {
|
||||
var row = RangeSelectionHelper.rangeForRow(grid, rowClicked);
|
||||
var cellSelectionModel = grid.getSelectionModel();
|
||||
var ranges = cellSelectionModel.getSelectedRanges();
|
||||
return RangeSelectionHelper.isRangeSelected(ranges, row);
|
||||
}
|
||||
|
||||
function isSingleRangeSelected() {
|
||||
var cellSelectionModel = grid.getSelectionModel();
|
||||
var ranges = cellSelectionModel.getSelectedRanges();
|
||||
return ranges.length === 1;
|
||||
}
|
||||
|
||||
function retrievePreviousSelectedRange() {
|
||||
var cellSelectionModel = grid.getSelectionModel();
|
||||
var ranges = cellSelectionModel.getSelectedRanges();
|
||||
return ranges[ranges.length - 2];
|
||||
}
|
||||
|
||||
function isArrowKey(event) {
|
||||
return event.which === KEY_RIGHT
|
||||
|| event.which === KEY_UP
|
||||
|| event.which === KEY_LEFT
|
||||
|| event.which === KEY_DOWN;
|
||||
}
|
||||
|
||||
function isModifiedByShiftOnly(event) {
|
||||
return event.shiftKey
|
||||
&& !event.ctrlKey
|
||||
&& !event.altKey;
|
||||
}
|
||||
|
||||
function isShiftArrowKey(event) {
|
||||
return isModifiedByShiftOnly(event) && isArrowKey(event);
|
||||
}
|
||||
|
||||
function hasActiveCell() {
|
||||
return !!grid.getActiveCell();
|
||||
}
|
||||
|
||||
function selectOnlyRangeOfActiveCell() {
|
||||
var cellSelectionModel = grid.getSelectionModel();
|
||||
var ranges = cellSelectionModel.getSelectedRanges();
|
||||
|
||||
if (ranges.length > 1) {
|
||||
cellSelectionModel.setSelectedRanges([ranges.pop()]);
|
||||
}
|
||||
}
|
||||
};
|
||||
});
|
||||
@@ -1,164 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin 4 - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2013 - 2022, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
define([
|
||||
'jquery',
|
||||
'sources/selection/range_selection_helper',
|
||||
'slickgrid',
|
||||
], function ($, RangeSelectionHelper) {
|
||||
return function () {
|
||||
var Slick = window.Slick,
|
||||
gridEventBus = new Slick.EventHandler(),
|
||||
onBeforeColumnSelectAll = new Slick.Event(),
|
||||
onColumnSelectAll = new Slick.Event();
|
||||
|
||||
var init = function (grid) {
|
||||
gridEventBus.subscribe(grid.onHeaderClick, handleHeaderClick.bind(null, grid));
|
||||
grid.getSelectionModel().onSelectedRangesChanged
|
||||
.subscribe(handleSelectedRangesChanged.bind(null, grid));
|
||||
onColumnSelectAll.subscribe(function(e, args) {
|
||||
updateRanges(args.grid, args.column.id);
|
||||
});
|
||||
};
|
||||
|
||||
var handleHeaderClick = function (grid, event, args) {
|
||||
var columnDefinition = args.column;
|
||||
|
||||
grid.focus();
|
||||
|
||||
if (isColumnSelectable(columnDefinition)) {
|
||||
var $columnHeader = $(event.target);
|
||||
if (hasClickedChildOfColumnHeader(event)) {
|
||||
if ($(event.target).hasClass('slick-resizable-handle')) {
|
||||
return;
|
||||
}
|
||||
$columnHeader = $(event.target).parents('.slick-header-column');
|
||||
}
|
||||
$columnHeader.toggleClass('selected');
|
||||
|
||||
if ($columnHeader.hasClass('selected')) {
|
||||
onBeforeColumnSelectAll.notify(args, event);
|
||||
}
|
||||
|
||||
if (!(event.isPropagationStopped() || event.isImmediatePropagationStopped())) {
|
||||
updateRanges(grid, columnDefinition.id);
|
||||
}
|
||||
} else {
|
||||
toggleColumnHeaderForCopyHeader(grid);
|
||||
}
|
||||
};
|
||||
|
||||
var toggleColumnHeaderForCopyHeader = function(grid) {
|
||||
if(!$('.copy-with-header').hasClass('visibility-hidden')) {
|
||||
var selRowCnt = grid.getSelectedRows();
|
||||
$('.slick-header-column').each(function (index, columnHeader) {
|
||||
if (selRowCnt.length == 0) {
|
||||
$(columnHeader).removeClass('selected');
|
||||
grid.getColumns()[index].selected = false;
|
||||
}
|
||||
else {
|
||||
if (index > 0 && grid.getColumns()[index].selectable) {
|
||||
$(columnHeader).addClass('selected');
|
||||
grid.getColumns()[index].selected = true;
|
||||
}
|
||||
}
|
||||
|
||||
});
|
||||
} else {
|
||||
$('.slick-header-column').each(function (index, columnHeader) {
|
||||
$(columnHeader).removeClass('selected');
|
||||
});
|
||||
}
|
||||
}.bind(RangeSelectionHelper);
|
||||
|
||||
var handleSelectedRangesChanged = function (grid, event, selectedRanges) {
|
||||
$('.slick-header-column').each(function (index, columnHeader) {
|
||||
var $spanHeaderColumn = $(columnHeader).find('[data-cell-type="column-header-row"]');
|
||||
var columnIndex = grid.getColumnIndex($spanHeaderColumn.data('column-id'));
|
||||
if (isColumnSelected(grid, selectedRanges, columnIndex)) {
|
||||
$(columnHeader).addClass('selected');
|
||||
if (columnIndex) grid.getColumns()[columnIndex].selected = true;
|
||||
} else if(!RangeSelectionHelper.areAllRangesCompleteRows(grid, selectedRanges)){
|
||||
$(columnHeader).removeClass('selected');
|
||||
if (columnIndex) grid.getColumns()[columnIndex].selected = false;
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
var updateRanges = function (grid, columnId) {
|
||||
var selectionModel = grid.getSelectionModel();
|
||||
var ranges = selectionModel.getSelectedRanges();
|
||||
|
||||
var columnIndex = grid.getColumnIndex(columnId);
|
||||
|
||||
var columnRange = RangeSelectionHelper.rangeForColumn(grid, columnIndex);
|
||||
var newRanges;
|
||||
if (RangeSelectionHelper.isRangeSelected(ranges, columnRange)) {
|
||||
newRanges = RangeSelectionHelper.removeRange(ranges, columnRange);
|
||||
} else {
|
||||
if (RangeSelectionHelper.areAllRangesSingleColumns(ranges, grid)) {
|
||||
newRanges = RangeSelectionHelper.addRange(ranges, columnRange);
|
||||
} else {
|
||||
newRanges = [columnRange];
|
||||
}
|
||||
}
|
||||
selectionModel.setSelectedRanges(newRanges);
|
||||
};
|
||||
|
||||
var hasClickedChildOfColumnHeader = function (event) {
|
||||
return !$(event.target).hasClass('slick-header-column');
|
||||
};
|
||||
|
||||
var isColumnSelectable = function (columnDefinition) {
|
||||
return columnDefinition.selectable !== false;
|
||||
};
|
||||
|
||||
var isColumnSelected = function (grid, selectedRanges, columnIndex) {
|
||||
var allRangesAreRows = RangeSelectionHelper.areAllRangesCompleteRows(grid, selectedRanges);
|
||||
return isAnyCellSelectedInColumn(grid, selectedRanges, columnIndex) && !allRangesAreRows;
|
||||
};
|
||||
|
||||
var isAnyCellSelectedInColumn = function (grid, selectedRanges, columnIndex) {
|
||||
var isStillSelected = RangeSelectionHelper.isRangeEntirelyWithinSelectedRanges(selectedRanges,
|
||||
RangeSelectionHelper.rangeForColumn(grid, columnIndex));
|
||||
var cellSelectedInColumn = RangeSelectionHelper.isAnyCellOfColumnSelected(selectedRanges, columnIndex);
|
||||
|
||||
return isStillSelected || cellSelectedInColumn;
|
||||
};
|
||||
|
||||
var getColumnDefinitions = function (columnDefinitions) {
|
||||
return _.map(columnDefinitions, function (columnDefinition) {
|
||||
if (isColumnSelectable(columnDefinition)) {
|
||||
var name =
|
||||
'<span data-cell-type=\'column-header-row\' ' +
|
||||
' data-test=\'output-column-header\'' +
|
||||
' data-column-id=\'' + columnDefinition.id + '\'>' +
|
||||
' <span class=\'column-description\'>' +
|
||||
' <span class=\'column-name\'>' + columnDefinition.display_name + '</span>' +
|
||||
' <span class=\'column-type\'>' + columnDefinition.column_type + '</span>' +
|
||||
' </span>' +
|
||||
'</span>';
|
||||
return _.extend(columnDefinition, {
|
||||
name: name,
|
||||
});
|
||||
} else {
|
||||
return columnDefinition;
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
$.extend(this, {
|
||||
'init': init,
|
||||
'getColumnDefinitions': getColumnDefinitions,
|
||||
'onBeforeColumnSelectAll': onBeforeColumnSelectAll,
|
||||
'onColumnSelectAll': onColumnSelectAll,
|
||||
'toggleColumnHeaderForCopyHeader': toggleColumnHeaderForCopyHeader,
|
||||
});
|
||||
};
|
||||
});
|
||||
@@ -1,58 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin 4 - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2013 - 2022, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
define([
|
||||
'jquery',
|
||||
'underscore',
|
||||
'sources/selection/clipboard',
|
||||
'sources/selection/range_selection_helper',
|
||||
'sources/selection/range_boundary_navigator',
|
||||
],
|
||||
function ($, _, clipboard, RangeSelectionHelper, rangeBoundaryNavigator) {
|
||||
var copyData = function () {
|
||||
var self = this || window;
|
||||
|
||||
var grid = self.slickgrid;
|
||||
var columnDefinitions = grid.getColumns();
|
||||
var selectedRanges = grid.getSelectionModel().getSelectedRanges();
|
||||
var dataView = grid.getData();
|
||||
var rows = grid.getSelectedRows();
|
||||
var CSVOptions = grid.CSVOptions;
|
||||
|
||||
if (RangeSelectionHelper.areAllRangesCompleteRows(grid, selectedRanges)) {
|
||||
self.copied_rows = rows.map(function (rowIndex) {
|
||||
return grid.getDataItem(rowIndex);
|
||||
});
|
||||
setPasteRowButtonEnablement(self.can_edit, true);
|
||||
} else {
|
||||
self.copied_rows = [];
|
||||
setPasteRowButtonEnablement(self.can_edit, false);
|
||||
}
|
||||
var csvText = rangeBoundaryNavigator.rangesToCsv(dataView.getItems(), columnDefinitions,
|
||||
selectedRanges, CSVOptions, copyWithHeader());
|
||||
if (csvText) {
|
||||
clipboard.copyTextToClipboard(csvText);
|
||||
}
|
||||
};
|
||||
|
||||
var copyWithHeader = function () {
|
||||
return !$('.copy-with-header').hasClass('visibility-hidden');
|
||||
};
|
||||
|
||||
var setPasteRowButtonEnablement = function (canEditFlag, isEnabled) {
|
||||
if (canEditFlag) {
|
||||
$('#btn-paste-row').prop('disabled', !isEnabled);
|
||||
if(isEnabled && window.parent.$) {
|
||||
// trigger copied event to all sessions
|
||||
window.parent.$(window.parent.document).trigger('pgadmin-sqleditor:rows-copied', copyWithHeader());
|
||||
}
|
||||
}
|
||||
};
|
||||
return copyData;
|
||||
});
|
||||
@@ -1,92 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin 4 - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2013 - 2022, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
define(['jquery',
|
||||
'sources/gettext',
|
||||
'sources/selection/column_selector',
|
||||
'sources/selection/row_selector',
|
||||
'sources/selection/range_selection_helper',
|
||||
'sources/url_for',
|
||||
], function ($, gettext, ColumnSelector, RowSelector, RangeSelectionHelper, url_for) {
|
||||
return function (columnDefinitions) {
|
||||
var Slick = window.Slick,
|
||||
rowSelector = new RowSelector(columnDefinitions),
|
||||
columnSelector = new ColumnSelector(columnDefinitions),
|
||||
onBeforeGridSelectAll = new Slick.Event(),
|
||||
onGridSelectAll = new Slick.Event(),
|
||||
onBeforeGridColumnSelectAll = columnSelector.onBeforeColumnSelectAll,
|
||||
onGridColumnSelectAll = columnSelector.onColumnSelectAll;
|
||||
|
||||
var init = function (grid) {
|
||||
this.grid = grid;
|
||||
grid.onHeaderClick.subscribe(function (event, eventArguments) {
|
||||
if (eventArguments.column.selectAllOnClick && !$(event.target).hasClass('slick-resizable-handle')) {
|
||||
toggleSelectAll(grid, event, eventArguments);
|
||||
}
|
||||
});
|
||||
|
||||
grid.getSelectionModel().onSelectedRangesChanged
|
||||
.subscribe(handleSelectedRangesChanged.bind(null, grid));
|
||||
|
||||
grid.registerPlugin(rowSelector);
|
||||
grid.registerPlugin(columnSelector);
|
||||
|
||||
onGridSelectAll.subscribe(function(e, args) {
|
||||
RangeSelectionHelper.selectAll(args.grid);
|
||||
});
|
||||
};
|
||||
|
||||
var getColumnDefinitions = function (columnDefinition) {
|
||||
columnDefinition = columnSelector.getColumnDefinitions(columnDefinition);
|
||||
columnDefinition = rowSelector.getColumnDefinitions(columnDefinition);
|
||||
|
||||
columnDefinition[0].selectAllOnClick = true;
|
||||
columnDefinition[0].name = '<span data-id="select-all" ' +
|
||||
'title="' + gettext('Select/Deselect All') + '">' +
|
||||
'<br>' +
|
||||
columnDefinition[0].name +
|
||||
'<img class="select-all-icon" src="' + url_for('static', {'filename': 'img/select-all-icon.png'}) + '"></img>' +
|
||||
'</span>';
|
||||
return columnDefinition;
|
||||
};
|
||||
|
||||
function handleSelectedRangesChanged(grid) {
|
||||
if(RangeSelectionHelper.isEntireGridSelected(grid)) {
|
||||
$('[data-id=\'select-all\']').addClass('selected');
|
||||
} else {
|
||||
$('[data-id=\'select-all\']').removeClass('selected');
|
||||
}
|
||||
}
|
||||
|
||||
function toggleSelectAll(grid, event, eventArguments) {
|
||||
if (RangeSelectionHelper.isEntireGridSelected(grid)) {
|
||||
selectNone(grid);
|
||||
} else {
|
||||
onBeforeGridSelectAll.notify(eventArguments, event);
|
||||
if (!(event.isPropagationStopped() || event.isImmediatePropagationStopped())) {
|
||||
RangeSelectionHelper.selectAll(grid);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function selectNone(grid) {
|
||||
var selectionModel = grid.getSelectionModel();
|
||||
selectionModel.setSelectedRanges([]);
|
||||
}
|
||||
|
||||
$.extend(this, {
|
||||
'init': init,
|
||||
'getColumnDefinitions': getColumnDefinitions,
|
||||
'onBeforeGridSelectAll': onBeforeGridSelectAll,
|
||||
'onGridSelectAll': onGridSelectAll,
|
||||
'onBeforeGridColumnSelectAll': onBeforeGridColumnSelectAll,
|
||||
'onGridColumnSelectAll': onGridColumnSelectAll,
|
||||
});
|
||||
};
|
||||
});
|
||||
@@ -1,171 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin 4 - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2013 - 2022, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
define(['slickgrid'], function () {
|
||||
var Slick = window.Slick;
|
||||
|
||||
var isSameRange = function (range, otherRange) {
|
||||
return range.fromCell == otherRange.fromCell && range.toCell == otherRange.toCell &&
|
||||
range.fromRow == otherRange.fromRow && range.toRow == otherRange.toRow;
|
||||
};
|
||||
|
||||
var isRangeSelected = function (selectedRanges, range) {
|
||||
return _.any(selectedRanges, function (selectedRange) {
|
||||
return isSameRange(selectedRange, range);
|
||||
});
|
||||
};
|
||||
|
||||
var isAnyCellOfColumnSelected = function (selectedRanges, column) {
|
||||
return _.any(selectedRanges, function (selectedRange) {
|
||||
return selectedRange.fromCell <= column && selectedRange.toCell >= column;
|
||||
});
|
||||
};
|
||||
|
||||
var isAnyCellOfRowSelected = function (selectedRanges, row) {
|
||||
return _.any(selectedRanges, function (selectedRange) {
|
||||
return selectedRange.fromRow <= row && selectedRange.toRow >= row;
|
||||
});
|
||||
};
|
||||
|
||||
var isRangeEntirelyWithinSelectedRanges = function (selectedRanges, range) {
|
||||
return _.any(selectedRanges, function (selectedRange) {
|
||||
return selectedRange.fromCell <= range.fromCell && selectedRange.toCell >= range.toCell &&
|
||||
selectedRange.fromRow <= range.fromRow && selectedRange.toRow >= range.toRow;
|
||||
});
|
||||
};
|
||||
|
||||
var removeRange = function (selectedRanges, range) {
|
||||
return _.filter(selectedRanges, function (selectedRange) {
|
||||
return !(isSameRange(selectedRange, range));
|
||||
});
|
||||
};
|
||||
|
||||
var addRange = function (ranges, range) {
|
||||
ranges.push(range);
|
||||
return ranges;
|
||||
};
|
||||
|
||||
var areAllRangesSingleRows = function (ranges, grid) {
|
||||
return _.every(ranges, function (range) {
|
||||
return range.fromRow == range.toRow && rangeHasCompleteRows(grid, range);
|
||||
});
|
||||
};
|
||||
|
||||
var areAllRangesSingleColumns = function (ranges, grid) {
|
||||
return _.every(ranges, isRangeAColumn.bind(this, grid));
|
||||
};
|
||||
|
||||
var rangeForRow = function (grid, rowId) {
|
||||
var columnDefinitions = grid.getColumns();
|
||||
if (isFirstColumnData(columnDefinitions)) {
|
||||
return new Slick.Range(rowId, 0, rowId, grid.getColumns().length - 1);
|
||||
}
|
||||
return new Slick.Range(rowId, 1, rowId, grid.getColumns().length - 1);
|
||||
};
|
||||
|
||||
var rangeForColumn = function (grid, columnIndex) {
|
||||
return new Slick.Range(0, columnIndex, grid.getDataLength() - 1, columnIndex);
|
||||
};
|
||||
|
||||
var getRangeOfWholeGrid = function (grid) {
|
||||
return new Slick.Range(0, 1, grid.getDataLength() - 1, grid.getColumns().length - 1);
|
||||
};
|
||||
|
||||
var isEntireGridSelected = function (grid) {
|
||||
var selectionModel = grid.getSelectionModel();
|
||||
var selectedRanges = selectionModel.getSelectedRanges();
|
||||
return selectedRanges.length == 1 && isSameRange(selectedRanges[0], getRangeOfWholeGrid(grid));
|
||||
};
|
||||
|
||||
var isFirstColumnData = function (columnDefinitions) {
|
||||
return !_.isUndefined(columnDefinitions[0].pos);
|
||||
};
|
||||
|
||||
var areAllRangesCompleteColumns = function (grid, ranges) {
|
||||
return _.every(ranges, function (range) {
|
||||
return rangeHasCompleteColumns(grid, range);
|
||||
});
|
||||
};
|
||||
|
||||
var areAllRangesCompleteRows = function (grid, ranges) {
|
||||
return _.every(ranges, function (range) {
|
||||
return rangeHasCompleteRows(grid, range);
|
||||
});
|
||||
};
|
||||
|
||||
var getIndexesOfCompleteRows = function (grid, ranges) {
|
||||
var indexArray = [];
|
||||
ranges.forEach(function (range) {
|
||||
if (rangeHasCompleteRows(grid, range))
|
||||
indexArray = indexArray.concat(_.range(range.fromRow, range.toRow + 1));
|
||||
});
|
||||
|
||||
return indexArray;
|
||||
};
|
||||
|
||||
var isRangeAColumn = function (grid, range) {
|
||||
return range.fromCell == range.toCell &&
|
||||
range.fromRow == 0 && range.toRow == grid.getDataLength() - 1;
|
||||
};
|
||||
|
||||
var rangeHasCompleteColumns = function (grid, range) {
|
||||
return range.fromRow === 0 && range.toRow === grid.getDataLength() - 1;
|
||||
};
|
||||
|
||||
var rangeHasCompleteRows = function (grid, range) {
|
||||
return range.fromCell === getFirstDataColumnIndex(grid) &&
|
||||
range.toCell === getLastDataColumnIndex(grid);
|
||||
};
|
||||
|
||||
function getFirstDataColumnIndex(grid) {
|
||||
return _.findIndex(grid.getColumns(), function (columnDefinition) {
|
||||
var pos = columnDefinition.pos;
|
||||
|
||||
return !_.isUndefined(pos) && isSelectable(columnDefinition);
|
||||
});
|
||||
}
|
||||
|
||||
function getLastDataColumnIndex(grid) {
|
||||
return _.findLastIndex(grid.getColumns(), isSelectable);
|
||||
}
|
||||
|
||||
function isSelectable(columnDefinition) {
|
||||
return (_.isUndefined(columnDefinition.selectable) || columnDefinition.selectable === true);
|
||||
}
|
||||
|
||||
function selectAll(grid) {
|
||||
var range = getRangeOfWholeGrid(grid);
|
||||
var selectionModel = grid.getSelectionModel();
|
||||
|
||||
selectionModel.setSelectedRanges([range]);
|
||||
}
|
||||
|
||||
return {
|
||||
addRange: addRange,
|
||||
removeRange: removeRange,
|
||||
isRangeSelected: isRangeSelected,
|
||||
areAllRangesSingleRows: areAllRangesSingleRows,
|
||||
areAllRangesSingleColumns: areAllRangesSingleColumns,
|
||||
areAllRangesCompleteRows: areAllRangesCompleteRows,
|
||||
areAllRangesCompleteColumns: areAllRangesCompleteColumns,
|
||||
rangeForRow: rangeForRow,
|
||||
rangeForColumn: rangeForColumn,
|
||||
isEntireGridSelected: isEntireGridSelected,
|
||||
getRangeOfWholeGrid: getRangeOfWholeGrid,
|
||||
isFirstColumnData: isFirstColumnData,
|
||||
getIndexesOfCompleteRows: getIndexesOfCompleteRows,
|
||||
selectAll: selectAll,
|
||||
isRangeAColumn: isRangeAColumn,
|
||||
rangeHasCompleteColumns: rangeHasCompleteColumns,
|
||||
rangeHasCompleteRows: rangeHasCompleteRows,
|
||||
isAnyCellOfColumnSelected: isAnyCellOfColumnSelected,
|
||||
isRangeEntirelyWithinSelectedRanges: isRangeEntirelyWithinSelectedRanges,
|
||||
isAnyCellOfRowSelected: isAnyCellOfRowSelected,
|
||||
};
|
||||
});
|
||||
@@ -1,110 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin 4 - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2013 - 2022, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
define([
|
||||
'jquery',
|
||||
'sources/selection/range_selection_helper',
|
||||
'sources/selection/column_selector',
|
||||
'slickgrid',
|
||||
], function ($, RangeSelectionHelper, ColumnSelector) {
|
||||
return function () {
|
||||
var Slick = window.Slick;
|
||||
|
||||
var gridEventBus = new Slick.EventHandler();
|
||||
var columnSelector = new ColumnSelector();
|
||||
|
||||
var init = function (grid) {
|
||||
grid.getSelectionModel().onSelectedRangesChanged
|
||||
.subscribe(handleSelectedRangesChanged.bind(null, grid));
|
||||
gridEventBus
|
||||
.subscribe(grid.onClick, handleClick.bind(null, grid));
|
||||
};
|
||||
|
||||
var handleClick = function (grid, event, args) {
|
||||
if (grid.getColumns()[args.cell].id === 'row-header-column') {
|
||||
var $rowHeaderSpan = $(event.target);
|
||||
|
||||
if ($rowHeaderSpan.data('cell-type') != 'row-header-selector') {
|
||||
$rowHeaderSpan = $(event.target).find('[data-cell-type="row-header-selector"]');
|
||||
}
|
||||
|
||||
$rowHeaderSpan.parent().toggleClass('selected');
|
||||
updateRanges(grid, args.row);
|
||||
columnSelector.toggleColumnHeaderForCopyHeader(grid);
|
||||
}
|
||||
};
|
||||
|
||||
var handleSelectedRangesChanged = function (grid, event, selectedRanges) {
|
||||
$('[data-cell-type="row-header-selector"]').each(function (index, rowHeaderSpan) {
|
||||
var $rowHeaderSpan = $(rowHeaderSpan);
|
||||
var row = parseInt($rowHeaderSpan.data('row'));
|
||||
|
||||
if (isRowSelected(grid, selectedRanges, row)) {
|
||||
$rowHeaderSpan.parent().addClass('selected');
|
||||
} else {
|
||||
$rowHeaderSpan.parent().removeClass('selected');
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
var updateRanges = function (grid, rowId) {
|
||||
var selectionModel = grid.getSelectionModel();
|
||||
var ranges = selectionModel.getSelectedRanges();
|
||||
|
||||
var rowRange = RangeSelectionHelper.rangeForRow(grid, rowId);
|
||||
|
||||
var newRanges;
|
||||
if (RangeSelectionHelper.isRangeSelected(ranges, rowRange)) {
|
||||
newRanges = RangeSelectionHelper.removeRange(ranges, rowRange);
|
||||
} else {
|
||||
if (RangeSelectionHelper.areAllRangesSingleRows(ranges, grid)) {
|
||||
newRanges = RangeSelectionHelper.addRange(ranges, rowRange);
|
||||
} else {
|
||||
newRanges = [rowRange];
|
||||
}
|
||||
}
|
||||
selectionModel.setSelectedRanges(newRanges);
|
||||
};
|
||||
|
||||
var isAnyCellSelectedInRow = function (grid, selectedRanges, row) {
|
||||
var isStillSelected = RangeSelectionHelper.isRangeEntirelyWithinSelectedRanges(selectedRanges,
|
||||
RangeSelectionHelper.rangeForRow(grid, row));
|
||||
var cellSelectedInRow = RangeSelectionHelper.isAnyCellOfRowSelected(selectedRanges, row);
|
||||
|
||||
return isStillSelected || cellSelectedInRow;
|
||||
};
|
||||
|
||||
var isRowSelected = function (grid, selectedRanges, row) {
|
||||
var allRangesAreColumns = RangeSelectionHelper.areAllRangesCompleteColumns(grid, selectedRanges);
|
||||
return isAnyCellSelectedInRow(grid, selectedRanges, row) && !allRangesAreColumns;
|
||||
};
|
||||
|
||||
var getColumnDefinitions = function (columnDefinitions) {
|
||||
columnDefinitions.unshift({
|
||||
id: 'row-header-column',
|
||||
name: '',
|
||||
selectable: false,
|
||||
focusable: false,
|
||||
formatter: function (rowIndex) {
|
||||
return '<span ' +
|
||||
'data-row="' + rowIndex + '" ' +
|
||||
'data-cell-type="row-header-selector">' +
|
||||
(rowIndex+1) + '</span>';
|
||||
},
|
||||
width: 30,
|
||||
});
|
||||
return columnDefinitions;
|
||||
};
|
||||
|
||||
$.extend(this, {
|
||||
'init': init,
|
||||
'getColumnDefinitions': getColumnDefinitions,
|
||||
});
|
||||
};
|
||||
});
|
||||
@@ -1,240 +0,0 @@
|
||||
/////////////////////////////////////////////////////////////
|
||||
//
|
||||
// pgAdmin 4 - PostgreSQL Tools
|
||||
//
|
||||
// Copyright (C) 2013 - 2022, The pgAdmin Development Team
|
||||
// This software is released under the PostgreSQL Licence
|
||||
//
|
||||
//////////////////////////////////////////////////////////////
|
||||
|
||||
define([
|
||||
'jquery',
|
||||
'underscore',
|
||||
'sources/selection/range_selection_helper',
|
||||
'sources/window',
|
||||
'slickgrid',
|
||||
], function ($, _, RangeSelectionHelper, pgWindow) {
|
||||
return function (options) {
|
||||
|
||||
var KEY_ARROW_RIGHT = 39;
|
||||
var KEY_ARROW_LEFT = 37;
|
||||
var KEY_ARROW_UP = 38;
|
||||
var KEY_ARROW_DOWN = 40;
|
||||
|
||||
var Slick = window.Slick;
|
||||
var _grid;
|
||||
var _ranges = [];
|
||||
var _self = this;
|
||||
var _selector = new Slick.CellRangeSelector({
|
||||
selectionCss: {
|
||||
border: '2px solid black',
|
||||
},
|
||||
offset: {
|
||||
top: 0,
|
||||
left: -1,
|
||||
height: 2,
|
||||
width: 1,
|
||||
},
|
||||
});
|
||||
var _options;
|
||||
var _defaults = {
|
||||
selectActiveCell: true,
|
||||
};
|
||||
|
||||
|
||||
function init(grid) {
|
||||
_options = $.extend(true, {}, _defaults, options);
|
||||
_grid = grid;
|
||||
_grid.onActiveCellChanged.subscribe(handleActiveCellChange);
|
||||
_grid.onKeyDown.subscribe(handleKeyDown);
|
||||
grid.registerPlugin(_selector);
|
||||
_selector.onCellRangeSelected.subscribe(handleCellRangeSelected);
|
||||
_selector.onBeforeCellRangeSelected.subscribe(handleBeforeCellRangeSelected);
|
||||
$(pgWindow.default).on('mouseup',handleWindowMouseUp);
|
||||
}
|
||||
|
||||
function destroy() {
|
||||
_grid.onActiveCellChanged.unsubscribe(handleActiveCellChange);
|
||||
_grid.onKeyDown.unsubscribe(handleKeyDown);
|
||||
_selector.onCellRangeSelected.unsubscribe(handleCellRangeSelected);
|
||||
_selector.onBeforeCellRangeSelected.unsubscribe(handleBeforeCellRangeSelected);
|
||||
_grid.unregisterPlugin(_selector);
|
||||
$(pgWindow.default).off('mouseup', handleWindowMouseUp);
|
||||
}
|
||||
|
||||
function removeInvalidRanges(ranges) {
|
||||
var result = [];
|
||||
|
||||
for (let range_val of ranges) {
|
||||
var r = range_val;
|
||||
if (_grid.canCellBeSelected(r.fromRow, r.fromCell) && _grid.canCellBeSelected(r.toRow, r.toCell)) {
|
||||
result.push(r);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
function setSelectedRanges(ranges) {
|
||||
// simple check for: empty selection didn't change, prevent firing onSelectedRangesChanged
|
||||
if ((!_ranges || _ranges.length === 0) && (!ranges || ranges.length === 0)) { return; }
|
||||
|
||||
_ranges = removeInvalidRanges(ranges);
|
||||
_self.onSelectedRangesChanged.notify(_ranges);
|
||||
}
|
||||
|
||||
function getSelectedRanges() {
|
||||
return _ranges;
|
||||
}
|
||||
|
||||
function setSelectedRows(rows) {
|
||||
_ranges = [];
|
||||
|
||||
for(let row_val of rows) {
|
||||
_ranges.push(RangeSelectionHelper.rangeForRow(_grid, row_val));
|
||||
}
|
||||
}
|
||||
|
||||
function handleBeforeCellRangeSelected(e) {
|
||||
if (_grid.getEditorLock().isActive()) {
|
||||
e.stopPropagation();
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function handleCellRangeSelected(e, args) {
|
||||
setSelectedRanges([args.range]);
|
||||
}
|
||||
|
||||
function handleActiveCellChange(e, args) {
|
||||
if (_options.selectActiveCell && args.row != null && args.cell != null) {
|
||||
setSelectedRanges([new Slick.Range(args.row, args.cell)]);
|
||||
}
|
||||
}
|
||||
|
||||
function arrowKeyPressed(event) {
|
||||
return event.which == KEY_ARROW_RIGHT
|
||||
|| event.which == KEY_ARROW_LEFT
|
||||
|| event.which == KEY_ARROW_UP
|
||||
|| event.which == KEY_ARROW_DOWN;
|
||||
}
|
||||
|
||||
function shiftArrowKeyPressed(event) {
|
||||
return event.shiftKey && !event.ctrlKey && !event.altKey &&
|
||||
(arrowKeyPressed(event));
|
||||
}
|
||||
|
||||
function needUpdateRange(newRange) {
|
||||
return removeInvalidRanges([newRange]).length;
|
||||
}
|
||||
|
||||
function handleKeyDown(e) {
|
||||
var ranges;
|
||||
var lastSelectedRange;
|
||||
var anchorActiveCell = _grid.getActiveCell();
|
||||
|
||||
function isKey(key) { return e.which === key; }
|
||||
|
||||
function getKeycode() { return e.which; }
|
||||
|
||||
function shouldScrollToBottommostRow() { return anchorActiveCell.row === newSelectedRange.fromRow; }
|
||||
|
||||
function shouldScrollToRightmostColumn() { return anchorActiveCell.cell === newSelectedRange.fromCell; }
|
||||
|
||||
function getMobileCellFromRange(range, activeCell) {
|
||||
var localMobileCell = {};
|
||||
|
||||
localMobileCell.row = range.fromRow === activeCell.row ? range.toRow : range.fromRow;
|
||||
localMobileCell.cell = range.fromCell === activeCell.cell ? range.toCell : range.fromCell;
|
||||
|
||||
return localMobileCell;
|
||||
}
|
||||
|
||||
function getNewRange(rangeCorner, oppositeCorner) {
|
||||
var newFromCell = rangeCorner.cell <= oppositeCorner.cell ? rangeCorner.cell : oppositeCorner.cell;
|
||||
var newToCell = rangeCorner.cell <= oppositeCorner.cell ? oppositeCorner.cell : rangeCorner.cell;
|
||||
|
||||
var newFromRow = rangeCorner.row <= oppositeCorner.row ? rangeCorner.row : oppositeCorner.row;
|
||||
var newToRow = rangeCorner.row <= oppositeCorner.row ? oppositeCorner.row : rangeCorner.row;
|
||||
|
||||
return new Slick.Range(
|
||||
newFromRow,
|
||||
newFromCell,
|
||||
newToRow,
|
||||
newToCell
|
||||
);
|
||||
}
|
||||
|
||||
if (anchorActiveCell && shiftArrowKeyPressed(e)) {
|
||||
ranges = getSelectedRanges();
|
||||
if (!ranges.length) {
|
||||
ranges.push(new Slick.Range(anchorActiveCell.row, anchorActiveCell.cell));
|
||||
}
|
||||
|
||||
// keyboard can work with last range only
|
||||
lastSelectedRange = ranges.pop();
|
||||
|
||||
// can't handle selection out of active cell
|
||||
if (!lastSelectedRange.contains(anchorActiveCell.row, anchorActiveCell.cell)) {
|
||||
lastSelectedRange = new Slick.Range(anchorActiveCell.row, anchorActiveCell.cell);
|
||||
}
|
||||
|
||||
var mobileCell = getMobileCellFromRange(lastSelectedRange, anchorActiveCell);
|
||||
|
||||
switch (getKeycode()) {
|
||||
case KEY_ARROW_LEFT:
|
||||
mobileCell.cell -= 1;
|
||||
break;
|
||||
case KEY_ARROW_RIGHT:
|
||||
mobileCell.cell += 1;
|
||||
break;
|
||||
case KEY_ARROW_UP:
|
||||
mobileCell.row -= 1;
|
||||
break;
|
||||
case KEY_ARROW_DOWN:
|
||||
mobileCell.row += 1;
|
||||
break;
|
||||
}
|
||||
|
||||
var newSelectedRange = getNewRange(anchorActiveCell, mobileCell);
|
||||
|
||||
if (needUpdateRange(newSelectedRange)) {
|
||||
var rowToView = shouldScrollToBottommostRow() ? newSelectedRange.toRow : newSelectedRange.fromRow;
|
||||
var columnToView = shouldScrollToRightmostColumn() ? newSelectedRange.toCell : newSelectedRange.fromCell;
|
||||
|
||||
if (isKey(KEY_ARROW_RIGHT) || isKey(KEY_ARROW_LEFT)) {
|
||||
_grid.scrollColumnIntoView(columnToView);
|
||||
} else if (isKey(KEY_ARROW_UP) || isKey(KEY_ARROW_DOWN)) {
|
||||
_grid.scrollRowIntoView(rowToView);
|
||||
}
|
||||
ranges.push(newSelectedRange);
|
||||
} else {
|
||||
ranges.push(lastSelectedRange);
|
||||
}
|
||||
|
||||
setSelectedRanges(ranges);
|
||||
|
||||
e.preventDefault();
|
||||
e.stopPropagation();
|
||||
}
|
||||
}
|
||||
|
||||
function handleWindowMouseUp() {
|
||||
var selectedRange = _selector.getCurrentRange();
|
||||
if (!_.isUndefined(selectedRange)) {
|
||||
_grid.onDragEnd.notify({range: selectedRange});
|
||||
}
|
||||
}
|
||||
|
||||
$.extend(this, {
|
||||
'getSelectedRanges': getSelectedRanges,
|
||||
'setSelectedRanges': setSelectedRanges,
|
||||
'setSelectedRows': setSelectedRows,
|
||||
|
||||
'init': init,
|
||||
'destroy': destroy,
|
||||
|
||||
'onSelectedRangesChanged': new Slick.Event(),
|
||||
});
|
||||
};
|
||||
});
|
||||
Reference in New Issue
Block a user