2286 lines
75 KiB
JavaScript
2286 lines
75 KiB
JavaScript
/*
|
||
* (c) Copyright Ascensio System SIA 2010-2024
|
||
*
|
||
* This program is a free software product. You can redistribute it and/or
|
||
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
||
* version 3 as published by the Free Software Foundation. In accordance with
|
||
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
||
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
||
* of any third-party rights.
|
||
*
|
||
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
||
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
||
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
||
*
|
||
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
||
* street, Riga, Latvia, EU, LV-1050.
|
||
*
|
||
* The interactive user interfaces in modified source and object code versions
|
||
* of the Program must display Appropriate Legal Notices, as required under
|
||
* Section 5 of the GNU AGPL version 3.
|
||
*
|
||
* Pursuant to Section 7(b) of the License you must retain the original Product
|
||
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
||
* grant you any rights under trademark law for use of our trademarks.
|
||
*
|
||
* All the Product's GUI elements, including illustrations and icon sets, as
|
||
* well as technical writing content are licensed under the terms of the
|
||
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
||
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
||
*
|
||
*/
|
||
|
||
"use strict";
|
||
|
||
(/**
|
||
* @param {jQuery} $
|
||
* @param {Window} window
|
||
* @param {undefined} undefined
|
||
*/
|
||
function ($, window, undefined) {
|
||
|
||
var AscBrowser = AscCommon.AscBrowser;
|
||
|
||
var asc = window["Asc"] ? window["Asc"] : (window["Asc"] = {});
|
||
var asc_applyFunction = AscCommonExcel.applyFunction;
|
||
var c_oTargetType = AscCommonExcel.c_oTargetType;
|
||
|
||
/**
|
||
* Desktop event controller for WorkbookView
|
||
* -----------------------------------------------------------------------------
|
||
* @constructor
|
||
* @memberOf Asc
|
||
*/
|
||
function asc_CEventsController() {
|
||
//----- declaration -----
|
||
this.settings = {
|
||
vscrollStep: 10,
|
||
hscrollStep: 10,
|
||
scrollTimeout: 20,
|
||
wheelScrollLinesV: 3
|
||
};
|
||
|
||
this.view = undefined;
|
||
this.widget = undefined;
|
||
this.element = undefined;
|
||
this.handlers = undefined;
|
||
this.vsb = undefined;
|
||
this.vsbApi = undefined;
|
||
this.vsbMax = undefined;
|
||
this.hsb = undefined;
|
||
this.hsbApi = undefined;
|
||
this.hsbMax = undefined;
|
||
|
||
this.resizeTimerId = undefined;
|
||
this.scrollTimerId = undefined;
|
||
this.moveRangeTimerId = undefined;
|
||
this.moveResizeRangeTimerId = undefined;
|
||
this.fillHandleModeTimerId = undefined;
|
||
this.enableKeyEvents = true;
|
||
this.isSelectMode = false;
|
||
this.hasCursor = false;
|
||
this.hasFocus = false;
|
||
this.skipKeyPress = undefined;
|
||
this.targetInfo = undefined;
|
||
this.isResizeMode = false;
|
||
this.isResizeModeMove = false;
|
||
|
||
// Autofill mode
|
||
this.isFillHandleMode = false;
|
||
this.isMoveRangeMode = false;
|
||
this.isMoveResizeRange = false;
|
||
// Pinned Areas Setup Mode
|
||
this.frozenAnchorMode = false;
|
||
|
||
// Click handler for graph objects
|
||
this.clickCounter = new AscFormat.ClickCounter();
|
||
this.isMousePressed = false;
|
||
this.isShapeAction = false;
|
||
this.isUpOnCanvas = false;
|
||
|
||
// Was DblClick handled in onMouseDown event
|
||
this.isDblClickInMouseDown = false;
|
||
// Should I handle the browser event dblClick
|
||
this.isDoBrowserDblClick = false;
|
||
// Last coordinates, on MouseDown (for IE)
|
||
this.mouseDownLastCord = null;
|
||
//-----------------------
|
||
|
||
this.vsbApiLockMouse = false;
|
||
this.hsbApiLockMouse = false;
|
||
|
||
// when you click on the collapse/expand button for a group of rows
|
||
this.isRowGroup = false;
|
||
|
||
this.smoothWheelCorrector = null;
|
||
if (AscCommon.AscBrowser.isMacOs) {
|
||
this.smoothWheelCorrector = new AscCommon.CMouseSmoothWheelCorrector(this, function (deltaX, deltaY) {
|
||
|
||
if (deltaX) {
|
||
deltaX = Math.sign(deltaX) * Math.ceil(Math.abs(deltaX / 3));
|
||
this.scrollHorizontal(deltaX, null);
|
||
}
|
||
if (deltaY) {
|
||
deltaY = Math.sign(deltaY) * Math.ceil(Math.abs(deltaY * this.settings.wheelScrollLinesV / 3));
|
||
this.scrollVertical(deltaY, null);
|
||
}
|
||
|
||
});
|
||
|
||
this.smoothWheelCorrector.setNormalDeltaActive(3);
|
||
}
|
||
|
||
this.lastTab = null;
|
||
|
||
this.skipCellEditor = false;
|
||
|
||
return this;
|
||
}
|
||
|
||
/**
|
||
* @param {AscCommonExcel.WorkbookView} view
|
||
* @param {Element} widgetElem
|
||
* @param {Element} canvasElem
|
||
* @param {Object} handlers Event handlers (resize, scrollY, scrollX, changeSelection, ...)
|
||
*/
|
||
asc_CEventsController.prototype.init = function (view, widgetElem, canvasElem, handlers) {
|
||
var self = this;
|
||
this.view = view;
|
||
this.widget = widgetElem;
|
||
this.element = canvasElem;
|
||
this.handlers = new AscCommonExcel.asc_CHandlersList(handlers);
|
||
this._createScrollBars();
|
||
|
||
if (!Asc.editor.frameManager.isInitFrameManager) {
|
||
return;
|
||
}
|
||
|
||
if (this.view.Api.isUseOldMobileVersion()) {
|
||
/*Previously, resize events were called from the menu via the controller. Now the controller is not available in the menu, for resize we subscribe to the global resize from window.*/
|
||
window.addEventListener("resize", function () {
|
||
self._onWindowResize.apply(self, arguments);
|
||
}, false);
|
||
return this;
|
||
}
|
||
|
||
// initialize events
|
||
if (window.addEventListener) {
|
||
window.addEventListener("resize", function () {
|
||
self._onWindowResize.apply(self, arguments);
|
||
}, false);
|
||
window.addEventListener(AscCommon.getPtrEvtName("move"), function () {
|
||
return self._onWindowMouseMove.apply(self, arguments);
|
||
}, false);
|
||
window.addEventListener(AscCommon.getPtrEvtName("up"), function () {
|
||
return self._onWindowMouseUp.apply(self, arguments);
|
||
}, false);
|
||
window.addEventListener(AscCommon.getPtrEvtName("leave"), function () {
|
||
return self._onWindowMouseLeaveOut.apply(self, arguments);
|
||
}, false);
|
||
window.addEventListener(AscCommon.getPtrEvtName("out"), function () {
|
||
return self._onWindowMouseLeaveOut.apply(self, arguments);
|
||
}, false);
|
||
}
|
||
|
||
// prevent changing mouse cursor when 'mousedown' is occurred
|
||
if (this.element.onselectstart) {
|
||
this.element.onselectstart = function () {
|
||
return false;
|
||
};
|
||
}
|
||
|
||
if (this.element.addEventListener) {
|
||
this.element.addEventListener(AscCommon.getPtrEvtName("down"), function () {
|
||
return self._onMouseDown.apply(self, arguments);
|
||
}, false);
|
||
this.element.addEventListener(AscCommon.getPtrEvtName("up"), function () {
|
||
return self._onMouseUp.apply(self, arguments);
|
||
}, false);
|
||
this.element.addEventListener(AscCommon.getPtrEvtName("move"), function () {
|
||
return self._onMouseMove.apply(self, arguments);
|
||
}, false);
|
||
this.element.addEventListener(AscCommon.getPtrEvtName("leave"), function () {
|
||
return self._onMouseLeave.apply(self, arguments);
|
||
}, false);
|
||
this.element.addEventListener("dblclick", function () {
|
||
return self._onMouseDblClick.apply(self, arguments);
|
||
}, false);
|
||
}
|
||
if (this.widget.addEventListener) {
|
||
// https://developer.mozilla.org/en-US/docs/Web/Reference/Events/wheel
|
||
// detect available wheel event
|
||
var nameWheelEvent = (!AscCommon.AscBrowser.isMacOs && "onwheel" in document.createElement("div")) ? "wheel" : // Modern browsers support "wheel"
|
||
document.onmousewheel !== undefined ? "mousewheel" : // Webkit and IE support at least "mousewheel"
|
||
"DOMMouseScroll"; // let's assume that remaining browsers are older Firefox
|
||
|
||
this.widget.addEventListener(nameWheelEvent, function () {
|
||
return self._onMouseWheel.apply(self, arguments);
|
||
}, false);
|
||
this.widget.addEventListener('contextmenu', function (e) {
|
||
e.stopPropagation();
|
||
e.preventDefault();
|
||
return false;
|
||
}, false)
|
||
}
|
||
|
||
// Cursor for graphic objects. We define mousedown and mouseup for text selection.
|
||
var oShapeCursor = document.getElementById("id_target_cursor");
|
||
if (null != oShapeCursor && oShapeCursor.addEventListener) {
|
||
oShapeCursor.addEventListener(AscCommon.getPtrEvtName("down"), function () {
|
||
return self._onMouseDown.apply(self, arguments);
|
||
}, false);
|
||
oShapeCursor.addEventListener(AscCommon.getPtrEvtName("up"), function () {
|
||
return self._onMouseUp.apply(self, arguments);
|
||
}, false);
|
||
oShapeCursor.addEventListener(AscCommon.getPtrEvtName("move"), function () {
|
||
return self._onMouseMove.apply(self, arguments);
|
||
}, false);
|
||
oShapeCursor.addEventListener(AscCommon.getPtrEvtName("leave"), function () {
|
||
return self._onMouseLeave.apply(self, arguments);
|
||
}, false);
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
asc_CEventsController.prototype.destroy = function () {
|
||
return this;
|
||
};
|
||
|
||
/** @param flag {Boolean} */
|
||
asc_CEventsController.prototype.enableKeyEventsHandler = function (flag) {
|
||
this.enableKeyEvents = !!flag;
|
||
};
|
||
|
||
/** @return {Boolean} */
|
||
asc_CEventsController.prototype.canEdit = function () {
|
||
return this.view.canEdit();
|
||
};
|
||
|
||
/** @return {Boolean} */
|
||
asc_CEventsController.prototype.getCellEditMode = function () {
|
||
return this.view.isCellEditMode;
|
||
};
|
||
|
||
asc_CEventsController.prototype.setFocus = function (hasFocus) {
|
||
this.hasFocus = !!hasFocus;
|
||
};
|
||
|
||
asc_CEventsController.prototype.gotFocus = function (hasFocus) {
|
||
this.setFocus(hasFocus);
|
||
this.handlers.trigger('gotFocus', this.hasFocus);
|
||
};
|
||
|
||
/** @return {Boolean} */
|
||
asc_CEventsController.prototype.getFormulaEditMode = function () {
|
||
return this.view.isFormulaEditMode;
|
||
};
|
||
|
||
asc_CEventsController.prototype.getSelectionDialogMode = function () {
|
||
return this.view.selectionDialogMode;
|
||
};
|
||
|
||
asc_CEventsController.prototype.reinitScrollX = function (settings, pos, max, max2) {
|
||
var step = this.settings.hscrollStep;
|
||
this.hsbMax = Math.max(max * step, 1);
|
||
settings.contentW = this.hsbMax - 1;
|
||
this.hsbApi.Repos(settings, false, false, pos * step);
|
||
this.hsbApi.maxScrollX2 = Math.max(max2 * step, 1);
|
||
};
|
||
asc_CEventsController.prototype.reinitScrollY = function (settings, pos, max, max2) {
|
||
var step = this.settings.vscrollStep;
|
||
this.vsbMax = Math.max(max * step, 1);
|
||
settings.contentH = this.vsbMax - 1;
|
||
this.vsbApi.Repos(settings, false, false, pos * step);
|
||
this.vsbApi.maxScrollY2 = Math.max(max2 * step, 1);
|
||
};
|
||
|
||
/**
|
||
* @param {AscCommon.CellBase} delta
|
||
*/
|
||
asc_CEventsController.prototype.scroll = function (delta) {
|
||
if (delta) {
|
||
if (delta.col) {
|
||
this.scrollHorizontal(delta.col);
|
||
}
|
||
if (delta.row) {
|
||
this.scrollVertical(delta.row);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @param delta {Number}
|
||
* @param [event] {MouseEvent}
|
||
*/
|
||
asc_CEventsController.prototype.scrollVertical = function (delta, event) {
|
||
if (window["NATIVE_EDITOR_ENJINE"])
|
||
return;
|
||
|
||
if (event && event.preventDefault)
|
||
event.preventDefault();
|
||
this.vsbApi.scrollByY(this.settings.vscrollStep * delta);
|
||
return true;
|
||
};
|
||
|
||
/**
|
||
* @param delta {Number}
|
||
* @param [event] {MouseEvent}
|
||
*/
|
||
asc_CEventsController.prototype.scrollHorizontal = function (delta, event) {
|
||
if (window["NATIVE_EDITOR_ENJINE"])
|
||
return;
|
||
|
||
if (event && event.preventDefault)
|
||
event.preventDefault();
|
||
this.hsbApi.scrollByX(this.settings.hscrollStep * delta);
|
||
return true;
|
||
};
|
||
|
||
// We will do dblClick as in Excel
|
||
asc_CEventsController.prototype.doMouseDblClick = function (event) {
|
||
var t = this;
|
||
var ctrlKey = !AscCommon.getAltGr(event) && (event.metaKey || event.ctrlKey);
|
||
|
||
// The formula does not require exiting cell editing
|
||
if (this.getFormulaEditMode() || this.getSelectionDialogMode()) {
|
||
return true;
|
||
}
|
||
|
||
if (this.view.Api.isEditVisibleAreaOleEditor) {
|
||
return true;
|
||
}
|
||
|
||
if (this.targetInfo && (this.targetInfo.target === AscCommonExcel.c_oTargetType.GroupRow ||
|
||
this.targetInfo.target === AscCommonExcel.c_oTargetType.GroupCol)) {
|
||
return false;
|
||
}
|
||
|
||
if (this.targetInfo && (this.targetInfo.target === c_oTargetType.MoveResizeRange ||
|
||
this.targetInfo.target === c_oTargetType.MoveRange ||
|
||
this.targetInfo.target === c_oTargetType.FilterObject ||
|
||
this.targetInfo.target === c_oTargetType.TableSelectionChange))
|
||
return true;
|
||
|
||
if (t.getCellEditMode()) {
|
||
if (!t.handlers.trigger("stopCellEditing")) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
var coord = t._getCoordinates(event);
|
||
var graphicsInfo = t.handlers.trigger("getGraphicsInfo", coord.x, coord.y);
|
||
if (graphicsInfo)
|
||
return;
|
||
|
||
setTimeout(function () {
|
||
var coord = t._getCoordinates(event);
|
||
t.handlers.trigger("mouseDblClick", coord.x, coord.y, event, function () {
|
||
// We resized the column/row, not edited the cell. Update the cursor state
|
||
t.handlers.trigger("updateWorksheet", coord.x, coord.y, ctrlKey,
|
||
function (info) {
|
||
t.targetInfo = info;
|
||
});
|
||
});
|
||
}, 100);
|
||
|
||
return true;
|
||
};
|
||
|
||
// We will show the cursor near the cell editor (only for dblClick)
|
||
asc_CEventsController.prototype.showCellEditorCursor = function () {
|
||
if (this.getCellEditMode()) {
|
||
if (this.isDoBrowserDblClick) {
|
||
this.isDoBrowserDblClick = false;
|
||
this.handlers.trigger("showCellEditorCursor");
|
||
}
|
||
}
|
||
};
|
||
|
||
asc_CEventsController.prototype.createScrollSettings = function () {
|
||
var settings = new AscCommon.ScrollSettings();
|
||
|
||
settings.scrollBackgroundColor = GlobalSkin.ScrollBackgroundColor;
|
||
settings.scrollBackgroundColorHover = GlobalSkin.ScrollBackgroundColor;
|
||
settings.scrollBackgroundColorActive = GlobalSkin.ScrollBackgroundColor;
|
||
|
||
settings.scrollerColor = GlobalSkin.ScrollerColor;
|
||
settings.scrollerHoverColor = GlobalSkin.ScrollerHoverColor;
|
||
settings.scrollerActiveColor = GlobalSkin.ScrollerActiveColor;
|
||
|
||
settings.arrowColor = GlobalSkin.ScrollArrowColor;
|
||
settings.arrowHoverColor = GlobalSkin.ScrollArrowHoverColor;
|
||
settings.arrowActiveColor = GlobalSkin.ScrollArrowActiveColor;
|
||
|
||
settings.strokeStyleNone = GlobalSkin.ScrollOutlineColor;
|
||
settings.strokeStyleOver = GlobalSkin.ScrollOutlineHoverColor;
|
||
settings.strokeStyleActive = GlobalSkin.ScrollOutlineActiveColor;
|
||
|
||
settings.targetColor = GlobalSkin.ScrollerTargetColor;
|
||
settings.targetHoverColor = GlobalSkin.ScrollerTargetHoverColor;
|
||
settings.targetActiveColor = GlobalSkin.ScrollerTargetActiveColor;
|
||
|
||
return settings;
|
||
};
|
||
|
||
asc_CEventsController.prototype.updateScrollSettings = function () {
|
||
var opt = this.settings, settings;
|
||
var ws = window["Asc"]["editor"].wb.getWorksheet();
|
||
if (this.vsbApi) {
|
||
settings = this.createScrollSettings();
|
||
|
||
settings.vscrollStep = opt.vscrollStep;
|
||
settings.hscrollStep = opt.hscrollStep;
|
||
settings.wheelScrollLines = opt.wheelScrollLinesV;
|
||
settings.isVerticalScroll = true;
|
||
settings.isHorizontalScroll = false;
|
||
this.vsbApi.canvasH = null;
|
||
this.reinitScrollY(settings, ws.workbook.getSmoothScrolling() ? ws.getFirstVisibleRowSmoothScroll(true) : ws.getFirstVisibleRow(true), ws.getVerticalScrollRange(), ws.getVerticalScrollMax());
|
||
this.vsbApi.settings = settings;
|
||
}
|
||
if (this.hsbApi) {
|
||
settings = this.createScrollSettings();
|
||
settings.vscrollStep = opt.vscrollStep;
|
||
settings.hscrollStep = opt.hscrollStep;
|
||
settings.isVerticalScroll = false;
|
||
settings.isHorizontalScroll = true;
|
||
this.hsbApi.canvasW = null;
|
||
this.reinitScrollX(settings, ws.workbook.getSmoothScrolling() ? ws.getFirstVisibleColSmoothScroll(true) : ws.getFirstVisibleCol(true), ws.getHorizontalScrollRange(), ws.getHorizontalScrollMax());
|
||
this.hsbApi.settings = settings;
|
||
}
|
||
};
|
||
|
||
asc_CEventsController.prototype._createScrollBars = function () {
|
||
var self = this, settings, opt = this.settings;
|
||
|
||
// vertical scroll bar
|
||
if (!this.vsb || !document.getElementById("ws-v-scrollbar")) {
|
||
this.vsb = document.createElement('div');
|
||
this.vsb.id = "ws-v-scrollbar";
|
||
this.vsb.style.backgroundColor = AscCommon.GlobalSkin.ScrollBackgroundColor;
|
||
|
||
//TODO test rtl
|
||
/*if (window.rightToleft) {
|
||
this.vsb.style.left = "0px";
|
||
this.widget.prepend(this.vsb);
|
||
this.widget.children[1].style.left = this.vsb.clientWidth + "px";
|
||
this.widget.children[1].style.overflow = "visible"
|
||
} else {*/
|
||
this.widget.appendChild(this.vsb);
|
||
//}
|
||
}
|
||
|
||
if (!this.vsbApi) {
|
||
settings = this.createScrollSettings();
|
||
settings.vscrollStep = opt.vscrollStep;
|
||
settings.hscrollStep = opt.hscrollStep;
|
||
settings.wheelScrollLines = opt.wheelScrollLinesV;
|
||
settings.isVerticalScroll = true;
|
||
settings.isHorizontalScroll = false;
|
||
|
||
this.vsbApi = new AscCommon.ScrollObject(this.vsb.id, settings);
|
||
this.vsbApi.bind("scrollvertical", function (evt) {
|
||
self.handlers.trigger("scrollY", evt.scrollPositionY / self.settings.vscrollStep, !self.vsbApi.scrollerMouseDown);
|
||
});
|
||
this.vsbApi.bind(AscCommon.getPtrEvtName("up"), function (evt) {
|
||
if (self.vsbApi.scrollerMouseDown) {
|
||
self.handlers.trigger('initRowsCount');
|
||
}
|
||
});
|
||
this.vsbApi.onLockMouse = function (evt) {
|
||
self.vsbApiLockMouse = true;
|
||
};
|
||
this.vsbApi.offLockMouse = function () {
|
||
self.vsbApiLockMouse = false;
|
||
};
|
||
}
|
||
|
||
// horizontal scroll bar
|
||
if (!this.hsb || !document.getElementById("ws-h-scrollbar")) {
|
||
this.hsb = document.createElement('div');
|
||
this.hsb.id = "ws-h-scrollbar";
|
||
this.hsb.style.backgroundColor = AscCommon.GlobalSkin.ScrollBackgroundColor;
|
||
this.widget.appendChild(this.hsb);
|
||
}
|
||
|
||
if (!this.hsbApi) {
|
||
settings = this.createScrollSettings();
|
||
settings.vscrollStep = opt.vscrollStep;
|
||
settings.hscrollStep = opt.hscrollStep;
|
||
settings.isVerticalScroll = false;
|
||
settings.isHorizontalScroll = true;
|
||
|
||
this.hsbApi = new AscCommon.ScrollObject(this.hsb.id, settings);
|
||
this.hsbApi.bind("scrollhorizontal", function (evt) {
|
||
self.handlers.trigger("scrollX", evt.scrollPositionX / self.settings.hscrollStep, !self.hsbApi.scrollerMouseDown);
|
||
});
|
||
this.hsbApi.bind(AscCommon.getPtrEvtName("up"), function (evt) {
|
||
if (self.hsbApi.scrollerMouseDown) {
|
||
self.handlers.trigger('initColsCount');
|
||
}
|
||
});
|
||
this.hsbApi.onLockMouse = function () {
|
||
self.hsbApiLockMouse = true;
|
||
};
|
||
this.hsbApi.offLockMouse = function () {
|
||
self.hsbApiLockMouse = false;
|
||
};
|
||
}
|
||
|
||
if (!this.view.Api.isMobileVersion) {
|
||
// right bottom corner
|
||
var corner = document.createElement('div');
|
||
corner.id = "ws-scrollbar-corner";
|
||
corner.style.backgroundColor = AscCommon.GlobalSkin.ScrollBackgroundColor
|
||
this.widget.appendChild(corner);
|
||
} else {
|
||
this.hsb.style.zIndex = -10;
|
||
this.hsb.style.right = 0;
|
||
this.hsb.style.display = "none";
|
||
this.vsb.style.zIndex = -10;
|
||
this.vsb.style.bottom = 0;
|
||
this.vsb.style.display = "none";
|
||
}
|
||
|
||
this.showVerticalScroll(this.view.getShowVerticalScroll());
|
||
this.showHorizontalScroll(this.view.getShowHorizontalScroll());
|
||
};
|
||
|
||
/**
|
||
* @param event {MouseEvent}
|
||
* @param callback {Function}
|
||
* @private
|
||
*/
|
||
asc_CEventsController.prototype._continueChangeVisibleArea = function (event, callback) {
|
||
var t = this;
|
||
var coord = this._getCoordinates(event);
|
||
|
||
this.handlers.trigger("changeVisibleArea", /*isStartPoint*/false, coord.x, coord.y, false,
|
||
function (d) {
|
||
t.scroll(d);
|
||
|
||
asc_applyFunction(callback);
|
||
});
|
||
};
|
||
|
||
/**
|
||
*
|
||
* @param event {MouseEvent}
|
||
*/
|
||
asc_CEventsController.prototype._continueChangeVisibleArea2 = function (event) {
|
||
var t = this;
|
||
var fn = function () {
|
||
t._continueChangeVisibleArea2(event);
|
||
};
|
||
|
||
var callback = function () {
|
||
if (t.isChangeVisibleAreaMode && !t.hasCursor) {
|
||
t.visibleAreaSelectionTimerId = window.setTimeout(fn, t.settings.scrollTimeout);
|
||
}
|
||
}
|
||
window.clearTimeout(t.visibleAreaSelectionTimerId);
|
||
window.setTimeout(function () {
|
||
if (t.isChangeVisibleAreaMode && !t.hasCursor) {
|
||
t._continueChangeVisibleArea(event, callback);
|
||
}
|
||
}, 0);
|
||
|
||
};
|
||
|
||
/**
|
||
*
|
||
* @param event {MouseEvent}
|
||
* @param callback {Function}
|
||
*/
|
||
asc_CEventsController.prototype._startChangeVisibleArea = function (event, callback) {
|
||
var coord = this._getCoordinates(event);
|
||
this.handlers.trigger("changeVisibleArea", /*isStartPoint*/true, coord.x, coord.y, false, callback);
|
||
};
|
||
|
||
/**
|
||
* @param event {MouseEvent}
|
||
* @param callback {Function}
|
||
*/
|
||
asc_CEventsController.prototype._changeSelection = function (event, callback) {
|
||
var t = this;
|
||
var coord = this._getCoordinates(event);
|
||
|
||
this.handlers.trigger("changeSelection", /*isStartPoint*/false, coord.x, coord.y, /*isCoord*/true, false,
|
||
function (d) {
|
||
t.scroll(d);
|
||
|
||
asc_applyFunction(callback);
|
||
});
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._changeSelection2 = function (event) {
|
||
var t = this;
|
||
|
||
var fn = function () {
|
||
t._changeSelection2(event);
|
||
};
|
||
var callback = function () {
|
||
if (t.isSelectMode && !t.hasCursor) {
|
||
t.scrollTimerId = window.setTimeout(fn, t.settings.scrollTimeout);
|
||
}
|
||
};
|
||
|
||
window.clearTimeout(t.scrollTimerId);
|
||
t.scrollTimerId = window.setTimeout(function () {
|
||
if (t.isSelectMode && !t.hasCursor) {
|
||
t._changeSelection(event, callback);
|
||
}
|
||
}, 0);
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._moveRangeHandle2 = function (event) {
|
||
var t = this;
|
||
|
||
var fn = function () {
|
||
t._moveRangeHandle2(event);
|
||
};
|
||
|
||
var callback = function () {
|
||
if (t.isMoveRangeMode && !t.hasCursor) {
|
||
t.moveRangeTimerId = window.setTimeout(fn, t.settings.scrollTimeout);
|
||
}
|
||
};
|
||
|
||
window.clearTimeout(t.moveRangeTimerId);
|
||
t.moveRangeTimerId = window.setTimeout(function () {
|
||
if (t.isMoveRangeMode && !t.hasCursor) {
|
||
t._moveRangeHandle(event, callback);
|
||
}
|
||
}, 0);
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._moveResizeRangeHandle2 = function (event) {
|
||
var t = this;
|
||
|
||
var fn = function () {
|
||
t._moveResizeRangeHandle2(event);
|
||
};
|
||
|
||
var callback = function () {
|
||
if (t.isMoveResizeRange && !t.hasCursor) {
|
||
t.moveResizeRangeTimerId = window.setTimeout(fn, t.settings.scrollTimeout);
|
||
}
|
||
};
|
||
|
||
window.clearTimeout(t.moveResizeRangeTimerId);
|
||
t.moveResizeRangeTimerId = window.setTimeout(function () {
|
||
if (t.isMoveResizeRange && !t.hasCursor) {
|
||
t._moveResizeRangeHandle(event, t.targetInfo, callback);
|
||
}
|
||
}, 0);
|
||
};
|
||
|
||
/**
|
||
* End of selection
|
||
* @param event {MouseEvent}
|
||
*/
|
||
asc_CEventsController.prototype._changeSelectionDone = function (event) {
|
||
var coord = this._getCoordinates(event);
|
||
var ctrlKey = !AscCommon.getAltGr(event) && (event.metaKey || event.ctrlKey);
|
||
if (false !== ctrlKey) {
|
||
coord.x = -1;
|
||
coord.y = -1;
|
||
}
|
||
this.handlers.trigger("changeSelectionDone", coord.x, coord.y, event);
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._resizeElement = function (event) {
|
||
var coord = this._getCoordinates(event);
|
||
this.handlers.trigger("resizeElement", this.targetInfo, coord.x, coord.y);
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._resizeElementDone = function (event) {
|
||
var coord = this._getCoordinates(event);
|
||
this.handlers.trigger("resizeElementDone", this.targetInfo, coord.x, coord.y, this.isResizeModeMove);
|
||
this.isResizeModeMove = false;
|
||
};
|
||
|
||
/**
|
||
* @param event {MouseEvent}
|
||
* @param callback {Function}
|
||
*/
|
||
asc_CEventsController.prototype._changeFillHandle = function (event, callback, tableIndex) {
|
||
var t = this;
|
||
// Update in autofill mode
|
||
var coord = this._getCoordinates(event);
|
||
this.handlers.trigger("changeFillHandle", coord.x, coord.y,
|
||
function (d) {
|
||
if (!d) return;
|
||
t.scroll(d);
|
||
asc_applyFunction(callback);
|
||
}, tableIndex);
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._changeFillHandle2 = function (event) {
|
||
var t = this;
|
||
|
||
var fn = function () {
|
||
t._changeFillHandle2(event);
|
||
};
|
||
|
||
var callback = function () {
|
||
if (t.isFillHandleMode && !t.hasCursor) {
|
||
t.fillHandleModeTimerId = window.setTimeout(fn, t.settings.scrollTimeout);
|
||
}
|
||
};
|
||
|
||
window.clearTimeout(t.fillHandleModeTimerId);
|
||
t.fillHandleModeTimerId = window.setTimeout(function () {
|
||
if (t.isFillHandleMode && !t.hasCursor) {
|
||
t._changeFillHandle(event, callback);
|
||
}
|
||
}, 0);
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._changeFillHandleDone = function (event) {
|
||
// We've finished autofilling, let's recalculate
|
||
var coord = this._getCoordinates(event);
|
||
var ctrlKey = !AscCommon.getAltGr(event) && (event.metaKey || event.ctrlKey);
|
||
this.handlers.trigger("changeFillHandleDone", coord.x, coord.y, ctrlKey);
|
||
};
|
||
|
||
/**
|
||
* @param event {MouseEvent}
|
||
* @param callback {Function}
|
||
*/
|
||
asc_CEventsController.prototype._moveRangeHandle = function (event, callback, colRowMoveProps) {
|
||
var t = this;
|
||
// Updating in range moving mode
|
||
var coord = this._getCoordinates(event);
|
||
this.handlers.trigger("moveRangeHandle", coord.x, coord.y,
|
||
function (d) {
|
||
if (!d) return;
|
||
t.scroll(d);
|
||
asc_applyFunction(callback);
|
||
}, colRowMoveProps);
|
||
};
|
||
|
||
/**
|
||
* @param event {MouseEvent}
|
||
* @param target
|
||
*/
|
||
asc_CEventsController.prototype._moveFrozenAnchorHandle = function (event, target) {
|
||
var t = this;
|
||
var coord = t._getCoordinates(event);
|
||
t.handlers.trigger("moveFrozenAnchorHandle", coord.x, coord.y, target);
|
||
};
|
||
|
||
/**
|
||
* @param event {MouseEvent}
|
||
* @param target
|
||
*/
|
||
asc_CEventsController.prototype._moveFrozenAnchorHandleDone = function (event, target) {
|
||
// Fixing the area
|
||
var t = this;
|
||
var coord = t._getCoordinates(event);
|
||
t.handlers.trigger("moveFrozenAnchorHandleDone", coord.x, coord.y, target);
|
||
};
|
||
|
||
/**
|
||
* @param event {MouseEvent}
|
||
* @param target
|
||
* @param callback {Function}
|
||
*/
|
||
asc_CEventsController.prototype._moveResizeRangeHandle = function (event, target, callback) {
|
||
var t = this;
|
||
// Updating in range moving mode
|
||
var coord = this._getCoordinates(event);
|
||
this.handlers.trigger("moveResizeRangeHandle", coord.x, coord.y, target,
|
||
function (d) {
|
||
if (!d) return;
|
||
t.scroll(d);
|
||
asc_applyFunction(callback);
|
||
});
|
||
};
|
||
|
||
asc_CEventsController.prototype._groupRowClick = function (event, target) {
|
||
// Updating in range moving mode
|
||
var coord = this._getCoordinates(event);
|
||
return this.handlers.trigger("groupRowClick", coord.x, coord.y, target, event.type);
|
||
};
|
||
|
||
asc_CEventsController.prototype._commentCellClick = function (event) {
|
||
// ToDo delete this function!
|
||
var coord = this._getCoordinates(event);
|
||
this.handlers.trigger("commentCellClick", coord.x, coord.y);
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._moveRangeHandleDone = function (event) {
|
||
// We've finished moving the range, let's recalculate
|
||
var ctrlKey = !AscCommon.getAltGr(event) && (event.metaKey || event.ctrlKey);
|
||
this.handlers.trigger("moveRangeHandleDone", ctrlKey);
|
||
};
|
||
|
||
asc_CEventsController.prototype._moveResizeRangeHandleDone = function (isPageBreakPreview) {
|
||
// We've finished moving the range, let's recalculate
|
||
this.handlers.trigger("moveResizeRangeHandleDone", isPageBreakPreview);
|
||
};
|
||
|
||
/** @param event {jQuery.Event} */
|
||
asc_CEventsController.prototype._onWindowResize = function (event) {
|
||
var self = this;
|
||
window.clearTimeout(this.resizeTimerId);
|
||
this.resizeTimerId = window.setTimeout(function () {
|
||
self.handlers.trigger("resize", event);
|
||
}, 150);
|
||
};
|
||
asc_CEventsController.prototype.executeShortcut = function(nShortcutAction) {
|
||
let oRet = {keyResult: keydownresult_PreventAll};
|
||
const bSelectionDialogMode = this.getSelectionDialogMode();
|
||
const bCanEdit = this.canEdit();
|
||
switch (nShortcutAction) {
|
||
case Asc.c_oAscSpreadsheetShortcutType.RecalculateAll: {
|
||
this.handlers.trigger("calculate", Asc.c_oAscCalculateType.All);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.RecalculateActiveSheet: {
|
||
this.handlers.trigger("calculate", Asc.c_oAscCalculateType.ActiveSheet);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.RefreshAllPivots:
|
||
case Asc.c_oAscSpreadsheetShortcutType.RefreshSelectedPivots: {
|
||
if (bCanEdit && !this.getCellEditMode() && !bSelectionDialogMode) {
|
||
this.handlers.trigger("refreshConnections", nShortcutAction === Asc.c_oAscSpreadsheetShortcutType.RefreshAllPivots);
|
||
}
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.EditSelectAll: {
|
||
if (!this.getCellEditMode()) {
|
||
this.handlers.trigger("selectAllByRange");
|
||
}
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellInsertDate:
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellInsertTime: {
|
||
if (!bCanEdit || this.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
// When pressing the symbol, we do not set the focus. We clear the contents of the cell
|
||
const oEnterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
oEnterOptions.newText = '';
|
||
oEnterOptions.quickInput = true;
|
||
this.handlers.trigger("editCell", oEnterOptions);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.NextWorksheet: {
|
||
this.handlers.trigger("showNextPrevWorksheet", +1);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.PreviousWorksheet: {
|
||
this.handlers.trigger("showNextPrevWorksheet", -1);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.Strikeout: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setFontAttributes", "s");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.Italic: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setFontAttributes", "i");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.Bold: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setFontAttributes", "b");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.Underline: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setFontAttributes", "u");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.EditRedo: {
|
||
if (!(bCanEdit || this.handlers.trigger('isRestrictionComments')) || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("redo");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.EditUndo: {
|
||
if (!(bCanEdit || this.handlers.trigger('isRestrictionComments')) || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("undo");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.SpeechWorker: {
|
||
if (this.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
AscCommon.EditorActionSpeaker.toggle();
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellInsertSumFunction: {
|
||
if (!bCanEdit || this.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
this.handlers.trigger('addFunction',
|
||
AscCommonExcel.cFormulaFunctionToLocale ? AscCommonExcel.cFormulaFunctionToLocale['SUM'] :
|
||
'SUM', Asc.c_oAscPopUpSelectorType.Func, true);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.PrintPreviewAndPrint: {
|
||
if (this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("print");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.EditOpenCellEditor: {
|
||
if (!bCanEdit || this.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
if (!AscBrowser.isOpera) {
|
||
oRet.keyResult = keydownresult_PreventNothing;
|
||
}
|
||
// With F2 we set the focus in the editor
|
||
const oEnterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
oEnterOptions.focus = true;
|
||
this.handlers.trigger("editCell", oEnterOptions);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellAddSeparator: {
|
||
if (!bCanEdit || this.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
window["Asc"]["editor"].wb.EnterText(this.view.Api.asc_getDecimalSeparator().charCodeAt(0), true);
|
||
//stop to prevent double enter
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellNumberFormat: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setCellFormat", Asc.c_oAscNumFormatType.Number);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellTimeFormat: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setCellFormat", Asc.c_oAscNumFormatType.Time);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellDateFormat: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setCellFormat", Asc.c_oAscNumFormatType.Date);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellCurrencyFormat: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setCellFormat", Asc.c_oAscNumFormatType.Currency);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellPercentFormat: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setCellFormat", Asc.c_oAscNumFormatType.Percent);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellExponentialFormat: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setCellFormat", Asc.c_oAscNumFormatType.Scientific);
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.CellGeneralFormat: {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("setCellFormat", Asc.c_oAscNumFormatType.General);
|
||
break;
|
||
}
|
||
|
||
case Asc.c_oAscSpreadsheetShortcutType.ShowFormulas: {
|
||
if (bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
this.handlers.trigger("showFormulas");
|
||
break;
|
||
}
|
||
case Asc.c_oAscSpreadsheetShortcutType.IncreaseFontSize:
|
||
case Asc.c_oAscSpreadsheetShortcutType.DecreaseFontSize: {
|
||
if (this.getCellEditMode() || !bCanEdit || bSelectionDialogMode) {
|
||
return true;
|
||
}
|
||
this.view.setFontAttributes("changeFontSize", nShortcutAction === Asc.c_oAscSpreadsheetShortcutType.IncreaseFontSize);
|
||
break;
|
||
}
|
||
default: {
|
||
const oCustom = this.view.Api.getCustomShortcutAction(nShortcutAction);
|
||
if (oCustom) {
|
||
if (!bCanEdit || bSelectionDialogMode || this.getCellEditMode()) {
|
||
break;
|
||
}
|
||
if (AscCommon.c_oAscCustomShortcutType.Symbol === oCustom.Type) {
|
||
const oEnterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
oEnterOptions.newText = '';
|
||
oEnterOptions.quickInput = true;
|
||
this.handlers.trigger("editCell", oEnterOptions);
|
||
}
|
||
} else {
|
||
oRet = null;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return oRet;
|
||
};
|
||
/** @param oEvent {AscCommon.CKeyboardEvent} */
|
||
asc_CEventsController.prototype._onWindowKeyDown = function (oEvent) {
|
||
const oThis = this;
|
||
let nRetValue = keydownresult_PreventKeyPress;
|
||
const nShortcutAction = oThis.view.Api.getShortcut(oEvent);
|
||
|
||
// For those browsers that do not send the left mouse button release for double click, when exiting
|
||
// the editor window and releasing the button, we will handle exiting the window (only Chrome sends the MouseUp event even when exiting the browser)
|
||
this.showCellEditorCursor();
|
||
|
||
if (oThis.getCellEditMode() && !oThis.hasFocus || oThis.isSelectMode ||
|
||
oThis.isFillHandleMode || oThis.isMoveRangeMode || oThis.isMoveResizeRange) {
|
||
// For some reason, I really want to process extra conditions in our code, instead of processing them at the top...
|
||
if (oThis.enableKeyEvents || (nShortcutAction !== Asc.c_oAscSpreadsheetShortcutType.PrintPreviewAndPrint)) {
|
||
// Only if events are disabled and Ctrl+S or Ctrl+P is pressed we will process them
|
||
return nRetValue;
|
||
}
|
||
}
|
||
|
||
let bIsSelect = oEvent.IsShift();
|
||
const bIsMacOs = AscCommon.AscBrowser.isMacOs;
|
||
const bSelectionDialogMode = this.getSelectionDialogMode();
|
||
const bIsFormulaEditMode = this.getFormulaEditMode();
|
||
const bCanEdit = this.canEdit();
|
||
let nDeltaColumn = 0;
|
||
let nDeltaRow = 0;
|
||
//Are we moving in the selected area?
|
||
let bSelectionActivePointChanged = false;
|
||
let bIsNeedCheckActiveCellChanged = null;
|
||
let oActiveCell;
|
||
|
||
const oWb = window["Asc"]["editor"].wb;
|
||
const oWs = oWb.getWorksheet();
|
||
const isRightToLeft = oWs && oWs.getRightToLeft();
|
||
|
||
const oShortcutRes = this.executeShortcut(nShortcutAction);
|
||
if (oShortcutRes) {
|
||
nRetValue = oShortcutRes.keyResult;
|
||
} else {
|
||
switch (oEvent.GetKeyCode()) {
|
||
case 82:
|
||
if (oEvent.CtrlKey && bIsSelect) {
|
||
if (bCanEdit && !oThis.getCellEditMode() && !bSelectionDialogMode) {
|
||
oThis.handlers.trigger("changeFormatTableInfo");
|
||
}
|
||
nRetValue = keydownresult_PreventAll;
|
||
}
|
||
break;
|
||
case 8: // backspace
|
||
if (!bCanEdit || oThis.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
nRetValue = keydownresult_PreventAll;
|
||
|
||
// When backspace is pressed, the focus is not in the editor (we erase the contents)
|
||
const oEnterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
oEnterOptions.newText = '';
|
||
oThis.handlers.trigger("editCell", oEnterOptions);
|
||
break;
|
||
|
||
case 46: // Del
|
||
if (!bCanEdit || this.getCellEditMode() || bSelectionDialogMode || bIsSelect) {
|
||
break;
|
||
}
|
||
// Delete the contents
|
||
this.handlers.trigger("empty");
|
||
break;
|
||
|
||
case 9: // tab
|
||
if (oThis.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
// Disable the browser's standard handling of tab pressing
|
||
nRetValue = keydownresult_PreventAll;
|
||
|
||
// Special case (movement in the selected area is possible)
|
||
bSelectionActivePointChanged = true;
|
||
if (bIsSelect) {
|
||
nDeltaColumn = -1; // (shift + tab) - move cells to the left by 1 column
|
||
bIsSelect = false; // Let's drop shift because we're not selecting
|
||
} else {
|
||
oActiveCell = oThis.handlers.trigger("getActiveCell");
|
||
if (oThis.lastTab === null) {
|
||
if (oActiveCell) {
|
||
oThis.lastTab = oActiveCell.c2;
|
||
}
|
||
} else if (!oActiveCell) {
|
||
oThis.lastTab = null;
|
||
}
|
||
nDeltaColumn = +1; // (tab) - move cells to the right by 1 column
|
||
}
|
||
break;
|
||
|
||
case 13: // "enter"
|
||
if (oThis.getCellEditMode() || bSelectionDialogMode) {
|
||
break;
|
||
}
|
||
|
||
if (bCanEdit && (oEvent.CtrlKey || oEvent.AltKey)) {
|
||
oThis.setSkipCellEditor(true);
|
||
const oEnterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
oEnterOptions.focus = true;
|
||
oThis.handlers.trigger("editCell", oEnterOptions);
|
||
break;
|
||
}
|
||
// Special case (movement in the selected area is possible)
|
||
bSelectionActivePointChanged = true;
|
||
if (bIsSelect) {
|
||
nDeltaRow = -1; // (shift + enter) - move up cells by 1 row
|
||
bIsSelect = false; // Let's drop shift because we're not selecting
|
||
oThis.lastTab = null;
|
||
} else {
|
||
if (oThis.lastTab !== null) {
|
||
oActiveCell = oThis.handlers.trigger("getActiveCell");
|
||
if (oActiveCell) {
|
||
nDeltaColumn = oThis.lastTab - oActiveCell.c2;
|
||
} else {
|
||
oThis.lastTab = null;
|
||
}
|
||
}
|
||
nDeltaRow = +1; // (enter) - move down cells by 1 row
|
||
}
|
||
break;
|
||
|
||
case 27: // Esc
|
||
oThis.handlers.trigger("stopFormatPainter");
|
||
oThis.handlers.trigger("stopAddShape");
|
||
oThis.handlers.trigger("cleanCutData", true, true);
|
||
oThis.handlers.trigger("cleanCopyData", true, true);
|
||
oThis.view.Api.cancelEyedropper();
|
||
window['AscCommon'].g_specialPasteHelper.SpecialPasteButton_Hide();
|
||
break;
|
||
|
||
case 144: //Num Lock
|
||
case 145: //Scroll Lock
|
||
if (AscBrowser.isOpera) {
|
||
nRetValue = keydownresult_PreventAll;
|
||
}
|
||
break;
|
||
|
||
case 32: // Spacebar
|
||
if (oThis.getCellEditMode()) {
|
||
break;
|
||
}
|
||
const bIsSelectColumns = oEvent.IsShortcutCtrl() || oEvent.IsCmd();
|
||
if (bIsSelectColumns && bIsSelect && bIsMacOs) {
|
||
break;
|
||
}
|
||
// Disable the browser's standard click handling
|
||
// Ctrl+Shift+Spacebar, Ctrl+Spacebar, Shift+Spacebar
|
||
if (bIsSelectColumns) {
|
||
oThis.handlers.trigger("selectColumnsByRange");
|
||
nRetValue = keydownresult_PreventAll;
|
||
}
|
||
if (bIsSelect) {
|
||
oThis.handlers.trigger("selectRowsByRange");
|
||
nRetValue = keydownresult_PreventAll;
|
||
}
|
||
break;
|
||
case 33: // PageUp
|
||
nDeltaRow = -0.5;
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
nRetValue = keydownresult_PreventAll;
|
||
break;
|
||
|
||
case 34: // PageDown
|
||
nDeltaRow = +0.5;
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
nRetValue = keydownresult_PreventAll;
|
||
break;
|
||
|
||
case 37: // left
|
||
nDeltaColumn = oEvent.CtrlKey ? -1.5 : -1; // Movement with arrows (left-right, up-down)
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
nRetValue = keydownresult_PreventAll; // Disable the browser's standard handling of pressing left
|
||
if (isRightToLeft) {
|
||
nDeltaColumn = -nDeltaColumn;
|
||
}
|
||
break;
|
||
|
||
case 38: // up
|
||
if (bCanEdit && !oThis.getCellEditMode() && !bSelectionDialogMode && oEvent.IsAlt() && oThis.handlers.trigger("onDataValidation")) {
|
||
break;
|
||
}
|
||
nDeltaRow = oEvent.CtrlKey ? -1.5 : -1; // Movement with arrows (left-right, up-down)
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
nRetValue = keydownresult_PreventAll; // Disable the browser's standard handling of pressing up
|
||
break;
|
||
|
||
case 39: // right
|
||
nDeltaColumn = oEvent.CtrlKey ? +1.5 : +1; // Movement with arrows (left-right, up-down)
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
nRetValue = keydownresult_PreventAll; // Disable the browser's standard handling of pressing right
|
||
if (isRightToLeft) {
|
||
nDeltaColumn = -nDeltaColumn;
|
||
}
|
||
break;
|
||
|
||
case 40: // down
|
||
nRetValue = keydownresult_PreventAll; // Disable the browser's standard handling of pressing down
|
||
// Alt + down processing
|
||
if (bCanEdit && !oThis.getCellEditMode() && !bSelectionDialogMode && oEvent.IsAlt()) {
|
||
if (oThis.handlers.trigger("onShowFilterOptionsActiveCell")) {
|
||
break;
|
||
}
|
||
if (oThis.handlers.trigger("onDataValidation")) {
|
||
break;
|
||
}
|
||
oThis.handlers.trigger("showAutoComplete");
|
||
break;
|
||
}
|
||
nDeltaRow = oEvent.CtrlKey ? +1.5 : +1; // Movement with arrows (left-right, up-down)
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
break;
|
||
|
||
case 36: // home
|
||
nRetValue = keydownresult_PreventAll; // Disable the browser's standard handling of pressing home
|
||
if (bIsFormulaEditMode) {
|
||
break;
|
||
}
|
||
nDeltaColumn = -2.5;
|
||
if (oEvent.CtrlKey) {
|
||
nDeltaRow = -2.5;
|
||
}
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
break;
|
||
|
||
case 35: // end
|
||
nRetValue = keydownresult_PreventAll; // Disable the browser's standard handling of pressing end
|
||
if (bIsFormulaEditMode) {
|
||
break;
|
||
}
|
||
nDeltaColumn = 2.5;
|
||
if (oEvent.CtrlKey) {
|
||
nDeltaRow = 2.5;
|
||
}
|
||
bIsNeedCheckActiveCellChanged = true;
|
||
break;
|
||
case 93:
|
||
if (!oEvent.MacCmdKey) {
|
||
nRetValue = keydownresult_PreventAll;
|
||
this.handlers.trigger('onContextMenu', oEvent);
|
||
}
|
||
break;
|
||
default:
|
||
nRetValue = keydownresult_PreventNothing;
|
||
break;
|
||
}
|
||
}
|
||
|
||
let oActiveCellBefore;
|
||
if (bIsNeedCheckActiveCellChanged) {
|
||
oActiveCellBefore = oThis.handlers.trigger("getActiveCell");
|
||
}
|
||
const CheckLastTab = function () {
|
||
if (bIsNeedCheckActiveCellChanged) {
|
||
const oActiveCellAfter = oThis.handlers.trigger("getActiveCell");
|
||
if (!oActiveCellBefore || !oActiveCellAfter || !oActiveCellAfter.isEqual(oActiveCellBefore)) {
|
||
oThis.lastTab = null;
|
||
}
|
||
}
|
||
};
|
||
|
||
if ((nDeltaColumn !== 0 || nDeltaRow !== 0) && false === oThis.handlers.trigger("isGlobalLockEditCell")) {
|
||
const bIsChangeVisibleAreaMode = this.view.Api.isEditVisibleAreaOleEditor;
|
||
if (bIsChangeVisibleAreaMode) {
|
||
oThis.handlers.trigger("changeVisibleArea", !bIsSelect, nDeltaColumn, nDeltaRow, false, function (d) {
|
||
if (oThis.targetInfo) {
|
||
oWb._onUpdateWorksheet(oThis.targetInfo.coordX, oThis.targetInfo.coordY, false);
|
||
}
|
||
oThis.scroll(d);
|
||
const oOleSize = oWb.getOleSize();
|
||
oOleSize.addPointToLocalHistory();
|
||
CheckLastTab();
|
||
}, true);
|
||
} else if (bSelectionActivePointChanged) { // Check for movement in a selected area
|
||
oThis.handlers.trigger("selectionActivePointChanged", nDeltaColumn, nDeltaRow, function (d) {
|
||
oThis.scroll(d);
|
||
CheckLastTab();
|
||
});
|
||
} else {
|
||
oThis.handlers.trigger("changeSelection", /*isStartPoint*/!bIsSelect, nDeltaColumn, nDeltaRow, /*isCoord*/false, false,
|
||
function (d) {
|
||
const oWb = window["Asc"]["editor"].wb;
|
||
if (oThis.targetInfo) {
|
||
oWb._onUpdateWorksheet(oThis.targetInfo.coordX, oThis.targetInfo.coordY, false);
|
||
}
|
||
oThis.scroll(oWs.convertOffsetToSmooth(d));
|
||
CheckLastTab();
|
||
});
|
||
}
|
||
}
|
||
|
||
if (nRetValue & keydownresult_PreventKeyPress) {
|
||
oThis._setSkipKeyPress(true);
|
||
}
|
||
return nRetValue;
|
||
};
|
||
|
||
|
||
/** @param event {AscCommon.CKeyboardEvent} */
|
||
asc_CEventsController.prototype._onWindowKeyPress = function (event) {
|
||
// It is not allowed to return false when events are disabled (this also applies to ViewerMode)
|
||
if (!this.enableKeyEvents) {
|
||
return true;
|
||
}
|
||
|
||
// do not enter text in view mode
|
||
// if false is returned in FF, then further processing of the keydown -> keypress -> keyup series is cancelled
|
||
// and then we will not process ctrl+c and similar events
|
||
if (!this.canEdit() || this.getSelectionDialogMode() || this.view.Api.isEditVisibleAreaOleEditor) {
|
||
return true;
|
||
}
|
||
|
||
// For those browsers that do not send the left mouse button release for double click, when exiting the editor
|
||
// window and releasing the button, we will handle exiting the window (only Chrome sends the MouseUp event even when exiting the browser)
|
||
this.showCellEditorCursor();
|
||
|
||
// Cannot enter when selecting or when performing actions on an object
|
||
if (this.getCellEditMode() && !this.hasFocus || this.isSelectMode ||
|
||
!this.handlers.trigger('canReceiveKeyPress')) {
|
||
return true;
|
||
}
|
||
|
||
if (this.skipKeyPress || event.KeyCode < 32) {
|
||
this._setSkipKeyPress(true);
|
||
return true;
|
||
}
|
||
|
||
if (!this.getCellEditMode()) {
|
||
if (this.handlers.trigger("graphicObjectWindowKeyPress", event)) {
|
||
return true;
|
||
}
|
||
|
||
// When a symbol is pressed, we do not set the focus and clear the contents of the cell
|
||
var enterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
enterOptions.newText = '';
|
||
enterOptions.quickInput = true;
|
||
this.handlers.trigger("editCell", enterOptions);
|
||
}
|
||
return true;
|
||
};
|
||
|
||
asc_CEventsController.prototype.EnterText = function (codePoints) {
|
||
//TODO is almost a copy of _onWindowKeyPress - after the EnterText function is enabled - check and merge the functions
|
||
// It is impossible to return false when events are disabled (this also applies to ViewerMode)
|
||
if (!this.enableKeyEvents) {
|
||
return true;
|
||
}
|
||
|
||
// do not enter text in view mode
|
||
// if false is returned in FF, then further processing of the keydown -> keypress -> keyup series is cancelled
|
||
// and then we will not process ctrl+c and similar events
|
||
if (!this.canEdit() || this.getSelectionDialogMode() || this.view.Api.isEditVisibleAreaOleEditor) {
|
||
return true;
|
||
}
|
||
|
||
// For those browsers that do not send the left mouse button release for double click, when exiting the editor window and releasing the button,
|
||
// we will handle exiting the window (only Chrome sends the MouseUp event even when exiting the browser)
|
||
this.showCellEditorCursor();
|
||
|
||
// Cannot enter when selecting or when performing actions on an object
|
||
if (this.getCellEditMode() && !this.hasFocus || this.isSelectMode ||
|
||
!this.handlers.trigger('canReceiveKeyPress')) {
|
||
return true;
|
||
}
|
||
|
||
/*if (this.skipKeyPress) {
|
||
this._setSkipKeyPress(true);
|
||
return true;
|
||
}*/
|
||
|
||
if (!this.getCellEditMode()) {
|
||
if (this.handlers.trigger("graphicObjectWindowEnterText", codePoints)) {
|
||
return true;
|
||
}
|
||
|
||
// When a symbol is pressed, we do not set the focus and clear the contents of the cell
|
||
var enterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
enterOptions.newText = '';
|
||
enterOptions.quickInput = true;
|
||
this.handlers.trigger("editCell", enterOptions);
|
||
}
|
||
return true;
|
||
};
|
||
|
||
/** @param event {AscCommon.CKeyboardEvent} */
|
||
asc_CEventsController.prototype._onWindowKeyUp = function (event) {
|
||
// When you release shift, you need to send the selection information
|
||
if (16 === event.KeyCode) {
|
||
this.handlers.trigger("updateSelectionName");
|
||
}
|
||
this.handlers.trigger("graphicObjectWindowKeyUp", event);
|
||
|
||
return true;
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onWindowMouseMove = function (event) {
|
||
var coord = this._getCoordinates(event);
|
||
|
||
if (this.isSelectMode && !this.hasCursor) {
|
||
this._changeSelection2(event);
|
||
}
|
||
if (this.isChangeVisibleAreaMode && !this.hasCursor) {
|
||
this._continueChangeVisibleArea2(event);
|
||
}
|
||
if (this.isResizeMode && !this.hasCursor) {
|
||
this.isResizeModeMove = true;
|
||
this._resizeElement(event);
|
||
}
|
||
if (this.hsbApiLockMouse)
|
||
this.hsbApi.mouseDown ? this.hsbApi.evt_mousemove.call(this.hsbApi, event) : false;
|
||
else if (this.vsbApiLockMouse)
|
||
this.vsbApi.mouseDown ? this.vsbApi.evt_mousemove.call(this.vsbApi, event) : false;
|
||
|
||
// Pinned Areas Setup Mode
|
||
if (this.frozenAnchorMode) {
|
||
this._moveFrozenAnchorHandle(event, this.frozenAnchorMode);
|
||
return true;
|
||
}
|
||
|
||
if (this.isShapeAction) {
|
||
event.isLocked = this.isMousePressed;
|
||
this.handlers.trigger("graphicObjectMouseMove", event, coord.x, coord.y);
|
||
}
|
||
|
||
if (this.isRowGroup) {
|
||
if (!this._groupRowClick(event, this.targetInfo)) {
|
||
this.isRowGroup = false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onWindowMouseUp = function (event) {
|
||
AscCommon.global_mouseEvent.UnLockMouse();
|
||
|
||
var button = AscCommon.getMouseButton(event);
|
||
var coord = this._getCoordinates(event);
|
||
if (this.hsbApiLockMouse)
|
||
this.hsbApi.mouseDown ? this.hsbApi.evt_mouseup.call(this.hsbApi, event) : false;
|
||
else if (this.vsbApiLockMouse)
|
||
this.vsbApi.mouseDown ? this.vsbApi.evt_mouseup.call(this.vsbApi, event) : false;
|
||
|
||
this.isMousePressed = false;
|
||
// Shapes
|
||
if (this.isShapeAction) {
|
||
if (!this.isUpOnCanvas) {
|
||
let oDrawingsController = this.view.getWorksheet().objectRender.controller;
|
||
if (oDrawingsController.haveTrackedObjects()) {
|
||
event.isLocked = this.isMousePressed;
|
||
event.ClickCount = this.clickCounter.clickCount;
|
||
event.fromWindow = true;
|
||
this.handlers.trigger("graphicObjectMouseUp", event, coord.x, coord.y);
|
||
this._changeSelectionDone(event);
|
||
}
|
||
}
|
||
this.isUpOnCanvas = false;
|
||
return true;
|
||
}
|
||
|
||
if (this.isChangeVisibleAreaMode) {
|
||
this.isChangeVisibleAreaMode = false;
|
||
const oOleSize = this.view.getOleSize();
|
||
oOleSize.addPointToLocalHistory();
|
||
}
|
||
|
||
if (this.isSelectMode) {
|
||
this.isSelectMode = false;
|
||
this._changeSelectionDone(event);
|
||
}
|
||
|
||
if (this.isResizeMode) {
|
||
this.isResizeMode = false;
|
||
this._resizeElementDone(event);
|
||
}
|
||
|
||
// Autofill mode
|
||
if (this.isFillHandleMode) {
|
||
// Finished autofilling
|
||
this.isFillHandleMode = false;
|
||
if (2 === button && this.handlers.trigger('isRightClickFill')) {
|
||
this.handlers.trigger('onContextMenu', event, Asc.c_oAscContextMenuTypes.changeSeries);
|
||
} else {
|
||
this._changeFillHandleDone(event);
|
||
}
|
||
}
|
||
|
||
// Range Shift Mode
|
||
if (this.isMoveRangeMode) {
|
||
// Finished moving the range
|
||
this.isMoveRangeMode = false;
|
||
this._moveRangeHandleDone(event);
|
||
}
|
||
|
||
if (this.isMoveResizeRange) {
|
||
this.isMoveResizeRange = false;
|
||
this._moveResizeRangeHandleDone(this.targetInfo && this.targetInfo.isPageBreakPreview);
|
||
}
|
||
// Pinned Areas Setup Mode
|
||
if (this.frozenAnchorMode) {
|
||
this._moveFrozenAnchorHandleDone(event, this.frozenAnchorMode);
|
||
this.frozenAnchorMode = false;
|
||
}
|
||
|
||
// We may not work on dblClick if we left the area and released the mouse button, we need to work on it
|
||
this.showCellEditorCursor();
|
||
|
||
|
||
return true;
|
||
};
|
||
|
||
/**
|
||
*
|
||
* @param event
|
||
* @param x
|
||
* @param y
|
||
*/
|
||
asc_CEventsController.prototype._onWindowMouseUpExternal = function (event, x, y) {
|
||
// ToDo should be reworked into a normal scheme, for now we will write it directly in the event
|
||
if (null != x && null != y)
|
||
event.coord = {x: x, y: y};
|
||
this._onWindowMouseUp(event);
|
||
|
||
if (window.g_asc_plugins)
|
||
window.g_asc_plugins.onExternalMouseUp();
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onWindowMouseLeaveOut = function (event) {
|
||
// When there is nothing to process, we leave.
|
||
if (!this.isDoBrowserDblClick)
|
||
return true;
|
||
|
||
var relatedTarget = event.relatedTarget || event.fromElement;
|
||
// If we move along the cell editor, we don’t remove anything.
|
||
if (relatedTarget && ("ce-canvas-outer" === relatedTarget.id ||
|
||
"ce-canvas" === relatedTarget.id || "ce-canvas-overlay" === relatedTarget.id ||
|
||
"ce-cursor" === relatedTarget.id || "ws-canvas-overlay" === relatedTarget.id))
|
||
return true;
|
||
|
||
// For those browsers that do not send the left mouse button release for double click, when exiting the editor window
|
||
// and releasing the button, we will handle exiting the window (only Chrome sends the MouseUp event even when exiting the browser)
|
||
this.showCellEditorCursor();
|
||
return true;
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onMouseDown = function (event) {
|
||
let touchManager = this.view.Api.wb.MobileTouchManager;
|
||
if (touchManager && touchManager.checkTouchEvent(event))
|
||
{
|
||
touchManager.startTouchingInProcess();
|
||
let res = touchManager.mainOnTouchStart(event);
|
||
touchManager.stopTouchingInProcess();
|
||
return res;
|
||
}
|
||
if (touchManager)
|
||
touchManager.checkMouseFocus(event);
|
||
|
||
var t = this;
|
||
asc["editor"].checkInterfaceElementBlur();
|
||
var ctrlKey = !AscCommon.getAltGr(event) && (event.metaKey || event.ctrlKey);
|
||
var coord = t._getCoordinates(event);
|
||
var button = AscCommon.getMouseButton(event);
|
||
event.isLocked = t.isMousePressed = true;
|
||
this.isShapeAction = false;
|
||
// Shapes
|
||
var graphicsInfo = t.handlers.trigger("getGraphicsInfo", coord.x, coord.y);
|
||
if (!graphicsInfo) {
|
||
// Update state for device without cursor
|
||
this._onMouseMove(event);
|
||
}
|
||
|
||
if (this.view.Api.isEditVisibleAreaOleEditor) {
|
||
if (button === 0 && this.view.isInnerOfWorksheet(coord.x, coord.y)) {
|
||
if (this.targetInfo && this.targetInfo.target === c_oTargetType.MoveResizeRange) {
|
||
t._moveResizeRangeHandle(event, t.targetInfo);
|
||
t.isMoveResizeRange = true;
|
||
} else {
|
||
this._startChangeVisibleArea(event);
|
||
this.isChangeVisibleAreaMode = true;
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (AscCommon.g_inputContext) {
|
||
AscCommon.g_inputContext.externalChangeFocus();
|
||
}
|
||
|
||
AscCommon.global_mouseEvent.LockMouse();
|
||
AscCommon.capturePointer(event, this.element);
|
||
|
||
if (t.view.Api.isEyedropperStarted()) {
|
||
return;
|
||
}
|
||
if (t.handlers.trigger("isGlobalLockEditCell")) {
|
||
return;
|
||
}
|
||
|
||
if (!this.enableKeyEvents) {
|
||
t.handlers.trigger("canvasClick");
|
||
}
|
||
|
||
if (!(asc["editor"].isStartAddShape || asc["editor"].isInkDrawerOn() || this.getSelectionDialogMode() || this.getCellEditMode() && !this.handlers.trigger("stopCellEditing"))) {
|
||
const isPlaceholder = t.handlers.trigger("onPointerDownPlaceholder", coord.x, coord.y);
|
||
if (isPlaceholder) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
// do not work with drawings in selection dialog mode
|
||
if (!this.getSelectionDialogMode()) {
|
||
if (asc["editor"].isStartAddShape || asc["editor"].isInkDrawerOn() || graphicsInfo) {
|
||
|
||
|
||
if (this.getCellEditMode() && !this.handlers.trigger("stopCellEditing")) {
|
||
return;
|
||
}
|
||
|
||
t.isShapeAction = true;
|
||
t.isUpOnCanvas = false;
|
||
|
||
|
||
t.clickCounter.mouseDownEvent(coord.x, coord.y, button);
|
||
event.ClickCount = t.clickCounter.clickCount;
|
||
if (0 === event.ClickCount % 2) {
|
||
t.isDblClickInMouseDown = true;
|
||
}
|
||
|
||
t.handlers.trigger("graphicObjectMouseDown", event, coord.x, coord.y);
|
||
t.handlers.trigger("updateSelectionShape", /*isSelectOnShape*/true);
|
||
return;
|
||
}
|
||
}
|
||
|
||
|
||
if (2 === event.detail) {
|
||
// This means that it is MouseDown for dblClick event (it does not need to be processed)
|
||
// The order of events for dblClick is http://javascript.ru/tutorial/events/mouse#dvoynoy-levyy-klik
|
||
|
||
// Check for IE, because it sends DblClick when the mouse moves...
|
||
if (this.mouseDownLastCord && coord.x === this.mouseDownLastCord.x && coord.y === this.mouseDownLastCord.y &&
|
||
0 === button && !this.handlers.trigger('isFormatPainter')) {
|
||
// We show that we have already done dblClick (otherwise the browser suddenly does not support the detail property)
|
||
this.isDblClickInMouseDown = true;
|
||
// We need to handle the browser event about dblClick (if we edit a cell, then we will show the cursor, if not, then nothing will happen)
|
||
this.isDoBrowserDblClick = true;
|
||
this.doMouseDblClick(event);
|
||
// We reset the coordinates
|
||
this.mouseDownLastCord = null;
|
||
return;
|
||
}
|
||
}
|
||
// For IE preventDefault is not necessary
|
||
if (!(AscBrowser.isIE || AscBrowser.isOpera)) {
|
||
if (event.preventDefault) {
|
||
event.preventDefault();
|
||
} else {
|
||
event.returnValue = false;
|
||
}
|
||
}
|
||
|
||
// Remember the coordinates of the click
|
||
this.mouseDownLastCord = coord;
|
||
|
||
if (!t.getCellEditMode() && !t.getSelectionDialogMode()) {
|
||
this.gotFocus(true);
|
||
if (event.shiftKey && !(t.targetInfo.target === c_oTargetType.ColumnRowHeaderMove && this.canEdit())) {
|
||
t.isSelectMode = true;
|
||
t._changeSelection(event);
|
||
return;
|
||
}
|
||
if (t.targetInfo) {
|
||
if ((t.targetInfo.target === c_oTargetType.ColumnResize ||
|
||
t.targetInfo.target === c_oTargetType.RowResize) && 0 === button) {
|
||
t.isResizeMode = true;
|
||
t._resizeElement(event);
|
||
return;
|
||
} else if (t.targetInfo.target === c_oTargetType.FillHandle && this.canEdit()) {
|
||
// In autofill mode
|
||
this.isFillHandleMode = true;
|
||
t._changeFillHandle(event, null, t.targetInfo.tableIndex);
|
||
return;
|
||
} else if (t.targetInfo.target === c_oTargetType.MoveRange && this.canEdit()) {
|
||
// In range moving mode
|
||
this.isMoveRangeMode = true;
|
||
t._moveRangeHandle(event);
|
||
return;
|
||
} else if (t.targetInfo.target === c_oTargetType.FilterObject) {
|
||
if (0 === button) {
|
||
if (t.targetInfo.isDataValidation) {
|
||
this.handlers.trigger('onDataValidation');
|
||
} else if (t.targetInfo.idPivot) {
|
||
this.handlers.trigger("pivotFiltersClick", t.targetInfo.idPivot);
|
||
} else if (t.targetInfo.idPivotCollapse) {
|
||
this.handlers.trigger("pivotCollapseClick", t.targetInfo.idPivotCollapse);
|
||
} else if (t.targetInfo.idTableTotal) {
|
||
this.handlers.trigger("tableTotalClick", t.targetInfo.idTableTotal);
|
||
} else {
|
||
this.handlers.trigger("autoFiltersClick", t.targetInfo.idFilter);
|
||
}
|
||
}
|
||
event.preventDefault && event.preventDefault();
|
||
event.stopPropagation && event.stopPropagation();
|
||
return;
|
||
} else if (t.targetInfo.commentIndexes) {
|
||
t._commentCellClick(event);
|
||
} else if (t.targetInfo.target === c_oTargetType.MoveResizeRange && this.canEdit()) {
|
||
this.isMoveResizeRange = true;
|
||
t._moveResizeRangeHandle(event, t.targetInfo);
|
||
return;
|
||
} else if ((t.targetInfo.target === c_oTargetType.FrozenAnchorV ||
|
||
t.targetInfo.target === c_oTargetType.FrozenAnchorH) && this.canEdit()) {
|
||
// Pinned Areas Setup Mode
|
||
this.frozenAnchorMode = t.targetInfo.target;
|
||
t._moveFrozenAnchorHandle(event, this.frozenAnchorMode);
|
||
return;
|
||
} else if (t.targetInfo.target === c_oTargetType.GroupRow && 0 === button) {
|
||
if (t._groupRowClick(event, t.targetInfo)) {
|
||
t.isRowGroup = true;
|
||
}
|
||
return;
|
||
} else if (t.targetInfo.target === c_oTargetType.GroupCol && 0 === button) {
|
||
if (t._groupRowClick(event, t.targetInfo)) {
|
||
t.isRowGroup = true;
|
||
}
|
||
return;
|
||
} else if ((t.targetInfo.target === c_oTargetType.GroupCol || t.targetInfo.target === c_oTargetType.GroupRow) && 2 === button) {
|
||
this.handlers.trigger('onContextMenu', null);
|
||
return;
|
||
} else if (t.targetInfo.target === c_oTargetType.TableSelectionChange) {
|
||
this.handlers.trigger('onChangeTableSelection', t.targetInfo);
|
||
return;
|
||
} else if (t.targetInfo.target === c_oTargetType.TraceDependents) {
|
||
// if we do a single click on traces, do nothing
|
||
return;
|
||
}
|
||
}
|
||
} else {
|
||
if (this.getFormulaEditMode()) {
|
||
if (this.targetInfo && this.targetInfo.target === c_oTargetType.MoveResizeRange) {
|
||
this.isMoveResizeRange = true;
|
||
this._moveResizeRangeHandle(event, this.targetInfo);
|
||
return;
|
||
} else if (this.targetInfo && this.targetInfo.target === c_oTargetType.FillHandle) {
|
||
return;
|
||
}
|
||
|
||
if (2 === button) {
|
||
return;
|
||
}
|
||
} else {
|
||
if (!this.handlers.trigger("stopCellEditing")) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
this.gotFocus(true);
|
||
|
||
if (event.shiftKey) {
|
||
this.isSelectMode = true;
|
||
this._changeSelection(event);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// If you press the right mouse button, then we will change the selection only if we are not in the selected area
|
||
if (2 === button) {
|
||
this.handlers.trigger("changeSelectionRightClick", coord.x, coord.y, this.targetInfo && this.targetInfo.target);
|
||
this.handlers.trigger('onContextMenu', event);
|
||
} else {
|
||
if (this.targetInfo && this.targetInfo.target === c_oTargetType.FillHandle && this.canEdit()) {
|
||
// In autofill mode
|
||
this.isFillHandleMode = true;
|
||
this._changeFillHandle(event, null, t.targetInfo.tableIndex);
|
||
} else {
|
||
if (this.targetInfo && this.targetInfo.target === c_oTargetType.ColumnRowHeaderMove) {
|
||
this.isMoveRangeMode = true;
|
||
t._moveRangeHandle(event, null, {ctrlKey: ctrlKey, shiftKey: event.shiftKey});
|
||
t.handlers.trigger("updateWorksheet", coord.x, coord.y);
|
||
//t.handlers.trigger("updateWorksheet", coord.x, coord.y, ctrlKey, function(info){t.targetInfo = info;});
|
||
} else {
|
||
this.isSelectMode = true;
|
||
this.handlers.trigger("changeSelection", /*isStartPoint*/true, coord.x, coord.y, /*isCoord*/true,
|
||
ctrlKey);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onMouseUp = function (event) {
|
||
let touchManager = this.view.Api.wb.MobileTouchManager;
|
||
if (touchManager && touchManager.checkTouchEvent(event))
|
||
{
|
||
touchManager.startTouchingInProcess();
|
||
let res = touchManager.mainOnTouchEnd(event);
|
||
touchManager.stopTouchingInProcess();
|
||
return res;
|
||
}
|
||
|
||
var button = AscCommon.getMouseButton(event);
|
||
AscCommon.global_mouseEvent.UnLockMouse();
|
||
|
||
if (this.isChangeVisibleAreaMode) {
|
||
this.isChangeVisibleAreaMode = false;
|
||
const oOleSize = this.view.getOleSize();
|
||
oOleSize.addPointToLocalHistory();
|
||
}
|
||
|
||
var coord = this._getCoordinates(event);
|
||
// Shapes
|
||
event.isLocked = this.isMousePressed = false;
|
||
if (2 === button) {
|
||
if (this.isShapeAction) {
|
||
event.ClickCount = this.clickCounter.clickCount;
|
||
this.handlers.trigger("graphicObjectMouseUp", event, coord.x, coord.y);
|
||
this.handlers.trigger('onContextMenu', event);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
if (this.view.Api.isEyedropperStarted()) {
|
||
this.view.Api.finishEyedropper();
|
||
var t = this;
|
||
t.handlers.trigger("updateWorksheet", coord.x, coord.y, false, function (info) {
|
||
t.targetInfo = info;
|
||
});
|
||
return true;
|
||
}
|
||
|
||
if (this.isShapeAction) {
|
||
event.ClickCount = this.clickCounter.clickCount;
|
||
this.handlers.trigger("graphicObjectMouseUp", event, coord.x, coord.y);
|
||
this._changeSelectionDone(event);
|
||
if (asc["editor"].isStartAddShape || asc["editor"].isInkDrawerOn()) {
|
||
event.preventDefault && event.preventDefault();
|
||
event.stopPropagation && event.stopPropagation();
|
||
} else {
|
||
this.isUpOnCanvas = true;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
if (this.isSelectMode) {
|
||
this.isSelectMode = false;
|
||
this._changeSelectionDone(event);
|
||
}
|
||
|
||
if (this.isResizeMode) {
|
||
this.isResizeMode = false;
|
||
this._resizeElementDone(event);
|
||
}
|
||
// Autofill mode
|
||
if (this.isFillHandleMode) {
|
||
// Finished autofilling
|
||
this.isFillHandleMode = false;
|
||
this._changeFillHandleDone(event);
|
||
}
|
||
// Range Shift Mode
|
||
if (this.isMoveRangeMode) {
|
||
this.isMoveRangeMode = false;
|
||
this._moveRangeHandleDone(event);
|
||
}
|
||
|
||
if (this.isMoveResizeRange) {
|
||
this.isMoveResizeRange = false;
|
||
this._moveResizeRangeHandleDone(this.targetInfo && this.targetInfo.pageBreakSelectionType);
|
||
return true;
|
||
}
|
||
// Pinned Areas Setup Mode
|
||
if (this.frozenAnchorMode) {
|
||
this._moveFrozenAnchorHandleDone(event, this.frozenAnchorMode);
|
||
this.frozenAnchorMode = false;
|
||
}
|
||
|
||
if (this.isRowGroup/* && this.targetInfo && this.targetInfo.target === c_oTargetType.GroupRow && 0 === event.button*/) {
|
||
this._groupRowClick(event, this.targetInfo);
|
||
this.isRowGroup = false;
|
||
return;
|
||
}
|
||
|
||
if (this.targetInfo && this.targetInfo.target === c_oTargetType.ColumnHeader) {
|
||
this._onMouseMove(event);
|
||
}
|
||
|
||
// We may not work on dblClick if we left the area and released the mouse button, we need to work on it
|
||
this.showCellEditorCursor();
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onMouseMove = function (event) {
|
||
let touchManager = this.view.Api.wb.MobileTouchManager;
|
||
if (touchManager && touchManager.checkTouchEvent(event))
|
||
{
|
||
touchManager.startTouchingInProcess();
|
||
let res = touchManager.mainOnTouchMove(event);
|
||
touchManager.stopTouchingInProcess();
|
||
return res;
|
||
}
|
||
|
||
var t = this;
|
||
var ctrlKey = !AscCommon.getAltGr(event) && (event.metaKey || event.ctrlKey);
|
||
var coord = t._getCoordinates(event);
|
||
|
||
t.hasCursor = true;
|
||
|
||
if (t.view.Api.isEyedropperStarted()) {
|
||
t.view.Api.checkEyedropperColor(coord.x, coord.y);
|
||
t.handlers.trigger("updateWorksheet", coord.x, coord.y, ctrlKey, function (info) {
|
||
t.targetInfo = info;
|
||
});
|
||
return true;
|
||
}
|
||
// Shapes
|
||
var graphicsInfo = t.handlers.trigger("getGraphicsInfo", coord.x, coord.y);
|
||
if (graphicsInfo)
|
||
this.clickCounter.mouseMoveEvent(coord.x, coord.y);
|
||
|
||
if (t.isSelectMode) {
|
||
t._changeSelection(event);
|
||
return true;
|
||
}
|
||
|
||
if (t.isChangeVisibleAreaMode) {
|
||
t._continueChangeVisibleArea(event);
|
||
return true;
|
||
}
|
||
|
||
if (t.isResizeMode) {
|
||
t._resizeElement(event);
|
||
this.isResizeModeMove = true;
|
||
return true;
|
||
}
|
||
|
||
// Autofill mode
|
||
if (t.isFillHandleMode) {
|
||
t._changeFillHandle(event);
|
||
return true;
|
||
}
|
||
|
||
// Range Shift Mode
|
||
if (t.isMoveRangeMode) {
|
||
t._moveRangeHandle(event);
|
||
return true;
|
||
}
|
||
|
||
if (t.isMoveResizeRange) {
|
||
t._moveResizeRangeHandle(event, t.targetInfo);
|
||
return true;
|
||
}
|
||
|
||
// Pinned Areas Setup Mode
|
||
if (t.frozenAnchorMode) {
|
||
t._moveFrozenAnchorHandle(event, this.frozenAnchorMode);
|
||
return true;
|
||
}
|
||
|
||
if (t.isShapeAction || graphicsInfo || asc["editor"].isInkDrawerOn()) {
|
||
event.isLocked = t.isMousePressed;
|
||
t.handlers.trigger("graphicObjectMouseMove", event, coord.x, coord.y);
|
||
t.handlers.trigger("updateWorksheet", coord.x, coord.y, ctrlKey, function (info) {
|
||
t.targetInfo = info;
|
||
});
|
||
return true;
|
||
}
|
||
|
||
t.handlers.trigger("updateWorksheet", coord.x, coord.y, ctrlKey, function (info) {
|
||
t.targetInfo = info;
|
||
});
|
||
return true;
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onMouseLeave = function (event) {
|
||
var t = this;
|
||
var coord = t._getCoordinates(event);
|
||
this.hasCursor = false;
|
||
if (!this.isSelectMode && !this.isResizeMode && !this.isMoveResizeRange) {
|
||
this.targetInfo = undefined;
|
||
this.handlers.trigger("updateWorksheet", coord.x, coord.y);
|
||
}
|
||
if (this.isMoveRangeMode) {
|
||
t.moveRangeTimerId = window.setTimeout(function () {
|
||
t._moveRangeHandle2(event)
|
||
}, 0);
|
||
}
|
||
if (this.isMoveResizeRange) {
|
||
t.moveResizeRangeTimerId = window.setTimeout(function () {
|
||
t._moveResizeRangeHandle2(event)
|
||
}, 0);
|
||
}
|
||
if (this.isFillHandleMode) {
|
||
t.fillHandleModeTimerId = window.setTimeout(function () {
|
||
t._changeFillHandle2(event)
|
||
}, 0);
|
||
}
|
||
if (t.view.Api.isEyedropperStarted()) {
|
||
this.view.Api.sendEvent("asc_onHideEyedropper");
|
||
}
|
||
return true;
|
||
};
|
||
|
||
/** @param event {MouseEvent} */
|
||
asc_CEventsController.prototype._onMouseWheel = function (event) {
|
||
var ctrlKey = !AscCommon.getAltGr(event) && (event.metaKey || event.ctrlKey);
|
||
if (ctrlKey) {
|
||
if (event.preventDefault) {
|
||
event.preventDefault();
|
||
} else {
|
||
event.returnValue = false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
if (this.isFillHandleMode || this.isMoveRangeMode || this.isMoveResizeRange || this.isChangeVisibleAreaMode) {
|
||
return true;
|
||
}
|
||
|
||
if (undefined !== window["AscDesktopEditor"]) {
|
||
if (false === window["AscDesktopEditor"]["CheckNeedWheel"]())
|
||
return true;
|
||
}
|
||
|
||
var self = this;
|
||
var deltaX = 0, deltaY = 0;
|
||
|
||
//TODO!!! while only check direction. need refactor, and replace up code on checkMouseWhell function
|
||
let values = AscCommon.checkMouseWhell(event, {
|
||
isSupportBidirectional : false,
|
||
isAllowHorizontal : true,
|
||
isUseMaximumDelta : true
|
||
});
|
||
|
||
const wb = window["Asc"]["editor"].wb;
|
||
//TODO for mac touchpads. need review
|
||
if (wb.smoothScroll && AscCommon.AscBrowser.isMacOs) {
|
||
deltaX = (values.x / wb.getWorksheet().getHScrollStep()) * AscCommon.AscBrowser.retinaPixelRatio;
|
||
deltaY = (values.y / wb.getWorksheet().getVScrollStep()) * AscCommon.AscBrowser.retinaPixelRatio;
|
||
} else {
|
||
if (undefined !== event.wheelDelta && 0 !== event.wheelDelta) {
|
||
deltaY = -1 * event.wheelDelta / 40;
|
||
} else if (undefined !== event.detail && 0 !== event.detail) {
|
||
// FF
|
||
deltaY = event.detail;
|
||
} else if (undefined !== event.deltaY && 0 !== event.deltaY) {
|
||
// FF
|
||
//limiting step due to incorrect deltaY value after FF update
|
||
//TODO needs to be revised. correct values are needed and taking into account the system step.
|
||
var _maxDelta = 3;
|
||
if (AscCommon.AscBrowser.isMozilla && Math.abs(event.deltaY) > _maxDelta) {
|
||
deltaY = Math.sign(event.deltaY) * _maxDelta;
|
||
} else {
|
||
deltaY = event.deltaY;
|
||
}
|
||
}
|
||
if (undefined !== event.deltaX && 0 !== event.deltaX) {
|
||
deltaX = event.deltaX;
|
||
}
|
||
if (event.axis !== undefined && event.axis === event.HORIZONTAL_AXIS) {
|
||
deltaX = deltaY;
|
||
deltaY = 0;
|
||
}
|
||
|
||
if (undefined !== event.wheelDeltaX && 0 !== event.wheelDeltaX) {
|
||
// Webkit
|
||
deltaX = -1 * event.wheelDeltaX / 40;
|
||
}
|
||
if (undefined !== event.wheelDeltaY && 0 !== event.wheelDeltaY) {
|
||
// Webkit
|
||
deltaY = -1 * event.wheelDeltaY / 40;
|
||
}
|
||
}
|
||
|
||
if (values.x === 0) {
|
||
deltaX = 0;
|
||
}
|
||
if (values.y === 0) {
|
||
deltaY = 0;
|
||
}
|
||
|
||
if (!AscCommon.AscBrowser.isMacOs && event.shiftKey) {
|
||
deltaX = deltaY;
|
||
deltaY = 0;
|
||
}
|
||
|
||
if (this.smoothWheelCorrector && !wb.smoothScroll) {
|
||
deltaX = this.smoothWheelCorrector.get_DeltaX(deltaX);
|
||
deltaY = this.smoothWheelCorrector.get_DeltaY(deltaY);
|
||
}
|
||
if (this.handlers.trigger("graphicObjectMouseWheel", deltaX, deltaY)) {
|
||
self._onMouseMove(event);
|
||
AscCommon.stopEvent(event);
|
||
return true;
|
||
}
|
||
|
||
this.handlers.trigger("updateWorksheet", /*x*/undefined, /*y*/undefined, /*ctrlKey*/undefined,
|
||
function () {
|
||
if (deltaX && (!self.smoothWheelCorrector || !self.smoothWheelCorrector.isBreakX())) {
|
||
if (!wb.smoothScroll) {
|
||
deltaX = Math.sign(deltaX) * Math.ceil(Math.abs(deltaX / 3));
|
||
}
|
||
self.scrollHorizontal(deltaX, event);
|
||
}
|
||
if (deltaY && (!self.smoothWheelCorrector || !self.smoothWheelCorrector.isBreakY())) {
|
||
if (!wb.smoothScroll) {
|
||
deltaY = Math.sign(deltaY) * Math.ceil(Math.abs(deltaY * self.settings.wheelScrollLinesV / 3));
|
||
}
|
||
self.scrollVertical(deltaY, event);
|
||
}
|
||
self._onMouseMove(event);
|
||
});
|
||
|
||
this.smoothWheelCorrector && this.smoothWheelCorrector.checkBreak();
|
||
AscCommon.stopEvent(event);
|
||
return true;
|
||
};
|
||
|
||
/** @param event {KeyboardEvent} */
|
||
asc_CEventsController.prototype._onMouseDblClick = function (event) {
|
||
if (this.handlers.trigger('isGlobalLockEditCell') || this.handlers.trigger('isFormatPainter')) {
|
||
return false;
|
||
}
|
||
|
||
// The browser does not support the detail property (we will do it by coordinates)
|
||
if (false === this.isDblClickInMouseDown) {
|
||
return this.doMouseDblClick(event);
|
||
}
|
||
|
||
this.isDblClickInMouseDown = false;
|
||
|
||
// Need to handle cursor display if dblClick was handled in MouseDown
|
||
this.showCellEditorCursor();
|
||
return true;
|
||
};
|
||
|
||
/** @param event */
|
||
asc_CEventsController.prototype._getCoordinates = function (event) {
|
||
// ToDo needs to be redone
|
||
if (event.coord) {
|
||
return event.coord;
|
||
}
|
||
|
||
var offs = AscCommon.UI.getBoundingClientRect(this.element);
|
||
var x = ((event.pageX * AscBrowser.zoom) >> 0) - offs.left;
|
||
var y = ((event.pageY * AscBrowser.zoom) >> 0) - offs.top;
|
||
|
||
x *= AscCommon.AscBrowser.retinaPixelRatio;
|
||
y *= AscCommon.AscBrowser.retinaPixelRatio;
|
||
|
||
return {x: x, y: y};
|
||
};
|
||
|
||
asc_CEventsController.prototype._setSkipKeyPress = function (val) {
|
||
this.skipKeyPress = val;
|
||
};
|
||
|
||
asc_CEventsController.prototype.showHorizontalScroll = function (val) {
|
||
if (!this.hsb || !this.hsb.style) {
|
||
return;
|
||
}
|
||
let toVisibility = val ? "visible" : "hidden";
|
||
let res;
|
||
if (this.hsb.style.visibility === toVisibility) {
|
||
res = false;
|
||
} else {
|
||
this.hsb.style.visibility = toVisibility;
|
||
res = true;
|
||
}
|
||
|
||
let isVisibleVerScroll = this.view.getShowVerticalScroll();
|
||
let scrollWidth = this.view && this.view.defaults && this.view.defaults.scroll ? this.view.defaults.scroll.widthPx : 14;
|
||
|
||
this.hsb.style.right = isVisibleVerScroll ? scrollWidth + "px" : "0px";
|
||
|
||
if (!this.view.Api.isMobileVersion) {
|
||
let cornerStyle = val && isVisibleVerScroll ? "visible" : "hidden";
|
||
let corner = document.getElementById("ws-scrollbar-corner");
|
||
if (corner) {
|
||
corner.style.visibility = cornerStyle;
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
|
||
asc_CEventsController.prototype.showVerticalScroll = function (val) {
|
||
if (!this.vsb || !this.vsb.style) {
|
||
return;
|
||
}
|
||
|
||
let toVisibility = val ? "visible" : "hidden";
|
||
let res;
|
||
if (this.vsb.style.visibility === toVisibility) {
|
||
res = false;
|
||
} else {
|
||
this.vsb.style.visibility = toVisibility;
|
||
res = true;
|
||
}
|
||
this.vsb.style.visibility = toVisibility;
|
||
let isVisibleHorScroll = this.view.getShowHorizontalScroll();
|
||
let scrollWidth = this.view && this.view.defaults && this.view.defaults.scroll ? this.view.defaults.scroll.heightPx : 14;
|
||
|
||
this.vsb.style.bottom = isVisibleHorScroll ? scrollWidth + "px" : "0px";
|
||
|
||
if (!this.view.Api.isMobileVersion) {
|
||
let cornerStyle = val && isVisibleHorScroll ? "visible" : "hidden";
|
||
let corner = document.getElementById("ws-scrollbar-corner");
|
||
if (corner) {
|
||
corner.style.visibility = cornerStyle;
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
|
||
asc_CEventsController.prototype.setSkipCellEditor = function (val) {
|
||
this.skipCellEditor = val;
|
||
};
|
||
|
||
//------------------------------------------------------------export---------------------------------------------------
|
||
window['AscCommonExcel'] = window['AscCommonExcel'] || {};
|
||
window["AscCommonExcel"].asc_CEventsController = asc_CEventsController;
|
||
}
|
||
)(jQuery, window);
|