7772 lines
274 KiB
JavaScript
7772 lines
274 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 {Window} window
|
||
* @param {undefined} undefined
|
||
*/
|
||
function(window, undefined) {
|
||
|
||
|
||
/*
|
||
* Import
|
||
* -----------------------------------------------------------------------------
|
||
*/
|
||
var c_oAscFormatPainterState = AscCommon.c_oAscFormatPainterState;
|
||
var AscBrowser = AscCommon.AscBrowser;
|
||
var CColor = AscCommon.CColor;
|
||
var cBoolLocal = AscCommon.cBoolLocal;
|
||
var History = AscCommon.History;
|
||
|
||
var asc = window["Asc"];
|
||
var asc_applyFunction = AscCommonExcel.applyFunction;
|
||
var asc_round = asc.round;
|
||
var asc_typeof = asc.typeOf;
|
||
var asc_CMM = AscCommonExcel.asc_CMouseMoveData;
|
||
var asc_CPrintPagesData = AscCommonExcel.CPrintPagesData;
|
||
var c_oTargetType = AscCommonExcel.c_oTargetType;
|
||
var c_oAscError = asc.c_oAscError;
|
||
var c_oAscCleanOptions = asc.c_oAscCleanOptions;
|
||
var c_oAscSelectionDialogType = asc.c_oAscSelectionDialogType;
|
||
var c_oAscMouseMoveType = asc.c_oAscMouseMoveType;
|
||
var c_oAscPopUpSelectorType = asc.c_oAscPopUpSelectorType;
|
||
var c_oAscAsyncAction = asc.c_oAscAsyncAction;
|
||
var c_oAscFontRenderingModeType = asc.c_oAscFontRenderingModeType;
|
||
var c_oAscAsyncActionType = asc.c_oAscAsyncActionType;
|
||
|
||
var g_clipboardExcel = AscCommonExcel.g_clipboardExcel;
|
||
|
||
function CCellFormatPasteData(oWSView) {
|
||
AscCommon.CFormattingPasteDataBase.call();
|
||
this.ws = oWSView.model;
|
||
this.range = this.ws.selectionRange.clone();
|
||
|
||
this.docData = null;
|
||
if (oWSView && oWSView.isSelectOnShape) {
|
||
if (oWSView.objectRender && oWSView.objectRender.controller) {
|
||
this.docData = oWSView.objectRender.controller.getFormatPainterData();
|
||
}
|
||
}
|
||
}
|
||
AscFormat.InitClassWithoutType(CCellFormatPasteData, AscCommon.CFormattingPasteDataBase);
|
||
CCellFormatPasteData.prototype.isDrawingData = function() {
|
||
return !!this.docData;
|
||
};
|
||
CCellFormatPasteData.prototype.getDocData = function() {
|
||
return this.docData;
|
||
};
|
||
|
||
function WorkbookCommentsModel(handlers, aComments) {
|
||
this.workbook = {handlers: handlers};
|
||
this.aComments = aComments;
|
||
}
|
||
|
||
WorkbookCommentsModel.prototype.getId = function() {
|
||
return null;
|
||
};
|
||
WorkbookCommentsModel.prototype.getMergedByCell = function() {
|
||
return null;
|
||
};
|
||
|
||
function WorksheetViewSettings() {
|
||
//TODO темные цвета необходимо скорректировать
|
||
this.getCColor = function (_color) {
|
||
var rgb = parseInt(_color.split('#')[1], 16);
|
||
return new CColor((rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
|
||
};
|
||
this.updateStyle = function () {
|
||
this.header.style = this._generateStyle();
|
||
this.header.groupDataBorder = this.getCColor(AscCommon.GlobalSkin.GroupDataBorder);
|
||
this.header.editorBorder = this.getCColor(AscCommon.GlobalSkin.EditorBorder);
|
||
this.header.cornerColor = this.getCColor(AscCommon.GlobalSkin.SelectAllIcon);
|
||
this.header.cornerColorSheetView = this.getCColor(AscCommon.GlobalSkin.SheetViewSelectAllIcon);
|
||
};
|
||
this._generateStyle = function () {
|
||
return [// Header colors
|
||
{ // kHeaderDefault
|
||
background: this.getCColor(AscCommon.GlobalSkin.Background),
|
||
border: this.getCColor(AscCommon.GlobalSkin.Border),
|
||
color: this.getCColor(AscCommon.GlobalSkin.Color),
|
||
backgroundDark: this.getCColor(AscCommon.GlobalSkin.SheetViewCellBackground),
|
||
colorDark: this.getCColor(AscCommon.GlobalSkin.ColorDark),
|
||
colorFiltering: this.getCColor(AscCommon.GlobalSkin.ColorFiltering),
|
||
colorDarkFiltering: this.getCColor(AscCommon.GlobalSkin.ColorDarkFiltering),
|
||
sheetViewCellTitleLabel: this.getCColor(AscCommon.GlobalSkin.SheetViewCellTitleLabel)
|
||
}, { // kHeaderActive
|
||
background: this.getCColor(AscCommon.GlobalSkin.BackgroundActive),
|
||
border: this.getCColor(AscCommon.GlobalSkin.BorderActive),
|
||
color: this.getCColor(AscCommon.GlobalSkin.ColorActive),
|
||
backgroundDark: this.getCColor(AscCommon.GlobalSkin.SheetViewCellBackgroundPressed),
|
||
colorDark: this.getCColor(AscCommon.GlobalSkin.ColorDarkActive),
|
||
colorFiltering: this.getCColor(AscCommon.GlobalSkin.ColorFiltering),
|
||
colorDarkFiltering: this.getCColor(AscCommon.GlobalSkin.ColorDarkFiltering),
|
||
sheetViewCellTitleLabel: this.getCColor(AscCommon.GlobalSkin.SheetViewCellTitleLabel)
|
||
}, { // kHeaderHighlighted
|
||
background: this.getCColor(AscCommon.GlobalSkin.BackgroundHighlighted),
|
||
border: this.getCColor(AscCommon.GlobalSkin.BorderHighlighted),
|
||
color: this.getCColor(AscCommon.GlobalSkin.ColorHighlighted),
|
||
backgroundDark: this.getCColor(AscCommon.GlobalSkin.SheetViewCellBackgroundHover),
|
||
colorDark: this.getCColor(AscCommon.GlobalSkin.ColorDarkHighlighted),
|
||
colorFiltering: this.getCColor(AscCommon.GlobalSkin.ColorFiltering),
|
||
colorDarkFiltering: this.getCColor(AscCommon.GlobalSkin.ColorDarkFiltering),
|
||
sheetViewCellTitleLabel: this.getCColor(AscCommon.GlobalSkin.SheetViewCellTitleLabel)
|
||
}];
|
||
};
|
||
this.header = {
|
||
style: this._generateStyle(),
|
||
cornerColor: this.getCColor(AscCommon.GlobalSkin.SelectAllIcon),
|
||
cornerColorSheetView: this.getCColor(AscCommon.GlobalSkin.SheetViewSelectAllIcon),
|
||
groupDataBorder: this.getCColor(AscCommon.GlobalSkin.GroupDataBorder),
|
||
editorBorder: this.getCColor(AscCommon.GlobalSkin.EditorBorder),
|
||
printBackground: new CColor(238, 238, 238),
|
||
printBorder: new CColor(216, 216, 216),
|
||
printColor: new CColor(0, 0, 0)
|
||
};
|
||
this.cells = {
|
||
defaultState: {
|
||
background: new CColor(255, 255, 255), border: new CColor(202, 202, 202)
|
||
}, padding: -1 /*px horizontal padding*/
|
||
};
|
||
this.activeCellBorderColor = new CColor(72, 121, 92);
|
||
this.activeCellBorderColor2 = new CColor(255, 255, 255, 1);
|
||
this.findFillColor = new CColor(255, 238, 128, 1);
|
||
|
||
// Цвет закрепленных областей
|
||
this.frozenColor = new CColor(129, 129, 129, 1);
|
||
|
||
// Число знаков для математической информации
|
||
this.mathMaxDigCount = 9;
|
||
|
||
var cnv = document.createElement("canvas");
|
||
cnv.width = 2;
|
||
cnv.height = 2;
|
||
var ctx = cnv.getContext("2d");
|
||
ctx.clearRect(0, 0, 2, 2);
|
||
ctx.fillStyle = "#000";
|
||
ctx.fillRect(0, 0, 1, 1);
|
||
ctx.fillRect(1, 1, 1, 1);
|
||
this.ptrnLineDotted1 = ctx.createPattern(cnv, "repeat");
|
||
|
||
this.halfSelection = false;
|
||
|
||
return this;
|
||
}
|
||
|
||
|
||
/**
|
||
* Widget for displaying and editing Workbook object
|
||
* -----------------------------------------------------------------------------
|
||
* @param {AscCommonExcel.Workbook} model Workbook
|
||
* @param {AscCommonExcel.asc_CEventsController} controller Events controller
|
||
* @param {HandlersList} handlers Events handlers for WorkbookView events
|
||
* @param {Element} elem Container element
|
||
* @param {Element} inputElem Input element for top line editor
|
||
* @param {Object} Api
|
||
* @param {CCollaborativeEditing} collaborativeEditing
|
||
* @param {c_oAscFontRenderingModeType} fontRenderingMode
|
||
*
|
||
* @constructor
|
||
* @memberOf Asc
|
||
*/
|
||
function WorkbookView(model, controller, handlers, elem, inputElem, Api, collaborativeEditing, fontRenderingMode) {
|
||
this.defaults = {
|
||
scroll: {
|
||
widthPx: 14, heightPx: 14
|
||
}, worksheetView: new WorksheetViewSettings()
|
||
};
|
||
|
||
this.model = model;
|
||
this.enableKeyEvents = true;
|
||
this.controller = controller;
|
||
this.handlers = handlers;
|
||
this.wsViewHandlers = null;
|
||
this.element = elem;
|
||
this.input = inputElem;
|
||
this.Api = Api;
|
||
this.History = History;
|
||
this.collaborativeEditing = this.CollaborativeEditing = collaborativeEditing;
|
||
this.collaborativeEditing.SetLogicDocument(this);
|
||
this.DrawingDocument = model.DrawingDocument;
|
||
this.lastSendInfoRange = null;
|
||
this.oSelectionInfo = null;
|
||
this.canUpdateAfterShiftUp = false; // Нужно ли обновлять информацию после отпускания Shift
|
||
this.keepType = false;
|
||
this.timerId = null;
|
||
this.timerEnd = false;
|
||
|
||
//----- declaration -----
|
||
this.isInit = false;
|
||
this.canvas = undefined;
|
||
this.canvasOverlay = undefined;
|
||
this.canvasGraphic = undefined;
|
||
this.canvasGraphicOverlay = undefined;
|
||
this.wsActive = -1;
|
||
this.wsMustDraw = false; // Означает, что мы выставили активный, но не отрисовали его
|
||
this.wsViews = [];
|
||
this.cellEditor = undefined;
|
||
this.fontRenderingMode = null;
|
||
this.lockDraw = false; // Lock отрисовки на некоторое время
|
||
|
||
this.isCellEditMode = false;
|
||
this.isFormulaEditMode = false;
|
||
this.isWizardMode = false;
|
||
|
||
this.isShowComments = true;
|
||
this.isShowSolved = true;
|
||
|
||
this.formulasList = []; // Список всех формул
|
||
this.lastFPos = -1; // Последняя позиция формулы
|
||
this.lastFNameLength = ''; // Последний кусок формулы
|
||
this.skipHelpSelector = false; // Пока true - не показываем окно подсказки
|
||
// Константы для подстановке формулы (что не нужно добавлять скобки)
|
||
this.arrExcludeFormulas = [];
|
||
|
||
// Информация об установленных прослушивателях, для их последующего удаления
|
||
this.eventListeners = [];
|
||
|
||
this.fReplaceCallback = null; // Callback для замены текста
|
||
|
||
// Фонт, который выставлен в DrawingContext, он должен быть один на все DrawingContext-ы
|
||
this.m_oFont = AscCommonExcel.g_oDefaultFormat.Font.clone();
|
||
|
||
// Теперь у нас 2 FontManager-а на весь документ + 1 для автофигур (а не на каждом листе свой)
|
||
this.fmgrGraphics = []; // FontManager for draw (1 для обычного + 1 для поворотного текста)
|
||
this.fmgrGraphics.push(new AscFonts.CFontManager({mode:"cell"})); // Для обычного
|
||
this.fmgrGraphics.push(new AscFonts.CFontManager({mode:"cell"})); // Для поворотного
|
||
this.fmgrGraphics.push(new AscFonts.CFontManager()); // Для автофигур
|
||
this.fmgrGraphics.push(new AscFonts.CFontManager({mode:"cell"})); // Для измерений
|
||
|
||
this.fmgrGraphics[0].Initialize(true); // IE memory enable
|
||
this.fmgrGraphics[1].Initialize(true); // IE memory enable
|
||
this.fmgrGraphics[2].Initialize(true); // IE memory enable
|
||
this.fmgrGraphics[3].Initialize(true); // IE memory enable
|
||
|
||
this.buffers = {};
|
||
this.drawingCtx = undefined;
|
||
this.overlayCtx = undefined;
|
||
this.drawingGraphicCtx = undefined;
|
||
this.overlayGraphicCtx = undefined;
|
||
this.shapeCtx = null;
|
||
this.shapeOverlayCtx = null;
|
||
this.mainGraphics = undefined;
|
||
this.stringRender = undefined;
|
||
this.trackOverlay = null;
|
||
this.mainOverlay = null;
|
||
this.autoShapeTrack = null;
|
||
|
||
|
||
this.selectionDialogMode = false;
|
||
this.dialogAbsName = false;
|
||
this.dialogSheetName = false;
|
||
this.dialogBookName = false;
|
||
this.copyActiveSheet = -1;
|
||
|
||
// Комментарии для всего документа
|
||
this.cellCommentator = null;
|
||
|
||
// Флаг о подписке на эвенты о смене позиции документа (скролл) для меню
|
||
this.isDocumentPlaceChangedEnabled = false;
|
||
|
||
// Максимальная ширина числа из 0,1,2...,9, померенная в нормальном шрифте(дефалтовый для книги) в px(целое)
|
||
// Ecma-376 Office Open XML Part 1, пункт 18.3.1.13
|
||
this.maxDigitWidth = 0;
|
||
//-----------------------
|
||
|
||
this.MobileTouchManager = null;
|
||
|
||
this.defNameAllowCreate = true;
|
||
|
||
this.externalSelectionController = new CExternalSelectionController(this);
|
||
|
||
this._init(fontRenderingMode);
|
||
|
||
this.autoCorrectStore = null;//объект для хранения параметров иконки авторазвертывания таблиц
|
||
this.cutIdSheet = null;
|
||
|
||
this.NeedUpdateTargetForCollaboration = true;
|
||
this.LastUpdateTargetTime = 0;
|
||
|
||
this.printPreviewState = new AscCommonExcel.CPrintPreviewState(this);
|
||
this.printOptionsJson = null;
|
||
|
||
this.SearchEngine = null;
|
||
if (typeof CDocumentSearchExcel !== "undefined") {
|
||
this.SearchEngine = new CDocumentSearchExcel(this);
|
||
}
|
||
|
||
this.changedCellWatchesSheets = null;
|
||
|
||
//ограничения на отрисовку какого-либо компонента на всех листах
|
||
//в данном случае добавляю для того, чтобы не рисовать группы в нативных редакторах
|
||
//внутри пока простой объект {groups: true}
|
||
this.drawRestrictions = null;
|
||
|
||
//for version history - changed ranges
|
||
this.oHistoryChangedRanges = null;
|
||
|
||
this.customFunctionEngine = null;
|
||
|
||
this.smoothScroll = true;
|
||
|
||
this.externalReferenceUpdateTimer = null;
|
||
|
||
return this;
|
||
}
|
||
|
||
WorkbookView.prototype._init = function(fontRenderingMode) {
|
||
var self = this;
|
||
|
||
// Init font managers rendering
|
||
// Изначально мы инициализируем c_oAscFontRenderingModeType.hintingAndSubpixeling
|
||
this.setFontRenderingMode(fontRenderingMode, /*isInit*/true);
|
||
|
||
// create canvas
|
||
if (null != this.element) {
|
||
this.canvas = document.getElementById("ws-canvas");
|
||
this.canvasOverlay = document.getElementById("ws-canvas-overlay");
|
||
this.canvasGraphic = document.getElementById("ws-canvas-graphic");
|
||
this.canvasGraphicOverlay = document.getElementById("ws-canvas-graphic-overlay");
|
||
}
|
||
|
||
this.buffers.main = new asc.DrawingContext({
|
||
canvas: this.canvas, units: 0/*px*/, fmgrGraphics: this.fmgrGraphics, font: this.m_oFont
|
||
});
|
||
this.buffers.overlay = new asc.DrawingContext({
|
||
canvas: this.canvasOverlay, units: 0/*px*/, fmgrGraphics: this.fmgrGraphics, font: this.m_oFont
|
||
});
|
||
|
||
this.buffers.mainGraphic = new asc.DrawingContext({
|
||
canvas: this.canvasGraphic, units: 0/*px*/, fmgrGraphics: this.fmgrGraphics, font: this.m_oFont
|
||
});
|
||
this.buffers.overlayGraphic = new asc.DrawingContext({
|
||
canvas: this.canvasGraphicOverlay, units: 0/*px*/, fmgrGraphics: this.fmgrGraphics, font: this.m_oFont
|
||
});
|
||
|
||
this.drawingCtx = this.buffers.main;
|
||
this.overlayCtx = this.buffers.overlay;
|
||
this.drawingGraphicCtx = this.buffers.mainGraphic;
|
||
this.overlayGraphicCtx = this.buffers.overlayGraphic;
|
||
|
||
this.shapeCtx = new AscCommon.CGraphics();
|
||
this.shapeOverlayCtx = new AscCommon.CGraphics();
|
||
this.mainGraphics = new AscCommon.CGraphics();
|
||
this.trackOverlay = new AscCommon.COverlay();
|
||
this.trackOverlay.IsCellEditor = true;
|
||
if(/*this.Api.isMobileVersion*/true) {
|
||
this.mainOverlay = new AscCommon.COverlay();
|
||
this.mainOverlay.IsCellEditor = true;
|
||
}
|
||
this.autoShapeTrack = new AscCommon.CAutoshapeTrack();
|
||
this.shapeCtx.m_oAutoShapesTrack = this.autoShapeTrack;
|
||
|
||
this.shapeCtx.m_oFontManager = this.fmgrGraphics[2];
|
||
this.shapeOverlayCtx.m_oFontManager = this.fmgrGraphics[2];
|
||
this.mainGraphics.m_oFontManager = this.fmgrGraphics[0];
|
||
|
||
// Обновляем размеры (чуть ниже, потому что должны быть проинициализированы ctx)
|
||
this._canResize();
|
||
|
||
this.stringRender = new AscCommonExcel.StringRender(this.buffers.main);
|
||
|
||
//need clean previous fonts settings, next in _calcMaxDigitWidth do setFont and reinstall setupFontSize/...
|
||
if (this.Api.VersionHistory) {
|
||
AscCommonExcel.resetDrawingContextFonts();
|
||
}
|
||
|
||
// Мерить нужно только со 100% и один раз для всего документа
|
||
this._calcMaxDigitWidth();
|
||
|
||
if (!window["NATIVE_EDITOR_ENJINE"]) {
|
||
// initialize events controller
|
||
this.controller && this.controller.init(this, this.element, /*this.canvasOverlay*/ this.canvasGraphicOverlay, /*handlers*/{
|
||
"resize": function () {
|
||
self.resize.apply(self, arguments);
|
||
}, "gotFocus": function (hasFocus) {
|
||
if (self.isCellEditMode) {
|
||
self.cellEditor.setFocus(!hasFocus);
|
||
}
|
||
}, "initRowsCount": function () {
|
||
self._onInitRowsCount.apply(self, arguments);
|
||
}, "initColsCount": function () {
|
||
self._onInitColsCount.apply(self, arguments);
|
||
}, "scrollY": function () {
|
||
self._onScrollY.apply(self, arguments);
|
||
}, "scrollX": function () {
|
||
self._onScrollX.apply(self, arguments);
|
||
}, "changeVisibleArea": function () {
|
||
self._onChangeVisibleArea.apply(self, arguments);
|
||
}, "changeSelection": function () {
|
||
self._onChangeSelection.apply(self, arguments);
|
||
}, "changeSelectionDone": function () {
|
||
self._onChangeSelectionDone.apply(self, arguments);
|
||
}, "changeSelectionRightClick": function () {
|
||
self._onChangeSelectionRightClick.apply(self, arguments);
|
||
}, "selectionActivePointChanged": function () {
|
||
self._onSelectionActivePointChanged.apply(self, arguments);
|
||
}, "updateWorksheet": function () {
|
||
self._onUpdateWorksheet.apply(self, arguments);
|
||
}, "resizeElement": function () {
|
||
self._onResizeElement.apply(self, arguments);
|
||
}, "resizeElementDone": function () {
|
||
self._onResizeElementDone.apply(self, arguments);
|
||
}, "changeFillHandle": function () {
|
||
self._onChangeFillHandle.apply(self, arguments);
|
||
}, "changeFillHandleDone": function () {
|
||
self._onChangeFillHandleDone.apply(self, arguments);
|
||
}, "moveRangeHandle": function () {
|
||
self._onMoveRangeHandle.apply(self, arguments);
|
||
}, "moveRangeHandleDone": function () {
|
||
self._onMoveRangeHandleDone.apply(self, arguments);
|
||
}, "moveResizeRangeHandle": function () {
|
||
self._onMoveResizeRangeHandle.apply(self, arguments);
|
||
}, "moveResizeRangeHandleDone": function () {
|
||
self._onMoveResizeRangeHandleDone.apply(self, arguments);
|
||
}, "editCell": function () {
|
||
self._onEditCell.apply(self, arguments);
|
||
}, "onPointerDownPlaceholder": function () {
|
||
return self._onPointerDownPlaceholder.apply(self, arguments);
|
||
}, "stopCellEditing": function () {
|
||
return self.closeCellEditor.apply(self, arguments);
|
||
}, "isRestrictionComments": function () {
|
||
return self.Api.isRestrictionComments();
|
||
}, "empty": function () {
|
||
self._onEmpty.apply(self, arguments);
|
||
}, "undo": function () {
|
||
self.undo.apply(self, arguments);
|
||
}, "redo": function () {
|
||
self.redo.apply(self, arguments);
|
||
}, "mouseDblClick": function () {
|
||
self._onMouseDblClick.apply(self, arguments);
|
||
}, "showNextPrevWorksheet": function () {
|
||
self._onShowNextPrevWorksheet.apply(self, arguments);
|
||
}, "setFontAttributes": function () {
|
||
self._onSetFontAttributes.apply(self, arguments);
|
||
}, "setCellFormat": function () {
|
||
self._onSetCellFormat.apply(self, arguments);
|
||
}, "selectColumnsByRange": function () {
|
||
self._onSelectColumnsByRange.apply(self, arguments);
|
||
}, "selectRowsByRange": function () {
|
||
self._onSelectRowsByRange.apply(self, arguments);
|
||
}, "selectAllByRange": function () {
|
||
self._onSelectAllByRange.apply(self, arguments);
|
||
}, "save": function () {
|
||
self.Api.asc_Save();
|
||
}, "showCellEditorCursor": function () {
|
||
self._onShowCellEditorCursor.apply(self, arguments);
|
||
}, "print": function () {
|
||
self.Api.onPrint();
|
||
}, "addFunction": function () {
|
||
self.insertInCellEditor.apply(self, arguments);
|
||
}, "canvasClick": function () {
|
||
self.enableKeyEventsHandler(true);
|
||
}, "autoFiltersClick": function () {
|
||
self._onAutoFiltersClick.apply(self, arguments);
|
||
}, "tableTotalClick": function () {
|
||
self._onTableTotalClick.apply(self, arguments);
|
||
}, "pivotFiltersClick": function () {
|
||
self._onPivotFiltersClick.apply(self, arguments);
|
||
}, "pivotCollapseClick": function () {
|
||
self._onPivotCollapseClick.apply(self, arguments);
|
||
}, "refreshConnections": function () {
|
||
return self._onRefreshConnections.apply(self, arguments);
|
||
}, "commentCellClick": function () {
|
||
self._onCommentCellClick.apply(self, arguments);
|
||
}, "isGlobalLockEditCell": function () {
|
||
return self.collaborativeEditing.getGlobalLockEditCell();
|
||
}, "updateSelectionName": function () {
|
||
self._onUpdateSelectionName.apply(self, arguments);
|
||
}, "stopFormatPainter": function () {
|
||
self._onStopFormatPainter.apply(self, arguments);
|
||
}, "groupRowClick": function () {
|
||
return self._onGroupRowClick.apply(self, arguments);
|
||
}, "onChangeTableSelection": function () {
|
||
return self._onChangeTableSelection.apply(self, arguments);
|
||
}, "getActiveCell": function () {
|
||
var ws = self.getWorksheet();
|
||
if (ws) {
|
||
var selectionRanges = ws.getSelectedRanges();
|
||
if (selectionRanges && selectionRanges.length === 1 && selectionRanges[0].bbox && selectionRanges[0].bbox.isOneCell()) {
|
||
return ws.getActiveCell(0, 0, false)
|
||
}
|
||
}
|
||
return null;
|
||
}, "showFormulas": function () {
|
||
self._onShowFormulas.apply(self, arguments);
|
||
},
|
||
|
||
|
||
// Shapes
|
||
"graphicObjectMouseDown": function () {
|
||
self._onGraphicObjectMouseDown.apply(self, arguments);
|
||
}, "graphicObjectMouseMove": function () {
|
||
self._onGraphicObjectMouseMove.apply(self, arguments);
|
||
}, "graphicObjectMouseUp": function () {
|
||
self._onGraphicObjectMouseUp.apply(self, arguments);
|
||
}, "graphicObjectMouseUpEx": function () {
|
||
self._onGraphicObjectMouseUpEx.apply(self, arguments);
|
||
}, "graphicObjectWindowKeyDown": function () {
|
||
return self._onGraphicObjectWindowKeyDown.apply(self, arguments);
|
||
}, "graphicObjectWindowKeyUp": function () {
|
||
return self._onGraphicObjectWindowKeyUp.apply(self, arguments);
|
||
}, "graphicObjectWindowKeyPress": function () {
|
||
return self._onGraphicObjectWindowKeyPress.apply(self, arguments);
|
||
}, "graphicObjectWindowEnterText": function () {
|
||
return self._onGraphicObjectWindowEnterText.apply(self, arguments);
|
||
}, "graphicObjectMouseWheel": function () {
|
||
return self._onGraphicObjecMouseWheel.apply(self, arguments);
|
||
}, "getGraphicsInfo": function () {
|
||
return self._onGetGraphicsInfo.apply(self, arguments);
|
||
}, "updateSelectionShape": function () {
|
||
return self._onUpdateSelectionShape.apply(self, arguments);
|
||
}, "canReceiveKeyPress": function () {
|
||
return self.getWorksheet().objectRender.controller.canReceiveKeyPress();
|
||
}, "stopAddShape": function () {
|
||
self.getWorksheet().objectRender.controller.checkEndAddShape();
|
||
},
|
||
|
||
// Frozen anchor
|
||
"moveFrozenAnchorHandle": function () {
|
||
self._onMoveFrozenAnchorHandle.apply(self, arguments);
|
||
}, "moveFrozenAnchorHandleDone": function () {
|
||
self._onMoveFrozenAnchorHandleDone.apply(self, arguments);
|
||
},
|
||
|
||
// AutoComplete
|
||
"showAutoComplete": function () {
|
||
self.showAutoComplete.apply(self, arguments);
|
||
}, "onContextMenu": function (event, type) {
|
||
self.handlers.trigger("asc_onContextMenu", event, type);
|
||
},
|
||
"isRightClickFill": function () {
|
||
let ws = self.getWorksheet();
|
||
let selection = ws && ws.model && ws.model.getSelection();
|
||
selection = selection && selection.isSingleRange() && selection.getLast();
|
||
if (ws.activeFillHandle && selection && !selection.containsRange(ws.activeFillHandle)) {
|
||
return true;
|
||
}
|
||
return false;
|
||
},
|
||
|
||
// DataValidation
|
||
"onDataValidation": function () {
|
||
if (self.oSelectionInfo && self.oSelectionInfo.dataValidation) {
|
||
var list = self.oSelectionInfo.dataValidation.getListValues(self.model.getActiveWs());
|
||
if (list) {
|
||
self.handlers.trigger("asc_onValidationListMenu", list[0], list[1]);
|
||
}
|
||
return !!list;
|
||
}
|
||
},
|
||
|
||
"onShowFilterOptionsActiveCell": function () {
|
||
return self.getWorksheet().showAutoFilterOptionsFromActiveCell();
|
||
},
|
||
|
||
// FormatPainter
|
||
'isFormatPainter': function () {
|
||
return self.Api.getFormatPainterState();
|
||
},
|
||
|
||
//calculate
|
||
'calculate': function () {
|
||
self.calculate.apply(self, arguments);
|
||
},
|
||
|
||
'changeFormatTableInfo': function () {
|
||
var table = self.getSelectionInfo().formatTableInfo;
|
||
return table && self.changeFormatTableInfo(table.tableName, Asc.c_oAscChangeTableStyleInfo.rowTotal, !table.lastRow);
|
||
},
|
||
|
||
//special paste
|
||
"hideSpecialPasteOptions": function () {
|
||
self.handlers.trigger("hideSpecialPasteOptions");
|
||
},
|
||
|
||
"cleanCutData": function (bDrawSelection, bCleanBuffer) {
|
||
self.cleanCutData(bDrawSelection, bCleanBuffer);
|
||
},
|
||
|
||
"cleanCopyData": function (bDrawSelection, bCleanBuffer) {
|
||
self.cleanCopyData(bDrawSelection, bCleanBuffer);
|
||
}
|
||
});
|
||
|
||
if (this.input && this.input.addEventListener) {
|
||
var eventInfo = new AscCommon.CEventListenerInfo(this.input, "focus", function () {
|
||
if (this.Api.isEditVisibleAreaOleEditor) {
|
||
this._blurCellEditor();
|
||
return;
|
||
}
|
||
this.input.isFocused = true;
|
||
if (!this.canEdit()) {
|
||
return;
|
||
}
|
||
if (this.isUserProtectActiveCell()) {
|
||
this._blurCellEditor();
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.ProtectedRangeByOtherUser, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
if (this.isProtectActiveCell()) {
|
||
this._blurCellEditor();
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.ChangeOnProtectedSheet, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
this._onStopFormatPainter();
|
||
this.cellEditor.callTopLineMouseup = true;
|
||
if (!this.getCellEditMode() && !this.controller.isFillHandleMode) {
|
||
var enterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
enterOptions.focus = true;
|
||
this._onEditCell(enterOptions);
|
||
}
|
||
}.bind(this), false);
|
||
this.eventListeners.push(eventInfo);
|
||
|
||
|
||
eventInfo = new AscCommon.CEventListenerInfo(this.input, "keydown", function (event) {
|
||
if (this.isCellEditMode) {
|
||
this.handlers.trigger('asc_onInputKeyDown', event);
|
||
if (!event.defaultPrevented) {
|
||
AscCommon.check_KeyboardEvent(event);
|
||
const nRetValue = this.cellEditor._onWindowKeyDown(AscCommon.global_keyboardEvent);
|
||
if (nRetValue & keydownresult_PreventPropagation) {
|
||
event.stopPropagation();
|
||
}
|
||
if (nRetValue & keydownresult_PreventDefault) {
|
||
event.preventDefault();
|
||
}
|
||
}
|
||
}
|
||
}.bind(this), false);
|
||
this.eventListeners.push(eventInfo);
|
||
}
|
||
|
||
this.Api.onKeyDown = function (oEvent) {
|
||
if (!self.enableKeyEvents && oEvent.emulated !== true && oEvent.keyCode !== 80) {
|
||
return;
|
||
}
|
||
AscCommon.check_KeyboardEvent(oEvent);
|
||
const nRetValue = self.onKeyDown(AscCommon.global_keyboardEvent);
|
||
if (nRetValue & keydownresult_PreventPropagation) {
|
||
oEvent.stopPropagation();
|
||
}
|
||
if (nRetValue & keydownresult_PreventDefault) {
|
||
oEvent.preventDefault();
|
||
}
|
||
};
|
||
this.Api.onKeyPress = function (oEvent) {
|
||
AscCommon.check_KeyboardEvent(oEvent);
|
||
self.onKeyPress(AscCommon.global_keyboardEvent);
|
||
};
|
||
this.Api.onKeyUp = function (oEvent) {
|
||
AscCommon.check_KeyboardEvent(oEvent);
|
||
self.onKeyUp(AscCommon.global_keyboardEvent);
|
||
};
|
||
this.Api.Begin_CompositeInput = function () {
|
||
var oWSView = self.getWorksheet();
|
||
if (oWSView && oWSView.isSelectOnShape) {
|
||
if (oWSView.objectRender) {
|
||
oWSView.objectRender.Begin_CompositeInput();
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (!self.isCellEditMode) {
|
||
var enterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
enterOptions.newText = '';
|
||
enterOptions.quickInput = true;
|
||
self._onEditCell(enterOptions, function () {
|
||
self.cellEditor.Begin_CompositeInput();
|
||
});
|
||
} else {
|
||
self.cellEditor.Begin_CompositeInput();
|
||
}
|
||
};
|
||
this.Api.Replace_CompositeText = function (arrCharCodes) {
|
||
var oWSView = self.getWorksheet();
|
||
if(oWSView && oWSView.isSelectOnShape){
|
||
if(oWSView.objectRender){
|
||
oWSView.objectRender.Replace_CompositeText(arrCharCodes);
|
||
}
|
||
return;
|
||
}
|
||
if (self.isCellEditMode) {
|
||
self.cellEditor.Replace_CompositeText(arrCharCodes);
|
||
}
|
||
};
|
||
this.Api.End_CompositeInput = function () {
|
||
var oWSView = self.getWorksheet();
|
||
if(oWSView && oWSView.isSelectOnShape){
|
||
if(oWSView.objectRender){
|
||
oWSView.objectRender.End_CompositeInput();
|
||
}
|
||
return;
|
||
}
|
||
if (self.isCellEditMode) {
|
||
self.cellEditor.End_CompositeInput();
|
||
}
|
||
};
|
||
this.Api.Set_CursorPosInCompositeText = function (nPos) {
|
||
var oWSView = self.getWorksheet();
|
||
if(oWSView && oWSView.isSelectOnShape){
|
||
if(oWSView.objectRender){
|
||
oWSView.objectRender.Set_CursorPosInCompositeText(nPos);
|
||
}
|
||
return;
|
||
}
|
||
if (self.isCellEditMode) {
|
||
self.cellEditor.Set_CursorPosInCompositeText(nPos);
|
||
}
|
||
};
|
||
this.Api.Get_CursorPosInCompositeText = function () {
|
||
var res = 0;
|
||
var oWSView = self.getWorksheet();
|
||
if(oWSView && oWSView.isSelectOnShape){
|
||
if(oWSView.objectRender){
|
||
res = oWSView.objectRender.Get_CursorPosInCompositeText();
|
||
}
|
||
}
|
||
else if (self.isCellEditMode) {
|
||
res = self.cellEditor.Get_CursorPosInCompositeText();
|
||
}
|
||
return res;
|
||
};
|
||
this.Api.Get_MaxCursorPosInCompositeText = function () {
|
||
var res = 0; var oWSView = self.getWorksheet();
|
||
if(oWSView && oWSView.isSelectOnShape){
|
||
if(oWSView.objectRender){
|
||
res = oWSView.objectRender.Get_CursorPosInCompositeText();
|
||
}
|
||
}
|
||
else if (self.isCellEditMode) {
|
||
res = self.cellEditor.Get_MaxCursorPosInCompositeText();
|
||
}
|
||
return res;
|
||
};
|
||
this.Api.AddTextWithPr = function (familyName, arrCharCodes) {
|
||
var ws = self.getWorksheet();
|
||
if (ws && ws.isSelectOnShape) {
|
||
var textPr = new CTextPr();
|
||
textPr.RFonts = new CRFonts();
|
||
textPr.RFonts.SetAll(familyName, -1);
|
||
|
||
let settings = new AscCommon.CAddTextSettings();
|
||
settings.SetTextPr(textPr);
|
||
settings.MoveCursorOutside(true);
|
||
|
||
ws.objectRender.controller.addTextWithPr(new AscCommon.CUnicodeStringEmulator(arrCharCodes), settings);
|
||
return;
|
||
}
|
||
|
||
if (!self.isCellEditMode) {
|
||
self._onEditCell(new AscCommonExcel.CEditorEnterOptions(), function () {
|
||
self.cellEditor.setTextStyle('fn', familyName);
|
||
self.cellEditor._addCharCodes(arrCharCodes);
|
||
});
|
||
} else {
|
||
self.cellEditor.setTextStyle('fn', familyName);
|
||
self.cellEditor._addCharCodes(arrCharCodes);
|
||
}
|
||
};
|
||
this.Api.beginInlineDropTarget = function (event) {
|
||
if (!self.controller.isMoveRangeMode) {
|
||
self.controller.isMoveRangeMode = true;
|
||
self.getWorksheet().dragAndDropRange = new Asc.Range(0, 0, 0, 0);
|
||
}
|
||
self.controller._onMouseMove(event);
|
||
};
|
||
this.Api.endInlineDropTarget = function (event) {
|
||
var ws = self.getWorksheet();
|
||
if (!ws.activeMoveRange) {
|
||
return;
|
||
}
|
||
self.controller.isMoveRangeMode = false;
|
||
var newSelection = ws.activeMoveRange.clone();
|
||
ws._cleanSelectionMoveRange();
|
||
ws.dragAndDropRange = null;
|
||
self._onSetSelection(newSelection);
|
||
};
|
||
this.Api.isEnabledDropTarget = function () {
|
||
return !self.isCellEditMode;
|
||
};
|
||
|
||
|
||
AscCommon.InitBrowserInputContext(this.Api, "id_target_cursor");
|
||
AscCommonExcel.executeInR1C1Mode(false, function () {
|
||
self.model.dependencyFormulas.calcTree();
|
||
});
|
||
}
|
||
|
||
this.cellEditor =
|
||
new AscCommonExcel.CellEditor(this.element, this.input, this.fmgrGraphics, this.m_oFont, /*handlers*/{
|
||
"closed": function () {
|
||
self._onCloseCellEditor.apply(self, arguments);
|
||
}, "updated": function () {
|
||
self.Api.checkLastWork();
|
||
self._onUpdateCellEditor.apply(self, arguments);
|
||
self.externalSelectionController && self.externalSelectionController.sendExternalChangeSelection();
|
||
}, "gotFocus": function (hasFocus) {
|
||
self.controller.setFocus(!hasFocus);
|
||
}, "updateFormulaEditMod": function (val) {
|
||
self.setFormulaEditMode(val);
|
||
}, "updateEditorState": function (state) {
|
||
self.handlers.trigger("asc_onEditCell", state);
|
||
}, "updateTopLine": function (state) {
|
||
// Implemented through asc_onEditCell
|
||
self.handlers.trigger("asc_onEditCell", state);
|
||
}, "isGlobalLockEditCell": function () {
|
||
return self.collaborativeEditing.getGlobalLockEditCell();
|
||
}, "onMouseDown": function (event) {
|
||
return self.controller._onMouseDown(event);
|
||
}, "newRanges": function (ranges) {
|
||
if (self.isActive()) {
|
||
var ws = self.getWorksheet();
|
||
ws.cleanSelection();
|
||
ws.oOtherRanges = ranges;
|
||
ws._drawSelection();
|
||
}
|
||
}, "cleanSelectRange": function () {
|
||
self._onCleanSelectRange();
|
||
}, "updateUndoRedoChanged": function (bCanUndo, bCanRedo) {
|
||
self.handlers.trigger("asc_onCanUndoChanged", bCanUndo);
|
||
self.handlers.trigger("asc_onCanRedoChanged", bCanRedo);
|
||
}, "applyCloseEvent": function () {
|
||
return self.controller._onWindowKeyDown.apply(self.controller, arguments);
|
||
}, "canEdit": function () {
|
||
return self.canEdit();
|
||
}, "isProtectActiveCell": function () {
|
||
return self.isProtectActiveCell();
|
||
}, "isUserProtectActiveCell": function () {
|
||
return self.isProtectActiveCell();
|
||
}, "getFormulaRanges": function () {
|
||
return self.isActive() ? self.getWorksheet().oOtherRanges : null;
|
||
}, "isActive": function () {
|
||
return self.isActive();
|
||
}, "getWizard": function () {
|
||
return self.isWizardMode;
|
||
}, "getActiveWS": function () {
|
||
return self.getActiveWS();
|
||
}, "getActiveWSView": function () {
|
||
return self.getWorksheet();
|
||
}, "updateEditorSelectionInfo": function (xfs) {
|
||
self.handlers.trigger("asc_onEditorSelectionChanged", xfs);
|
||
}, "onContextMenu": function (event) {
|
||
self.handlers.trigger("asc_onContextMenu", event);
|
||
}, "updatedEditableFunction": function (fName, pos, activeArgPos) {
|
||
self.handlers.trigger("asc_onFormulaInfo", fName, pos, activeArgPos);
|
||
}, "onSelectionEnd" : function () {
|
||
self.handlers.trigger("asc_onSelectionEnd");
|
||
}, "doEditorFocus" : function () {
|
||
self._setEditorFocus();
|
||
}, "getExternalSelectionController" : function () {
|
||
return self.externalSelectionController;
|
||
}
|
||
}, this.defaults.worksheetView.cells.padding);
|
||
|
||
this.wsViewHandlers = new AscCommonExcel.asc_CHandlersList(/*handlers*/{
|
||
"getViewMode": function () {
|
||
return self.Api.getViewMode();
|
||
}, "isRestrictionComments": function () {
|
||
return self.Api.isRestrictionComments();
|
||
}, "reinitializeScroll": function (type) {
|
||
self._onScrollReinitialize(type);
|
||
}, "selectionChanged": function () {
|
||
self._onWSSelectionChanged();
|
||
}, "selectionNameChanged": function () {
|
||
self._onSelectionNameChanged.apply(self, arguments);
|
||
}, "selectionMathInfoChanged": function () {
|
||
self._onSelectionMathInfoChanged.apply(self, arguments);
|
||
}, 'onFilterInfo': function (countFilter, countRecords) {
|
||
self.handlers.trigger("asc_onFilterInfo", countFilter, countRecords);
|
||
}, "onErrorEvent": function (errorId, level) {
|
||
self.handlers.trigger("asc_onError", errorId, level);
|
||
}, "slowOperation": function (isStart) {
|
||
(isStart ? self.Api.sync_StartAction : self.Api.sync_EndAction).call(self.Api,
|
||
c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.SlowOperation);
|
||
}, "setAutoFiltersDialog": function (arrVal) {
|
||
self.handlers.trigger("asc_onSetAFDialog", arrVal);
|
||
}, "selectionRangeChanged": function (val) {
|
||
self._onSelectionRangeChanged(val);
|
||
}, "onRenameCellTextEnd": function (countFind, countReplace) {
|
||
self.handlers.trigger("asc_onRenameCellTextEnd", countFind, countReplace);
|
||
}, 'onStopFormatPainter': function () {
|
||
self._onStopFormatPainter.apply(self, arguments);
|
||
}, "onDocumentPlaceChanged": function () {
|
||
self._onDocumentPlaceChanged();
|
||
}, "updateSheetViewSettings": function () {
|
||
self.handlers.trigger("asc_onUpdateSheetViewSettings");
|
||
}, "onScroll": function (d) {
|
||
self.controller.scroll(d);
|
||
}, "getLockDefNameManagerStatus": function () {
|
||
return self.defNameAllowCreate;
|
||
}, 'isActive': function () {
|
||
return self.isActive();
|
||
}, "drawMobileSelection": function (oOverlay, oColor) {
|
||
if (self.MobileTouchManager) {
|
||
self.MobileTouchManager.CheckSelect(oOverlay, oColor);
|
||
}
|
||
}, "showSpecialPasteOptions": function (val) {
|
||
self.handlers.trigger("asc_onShowSpecialPasteOptions", val);
|
||
if (!window['AscCommon'].g_specialPasteHelper.showSpecialPasteButton) {
|
||
window['AscCommon'].g_specialPasteHelper.showSpecialPasteButton = true;
|
||
}
|
||
}, 'checkLastWork': function () {
|
||
self.Api.checkLastWork();
|
||
}, "toggleAutoCorrectOptions": function (bIsShow, val) {
|
||
self.toggleAutoCorrectOptions(bIsShow, val);
|
||
}, "selectSearchingResults": function () {
|
||
return self.Api.selectSearchingResults;
|
||
}, "getMainGraphics": function () {
|
||
return self.mainGraphics;
|
||
}, "cleanCutData": function (bDrawSelection, bCleanBuffer) {
|
||
self.cleanCutData(bDrawSelection, bCleanBuffer);
|
||
}
|
||
});
|
||
|
||
this.model.handlers.add("changeSheetViewSettings", function (wsId, type) {
|
||
var ws = self.getWorksheetById(wsId, true);
|
||
if (ws) {
|
||
ws._onChangeSheetViewSettings(type);
|
||
}
|
||
});
|
||
|
||
this.model.handlers.add("cleanCellCache", function(wsId, oRanges, skipHeight, needResetCache) {
|
||
var ws = self.getWorksheetById(wsId, true);
|
||
if (ws) {
|
||
if (needResetCache) {
|
||
ws.cache && ws.cache.reset();
|
||
}
|
||
ws.updateRanges(oRanges, skipHeight);
|
||
}
|
||
});
|
||
this.model.handlers.add("changeWorksheetUpdate", function(wsId, val) {
|
||
var ws = self.getWorksheetById(wsId);
|
||
if (ws) {
|
||
ws.changeWorksheet("update", val);
|
||
}
|
||
});
|
||
this.model.handlers.add("changeDocument", function(prop, arg1, arg2, wsId, fMergeCellIndex) {
|
||
self.SearchEngine && self.SearchEngine.changeDocument(prop, arg1, arg2);
|
||
let ws = wsId && self.getWorksheetById(wsId, true);
|
||
if (ws) {
|
||
ws.traceDependentsManager.changeDocument(prop, arg1, arg2, fMergeCellIndex);
|
||
}
|
||
});
|
||
this.model.handlers.add("showWorksheet", function(wsId) {
|
||
var wsModel = self.model.getWorksheetById(wsId), index;
|
||
if (wsModel) {
|
||
index = wsModel.getIndex();
|
||
self.showWorksheet(index, true);
|
||
}
|
||
});
|
||
this.model.handlers.add("setSelection", function() {
|
||
self._onSetSelection.apply(self, arguments);
|
||
});
|
||
this.model.handlers.add("getSelectionState", function() {
|
||
return self._onGetSelectionState.apply(self);
|
||
});
|
||
this.model.handlers.add("setSelectionState", function() {
|
||
self._onSetSelectionState.apply(self, arguments);
|
||
});
|
||
this.model.handlers.add("drawWS", function() {
|
||
self.drawWS.apply(self, arguments);
|
||
});
|
||
this.model.handlers.add("scrollToTopLeftCell", function() {
|
||
self.scrollToTopLeftCell.apply(self, arguments);
|
||
});
|
||
this.model.handlers.add("showDrawingObjects", function() {
|
||
self.onShowDrawingObjects.apply(self, arguments);
|
||
});
|
||
this.model.handlers.add("setCanUndo", function(bCanUndo) {
|
||
if (!self.Api.canUndoRedoByRestrictions())
|
||
bCanUndo = false;
|
||
self.handlers.trigger("asc_onCanUndoChanged", bCanUndo);
|
||
});
|
||
this.model.handlers.add("setCanRedo", function(bCanRedo) {
|
||
if (!self.Api.canUndoRedoByRestrictions())
|
||
bCanRedo = false;
|
||
self.handlers.trigger("asc_onCanRedoChanged", bCanRedo);
|
||
});
|
||
this.model.handlers.add("setDocumentModified", function(bIsModified) {
|
||
self.Api.onUpdateDocumentModified(bIsModified);
|
||
});
|
||
this.model.handlers.add("updateWorksheetByModel", function() {
|
||
self.updateWorksheetByModel.apply(self, arguments);
|
||
});
|
||
this.model.handlers.add("undoRedoAddRemoveRowCols", function(sheetId, type, range, bUndo) {
|
||
if (true === bUndo) {
|
||
if (AscCH.historyitem_Worksheet_AddRows === type) {
|
||
self.collaborativeEditing.removeRowsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.undoRows(sheetId, range.r2 - range.r1 + 1);
|
||
} else if (AscCH.historyitem_Worksheet_RemoveRows === type) {
|
||
self.collaborativeEditing.addRowsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.undoRows(sheetId, range.r2 - range.r1 + 1);
|
||
} else if (AscCH.historyitem_Worksheet_AddCols === type) {
|
||
self.collaborativeEditing.removeColsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.undoCols(sheetId, range.c2 - range.c1 + 1);
|
||
} else if (AscCH.historyitem_Worksheet_RemoveCols === type) {
|
||
self.collaborativeEditing.addColsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.undoCols(sheetId, range.c2 - range.c1 + 1);
|
||
}
|
||
} else {
|
||
if (AscCH.historyitem_Worksheet_AddRows === type) {
|
||
self.collaborativeEditing.addRowsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.addRows(sheetId, range.r1, range.r2 - range.r1 + 1);
|
||
} else if (AscCH.historyitem_Worksheet_RemoveRows === type) {
|
||
self.collaborativeEditing.removeRowsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.removeRows(sheetId, range.r1, range.r2 - range.r1 + 1);
|
||
} else if (AscCH.historyitem_Worksheet_AddCols === type) {
|
||
self.collaborativeEditing.addColsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.addCols(sheetId, range.c1, range.c2 - range.c1 + 1);
|
||
} else if (AscCH.historyitem_Worksheet_RemoveCols === type) {
|
||
self.collaborativeEditing.removeColsRange(sheetId, range.clone(true));
|
||
self.collaborativeEditing.removeCols(sheetId, range.c1, range.c2 - range.c1 + 1);
|
||
}
|
||
}
|
||
});
|
||
this.model.handlers.add("undoRedoHideSheet", function(sheetId) {
|
||
self.showWorksheet(sheetId);
|
||
// Посылаем callback об изменении списка листов
|
||
self.Api.sheetsChanged();
|
||
});
|
||
this.model.handlers.add("updateSelection", function () {
|
||
if (!self.lockDraw) {
|
||
self.getWorksheet().updateSelection();
|
||
}
|
||
});
|
||
|
||
this.handlers.add("asc_onLockDefNameManager", function(reason) {
|
||
self.defNameAllowCreate = !(reason == Asc.c_oAscDefinedNameReason.LockDefNameManager);
|
||
});
|
||
this.handlers.add('addComment', function (id, data) {
|
||
self._onWSSelectionChanged();
|
||
self.handlers.trigger('asc_onAddComment', id, data);
|
||
});
|
||
this.handlers.add('removeComment', function (id) {
|
||
self._onWSSelectionChanged();
|
||
self.handlers.trigger('asc_onRemoveComment', id);
|
||
});
|
||
this.handlers.add('hiddenComments', function () {
|
||
return !self.isShowComments;
|
||
});
|
||
this.handlers.add('showSolved', function () {
|
||
return self.isShowSolved;
|
||
});
|
||
this.model.handlers.add("hideSpecialPasteOptions", function() {
|
||
self.handlers.trigger("asc_onHideSpecialPasteOptions");
|
||
});
|
||
this.model.handlers.add("toggleAutoCorrectOptions", function(bIsShow, val) {
|
||
self.toggleAutoCorrectOptions(bIsShow, val);
|
||
});
|
||
this.model.handlers.add("cleanCutData", function(bDrawSelection, bCleanBuffer) {
|
||
self.cleanCutData(bDrawSelection, bCleanBuffer);
|
||
});
|
||
this.model.handlers.add("cleanCopyData", function(bDrawSelection, bCleanBuffer) {
|
||
self.cleanCopyData(bDrawSelection, bCleanBuffer);
|
||
});
|
||
this.model.handlers.add("updateGroupData", function() {
|
||
self.updateGroupData();
|
||
});
|
||
this.model.handlers.add("updatePrintPreview", function() {
|
||
self.updatePrintPreview();
|
||
});
|
||
this.model.handlers.add("clearFindResults", function(index) {
|
||
self.clearSearchOnRecalculate(index);
|
||
});
|
||
this.model.handlers.add("updateCellWatches", function(recalcAll) {
|
||
self.sendUpdateCellWatches(recalcAll);
|
||
});
|
||
this.model.handlers.add("changeCellWatches", function(index) {
|
||
//делаю для оптимизации. в случае открытого окна Cell Watches: обновляем весь список только в случае когда меняется этот список
|
||
// в противном случае в интерфейс отправляю только то, что изменилось по индексу
|
||
self.changedCellWatchesSheets = true;
|
||
});
|
||
this.model.handlers.add("onChangePageSetupProps", function(wsId) {
|
||
var ws = self.getWorksheetById(wsId);
|
||
if (ws) {
|
||
ws.onChangePageSetupProps();
|
||
}
|
||
});
|
||
this.Api.asc_registerCallback("EndTransactionCheckSize", function() {
|
||
self.Api.checkChangesSize();
|
||
}, true);
|
||
this.model.handlers.add("changeUpdateLinks", function(val) {
|
||
self.changeUpdateLinks(val);
|
||
});
|
||
this.model.handlers.add("updateScrollVisibility", function() {
|
||
let isChangedVertScroll = self.controller.showVerticalScroll(self.getShowVerticalScroll());
|
||
let isChangedHorScroll = self.controller.showHorizontalScroll(self.getShowHorizontalScroll());
|
||
if (isChangedVertScroll || isChangedHorScroll) {
|
||
self._canResize();
|
||
|
||
let ws = self.getWorksheet();
|
||
ws._updateRange(new Asc.Range(0, 0, ws.model.getColsCount(), ws.model.getRowsCount()), true);
|
||
ws.draw();
|
||
}
|
||
});
|
||
this.cellCommentator = new AscCommonExcel.CCellCommentator({
|
||
model: new WorkbookCommentsModel(this.handlers, this.model.aComments),
|
||
collaborativeEditing: this.collaborativeEditing,
|
||
draw: function() {
|
||
},
|
||
handlers: {
|
||
trigger: function() {
|
||
return false;
|
||
}
|
||
}
|
||
});
|
||
if (this.cellCommentator && this.cellCommentator.worksheet && !this.cellCommentator.worksheet.workbook) {
|
||
this.cellCommentator.worksheet.workbook = this;
|
||
}
|
||
if (0 < this.model.aComments.length) {
|
||
this.handlers.trigger("asc_onAddComments", this.model.aComments);
|
||
}
|
||
|
||
this.initFormulasList();
|
||
|
||
this.fReplaceCallback = function() {
|
||
self._replaceCellTextCallback.apply(self, arguments);
|
||
};
|
||
this.addEventListeners();
|
||
|
||
this.initExternalReferenceUpdateTimer();
|
||
this.externalSelectionController.init();
|
||
|
||
return this;
|
||
};
|
||
|
||
WorkbookView.prototype.destroy = function() {
|
||
this.controller.destroy();
|
||
this.cellEditor.destroy();
|
||
return this;
|
||
};
|
||
|
||
WorkbookView.prototype.executeShortcut = function(nShortcutAction) {
|
||
const oObjectRender = this.getWorksheet().objectRender;
|
||
if (oObjectRender && oObjectRender.getSelectedGraphicObjects().length > 0 && !this.getCellEditMode() && !this.controller.isMousePressed && this.enableKeyEvents) {
|
||
const oGraphicRet = oObjectRender.controller.executeShortcut(nShortcutAction);
|
||
if (oGraphicRet) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
let oRetValue = this.controller.executeShortcut(nShortcutAction);
|
||
if (this.isCellEditMode && !this.controller.skipCellEditor) {
|
||
const oCellRetValue = this.cellEditor.executeShortcut(nShortcutAction);
|
||
oRetValue = oRetValue || oCellRetValue;
|
||
}
|
||
this.controller.setSkipCellEditor(false);
|
||
return !!oRetValue;
|
||
};
|
||
WorkbookView.prototype.onKeyDown = function (oEvent) {
|
||
this.Api.sendEvent("asc_onBeforeKeyDown", oEvent);
|
||
let nRetValue = keydownresult_PreventNothing;
|
||
|
||
if (!this.getCellEditMode() && !this.controller.isMousePressed && this.enableKeyEvents) {
|
||
nRetValue |= this.controller.handlers.trigger("graphicObjectWindowKeyDown", oEvent);
|
||
}
|
||
if (nRetValue === keydownresult_PreventNothing) {
|
||
nRetValue |= this.controller._onWindowKeyDown(oEvent);
|
||
|
||
if (this.isCellEditMode && !this.controller.skipCellEditor) {
|
||
nRetValue |= this.cellEditor._onWindowKeyDown(oEvent);
|
||
}
|
||
this.controller.setSkipCellEditor(false);
|
||
}
|
||
this.Api.sendEvent("asc_onKeyDown", oEvent);
|
||
return nRetValue;
|
||
};
|
||
|
||
WorkbookView.prototype.onKeyPress = function (oEvent) {
|
||
this.controller._onWindowKeyPress(oEvent);
|
||
if (this.isCellEditMode) {
|
||
this.cellEditor._onWindowKeyPress(oEvent);
|
||
}
|
||
};
|
||
WorkbookView.prototype.onKeyUp = function (oEvent) {
|
||
this.controller._onWindowKeyUp(oEvent);
|
||
if (this.isCellEditMode) {
|
||
this.cellEditor._onWindowKeyUp(oEvent);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.scrollToOleSize = function () {
|
||
var ws = this.getWorksheet();
|
||
ws.scrollToOleSize();
|
||
};
|
||
|
||
WorkbookView.prototype._createWorksheetView = function(wsModel) {
|
||
return new AscCommonExcel.WorksheetView(this, wsModel, this.wsViewHandlers, this.buffers, this.stringRender, this.maxDigitWidth, this.collaborativeEditing, this.defaults.worksheetView);
|
||
};
|
||
|
||
WorkbookView.prototype._onSelectionNameChanged = function (name) {
|
||
this.handlers.trigger("asc_onSelectionNameChanged", name);
|
||
};
|
||
|
||
WorkbookView.prototype._onSelectionMathInfoChanged = function (info) {
|
||
this.handlers.trigger("asc_onSelectionMathChanged", info);
|
||
};
|
||
|
||
WorkbookView.prototype._onSelectionRangeChanged = function (val) {
|
||
if (this.isFormulaEditMode && !this.isWizardMode) {
|
||
this.skipHelpSelector = true;
|
||
this.cellEditor.changeCellText(val);
|
||
this.skipHelpSelector = false;
|
||
}
|
||
this.handlers.trigger("asc_onSelectionRangeChanged", val);
|
||
};
|
||
|
||
WorkbookView.prototype._onCleanSelectRange = function (force) {
|
||
if (this.selectionDialogMode) {
|
||
var ws = this.getWorksheet();
|
||
if (ws.model.selectionRange || force) {
|
||
ws.cleanSelection();
|
||
ws.model.selectionRange = null;
|
||
if (this.isActive()) {
|
||
ws._drawSelection();
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
// Проверяет, сменили ли мы диапазон (для того, чтобы не отправлять одинаковую информацию о диапазоне)
|
||
WorkbookView.prototype._isEqualRange = function(range, isSelectOnShape) {
|
||
if (null === this.lastSendInfoRange) {
|
||
return false;
|
||
}
|
||
|
||
return this.lastSendInfoRange.isEqual(range) && this.lastSendInfoRangeIsSelectOnShape === isSelectOnShape;
|
||
};
|
||
|
||
WorkbookView.prototype._updateSelectionInfo = function () {
|
||
if (this.selectionDialogMode) {
|
||
return false;
|
||
}
|
||
if(this.Api && this.Api.noCreatePoint) {
|
||
return false;
|
||
}
|
||
var ws = this.getWorksheet();
|
||
this.oSelectionInfo = ws.getSelectionInfo();
|
||
this.lastSendInfoRange = ws.model.selectionRange.clone();
|
||
this.lastSendInfoRangeIsSelectOnShape = ws.getSelectionShape();
|
||
this.updateTargetForCollaboration();
|
||
|
||
return true;
|
||
};
|
||
WorkbookView.prototype._onWSSelectionChanged = function(isSaving) {
|
||
if (!this._updateSelectionInfo()) {
|
||
return;
|
||
}
|
||
|
||
// При редактировании ячейки не нужно пересылать изменения
|
||
if (this.input && !this.getCellEditMode()) {
|
||
// Сами запретим заходить в строку формул, когда выделен shape
|
||
if (this.lastSendInfoRangeIsSelectOnShape) {
|
||
this.input.disabled = true;
|
||
this.input.value = '';
|
||
} else {
|
||
this.input.disabled = false;
|
||
this.input.value = this.oSelectionInfo.text;
|
||
}
|
||
AscCommon.applyElementDirection(this.input);
|
||
}
|
||
this.handlers.trigger("asc_onSelectionChanged", this.oSelectionInfo);
|
||
this.handlers.trigger("asc_onSelectionEnd");
|
||
//если меняется выделенный диапазон
|
||
this.SearchEngine && this.SearchEngine.ResetCurrent(true);
|
||
|
||
this._onInputMessage();
|
||
if (!isSaving) {
|
||
this.Api.cleanSpelling();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onInputMessage = function () {
|
||
var title = null, message = null;
|
||
var dataValidation = this.oSelectionInfo && this.oSelectionInfo.dataValidation;
|
||
if (dataValidation && dataValidation.showInputMessage && !this.model.getActiveWs().getDisablePrompts()) {
|
||
title = dataValidation.promptTitle;
|
||
message = dataValidation.prompt;
|
||
}
|
||
this.handlers.trigger("asc_onInputMessage", title, message);
|
||
};
|
||
|
||
WorkbookView.prototype._onScrollReinitialize = function (type) {
|
||
if (window["NATIVE_EDITOR_ENJINE"] || !type) {
|
||
return;
|
||
}
|
||
|
||
var ws = this.getWorksheet();
|
||
if (AscCommonExcel.c_oAscScrollType.ScrollHorizontal & type) {
|
||
this.controller.reinitScrollX(this.controller.hsbApi.settings, this.getSmoothScrolling() ? ws.getFirstVisibleColSmoothScroll(true) : ws.getFirstVisibleCol(true), ws.getHorizontalScrollRange(), ws.getHorizontalScrollMax());
|
||
}
|
||
if (AscCommonExcel.c_oAscScrollType.ScrollVertical & type) {
|
||
this.controller.reinitScrollY(this.controller.vsbApi.settings, this.getSmoothScrolling() ? ws.getFirstVisibleRowSmoothScroll(true) : ws.getFirstVisibleRow(true), ws.getVerticalScrollRange(), ws.getVerticalScrollMax());
|
||
}
|
||
|
||
if (this.MobileTouchManager) {
|
||
this.MobileTouchManager.Resize();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onInitRowsCount = function () {
|
||
var ws = this.getWorksheet();
|
||
if (ws._initRowsCount()) {
|
||
this._onScrollReinitialize(AscCommonExcel.c_oAscScrollType.ScrollVertical);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onInitColsCount = function () {
|
||
var ws = this.getWorksheet();
|
||
if (ws._initColsCount()) {
|
||
this._onScrollReinitialize(AscCommonExcel.c_oAscScrollType.ScrollHorizontal);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onScrollY = function (pos, initRowsCount, bDefaultStep) {
|
||
let ws = this.getWorksheet();
|
||
let t = this;
|
||
let doScroll = function () {
|
||
var delta = !t.getSmoothScrolling() ? (asc_round(pos - ws.getFirstVisibleRow(true))) : (pos - ws.getFirstVisibleRowSmoothScroll(true));
|
||
if (delta !== 0) {
|
||
ws.scrollVertical(delta, t.cellEditor, initRowsCount);
|
||
}
|
||
}
|
||
if (bDefaultStep) {
|
||
ws.executeScrollDefaultStep(function () {
|
||
doScroll();
|
||
})
|
||
} else {
|
||
doScroll();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onScrollX = function (pos, initColsCount, bDefaultStep) {
|
||
let ws = this.getWorksheet();
|
||
let t = this;
|
||
let doScroll = function () {
|
||
var delta = !t.getSmoothScrolling() ? (asc_round(pos - ws.getFirstVisibleCol(true))) : (pos - ws.getFirstVisibleColSmoothScroll(true));
|
||
if (delta !== 0) {
|
||
ws.scrollHorizontal(delta, t.cellEditor, initColsCount);
|
||
}
|
||
}
|
||
if (bDefaultStep) {
|
||
ws.executeScrollDefaultStep(function () {
|
||
doScroll();
|
||
})
|
||
} else {
|
||
doScroll();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onSetSelection = function(range) {
|
||
var ws = this.getWorksheet();
|
||
ws._endSelectionShape();
|
||
ws.setSelection(range);
|
||
};
|
||
|
||
WorkbookView.prototype._onGetSelectionState = function() {
|
||
var res = null;
|
||
var ws = this.getWorksheet(null, true);
|
||
if (ws && AscCommon.isRealObject(ws.objectRender) && AscCommon.isRealObject(ws.objectRender.controller)) {
|
||
res = ws.objectRender.controller.getSelectionState();
|
||
}
|
||
return (res && res[0] && res[0].focus) ? res : null;
|
||
};
|
||
|
||
WorkbookView.prototype._onSetSelectionState = function(state) {
|
||
if (null !== state) {
|
||
var ws = this.getWorksheetById(state[0].worksheetId);
|
||
if (ws && ws.objectRender && ws.objectRender.controller) {
|
||
ws.objectRender.controller.setSelectionState(state);
|
||
ws.setSelectionShape(true);
|
||
ws._scrollToRange(ws.objectRender.getSelectedDrawingsRange());
|
||
ws.objectRender.showDrawingObjectsEx();
|
||
ws.objectRender.controller.updateOverlay();
|
||
ws.objectRender.controller.updateSelectionState();
|
||
}
|
||
// Селектим после выставления состояния
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.isInnerOfWorksheet = function (x, y) {
|
||
var ws = this.getWorksheet();
|
||
return x >= ws.cellsLeft && y >= ws.cellsTop;
|
||
};
|
||
|
||
WorkbookView.prototype._onChangeVisibleArea = function (isStartPoint, dc, dr, isCtrl, callback, isRelative) {
|
||
var ws = this.getWorksheet();
|
||
var d = isStartPoint ? ws.changeVisibleAreaStartPoint(dc, dr, isCtrl, isRelative) :
|
||
ws.changeVisibleAreaEndPoint(dc, dr, isCtrl, isRelative);
|
||
|
||
asc_applyFunction(callback, d);
|
||
};
|
||
|
||
WorkbookView.prototype._onChangeSelection = function (isStartPoint, dc, dr, isCoord, isCtrl, callback) {
|
||
if (!this._checkStopCellEditorInFormulas()) {
|
||
return;
|
||
}
|
||
|
||
var ws = this.getWorksheet();
|
||
if (ws.model.getSheetProtection(Asc.c_oAscSheetProtectType.selectUnlockedCells)) {
|
||
return;
|
||
}
|
||
if (ws.model.getSheetProtection(Asc.c_oAscSheetProtectType.selectLockedCells)) {
|
||
//TODO _getRangeByXY ?
|
||
var newRange = isCoord ? ws._getRangeByXY(dc, dr) :
|
||
ws._calcSelectionEndPointByOffset(dc, dr);
|
||
var lockedCell = ws.model.getLockedCell(newRange.c2, newRange.r2);
|
||
if (lockedCell || lockedCell === null) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (this.selectionDialogMode && !ws.model.selectionRange) {
|
||
if (isCoord) {
|
||
ws.model.selectionRange = new AscCommonExcel.SelectionRange(ws.model);
|
||
|
||
// remove first range if we paste argument with ctrl key
|
||
if (isCtrl && ws.model.selectionRange.ranges && Array.isArray(ws.model.selectionRange.ranges)) {
|
||
ws.model.selectionRange.ranges.shift();
|
||
}
|
||
|
||
isStartPoint = true;
|
||
} else {
|
||
ws.model.selectionRange = ws.model.copySelection.clone();
|
||
}
|
||
}
|
||
|
||
var t = this;
|
||
var d = isStartPoint ? ws.changeSelectionStartPoint(dc, dr, isCoord, isCtrl) :
|
||
ws.changeSelectionEndPoint(dc, dr, isCoord, isCoord && this.keepType);
|
||
if (!isCoord && !isStartPoint) {
|
||
// Выделение с зажатым shift
|
||
this.canUpdateAfterShiftUp = true;
|
||
}
|
||
this.keepType = isCoord;
|
||
if (isCoord && !this.timerEnd && this.timerId === null) {
|
||
this.timerId = setTimeout(function () {
|
||
var arrClose = [];
|
||
arrClose.push(new asc_CMM({type: c_oAscMouseMoveType.None}));
|
||
t.handlers.trigger("asc_onMouseMove", arrClose);
|
||
t._onUpdateCursor(AscCommon.Cursors.CellCur);
|
||
t.timerId = null;
|
||
t.timerEnd = true;
|
||
}, 1000);
|
||
}
|
||
|
||
if (this.isFormulaEditMode && this.isCellEditMode && this.cellEditor && this.cellEditor.openFromTopLine) {
|
||
/* set focus to the top formula entry line */
|
||
this.cellEditor.restoreFocus();
|
||
}
|
||
|
||
asc_applyFunction(callback, d);
|
||
};
|
||
|
||
// Окончание выделения
|
||
WorkbookView.prototype._onChangeSelectionDone = function(x, y, event) {
|
||
if (this.timerId !== null) {
|
||
clearTimeout(this.timerId);
|
||
this.timerId = null;
|
||
}
|
||
this.keepType = false;
|
||
if (this.selectionDialogMode) {
|
||
return;
|
||
}
|
||
var formatPainterState = this.Api.getFormatPainterState();
|
||
var ws = this.getWorksheet();
|
||
ws.changeSelectionDone();
|
||
this._onSelectionNameChanged(ws.getSelectionName(/*bRangeText*/false));
|
||
// Проверим, нужно ли отсылать информацию о ячейке
|
||
var ar = ws.model.selectionRange.getLast();
|
||
var isSelectOnShape = ws.getSelectionShape();
|
||
this.MacrosAddData(AscDFH.historydescription_Spreadsheet_SelectRange, [ar]);
|
||
|
||
if (!this._isEqualRange(ws.model.selectionRange, isSelectOnShape)) {
|
||
this._onWSSelectionChanged();
|
||
let t = this;
|
||
ws.getSelectionMathInfo(function (info) {
|
||
t._onSelectionMathInfoChanged(info);
|
||
});
|
||
this.controller.lastTab = null;
|
||
}
|
||
|
||
// Нужно очистить поиск
|
||
this.model.cleanFindResults();
|
||
|
||
var ct = ws.getCursorTypeFromXY(x, y);
|
||
var t = this;
|
||
|
||
if(!this.isFormulaEditMode && !formatPainterState) {
|
||
if (c_oTargetType.Hyperlink === ct.target) {
|
||
// Проверим замерженность
|
||
var isHyperlinkClick = false;
|
||
if(isSelectOnShape) {
|
||
var button = 0;
|
||
if(event) {
|
||
button = AscCommon.getMouseButton(event);
|
||
}
|
||
if(button === 0) {
|
||
isHyperlinkClick = true;
|
||
}
|
||
}
|
||
else if(ar.isOneCell()) {
|
||
isHyperlinkClick = true;
|
||
}
|
||
else {
|
||
var mergedRange = ws.model.getMergedByCell(ar.r1, ar.c1);
|
||
if (mergedRange && ar.isEqual(mergedRange)) {
|
||
isHyperlinkClick = true;
|
||
}
|
||
}
|
||
if (isHyperlinkClick && !this.timerEnd) {
|
||
if (false === ct.hyperlink.hyperlinkModel.getVisited() && !isSelectOnShape) {
|
||
ct.hyperlink.hyperlinkModel.setVisited(true);
|
||
if (ct.hyperlink.hyperlinkModel.Ref) {
|
||
ws._updateRange(ct.hyperlink.hyperlinkModel.Ref.getBBox0());
|
||
ws.draw();
|
||
}
|
||
}
|
||
|
||
let type = ct.hyperlink.asc_getType();
|
||
let hyperlink = ct.hyperlink;
|
||
let hyperlinkProps = hyperlink.calculateProps();
|
||
if (hyperlinkProps) {
|
||
type = hyperlinkProps.asc_getType();
|
||
hyperlink = hyperlinkProps;
|
||
}
|
||
|
||
switch (type) {
|
||
case Asc.c_oAscHyperlinkType.WebLink:
|
||
this.handlers.trigger("asc_onHyperlinkClick", hyperlink.asc_getHyperlinkUrl());
|
||
break;
|
||
case Asc.c_oAscHyperlinkType.RangeLink:
|
||
// ToDo надо поправить отрисовку комментария для данной ячейки (с которой уходим)
|
||
this.handlers.trigger("asc_onHideComment");
|
||
this.Api._asc_setWorksheetRange(hyperlink);
|
||
break;
|
||
case Asc.c_oAscHyperlinkType.FileLink:
|
||
//нужно открыть файл через диалоговое окно
|
||
this.handlers.trigger("asc_onConfirmAction", Asc.c_oAscConfirm.ConfirmFileOpen, function (can) {
|
||
if (can) {
|
||
t.handlers.trigger("asc_onFileOpenClick", hyperlink.asc_getHyperlinkUrl());
|
||
}
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if(isSelectOnShape && c_oTargetType.Shape === ct.target && ct.macro) {
|
||
var button = 0;
|
||
if(event) {
|
||
button = AscCommon.getMouseButton(event);
|
||
}
|
||
if(button === 0) {
|
||
if(!this.timerEnd) {
|
||
this.Api.asc_runMacros(ct.macro);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//this.FinalizeAction();
|
||
this.timerEnd = false;
|
||
};
|
||
|
||
// Обработка нажатия правой кнопки мыши
|
||
WorkbookView.prototype._onChangeSelectionRightClick = function(dc, dr, target) {
|
||
var ws = this.getWorksheet();
|
||
ws.changeSelectionStartPointRightClick(dc, dr, target);
|
||
};
|
||
|
||
// Обработка движения в выделенной области
|
||
WorkbookView.prototype._onSelectionActivePointChanged = function(dc, dr, callback) {
|
||
var ws = this.getWorksheet();
|
||
var d = ws.changeSelectionActivePoint(dc, dr);
|
||
asc_applyFunction(callback, d);
|
||
};
|
||
|
||
WorkbookView.prototype._onPointerDownPlaceholder = function (x, y) {
|
||
if(window["IS_NATIVE_EDITOR"]) {
|
||
return false;
|
||
}
|
||
|
||
const oWS = this.getWorksheet();
|
||
if (x < oWS.cellsLeft || y < oWS.cellsTop) {
|
||
return false;
|
||
}
|
||
const oDrawingDocument = oWS.getDrawingDocument();
|
||
const nPage = this.model.nActive;
|
||
const oContext = this.trackOverlay.m_oContext;
|
||
const oRect = {};
|
||
const nLeft = 2 * oWS.cellsLeft - oWS._getColLeft(oWS.visibleRange.c1);
|
||
const nTop = 2 * oWS.cellsTop - oWS._getRowTop(oWS.visibleRange.r1);
|
||
oRect.left = nLeft;
|
||
oRect.right = nLeft + AscCommon.AscBrowser.convertToRetinaValue(oContext.canvas.width);
|
||
oRect.top = nTop;
|
||
oRect.bottom = nTop + AscCommon.AscBrowser.convertToRetinaValue(oContext.canvas.height);
|
||
const nPXtoMM = Asc.getCvtRatio(0/*mm*/, 3/*px*/, oWS._getPPIX());
|
||
const oOffsets = oWS.objectRender.drawingArea.getOffsets(x, y, true);
|
||
let nX = x;
|
||
let nY = y;
|
||
if (oOffsets) {
|
||
nX -= oOffsets.x;
|
||
nY -= oOffsets.y;
|
||
}
|
||
nX *= nPXtoMM;
|
||
nY *= nPXtoMM;
|
||
return oDrawingDocument.placeholders.onPointerDown({X: nX, Y: nY, Page: nPage}, oRect, oContext.canvas.width * nPXtoMM, oContext.canvas.height * nPXtoMM);
|
||
};
|
||
|
||
WorkbookView.prototype._onUpdateWorksheet = function(x, y, ctrlKey, callback) {
|
||
var ws = this.getWorksheet(), ct = undefined;
|
||
var arrMouseMoveObjects = []; // Теперь это массив из объектов, над которыми курсор
|
||
var t = this;
|
||
//ToDo: включить определение target, если находимся в режиме редактирования ячейки.
|
||
if (x === undefined && y === undefined) {
|
||
ws.cleanHighlightedHeaders();
|
||
if (this.timerId === null) {
|
||
this.timerId = setTimeout(function () {
|
||
var arrClose = [];
|
||
arrClose.push(new asc_CMM({type: c_oAscMouseMoveType.None}));
|
||
t.handlers.trigger("asc_onMouseMove", arrClose);
|
||
t.timerId = null;
|
||
}, 1000);
|
||
}
|
||
} else {
|
||
ct = ws.getCursorTypeFromXY(x, y);
|
||
ct.coordX = x;
|
||
ct.coordY = y;
|
||
if (this.timerId !== null) {
|
||
clearTimeout(this.timerId);
|
||
this.timerId = null;
|
||
}
|
||
|
||
// Отправление эвента об удалении всего листа (именно удалении, т.к. если просто залочен, то не рисуем рамку вокруг)
|
||
if (undefined !== ct.userIdAllSheet) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.LockedObject,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(ct.lockAllPosLeft),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(ct.lockAllPosTop),
|
||
userId: ct.userIdAllSheet,
|
||
lockedObjectType: Asc.c_oAscMouseMoveLockedObjectType.Sheet
|
||
}));
|
||
} else {
|
||
// Отправление эвента о залоченности свойств всего листа (только если не удален весь лист)
|
||
if (undefined !== ct.userIdAllProps) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.LockedObject,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(ct.lockAllPosLeft),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(ct.lockAllPosTop),
|
||
userId: ct.userIdAllProps,
|
||
lockedObjectType: Asc.c_oAscMouseMoveLockedObjectType.TableProperties
|
||
}));
|
||
}
|
||
}
|
||
// Отправление эвента о наведении на залоченный объект
|
||
if (undefined !== ct.userId) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.LockedObject,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(ct.lockRangePosLeft),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(ct.lockRangePosTop),
|
||
userId: ct.userId,
|
||
lockedObjectType: Asc.c_oAscMouseMoveLockedObjectType.Range
|
||
}));
|
||
}
|
||
|
||
// Отправление эвента о наведении на залоченный объект
|
||
if (undefined !== ct.userIdForeignSelect) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.ForeignSelect,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(ct.foreignSelectPosLeft),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(ct.foreignSelectPosTop),
|
||
userId: ct.userIdForeignSelect,
|
||
color: AscCommon.getUserColorById(ct.shortIdForeignSelect, null, true)
|
||
}));
|
||
}
|
||
|
||
|
||
// Проверяем комментарии ячейки
|
||
if (ct.commentIndexes) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.Comment,
|
||
x: ct.commentCoords.dLeftPX,
|
||
reverseX: ct.commentCoords.dReverseLeftPX,
|
||
y: ct.commentCoords.dTopPX,
|
||
aCommentIndexes: ct.commentIndexes
|
||
}));
|
||
}
|
||
// Проверяем гиперссылку
|
||
if (ct.target === c_oTargetType.Hyperlink) {
|
||
if (!ctrlKey) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.Hyperlink,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(x),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(y),
|
||
hyperlink: ct.hyperlink
|
||
}));
|
||
} else {
|
||
ct.cursor = AscCommon.Cursors.CellCur;
|
||
}
|
||
}
|
||
if (ct.target === c_oTargetType.Placeholder) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.Placeholder,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(x),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(y),
|
||
placeholderType: ct.placeholderType
|
||
}));
|
||
}
|
||
|
||
// проверяем фильтр
|
||
if (ct.target === c_oTargetType.FilterObject) {
|
||
var filterObj;
|
||
if (ct.idPivot) {
|
||
filterObj = ws.pivot_setDialogProp(ct.idPivot);
|
||
} else {
|
||
filterObj = ws.af_setDialogProp(ct.idFilter, true);
|
||
}
|
||
if(filterObj) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.Filter,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(x),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(y),
|
||
filter: filterObj
|
||
}));
|
||
}
|
||
}
|
||
|
||
// check shape
|
||
if (ct.target === c_oTargetType.Shape) {
|
||
if(typeof ct.tooltip === "string" && ct.tooltip.length > 0) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.Tooltip,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(x),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(y),
|
||
tooltip: ct.tooltip
|
||
}));
|
||
}
|
||
}
|
||
|
||
if(this.Api.isEyedropperStarted()) {
|
||
arrMouseMoveObjects.push(new asc_CMM({
|
||
type: c_oAscMouseMoveType.Eyedropper,
|
||
x: AscCommon.AscBrowser.convertToRetinaValue(x),
|
||
y: AscCommon.AscBrowser.convertToRetinaValue(y),
|
||
color: ct.color
|
||
}));
|
||
}
|
||
/* Проверяем, может мы на никаком объекте (такая схема оказалась приемлимой
|
||
* для отдела разработки приложений)
|
||
*/
|
||
if (0 === arrMouseMoveObjects.length) {
|
||
// Отправляем эвент, что мы ни на какой области
|
||
arrMouseMoveObjects.push(new asc_CMM({type: c_oAscMouseMoveType.None}));
|
||
}
|
||
// Отсылаем эвент с объектами
|
||
this.handlers.trigger("asc_onMouseMove", arrMouseMoveObjects);
|
||
|
||
if (ct.target === c_oTargetType.MoveRange && ctrlKey && ct.cursor === "move") {
|
||
ct.cursor = "copy";
|
||
}
|
||
|
||
const oDrawingDocument = Asc.editor.wbModel.DrawingDocument;
|
||
if(oDrawingDocument.m_sLockedCursorType !== "") {
|
||
ct.cursor = oDrawingDocument.m_sLockedCursorType;
|
||
}
|
||
|
||
if (ws.startCellMoveRange && ws.startCellMoveRange.colRowMoveProps) {
|
||
ct.cursor = "grabbing";
|
||
}
|
||
|
||
this._onUpdateCursor(ct.cursor);
|
||
if (ct.target === c_oTargetType.ColumnHeader || ct.target === c_oTargetType.RowHeader) {
|
||
ws.drawHighlightedHeaders(ct.col, ct.row);
|
||
} else {
|
||
ws.cleanHighlightedHeaders();
|
||
}
|
||
}
|
||
asc_applyFunction(callback, ct);
|
||
};
|
||
|
||
WorkbookView.prototype._onUpdateCursor = function (cursor) {
|
||
var newHtmlCursor = AscCommon.g_oHtmlCursor.value(cursor);
|
||
if (this.element.style.cursor !== newHtmlCursor) {
|
||
this.element.style.cursor = newHtmlCursor;
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onResizeElement = function(target, x, y) {
|
||
var arrMouseMoveObjects = [];
|
||
if (target.target === c_oTargetType.ColumnResize) {
|
||
arrMouseMoveObjects.push(this.getWorksheet().drawColumnGuides(target.col, x, y, target.mouseX));
|
||
} else if (target.target === c_oTargetType.RowResize) {
|
||
arrMouseMoveObjects.push(this.getWorksheet().drawRowGuides(target.row, x, y, target.mouseY));
|
||
}
|
||
|
||
/* Проверяем, может мы на никаком объекте (такая схема оказалась приемлимой
|
||
* для отдела разработки приложений)
|
||
*/
|
||
if (0 === arrMouseMoveObjects.length) {
|
||
// Отправляем эвент, что мы ни на какой области
|
||
arrMouseMoveObjects.push(new asc_CMM({type: c_oAscMouseMoveType.None}));
|
||
}
|
||
// Отсылаем эвент с объектами
|
||
this.handlers.trigger("asc_onMouseMove", arrMouseMoveObjects);
|
||
};
|
||
|
||
WorkbookView.prototype._onResizeElementDone = function(target, x, y, isResizeModeMove) {
|
||
var ws = this.getWorksheet();
|
||
if (isResizeModeMove) {
|
||
if (target.target === c_oTargetType.ColumnResize) {
|
||
ws.changeColumnWidth(target.col, x, target.mouseX);
|
||
} else if (target.target === c_oTargetType.RowResize) {
|
||
ws.changeRowHeight(target.row, y, target.mouseY);
|
||
}
|
||
window['AscCommon'].g_specialPasteHelper.SpecialPasteButton_Update_Position();
|
||
this._onDocumentPlaceChanged();
|
||
}
|
||
ws.draw();
|
||
|
||
// Отсылаем окончание смены размеров (в FF не срабатывало обычное движение)
|
||
this.handlers.trigger("asc_onMouseMove", [new asc_CMM({type: c_oAscMouseMoveType.None})]);
|
||
};
|
||
|
||
// Обработка автозаполнения
|
||
WorkbookView.prototype._onChangeFillHandle = function(x, y, callback, tableIndex) {
|
||
var ws = this.getWorksheet();
|
||
var d = ws.changeSelectionFillHandle(x, y, tableIndex);
|
||
asc_applyFunction(callback, d);
|
||
};
|
||
|
||
// Обработка окончания автозаполнения
|
||
WorkbookView.prototype._onChangeFillHandleDone = function(x, y, ctrlPress) {
|
||
var ws = this.getWorksheet();
|
||
ws.applyFillHandle(x, y, ctrlPress);
|
||
};
|
||
|
||
WorkbookView.prototype.fillHandleDone = function(range) {
|
||
var ws = this.getWorksheet();
|
||
ws.fillHandleDone(range);
|
||
};
|
||
|
||
WorkbookView.prototype.canFillHandle = function(range, checkColRowLimits) {
|
||
var ws = this.getWorksheet();
|
||
return ws.canFillHandle(range, checkColRowLimits);
|
||
};
|
||
|
||
|
||
// Обработка перемещения диапазона
|
||
WorkbookView.prototype._onMoveRangeHandle = function(x, y, callback, colRowMoveProps) {
|
||
var ws = this.getWorksheet();
|
||
var d = ws.changeSelectionMoveRangeHandle(x, y, colRowMoveProps);
|
||
asc_applyFunction(callback, d);
|
||
};
|
||
|
||
// Обработка окончания перемещения диапазона
|
||
WorkbookView.prototype._onMoveRangeHandleDone = function(ctrlKey) {
|
||
var ws = this.getWorksheet();
|
||
ws.applyMoveRangeHandle(ctrlKey);
|
||
};
|
||
|
||
WorkbookView.prototype._onMoveResizeRangeHandle = function(x, y, target, callback) {
|
||
var ws = this.getWorksheet();
|
||
var d;
|
||
|
||
if (this.Api.isEditVisibleAreaOleEditor && target.isOleRange) {
|
||
d = ws.changeSelectionMoveResizeVisibleAreaHandle(x, y, target);
|
||
} else if (target.pageBreakSelectionType) {
|
||
d = ws.changePageBreakPreviewAreaHandle(x, y, target);
|
||
} else {
|
||
d = ws.changeSelectionMoveResizeRangeHandle(x, y, target, this.cellEditor);
|
||
}
|
||
|
||
asc_applyFunction(callback, d);
|
||
};
|
||
|
||
WorkbookView.prototype.getOleSize = function () {
|
||
return this.model.getOleSize();
|
||
};
|
||
|
||
WorkbookView.prototype._onMoveResizeRangeHandleDone = function(isPageBreakPreview) {
|
||
var ws = this.getWorksheet();
|
||
isPageBreakPreview ? ws.applyResizePageBreakPreviewRangeHandle() : ws.applyMoveResizeRangeHandle();
|
||
};
|
||
|
||
// Frozen anchor
|
||
WorkbookView.prototype._onMoveFrozenAnchorHandle = function(x, y, target) {
|
||
var ws = this.getWorksheet();
|
||
ws.drawFrozenGuides(x, y, target);
|
||
};
|
||
|
||
WorkbookView.prototype._onMoveFrozenAnchorHandleDone = function(x, y, target) {
|
||
// Закрепляем область
|
||
var ws = this.getWorksheet();
|
||
ws.applyFrozenAnchor(x, y, target);
|
||
};
|
||
|
||
WorkbookView.prototype.showAutoComplete = function() {
|
||
var ws = this.getWorksheet();
|
||
var arrValues = ws.getCellAutoCompleteValues(ws.model.selectionRange.activeCell);
|
||
this.handlers.trigger('asc_onEntriesListMenu', arrValues);
|
||
};
|
||
|
||
WorkbookView.prototype._onAutoFiltersClick = function(idFilter) {
|
||
this.getWorksheet().af_setDialogProp(idFilter);
|
||
};
|
||
|
||
WorkbookView.prototype._onTableTotalClick = function(idTableTotal) {
|
||
var ws = this.getWorksheet();
|
||
if (idTableTotal) {
|
||
var _table = ws.model.TableParts ? ws.model.TableParts[idTableTotal.id] : null;
|
||
if (_table) {
|
||
var _tableColumn = _table.TableColumns[idTableTotal.colId];
|
||
if (_tableColumn) {
|
||
var val = _tableColumn.TotalsRowFunction;
|
||
if (null === val) {
|
||
val = Asc.ETotalsRowFunction.totalrowfunctionNone;
|
||
}
|
||
this.handlers.trigger("asc_onTableTotalMenu", val);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onPivotFiltersClick = function(idPivot) {
|
||
var filterObj = this.getWorksheet().pivot_setDialogProp(idPivot);
|
||
if (filterObj) {
|
||
this.handlers.trigger("asc_onSetAFDialog", filterObj);
|
||
}
|
||
};
|
||
WorkbookView.prototype._onPivotCollapseClick = function(idPivotCollapse) {
|
||
if (!idPivotCollapse || idPivotCollapse.hidden) {
|
||
return;
|
||
}
|
||
var pivotTable = this.model.getPivotTableById(idPivotCollapse.id);
|
||
if (!pivotTable) {
|
||
return;
|
||
}
|
||
pivotTable.setVisibleFieldItem(this.Api, !idPivotCollapse.sd, idPivotCollapse.fld, idPivotCollapse.index);
|
||
};
|
||
|
||
WorkbookView.prototype._onRefreshConnections = function(isAll) {
|
||
//todo all connections
|
||
if (isAll) {
|
||
this.Api.asc_refreshAllPivots();
|
||
return true;
|
||
}
|
||
let pivot = this.getSelectionInfo().asc_getPivotTableInfo();
|
||
pivot && pivot.asc_refresh(this.Api);
|
||
return !!pivot;
|
||
};
|
||
|
||
WorkbookView.prototype._onGroupRowClick = function(x, y, target, type) {
|
||
return this.getWorksheet().groupRowClick(x, y, target, type);
|
||
};
|
||
|
||
WorkbookView.prototype._onChangeTableSelection = function(target) {
|
||
var ws = this.getWorksheet();
|
||
if (ws && ws.model && target) {
|
||
var table = ws.model.TableParts[target.tableIndex];
|
||
if (table) {
|
||
ws.changeTableSelection(table.DisplayName, target.type, target.row, target.col);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onCommentCellClick = function(x, y) {
|
||
this.getWorksheet().cellCommentator.showCommentByXY(x, y);
|
||
};
|
||
|
||
WorkbookView.prototype._onUpdateSelectionName = function (forcibly) {
|
||
if (this.canUpdateAfterShiftUp || forcibly) {
|
||
this.canUpdateAfterShiftUp = false;
|
||
var ws = this.getWorksheet();
|
||
this._onSelectionNameChanged(ws.getSelectionName(/*bRangeText*/false));
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onStopFormatPainter = function (bLockDraw) {
|
||
if (this.Api.getFormatPainterState() !== c_oAscFormatPainterState.kOff) {
|
||
this.Api.changeFormatPainterState(c_oAscFormatPainterState.kOff, bLockDraw);
|
||
//update cursor
|
||
const oTargetInfo = this.controller.targetInfo;
|
||
if (oTargetInfo) {
|
||
this._onUpdateWorksheet(oTargetInfo.coordX, oTargetInfo.coordY, false);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onShowFormulas = function () {
|
||
let ws = this.getWorksheet();
|
||
let showFormulasVal = ws.model && ws.model.getShowFormulas();
|
||
ws.changeSheetViewSettings(AscCH.historyitem_Worksheet_SetShowFormulas, !showFormulasVal);
|
||
};
|
||
|
||
// Shapes
|
||
WorkbookView.prototype._onGraphicObjectMouseDown = function(e, x, y) {
|
||
var ws = this.getWorksheet();
|
||
ws.objectRender.graphicObjectMouseDown(e, x, y);
|
||
};
|
||
|
||
WorkbookView.prototype._onGraphicObjectMouseMove = function(e, x, y) {
|
||
var ws = this.getWorksheet();
|
||
ws.objectRender.graphicObjectMouseMove(e, x, y);
|
||
};
|
||
|
||
WorkbookView.prototype._onGraphicObjectMouseUp = function(e, x, y) {
|
||
var ws = this.getWorksheet();
|
||
ws.objectRender.graphicObjectMouseUp(e, x, y);
|
||
};
|
||
|
||
WorkbookView.prototype._onGraphicObjectMouseUpEx = function(e, x, y) {
|
||
//var ws = this.getWorksheet();
|
||
//ws.objectRender.calculateCell(x, y);
|
||
};
|
||
|
||
WorkbookView.prototype._onGraphicObjectWindowKeyDown = function(e) {
|
||
var objectRender = this.getWorksheet().objectRender;
|
||
return (0 < objectRender.getSelectedGraphicObjects().length) ? objectRender.graphicObjectKeyDown(e) : false;
|
||
};
|
||
WorkbookView.prototype._onGraphicObjectWindowKeyUp = function(e) {
|
||
var oWS, bRet = false;
|
||
for(var i in this.wsViews) {
|
||
oWS = this.wsViews[i];
|
||
if(oWS && oWS.objectRender) {
|
||
bRet |= oWS.objectRender.graphicObjectKeyUp(e);
|
||
}
|
||
}
|
||
return bRet;
|
||
};
|
||
|
||
WorkbookView.prototype._onGraphicObjectWindowKeyPress = function(e) {
|
||
var objectRender = this.getWorksheet().objectRender;
|
||
return (0 < objectRender.getSelectedGraphicObjects().length) ? objectRender.graphicObjectKeyPress(e) : false;
|
||
};
|
||
WorkbookView.prototype._onGraphicObjectWindowEnterText = function(codePoints) {
|
||
var objectRender = this.getWorksheet().objectRender;
|
||
return objectRender.controller && (0 < objectRender.getSelectedGraphicObjects().length) ? objectRender.controller.enterText(codePoints) : false;
|
||
};
|
||
WorkbookView.prototype._onGraphicObjecMouseWheel = function(deltaX, deltaY) {
|
||
var objectRender = this.getWorksheet().objectRender;
|
||
if(objectRender && objectRender.controller) {
|
||
return objectRender.controller.onMouseWheel(deltaX, deltaY);
|
||
}
|
||
return false;
|
||
};
|
||
|
||
WorkbookView.prototype._onGetGraphicsInfo = function(x, y) {
|
||
var ws = this.getWorksheet();
|
||
return ws.objectRender.checkCursorDrawingObject(x, y);
|
||
};
|
||
|
||
WorkbookView.prototype._onUpdateSelectionShape = function(isSelectOnShape) {
|
||
var ws = this.getWorksheet();
|
||
return ws.setSelectionShape(isSelectOnShape);
|
||
};
|
||
|
||
// Double click
|
||
WorkbookView.prototype._onMouseDblClick = function(x, y, event, callback) {
|
||
const ws = this.getWorksheet();
|
||
const ct = ws.getCursorTypeFromXY(x, y, true);
|
||
|
||
if (ct.target === c_oTargetType.TraceDependents && ct.coordLineInfo) {
|
||
let fromCell = ct.coordLineInfo.from;
|
||
let toCell = ct.coordLineInfo.to;
|
||
|
||
/* external ref, open goto window */
|
||
if (ct.coordLineInfo.external) {
|
||
// todo create goto window
|
||
// console.log(ct.coordLineInfo.external);
|
||
return
|
||
}
|
||
|
||
let fromRange = fromCell.areaRange ? fromCell.areaRange : fromCell.cellRange;
|
||
let toRange = toCell.areaRange ? toCell.areaRange : toCell.cellRange;
|
||
let selectedRange = ws.getSelectedRange();
|
||
|
||
if (selectedRange && selectedRange.bbox) {
|
||
if (selectedRange.bbox.isEqual(fromRange)) {
|
||
ws.setSelection(toRange);
|
||
} else {
|
||
ws.setSelection(fromRange);
|
||
}
|
||
return
|
||
}
|
||
|
||
// if we couldn't get the selected range, change the selection
|
||
ws.setSelection(fromRange);
|
||
return
|
||
} else if (ct.target === c_oTargetType.FillHandle) {
|
||
ws.applyFillHandleDoubleClick();
|
||
asc_applyFunction(callback);
|
||
} else if (ct.target === c_oTargetType.ColumnResize || ct.target === c_oTargetType.RowResize) {
|
||
if (ct.target === c_oTargetType.ColumnResize) {
|
||
ws.autoFitColumnsWidth(ct.col);
|
||
} else {
|
||
ws.autoFitRowHeight(ct.row, ct.row);
|
||
}
|
||
asc_applyFunction(callback);
|
||
} else {
|
||
// In view mode or click on column | row | all | frozenMove | drawing object do not process
|
||
if (!this.canEdit() || c_oTargetType.ColumnHeader === ct.target || c_oTargetType.RowHeader === ct.target ||
|
||
c_oTargetType.Corner === ct.target || c_oTargetType.FrozenAnchorH === ct.target ||
|
||
c_oTargetType.FrozenAnchorV === ct.target || ws.objectRender.checkCursorDrawingObject(x, y) ||
|
||
c_oTargetType.ColumnRowHeaderMove === ct.target) {
|
||
asc_applyFunction(callback);
|
||
return;
|
||
}
|
||
var pivotTable = ws.model.getPivotTable(ct.col, ct.row);
|
||
if (pivotTable) {
|
||
if(pivotTable.asc_canShowDetails(ct.row, ct.col)) {
|
||
this.Api.asc_pivotShowDetails(pivotTable);
|
||
return;
|
||
}
|
||
if (pivotTable.canExpandCollapse(ct.row, ct.col)) {
|
||
pivotTable.toggleExpandCollapseByActiveCell(this.Api, false);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// При dbl клике фокус выставляем в зависимости от наличия текста в ячейке
|
||
var enterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
enterOptions.focus = null;
|
||
enterOptions.eventPos = event;
|
||
this._onEditCell(enterOptions);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onWindowMouseUpExternal = function (event, x, y) {
|
||
this.controller._onWindowMouseUpExternal(event, x, y);
|
||
if (this.isCellEditMode) {
|
||
this.cellEditor._onWindowMouseUp(event, x, y);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onEditCell = function (enterOptions, callback) {
|
||
var t = this;
|
||
|
||
// Проверка глобального лока
|
||
if (this.collaborativeEditing.getGlobalLock() || this.controller.isResizeMode || !this.canEdit()) {
|
||
return;
|
||
}
|
||
|
||
var ws = t.getWorksheet();
|
||
var activeCellRange = ws.getActiveCell(0, 0, false);
|
||
var selectionRange = ws.model.selectionRange && ws.model.selectionRange.clone();
|
||
|
||
var activeWsModel = this.model.getActiveWs();
|
||
const pivot = activeWsModel.inPivotTable(activeCellRange);
|
||
if (pivot) {
|
||
if (!pivot.canEditCell(activeCellRange)) {
|
||
if (t.input.isFocused) {
|
||
t._blurCellEditor();
|
||
}
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.LockedCellPivot, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
}
|
||
|
||
var editFunction = function() {
|
||
if (needBlur) {
|
||
t.input && t.input.focus();
|
||
}
|
||
t.setCellEditMode(true);
|
||
t.hideSpecialPasteButton();
|
||
t.handlers.trigger("asc_onToggleAutoCorrectOptions");
|
||
|
||
ws.openCellEditor(t.cellEditor, enterOptions, selectionRange);
|
||
t.input.disabled = false;
|
||
|
||
t.Api.cleanSpelling(true);
|
||
|
||
t.updateTargetForCollaboration();
|
||
t.sendCursor(true);
|
||
|
||
asc_applyFunction(callback, true);
|
||
};
|
||
|
||
var editLockCallback = function(res) {
|
||
if (!res) {
|
||
t.setCellEditMode(false);
|
||
t.input.disabled = true;
|
||
|
||
// Выключаем lock для редактирования ячейки
|
||
t.collaborativeEditing.onStopEditCell();
|
||
t.cellEditor.close(false);
|
||
t._onWSSelectionChanged();
|
||
}
|
||
};
|
||
|
||
var doEdit = function (success) {
|
||
if (!success) {
|
||
return;
|
||
}
|
||
// Стартуем редактировать ячейку
|
||
activeCellRange = ws.expandActiveCellByFormulaArray(activeCellRange);
|
||
if (ws._isLockedCells(activeCellRange, /*subType*/null, editLockCallback)) {
|
||
editFunction();
|
||
}
|
||
};
|
||
|
||
var needBlur = false;
|
||
var needBlurFunc;
|
||
if (t.input && t.input.isFocused) {
|
||
needBlurFunc = function () {
|
||
t._blurCellEditor();
|
||
needBlur = true;
|
||
}
|
||
}
|
||
let checkRange = new Asc.Range(activeCellRange.c1, activeCellRange.r1, activeCellRange.c1, activeCellRange.r1);
|
||
if (ws.model.isIntersectionOtherUserProtectedRanges(checkRange)) {
|
||
//error
|
||
needBlurFunc && needBlurFunc();
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.ProtectedRangeByOtherUser, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
ws.checkProtectRangeOnEdit([checkRange], doEdit, null, needBlurFunc);
|
||
};
|
||
|
||
WorkbookView.prototype._blurCellEditor = function () {
|
||
if (this.Api.isMobileVersion && this.input && this.input.isFocused) {
|
||
this.input.blur();
|
||
}
|
||
this._setEditorFocus();
|
||
};
|
||
|
||
WorkbookView.prototype._setEditorFocus = function () {
|
||
this.element && this.element.focus();
|
||
};
|
||
|
||
/**
|
||
*
|
||
* @return { string } base64 image
|
||
*/
|
||
WorkbookView.prototype.getImageFromTableOleObject = function () {
|
||
const oThis = this;
|
||
return AscFormat.ExecuteNoHistory(function () {
|
||
return this._executeWithoutZoom(function () {
|
||
const oWorksheet = oThis.getWorksheet();
|
||
let sImageBase64;
|
||
if (oWorksheet.isHaveOnlyOneChart()) {
|
||
sImageBase64 = oWorksheet.createImageForChart();
|
||
} else {
|
||
sImageBase64 = oWorksheet.createImageFromMaxRange();
|
||
}
|
||
return sImageBase64;
|
||
});
|
||
}, this, []);
|
||
};
|
||
|
||
WorkbookView.prototype._checkStopCellEditorInFormulas = function() {
|
||
if (this.isCellEditMode && this.isFormulaEditMode && this.cellEditor.canEnterCellRange()) {
|
||
return true;
|
||
}
|
||
return this.closeCellEditor();
|
||
};
|
||
|
||
WorkbookView.prototype._onCloseCellEditor = function() {
|
||
var isCellEditMode = this.getCellEditMode();
|
||
this.setCellEditMode(false);
|
||
|
||
if (isCellEditMode) {
|
||
if (window['IS_NATIVE_EDITOR']) {
|
||
window["native"]["closeCellEditor"]();
|
||
}
|
||
}
|
||
|
||
// Обновляем состояние Undo/Redo
|
||
History._sendCanUndoRedo();
|
||
|
||
var ws = this.getWorksheet();
|
||
ws.cleanSelection();
|
||
ws.updateSelectionWithSparklines();
|
||
// Обновляем состояние информации
|
||
this._onWSSelectionChanged();
|
||
|
||
// Закрываем подбор формулы
|
||
if (-1 !== this.lastFPos) {
|
||
this.handlers.trigger('asc_onFormulaCompleteMenu', null);
|
||
this.lastFPos = -1;
|
||
this.lastFNameLength = 0;
|
||
}
|
||
this.handlers.trigger('asc_onFormulaInfo', null);
|
||
|
||
this.updateTargetForCollaboration();
|
||
this.sendCursor();
|
||
|
||
this.externalSelectionController.sendExternalCloseEditor();
|
||
};
|
||
|
||
WorkbookView.prototype._onEmpty = function() {
|
||
var ws = this.getWorksheet();
|
||
if (ws) {
|
||
var doDelete = function (success) {
|
||
if (success) {
|
||
ws.emptySelection(c_oAscCleanOptions.Text);
|
||
}
|
||
};
|
||
var selection = ws._getSelection();
|
||
var ranges = selection && selection.ranges;
|
||
if (ws.model.isIntersectionOtherUserProtectedRanges(ranges)) {
|
||
//error
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.ProtectedRangeByOtherUser, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
if (!ws.objectRender.selectedGraphicObjectsExists()) {
|
||
ws.checkProtectRangeOnEdit(ranges, doDelete);
|
||
} else {
|
||
doDelete(true);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onShowNextPrevWorksheet = function(direction) {
|
||
// Колличество листов
|
||
var countWorksheets = this.model.getWorksheetCount();
|
||
// Покажем следующий лист или предыдущий (если больше нет)
|
||
var i = this.wsActive + direction, ws;
|
||
while (i !== this.wsActive) {
|
||
if (0 > i) {
|
||
i = countWorksheets - 1;
|
||
} else if (i >= countWorksheets) {
|
||
i = 0;
|
||
}
|
||
|
||
ws = this.model.getWorksheet(i);
|
||
if (!ws.getHidden()) {
|
||
this.showWorksheet(i);
|
||
return true;
|
||
}
|
||
|
||
i += direction;
|
||
}
|
||
return false;
|
||
};
|
||
|
||
WorkbookView.prototype._onSetFontAttributes = function(prop) {
|
||
var val;
|
||
var xfs = this.getSelectionInfo().asc_getXfs();
|
||
switch (prop) {
|
||
case "b":
|
||
val = !(xfs.asc_getFontBold());
|
||
break;
|
||
case "i":
|
||
val = !(xfs.asc_getFontItalic());
|
||
break;
|
||
case "u":
|
||
// ToDo для двойного подчеркивания нужно будет немного переделать схему
|
||
val = !(xfs.asc_getFontUnderline());
|
||
val = val ? Asc.EUnderline.underlineSingle : Asc.EUnderline.underlineNone;
|
||
break;
|
||
case "s":
|
||
val = !(xfs.asc_getFontStrikeout());
|
||
break;
|
||
}
|
||
return this.setFontAttributes(prop, val);
|
||
};
|
||
|
||
WorkbookView.prototype._onSetCellFormat = function (prop) {
|
||
var info = new Asc.asc_CFormatCellsInfo();
|
||
info.asc_setSymbol(AscCommon.g_oDefaultCultureInfo.LCID);
|
||
info.asc_setType(Asc.c_oAscNumFormatType.None);
|
||
var formats = AscCommon.getFormatCells(info);
|
||
this.setCellFormat(formats[prop]);
|
||
};
|
||
|
||
WorkbookView.prototype.removeEventListeners = function () {
|
||
this.eventListeners.forEach(function (eventInfo) {
|
||
eventInfo.listeningElement.removeEventListener(eventInfo.eventName, eventInfo.listener);
|
||
});
|
||
};
|
||
|
||
WorkbookView.prototype.addEventListeners = function () {
|
||
this.eventListeners.forEach(function (eventInfo) {
|
||
eventInfo.listeningElement.addEventListener(eventInfo.eventName, eventInfo.listener, eventInfo.useCapture);
|
||
});
|
||
};
|
||
|
||
WorkbookView.prototype._onSelectColumnsByRange = function() {
|
||
this.getWorksheet()._selectColumnsByRange();
|
||
};
|
||
|
||
WorkbookView.prototype._onSelectRowsByRange = function() {
|
||
this.getWorksheet()._selectRowsByRange();
|
||
};
|
||
|
||
WorkbookView.prototype._onSelectAllByRange = function() {
|
||
this.getWorksheet()._selectAllByRange();
|
||
};
|
||
|
||
WorkbookView.prototype._onShowCellEditorCursor = function() {
|
||
// Показываем курсор
|
||
if (this.getCellEditMode()) {
|
||
this.cellEditor.showCursor();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.onFrameEditorReady = function () {
|
||
this.handlers.trigger("asc_onFrameEditorReady");
|
||
};
|
||
|
||
WorkbookView.prototype._onDocumentPlaceChanged = function() {
|
||
if (this.isDocumentPlaceChangedEnabled) {
|
||
this.handlers.trigger("asc_onDocumentPlaceChanged");
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getCellStyles = function(width, height) {
|
||
return AscCommonExcel.generateCellStyles(width, height, this);
|
||
};
|
||
WorkbookView.prototype.getSlicerStyles = function() {
|
||
return AscCommonExcel.generateSlicerStyles(36, 48, this);
|
||
};
|
||
|
||
WorkbookView.prototype.getWorksheetById = function(id, onlyExist) {
|
||
var wsModel = this.model.getWorksheetById(id);
|
||
if (wsModel) {
|
||
return this.getWorksheet(wsModel.getIndex(), onlyExist);
|
||
}
|
||
return null;
|
||
};
|
||
|
||
WorkbookView.prototype.getActiveWS = function () {
|
||
return this.model.getWorksheet(-1 === this.copyActiveSheet ? this.wsActive : this.copyActiveSheet)
|
||
};
|
||
|
||
/**
|
||
* @param {Number} [index]
|
||
* @param {Boolean} [onlyExist]
|
||
* @return {AscCommonExcel.WorksheetView}
|
||
*/
|
||
WorkbookView.prototype.getWorksheet = function(index, onlyExist) {
|
||
var wb = this.model;
|
||
var i = asc_typeof(index) === "number" && index >= 0 ? index : wb.getActive();
|
||
var ws = this.wsViews[i];
|
||
if (!ws && !onlyExist) {
|
||
ws = this.wsViews[i] = this._createWorksheetView(wb.getWorksheet(i));
|
||
ws._prepareComments();
|
||
ws._prepareDrawingObjects();
|
||
}
|
||
return ws;
|
||
};
|
||
|
||
|
||
WorkbookView.prototype.drawWorksheet = function () {
|
||
if (-1 === this.wsActive) {
|
||
return this.showWorksheet();
|
||
}
|
||
var ws = this.getWorksheet();
|
||
ws.draw();
|
||
ws.objectRender.controller.updateSelectionState();
|
||
ws.objectRender.controller.updateOverlay();
|
||
this._onScrollReinitialize(AscCommonExcel.c_oAscScrollType.ScrollVertical | AscCommonExcel.c_oAscScrollType.ScrollHorizontal);
|
||
};
|
||
|
||
/**
|
||
*
|
||
* @param index
|
||
* @param [bLockDraw]
|
||
* @returns {WorkbookView}
|
||
*/
|
||
WorkbookView.prototype.showWorksheet = function (index, bLockDraw) {
|
||
if (AscCommon.isFileBuild()) {
|
||
return this;
|
||
}
|
||
// ToDo disable method for assembly
|
||
var ws, wb = this.model;
|
||
if (asc_typeof(index) !== "number" || 0 > index) {
|
||
index = wb.getActive();
|
||
}
|
||
if (index === this.wsActive) {
|
||
if (!bLockDraw) {
|
||
this.drawWorksheet();
|
||
}
|
||
return this;
|
||
}
|
||
|
||
if(this.Api.isEyedropperStarted()) {
|
||
this.Api.cancelEyedropper();
|
||
}
|
||
var selectionRange = null;
|
||
// Только если есть активный
|
||
if (-1 !== this.wsActive) {
|
||
ws = this.getWorksheet();
|
||
// Останавливаем ввод данных в редакторе ввода. Если в режиме ввода формул, то продолжаем работать с cellEditor'ом, чтобы можно было
|
||
// выбирать ячейки для формулы
|
||
if (!this._checkStopCellEditorInFormulas()) {
|
||
index = this.copyActiveSheet;
|
||
} else {
|
||
// todo at this moment information doesn't come from the interface about the SHIFT key is pressed
|
||
// in the future we need to add an additional argument in the current open formula, according with the bug 59698
|
||
let wsByIndex = this.model.getWorksheet(index);
|
||
let sheetStr = wsByIndex.getName() + "!";
|
||
let editModeRange = ws.model.selectionRange && ws.model.selectionRange.getLast();
|
||
let rangeStr = editModeRange ? editModeRange.getName() : "";
|
||
// TODO the position of the cursor in formulaEdit changes to the end of the line
|
||
this._onSelectionRangeChanged(sheetStr + rangeStr);
|
||
}
|
||
// Делаем очистку селекта
|
||
ws.cleanSelection();
|
||
this.stopTarget(ws);
|
||
|
||
if (this.selectionDialogMode) {
|
||
// Copy selection to set on new sheet
|
||
if (ws.model.selectionRange) {
|
||
selectionRange = ws.model.selectionRange.getLast().clone(true);
|
||
}
|
||
ws.cloneSelection(false);
|
||
}
|
||
}
|
||
|
||
if (index !== wb.getActive()) {
|
||
wb.setActive(index);
|
||
}
|
||
this.wsActive = index;
|
||
this.wsMustDraw = bLockDraw;
|
||
|
||
// Посылаем эвент о смене активного листа
|
||
this.handlers.trigger("asc_onActiveSheetChanged", this.wsActive);
|
||
this.handlers.trigger("asc_onHideComment");
|
||
|
||
ws = this.getWorksheet(index);
|
||
if (this.selectionDialogMode) {
|
||
// Когда идет выбор диапазона, то на показываемом листе должны выставить нужный режим
|
||
ws.cloneSelection(true, selectionRange);
|
||
//this._onSelectionRangeChanged(ws.getSelectionRangeValue());
|
||
}
|
||
|
||
// Мы делали resize или меняли zoom, но не перерисовывали данный лист (он был не активный)
|
||
if (ws.updateResize && ws.updateZoom) {
|
||
ws.changeZoomResize();
|
||
} else if (ws.updateResize) {
|
||
ws.resize(true, this.cellEditor);
|
||
} else if (ws.updateZoom) {
|
||
ws.changeZoom(true);
|
||
}
|
||
|
||
this.updateGroupData();
|
||
|
||
if (this.cellEditor && this.isFormulaEditMode) {
|
||
if (this.isActive()) {
|
||
this.cellEditor._showCanvas();
|
||
} else {
|
||
this.cellEditor._hideCanvas();
|
||
}
|
||
}
|
||
|
||
if (!bLockDraw) {
|
||
ws.draw();
|
||
ws.objectRender.controller.updateSelectionState();
|
||
ws.objectRender.controller.updateOverlay();
|
||
}
|
||
|
||
if (!window["NATIVE_EDITOR_ENJINE"] || window["IS_NATIVE_EDITOR"]) {
|
||
this._onSelectionNameChanged(ws.getSelectionName(/*bRangeText*/false));
|
||
this._onWSSelectionChanged();
|
||
let t = this;
|
||
ws.getSelectionMathInfo(function (info) {
|
||
t._onSelectionMathInfoChanged(info);
|
||
});
|
||
|
||
}
|
||
this.checkScrollRtl(ws.getRightToLeft());
|
||
this._onScrollReinitialize(AscCommonExcel.c_oAscScrollType.ScrollVertical | AscCommonExcel.c_oAscScrollType.ScrollHorizontal);
|
||
// Zoom теперь на каждом листе одинаковый, не отправляем смену
|
||
|
||
//TODO при добавлении любого действия в историю (например добавление нового листа), мы можем его потом отменить с повощью опции авторазвертывания
|
||
this.toggleAutoCorrectOptions(null, true);
|
||
window['AscCommon'].g_specialPasteHelper.SpecialPasteButton_Hide();
|
||
ws.objectRender.controller.updatePlaceholders();
|
||
return this;
|
||
};
|
||
|
||
WorkbookView.prototype.stopTarget = function(ws) {
|
||
if (null === ws && -1 !== this.wsActive) {
|
||
ws = this.getWorksheet(this.wsActive);
|
||
}
|
||
if (null !== ws && ws.objectRender && ws.objectRender.drawingDocument) {
|
||
ws.objectRender.drawingDocument.TargetEnd();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.updateWorksheetByModel = function() {
|
||
// ToDo Сделал небольшую заглушку с показом листа. Нужно как мне кажется перейти от wsViews на wsViewsId (хранить по id)
|
||
var oldActiveWs;
|
||
if (-1 !== this.wsActive) {
|
||
oldActiveWs = this.wsViews[this.wsActive];
|
||
}
|
||
|
||
//расставляем ws так как они идут в модели.
|
||
var oNewWsViews = [];
|
||
for (var i in this.wsViews) {
|
||
var item = this.wsViews[i];
|
||
if (null != item && null != this.model.getWorksheetById(item.model.getId())) {
|
||
oNewWsViews[item.model.getIndex()] = item;
|
||
}
|
||
}
|
||
this.wsViews = oNewWsViews;
|
||
var wsActive = this.model.getActive();
|
||
|
||
var newActiveWs = this.wsViews[wsActive];
|
||
if (undefined === newActiveWs || oldActiveWs !== newActiveWs) {
|
||
// Если сменили, то покажем
|
||
this.wsActive = -1;
|
||
this.showWorksheet(wsActive, true);
|
||
} else {
|
||
this.wsActive = wsActive;
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._canResize = function() {
|
||
let showVerticalScroll = this.getShowVerticalScroll();
|
||
let showHorizontalScroll = this.getShowHorizontalScroll();
|
||
|
||
let styleWidth, styleHeight;
|
||
styleWidth = this.element.offsetWidth - (this.Api.isMobileVersion || !showVerticalScroll ? 0 : this.defaults.scroll.widthPx);
|
||
styleHeight = this.element.offsetHeight - (this.Api.isMobileVersion || !showHorizontalScroll ? 0 : this.defaults.scroll.heightPx);
|
||
|
||
this.canvasOverlay.parentNode.style.right = (this.Api.isMobileVersion || !showVerticalScroll) ? 0 : this.defaults.scroll.widthPx + 'px';
|
||
this.canvasOverlay.parentNode.style.bottom = (this.Api.isMobileVersion || !showHorizontalScroll) ? 0 : this.defaults.scroll.heightPx + 'px';
|
||
|
||
|
||
this.isInit = true;
|
||
|
||
this.canvas.style.width = this.canvasOverlay.style.width = this.canvasGraphic.style.width = this.canvasGraphicOverlay.style.width = styleWidth + 'px';
|
||
this.canvas.style.height = this.canvasOverlay.style.height = this.canvasGraphic.style.height = this.canvasGraphicOverlay.style.height = styleHeight + 'px';
|
||
|
||
AscCommon.calculateCanvasSize(this.canvas);
|
||
AscCommon.calculateCanvasSize(this.canvasOverlay);
|
||
AscCommon.calculateCanvasSize(this.canvasGraphic);
|
||
AscCommon.calculateCanvasSize(this.canvasGraphicOverlay);
|
||
|
||
this._reInitGraphics();
|
||
|
||
return true;
|
||
};
|
||
|
||
WorkbookView.prototype._reInitGraphics = function () {
|
||
var canvasWidth = this.canvasGraphic.width;
|
||
var canvasHeight = this.canvasGraphic.height;
|
||
this.shapeCtx.init(this.drawingGraphicCtx.ctx, canvasWidth, canvasHeight, canvasWidth * 25.4 / this.drawingGraphicCtx.ppiX, canvasHeight * 25.4 / this.drawingGraphicCtx.ppiY);
|
||
this.shapeCtx.CalculateFullTransform();
|
||
|
||
var overlayWidth = this.canvasGraphicOverlay.width;
|
||
var overlayHeight = this.canvasGraphicOverlay.height;
|
||
this.shapeOverlayCtx.init(this.overlayGraphicCtx.ctx, overlayWidth, overlayHeight, overlayWidth * 25.4 / this.overlayGraphicCtx.ppiX, overlayHeight * 25.4 / this.overlayGraphicCtx.ppiY);
|
||
this.shapeOverlayCtx.CalculateFullTransform();
|
||
|
||
this.mainGraphics.init(this.drawingCtx.ctx, canvasWidth, canvasHeight, canvasWidth * 25.4 / this.drawingCtx.ppiX, canvasHeight * 25.4 / this.drawingCtx.ppiY);
|
||
|
||
this.trackOverlay.init(this.shapeOverlayCtx.m_oContext, "ws-canvas-graphic-overlay", 0, 0, overlayWidth, overlayHeight, (overlayWidth * 25.4 / this.overlayGraphicCtx.ppiX), (overlayHeight * 25.4 / this.overlayGraphicCtx.ppiY));
|
||
this.autoShapeTrack.init(this.trackOverlay, 0, 0, overlayWidth, overlayHeight, overlayWidth * 25.4 / this.overlayGraphicCtx.ppiX, overlayHeight * 25.4 / this.overlayGraphicCtx.ppiY);
|
||
this.autoShapeTrack.Graphics.CalculateFullTransform();
|
||
if(this.mainOverlay) {
|
||
overlayWidth = this.canvasOverlay.width;
|
||
overlayHeight = this.canvasOverlay.height;
|
||
this.mainOverlay.init(this.overlayCtx.ctx, "ws-canvas-overlay", 0, 0, overlayWidth, overlayHeight, (overlayWidth * 25.4 / this.overlayCtx.ppiX), (overlayHeight * 25.4 / this.overlayCtx.ppiY))
|
||
}
|
||
};
|
||
|
||
/** @param event {jQuery.Event} */
|
||
WorkbookView.prototype.resize = function(event) {
|
||
if (this._canResize()) {
|
||
var item;
|
||
var activeIndex = this.model.getActive();
|
||
for (var i in this.wsViews) {
|
||
item = this.wsViews[i];
|
||
// Делаем resize (для не активных сменим как только сделаем его активным)
|
||
item.resize(/*isDraw*/i == activeIndex, this.cellEditor);
|
||
}
|
||
this.drawWorksheet();
|
||
this.checkScrollRtl(this.getWorksheet().getRightToLeft());
|
||
Asc.editor.toggleChartElementsCallback();
|
||
} else {
|
||
// ToDo не должно происходить ничего, но нам приходит resize сверху, поэтому проверим отрисовывали ли мы
|
||
if (-1 === this.wsActive || this.wsMustDraw) {
|
||
this.drawWorksheet();
|
||
}
|
||
}
|
||
this.wsMustDraw = false;
|
||
};
|
||
|
||
WorkbookView.prototype.getSelectionInfo = function () {
|
||
if (!this.oSelectionInfo) {
|
||
this._updateSelectionInfo();
|
||
}
|
||
return this.oSelectionInfo;
|
||
};
|
||
|
||
// Получаем свойство: редактируем мы сейчас или нет
|
||
WorkbookView.prototype.getCellEditMode = function() {
|
||
return this.isCellEditMode;
|
||
};
|
||
|
||
WorkbookView.prototype.canEdit = function() {
|
||
return this.Api.canEdit();
|
||
};
|
||
|
||
WorkbookView.prototype.isProtectActiveCell = function() {
|
||
var ws = this.getWorksheet();
|
||
if (!ws) {
|
||
return false;
|
||
}
|
||
return ws.isProtectActiveCell();
|
||
};
|
||
|
||
WorkbookView.prototype.isUserProtectActiveCell = function() {
|
||
var ws = this.getWorksheet();
|
||
if (!ws) {
|
||
return false;
|
||
}
|
||
return ws.isUserProtectActiveCell();
|
||
};
|
||
|
||
WorkbookView.prototype.getDialogSheetName = function () {
|
||
return this.dialogSheetName || !this.isActive();
|
||
};
|
||
|
||
WorkbookView.prototype.getDialogBookName = function () {
|
||
return this.dialogBookName;
|
||
};
|
||
|
||
WorkbookView.prototype.setCellEditMode = function(mode) {
|
||
this.isCellEditMode = !!mode;
|
||
if (!this.isCellEditMode) {
|
||
this.setWizardMode(false);
|
||
this.setFormulaEditMode(false);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setFormulaEditMode = function (mode) {
|
||
this.isFormulaEditMode = mode;
|
||
this.setSelectionDialogMode(mode ? c_oAscSelectionDialogType.Function : c_oAscSelectionDialogType.None, '');
|
||
if (mode) {
|
||
this.externalSelectionController.sendExternalSetFormulaEditMode();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setWizardMode = function (mode) {
|
||
if (mode !== this.isWizardMode) {
|
||
this.isWizardMode = mode;
|
||
if (this.isWizardMode) {
|
||
this.cellEditor.updateWizardMode(this.isWizardMode);
|
||
this._onCleanSelectRange(true);
|
||
}
|
||
this.input.disabled = this.isWizardMode;
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.isActive = function () {
|
||
if (this.externalSelectionController.getExternalFormulaEditMode()) {
|
||
return false;
|
||
}
|
||
return (-1 === this.copyActiveSheet || this.wsActive === this.copyActiveSheet);
|
||
};
|
||
|
||
WorkbookView.prototype.isDrawFormatPainter = function () {
|
||
if(this.Api.getFormatPainterState()) {
|
||
let oData = this.Api.getFormatPainterData();
|
||
if(oData && !oData.docData) {
|
||
let oWS = this.getWorksheet();
|
||
if(oWS && oWS.model === oData.ws) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
WorkbookView.prototype.getFormatPainterSheet = function () {
|
||
if(this.Api.getFormatPainterState()) {
|
||
let oData = this.Api.getFormatPainterData();
|
||
if(oData && oData.ws) {
|
||
return oData.ws;
|
||
}
|
||
}
|
||
return null;
|
||
};
|
||
|
||
WorkbookView.prototype.getIsTrackShape = function() {
|
||
var ws = this.getWorksheet();
|
||
if (!ws) {
|
||
return false;
|
||
}
|
||
if (ws.objectRender && ws.objectRender.controller) {
|
||
return ws.objectRender.controller.isTrackingDrawings();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getZoom = function() {
|
||
return this.drawingCtx.getZoom();
|
||
};
|
||
|
||
WorkbookView.prototype.changeZoom = function(factor, changeZoomOnPrint, doNotDraw) {
|
||
if (factor === this.getZoom()) {
|
||
return;
|
||
}
|
||
|
||
this.buffers.main.changeZoom(factor);
|
||
this.buffers.overlay.changeZoom(factor);
|
||
this.buffers.mainGraphic.changeZoom(factor);
|
||
this.buffers.overlayGraphic.changeZoom(factor);
|
||
if (!factor) {
|
||
this.cellEditor.changeZoom(factor);
|
||
}
|
||
|
||
// Нужно сбросить кэш букв
|
||
var i, length;
|
||
for (i = 0, length = this.fmgrGraphics.length; i < length; ++i)
|
||
this.fmgrGraphics[i].ClearFontsRasterCache();
|
||
|
||
if (AscCommon.g_fontManager) {
|
||
AscCommon.g_fontManager.ClearFontsRasterCache();
|
||
AscCommon.g_fontManager.m_pFont = null;
|
||
}
|
||
if (AscCommon.g_fontManager2) {
|
||
AscCommon.g_fontManager2.ClearFontsRasterCache();
|
||
AscCommon.g_fontManager2.m_pFont = null;
|
||
}
|
||
|
||
if (!factor) {
|
||
this.wsMustDraw = true;
|
||
//this._calcMaxDigitWidth();
|
||
}
|
||
|
||
var item;
|
||
var activeIndex = this.model.getActive();
|
||
for (i in this.wsViews) {
|
||
item = this.wsViews[i];
|
||
// Меняем zoom (для не активных сменим как только сделаем его активным)
|
||
if (!factor) {
|
||
item._initWorksheetDefaultWidth();
|
||
}
|
||
//changeZoomOnPrint - добавляю, поскольку при конвертации файлов есть проблемы. проверить, возможно отрисовка тоже не нужна
|
||
item.changeZoom(/*isDraw*/i == activeIndex, changeZoomOnPrint);
|
||
this._reInitGraphics();
|
||
item.objectRender.changeZoom(this.drawingCtx.scaleFactor);
|
||
if (i == activeIndex && factor && !doNotDraw) {
|
||
item.draw();
|
||
//ToDo item.drawDepCells();
|
||
}
|
||
}
|
||
|
||
Asc.editor.toggleChartElementsCallback();
|
||
|
||
this._onScrollReinitialize(AscCommonExcel.c_oAscScrollType.ScrollVertical | AscCommonExcel.c_oAscScrollType.ScrollHorizontal);
|
||
this.handlers.trigger("asc_onZoomChanged", this.getZoom());
|
||
};
|
||
|
||
WorkbookView.prototype.getEnableKeyEventsHandler = function(bIsNaturalFocus) {
|
||
var res = this.enableKeyEvents;
|
||
if (res && bIsNaturalFocus && this.getCellEditMode() && this.input.isFocused) {
|
||
res = false;
|
||
}
|
||
return res;
|
||
};
|
||
WorkbookView.prototype.enableKeyEventsHandler = function(f) {
|
||
this.enableKeyEvents = !!f;
|
||
this.controller.enableKeyEventsHandler(this.enableKeyEvents);
|
||
if (this.cellEditor) {
|
||
this.cellEditor.enableKeyEventsHandler(this.enableKeyEvents);
|
||
}
|
||
};
|
||
|
||
// Останавливаем ввод данных в редакторе ввода
|
||
WorkbookView.prototype.closeCellEditor = function (cancel) {
|
||
this.externalSelectionController.sendExternalCloseEditor();
|
||
return this.getCellEditMode() ? this.cellEditor.close(!cancel) : true;
|
||
};
|
||
|
||
WorkbookView.prototype.restoreFocus = function () {
|
||
if (window["NATIVE_EDITOR_ENJINE"]) {
|
||
return;
|
||
}
|
||
|
||
if (this.cellEditor.hasFocus) {
|
||
this.cellEditor.restoreFocus();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._onUpdateCellEditor = function (text, cursorPosition, fPos, fName) {
|
||
if (this.skipHelpSelector) {
|
||
return;
|
||
}
|
||
|
||
// ToDo для ускорения можно завести объект, куда класть результаты поиска по формулам и второй раз не искать.
|
||
let arrResult = [], _lastFNameLength;
|
||
if (fName) {
|
||
let obj = this._getEditableFunctions(fPos, fName, arrResult);
|
||
if (obj) {
|
||
fPos = obj.fPos;
|
||
_lastFNameLength = obj._lastFNameLength;
|
||
}
|
||
}
|
||
if (0 < arrResult.length) {
|
||
this.handlers.trigger('asc_onFormulaCompleteMenu', arrResult, this.cellEditor.calculateOffset(fPos));
|
||
|
||
this.lastFPos = fPos;
|
||
this.lastFNameLength = _lastFNameLength !== undefined ? _lastFNameLength : fName.length;
|
||
} else {
|
||
this.handlers.trigger('asc_onFormulaCompleteMenu', null);
|
||
|
||
this.lastFPos = -1;
|
||
this.lastFNameLength = 0;
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getEditableFunctions = function (pos, s) {
|
||
if (!s || s.charAt(0) !== "=") {
|
||
return;
|
||
}
|
||
|
||
let arrResult = [];
|
||
let obj = this.cellEditor._getFunctionByString(pos, s);
|
||
let fName = obj.fName;
|
||
let fPos = obj.fPos;
|
||
this._getEditableFunctions(fPos, fName, arrResult);
|
||
return arrResult;
|
||
};
|
||
|
||
WorkbookView.prototype._getEditableFunctions = function (fPos, fName, arrResult) {
|
||
if (fName == null || fPos == null) {
|
||
return;
|
||
}
|
||
|
||
var _getInnerTable = function (_sFullTable, tableName) {
|
||
var _bracketCount = 0;
|
||
var res = null;
|
||
for (let j = tableName.length; j < _sFullTable.length; j++) {
|
||
if (_sFullTable[j] === "[") {
|
||
_bracketCount++;
|
||
if (!res) {
|
||
res = "";
|
||
}
|
||
} else if (_sFullTable[j] === "]") {
|
||
_bracketCount--;
|
||
res = null;
|
||
if (_bracketCount <= 0) {
|
||
break;
|
||
}
|
||
} else {
|
||
if (_bracketCount > 0) {
|
||
if (!res) {
|
||
res = "";
|
||
}
|
||
res += _sFullTable[j];
|
||
} else {
|
||
res = null;
|
||
}
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
|
||
let oThis = this;
|
||
let getCompleteMenu = function (_name, _type) {
|
||
return new AscCommonExcel.asc_CCompleteMenu(_name, _type);
|
||
};
|
||
|
||
let defNamesList, defName, defNameStr, _lastFNameLength, _type;
|
||
fName = fName.toUpperCase();
|
||
for (let i = 0; i < this.formulasList.length; ++i) {
|
||
if (0 === this.formulasList[i].indexOf(fName)) {
|
||
arrResult.push(getCompleteMenu(this.formulasList[i], c_oAscPopUpSelectorType.Func));
|
||
}
|
||
}
|
||
|
||
defNamesList = this.getDefinedNames(Asc.c_oAscGetDefinedNamesList.WorksheetWorkbook);
|
||
fName = fName.toLowerCase();
|
||
for (let i = 0; i < defNamesList.length; ++i) {
|
||
defName = defNamesList[i];
|
||
defNameStr = defName.Name;
|
||
if (null !== defName.LocalSheetId && defNameStr.toLowerCase() === "print_area") {
|
||
defNameStr = AscCommon.translateManager.getValue("Print_Area");
|
||
}
|
||
|
||
if (0 === defNameStr.toLowerCase().indexOf(fName)) {
|
||
_type = c_oAscPopUpSelectorType.Range;
|
||
if (defName.type === Asc.c_oAscDefNameType.slicer) {
|
||
_type = c_oAscPopUpSelectorType.Slicer;
|
||
} else if (defName.type === Asc.c_oAscDefNameType.table) {
|
||
_type = c_oAscPopUpSelectorType.Table;
|
||
}
|
||
arrResult.push(getCompleteMenu(defNameStr, _type));
|
||
} else if (defName.type === Asc.c_oAscDefNameType.table && 0 === fName.indexOf(defNameStr.toLowerCase())) {
|
||
if (-1 !== fName.indexOf("[")) {
|
||
var tableNameParse = fName.split("[");
|
||
// add only columns to the dropdown menu if @ the last element
|
||
if (tableNameParse[0] && 0 === defNameStr.toLowerCase().indexOf(tableNameParse[0])) {
|
||
//ищем совпадения по названию столбцов
|
||
var table = this.model.getTableByName(defNameStr);
|
||
if (table) {
|
||
var sTableInner = _getInnerTable(fName, defNameStr.toLowerCase());
|
||
if (null !== sTableInner) {
|
||
var _str, j;
|
||
for (let j = 0; j < table.TableColumns.length; j++) {
|
||
_str = table.TableColumns[j].getTableColumnName();
|
||
_type = c_oAscPopUpSelectorType.TableColumnName;
|
||
|
||
let newStr;
|
||
if (sTableInner[0] === "@") {
|
||
newStr = sTableInner.slice(1);
|
||
if (newStr === "" || 0 === _str.toLowerCase().indexOf(newStr)) {
|
||
arrResult.push(getCompleteMenu(_str, _type));
|
||
}
|
||
}
|
||
else if (sTableInner === "" || 0 === _str.toLowerCase().indexOf(sTableInner)) {
|
||
arrResult.push(getCompleteMenu(_str, _type));
|
||
}
|
||
}
|
||
|
||
if (AscCommon.cStrucTableLocalColumns) {
|
||
for (let j in AscCommon.cStrucTableLocalColumns) {
|
||
_str = AscCommon.cStrucTableLocalColumns[j];
|
||
if (j === "h") {
|
||
_str = "#" + _str;
|
||
_type = c_oAscPopUpSelectorType.TableHeaders;
|
||
} else if (j === "d") {
|
||
_str = "#" + _str;
|
||
_type = c_oAscPopUpSelectorType.TableData;
|
||
} else if (j === "a") {
|
||
_str = "#" + _str;
|
||
_type = c_oAscPopUpSelectorType.TableAll;
|
||
} else if (j === "tr") {
|
||
_str = "@" + " - " + _str;
|
||
_type = c_oAscPopUpSelectorType.TableThisRow;
|
||
} else if (j === "t") {
|
||
_str = "#" + _str;
|
||
_type = c_oAscPopUpSelectorType.TableTotals;
|
||
}
|
||
if (sTableInner === "" || (0 === _str.toLocaleLowerCase().indexOf(sTableInner) && _type !== c_oAscPopUpSelectorType.TableThisRow)) {
|
||
arrResult.push(getCompleteMenu(_str, _type));
|
||
}
|
||
}
|
||
}
|
||
fPos += defNameStr.length + (fName.length - defNameStr.length - sTableInner.length);
|
||
_lastFNameLength = sTableInner.length;
|
||
// shift for fPos for correct work when we use result from dropdown menu
|
||
if (sTableInner[0] === "@") {
|
||
fPos++
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return {fPos: fPos, _lastFNameLength: _lastFNameLength};
|
||
};
|
||
|
||
|
||
// Вставка формулы в редактор
|
||
WorkbookView.prototype.insertInCellEditor = function (name, type, autoComplete) {
|
||
var t = this, ws = this.getWorksheet(), cursorPos, tmp;
|
||
|
||
var isNotFunction = c_oAscPopUpSelectorType.Func !== type;
|
||
|
||
let isCellEditMode = this.getCellEditMode(); // is the editor open
|
||
|
||
if (isCellEditMode && autoComplete) {
|
||
/* if cell editor is open and we call autocomplete function - we should close the editor */
|
||
this.cellEditor.close(true);
|
||
} else if (isCellEditMode) {
|
||
if (isNotFunction) {
|
||
this.skipHelpSelector = true;
|
||
}
|
||
|
||
if (-1 !== this.lastFPos) {
|
||
if (-1 === this.arrExcludeFormulas.indexOf(name) && !isNotFunction) {
|
||
//если следующий символ скобка - не добавляем ещё одну
|
||
if('(' !== this.cellEditor.getText(this.cellEditor.cursorPos, 1)) {
|
||
name += '('; // ToDo сделать проверки при добавлении, чтобы не вызывать постоянно окно
|
||
}
|
||
} else {
|
||
this.skipHelpSelector = true;
|
||
}
|
||
tmp = this.cellEditor.skipTLUpdate;
|
||
this.cellEditor.skipTLUpdate = false;
|
||
|
||
if (type === c_oAscPopUpSelectorType.TableThisRow) {
|
||
this.skipHelpSelector = false;
|
||
}
|
||
|
||
this.cellEditor.replaceText(this.lastFPos, this.lastFNameLength, type === c_oAscPopUpSelectorType.TableThisRow ? "@" : name);
|
||
this.cellEditor.skipTLUpdate = tmp;
|
||
} else if (false === this.cellEditor.insertFormula(name, isNotFunction)) {
|
||
// Не смогли вставить формулу, закроем редактор, с сохранением текста
|
||
this.cellEditor.close(true);
|
||
}
|
||
|
||
this.skipHelpSelector = false;
|
||
} else {
|
||
if (c_oAscPopUpSelectorType.None === type) {
|
||
ws.executeWithFirstActiveCellInMerge(function () {
|
||
ws.setSelectionInfo("value", name, /*onlyActive*/true);
|
||
});
|
||
return;
|
||
} else if (c_oAscPopUpSelectorType.TotalRowFunc === type) {
|
||
ws.setSelectionInfo("totalRowFunc", name, /*onlyActive*/true);
|
||
return;
|
||
}
|
||
|
||
var callback = function (success) {
|
||
// ToDo ?
|
||
if (isNotFunction) {
|
||
t.skipHelpSelector = false;
|
||
}
|
||
};
|
||
|
||
// Редактор закрыт
|
||
var cellRange = {};
|
||
// Если нужно сделать автозаполнение формулы, то ищем ячейки)
|
||
if (autoComplete) {
|
||
cellRange = ws.autoCompleteFormula(name);
|
||
}
|
||
if (isNotFunction) {
|
||
name = "=" + name;
|
||
} else {
|
||
if (cellRange.notEditCell) {
|
||
// Мы уже ввели все что нужно, редактор открывать не нужно
|
||
return;
|
||
}
|
||
if (cellRange.text) {
|
||
// Меняем значение ячейки
|
||
name = ws.generateAutoCompleteFormula(name, cellRange.text);
|
||
} else {
|
||
// Меняем значение ячейки
|
||
name = ws.generateAutoCompleteFormula(name, "")
|
||
}
|
||
// Вычисляем позицию курсора (он должен быть в функции)
|
||
cursorPos = name.length - 1;
|
||
}
|
||
|
||
if (isNotFunction) {
|
||
t.skipHelpSelector = true;
|
||
}
|
||
|
||
var enterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
// Открываем, с выставлением позиции курсора
|
||
enterOptions.newText = name;
|
||
enterOptions.cursorPos = cursorPos;
|
||
|
||
if (enterOptions.newText) {
|
||
AscFonts.FontPickerByCharacter.checkText(enterOptions.newText, this, function () {
|
||
t.Api._loadFonts([], function () {
|
||
t._onEditCell(enterOptions, callback);
|
||
});
|
||
});
|
||
} else {
|
||
this._onEditCell(enterOptions, callback);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.startWizard = function (name, doCleanCellContent) {
|
||
let t = this;
|
||
let callback = function (success) {
|
||
if (success) {
|
||
addFunction(name);
|
||
}
|
||
};
|
||
|
||
//need check all functions
|
||
let allowCompleteFunctions = {"SUM": 1, "AVERAGE": 1, "COUNT": 1, "MAX": 1, "MIN": 1, "COUNTA": 1, "STDEV": 1};
|
||
let getFunctionInfo = function (_name) {
|
||
let _res = new AscCommonExcel.CFunctionInfo(AscCommonExcel.cFormulaFunctionToLocale ? AscCommonExcel.cFormulaFunctionToLocale[_name] : _name);
|
||
let _parseResult = t.cellEditor._parseResult;
|
||
|
||
//получаем массив аргументов
|
||
_res.argumentsValue = _parseResult.getArgumentsValue(t.cellEditor._formula.Formula);
|
||
let argCalc;
|
||
if (_res.argumentsValue) {
|
||
let argumentsType = _parseResult.activeFunction.func.argumentsType;
|
||
_res.argumentsResult = [];
|
||
for (let i = 0; i < _res.argumentsValue.length; i++) {
|
||
let argType = null;
|
||
if (argumentsType) {
|
||
if (typeof argumentsType[i] == 'object') {
|
||
argType = argumentsType[i][0];
|
||
} else if (i > argumentsType.length - 1) {
|
||
let lastArgType = argumentsType[argumentsType.length - 1];
|
||
if (typeof lastArgType == 'object') {
|
||
argType = lastArgType[(i - (argumentsType.length - 1)) % lastArgType.length]
|
||
}
|
||
} else {
|
||
argType = argumentsType[i];
|
||
}
|
||
}
|
||
//вычисляем результат каждого аргумента
|
||
argCalc = ws.calculateWizardFormula(_res.argumentsValue[i], argType);
|
||
_res.argumentsResult[i] = argCalc.str;
|
||
}
|
||
}
|
||
|
||
//get result
|
||
let sArguments = _res.argumentsValue.join(AscCommon.FormulaSeparators.functionArgumentSeparator);
|
||
if (argCalc.obj && argCalc.obj.type !== AscCommonExcel.cElementType.error) {
|
||
let funcCalc = ws.calculateWizardFormula(_name + '(' + sArguments + ')');
|
||
_res.functionResult = funcCalc.str;
|
||
if (funcCalc.obj && funcCalc.obj.type !== AscCommonExcel.cElementType.error) {
|
||
_res.formulaResult = ws.calculateWizardFormula(t.cellEditor.getText().substring(1)).str;
|
||
}
|
||
}
|
||
|
||
return _res;
|
||
};
|
||
|
||
let wsView = this.getWorksheet();
|
||
let ws = this.getActiveWS();
|
||
let addFunction = function (name, cellEditMode) {
|
||
t.setWizardMode(true);
|
||
if (doCleanCellContent || !t.cellEditor.isFormula()) {
|
||
t.cellEditor.selectionBegin = 0;
|
||
t.cellEditor.selectionEnd = t.cellEditor.textRender.getEndOfText();
|
||
}
|
||
|
||
let res;
|
||
if (!name && t.cellEditor._formula && t.cellEditor._parseResult) {
|
||
let parseResult = t.cellEditor._parseResult;
|
||
name = parseResult.activeFunction && parseResult.activeFunction.func && parseResult.activeFunction.func.name;
|
||
|
||
if (cellEditMode) {
|
||
//ищем общую функцию, в которой находится курсор
|
||
//если начало и конец селекта в одной функции - показываем настройки для неё, если в разных - добавляем новую
|
||
let _start = t.cellEditor.selectionBegin !== -1 ? t.cellEditor.selectionBegin : t.cellEditor.cursorPos;
|
||
let _end = t.cellEditor.selectionEnd !== -1 ? t.cellEditor.selectionEnd : t.cellEditor.cursorPos;
|
||
let activeFunction = parseResult.getActiveFunction(_start, _end);
|
||
if (activeFunction) {
|
||
parseResult.activeFunction = activeFunction;
|
||
parseResult.argPosArr = activeFunction.args;
|
||
name = activeFunction.func && activeFunction.func.name;
|
||
}
|
||
}
|
||
|
||
if (name) {
|
||
res = getFunctionInfo(name);
|
||
|
||
t.cellEditor.lastRangePos = parseResult.argPosArr[0].start;
|
||
t.cellEditor.lastRangeLength = parseResult.argPosArr[parseResult.argPosArr.length - 1].end - parseResult.argPosArr[0].start;
|
||
|
||
t.cellEditor.selectionBegin = t.cellEditor.selectionEnd = -1;
|
||
t.cellEditor._cleanSelection();
|
||
}
|
||
} else {
|
||
let cellRange;
|
||
let oFormulaList = AscCommonExcel.cFormulaFunctionLocalized ? AscCommonExcel.cFormulaFunctionLocalized :
|
||
AscCommonExcel.cFormulaFunction;
|
||
|
||
let trueName = oFormulaList[name] && oFormulaList[name].prototype && oFormulaList[name].prototype.name;
|
||
if (allowCompleteFunctions[trueName]) {
|
||
cellRange = wsView.autoCompleteFormula(trueName, t.isWizardMode);
|
||
}
|
||
|
||
t.cellEditor.insertFormula(name, null, cellRange && !cellRange.notEditCell && cellRange.text);
|
||
if (cellRange) {
|
||
res = getFunctionInfo(trueName);
|
||
}
|
||
}
|
||
|
||
// ToDo send info from selection
|
||
if (!res) {
|
||
res = name ? new AscCommonExcel.CFunctionInfo(name) : null;
|
||
}
|
||
|
||
t.handlers.trigger("asc_onSendFunctionWizardInfo", res);
|
||
};
|
||
|
||
if (!this.getCellEditMode()) {
|
||
if (!name) {
|
||
this.cellEditor.needFindFirstFunction = true;
|
||
}
|
||
this._onEditCell(new AscCommonExcel.CEditorEnterOptions(), callback);
|
||
return;
|
||
}
|
||
|
||
addFunction(name, true);
|
||
};
|
||
|
||
WorkbookView.prototype.canEnterWizardRange = function (char) {
|
||
return this.getCellEditMode() && this.cellEditor.checkSymbolBeforeRange(char);
|
||
};
|
||
|
||
WorkbookView.prototype.insertArgumentsInFormula = function (args, argNum, argType, name, bEndInsertArg) {
|
||
if (this.getCellEditMode()) {
|
||
var ws = this.getActiveWS();
|
||
|
||
let needChange = false;
|
||
if (bEndInsertArg) {
|
||
if (argType === AscCommonExcel.cElementType.string) {
|
||
let curArg = args[argNum];
|
||
//!number + !defname + !quotes
|
||
if (curArg && !AscCommon.isNumber(curArg) && !(curArg[0] === '"' && curArg[curArg.length - 1] === '"')) {
|
||
let parser = new AscCommonExcel.parserFormula(curArg, null, ws);
|
||
let parseResultArg = new AscCommonExcel.ParseResult([], []);
|
||
parser.parse(true, true, parseResultArg, true);
|
||
|
||
let argRes = parser.calculate();
|
||
if (argRes && argRes.type === AscCommonExcel.cElementType.error && argRes.errorType === AscCommonExcel.cErrorType.wrong_name) {
|
||
//add quotes
|
||
args[argNum] = '"' + args[argNum] + '"';
|
||
needChange = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
var sArguments = args.join(AscCommon.FormulaSeparators.functionArgumentSeparator);
|
||
this.cellEditor.changeCellText(sArguments);
|
||
|
||
if (name) {
|
||
let res = new AscCommonExcel.CFunctionInfo(name);
|
||
if (needChange) {
|
||
res.asc_setArguments(args);
|
||
}
|
||
res.argumentsResult = [];
|
||
let argCalc = ws.calculateWizardFormula(args[argNum], argType);
|
||
res.argumentsResult[argNum] = argCalc.str;
|
||
//second condition: if we haven't received the formulaResult, calculate with those arguments that exist in the array
|
||
if ((argCalc.obj && argCalc.obj.type !== AscCommonExcel.cElementType.error) ||
|
||
(argCalc.obj === null && res && !res.functionResult && args && sArguments)) {
|
||
let funcCalc = ws.calculateWizardFormula(name + '(' + sArguments + ')');
|
||
res.functionResult = funcCalc.str;
|
||
if (funcCalc.obj && funcCalc.obj.type !== AscCommonExcel.cElementType.error) {
|
||
res.formulaResult = ws.calculateWizardFormula(this.cellEditor.getText().substring(1)).str;
|
||
}
|
||
}
|
||
|
||
return res;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
};
|
||
|
||
WorkbookView.prototype.bIsEmptyClipboard = function() {
|
||
return g_clipboardExcel.bIsEmptyClipboard(this.getCellEditMode());
|
||
};
|
||
|
||
WorkbookView.prototype.checkCopyToClipboard = function (_clipboard, _formats) {
|
||
if (this.isProtectedFromCut()) {
|
||
return false;
|
||
}
|
||
var ws = this.getWorksheet();
|
||
g_clipboardExcel.checkCopyToClipboard(ws, _clipboard, _formats);
|
||
};
|
||
|
||
WorkbookView.prototype.pasteData = function(_format, data1, data2, text_data, doNotShowButton, callback) {
|
||
var t = this, ws;
|
||
ws = t.getWorksheet();
|
||
g_clipboardExcel.pasteData(ws, _format, data1, data2, text_data, null, doNotShowButton, null, callback);
|
||
};
|
||
|
||
WorkbookView.prototype.specialPasteData = function(props) {
|
||
if (!this.getCellEditMode()) {
|
||
this.getWorksheet().specialPaste(props);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.showSpecialPasteButton = function(props) {
|
||
if (!this.getCellEditMode()) {
|
||
this.getWorksheet().showSpecialPasteOptions(props);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.updateSpecialPasteButton = function(props) {
|
||
if (!this.getCellEditMode()) {
|
||
this.getWorksheet().updateSpecialPasteButton(props);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.hideSpecialPasteButton = function() {
|
||
//TODO пересмотреть!
|
||
//сейчас сначала добавляются данные в историю, потом идет закрытие редактора ячейки
|
||
//следовательно убираю проверку на редактирование ячейки
|
||
/*if (!this.getCellEditMode()) {*/
|
||
this.handlers.trigger("hideSpecialPasteOptions");
|
||
//}
|
||
};
|
||
WorkbookView.prototype.isProtectedFromCut = function() {
|
||
var ws = this.getWorksheet();
|
||
if (ws && ws.model && ws.model.getSheetProtection() && AscCommon.g_clipboardBase.bCut) {
|
||
if(ws.isSelectOnShape) {
|
||
if(ws.objectRender && ws.objectRender.controller) {
|
||
var oController = ws.objectRender.controller;
|
||
if(oController.isProtectedFromCut()) {
|
||
return true;
|
||
}
|
||
}
|
||
} else {
|
||
var selection = ws._getSelection();
|
||
var selectionRanges = selection ? selection.ranges : null;
|
||
if (selectionRanges && ws.model.isIntersectLockedRanges(selectionRanges)) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
|
||
WorkbookView.prototype.selectionCut = function () {
|
||
if (this.getCellEditMode()) {
|
||
this.cellEditor.cutSelection();
|
||
} else {
|
||
var ws = this.getWorksheet();
|
||
if (this.isProtectedFromCut()) {
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.ChangeOnProtectedSheet, c_oAscError.Level.NoCritical);
|
||
return false;
|
||
}
|
||
|
||
if (ws.isNeedSelectionCut()) {
|
||
ws.emptySelection(c_oAscCleanOptions.All, true);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.undo = function(Options) {
|
||
if (true === AscCommon.CollaborativeEditing.Get_GlobalLock())
|
||
return;
|
||
|
||
if (true !== this.History.Can_Undo() && this.Api && this.CollaborativeEditing && true === this.CollaborativeEditing.Is_Fast() && true !== this.CollaborativeEditing.Is_SingleUser())
|
||
{
|
||
if (this.CollaborativeEditing.CanUndo() && true === this.Api.canSave)
|
||
{
|
||
this.CollaborativeEditing.Set_GlobalLock(true);
|
||
this.Api.forceSaveUndoRequest = true;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (this.History.Can_Undo())
|
||
{
|
||
this.Api.sendEvent("asc_onBeforeUndoRedo");
|
||
var oFormulaLocaleInfo = AscCommonExcel.oFormulaLocaleInfo;
|
||
oFormulaLocaleInfo.Parse = false;
|
||
oFormulaLocaleInfo.DigitSep = false;
|
||
if (this.Api.isEditVisibleAreaOleEditor) {
|
||
const oOleSize = this.getOleSize();
|
||
oOleSize.undo();
|
||
} else if (this.getCellEditMode()) {
|
||
this.cellEditor.undo();
|
||
} else {
|
||
History.Undo(Options)
|
||
}
|
||
oFormulaLocaleInfo.Parse = true;
|
||
oFormulaLocaleInfo.DigitSep = true;
|
||
if (!AscCommon.CollaborativeEditing.Get_GlobalLock()) {
|
||
this.restoreFocus();
|
||
}
|
||
|
||
this.Api.sendEvent("asc_onUndoRedo");
|
||
}
|
||
}
|
||
|
||
|
||
};
|
||
|
||
WorkbookView.prototype.redo = function() {
|
||
this.Api.sendEvent("asc_onBeforeUndoRedo");
|
||
if (this.Api.isEditVisibleAreaOleEditor) {
|
||
const oOleSize = this.getOleSize();
|
||
oOleSize.redo();
|
||
} else if (!this.getCellEditMode()) {
|
||
History.Redo();
|
||
} else {
|
||
this.cellEditor.redo();
|
||
}
|
||
this.Api.sendEvent("asc_onUndoRedo");
|
||
};
|
||
|
||
WorkbookView.prototype.setFontAttributes = function(prop, val) {
|
||
if (!this.getCellEditMode()) {
|
||
this.getWorksheet().setSelectionInfo(prop, val);
|
||
} else {
|
||
this.cellEditor.setTextStyle(prop, val);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.changeTextCase = function(val) {
|
||
if (!this.getCellEditMode()) {
|
||
this.getWorksheet().setSelectionInfo("changeTextCase", val);
|
||
} else {
|
||
this.cellEditor.changeTextCase(val);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.changeFontSize = function(prop, val) {
|
||
if (!this.getCellEditMode()) {
|
||
this.getWorksheet().setSelectionInfo(prop, val);
|
||
} else {
|
||
this.cellEditor.setTextStyle(prop, val);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setCellFormat = function (format) {
|
||
this.getWorksheet().setSelectionInfo("format", format);
|
||
};
|
||
|
||
WorkbookView.prototype.emptyCells = function (options, isMineComments) {
|
||
if (!this.getCellEditMode()) {
|
||
if (Asc.c_oAscCleanOptions.Comments === options) {
|
||
this.removeAllComments(false, true);
|
||
} else {
|
||
//TODO isMineComments - временный флаг, как только в сдк появится класс для групп, добавить этот флаг туда
|
||
this.getWorksheet().emptySelection(options, null, isMineComments);
|
||
}
|
||
this.restoreFocus();
|
||
} else {
|
||
this.cellEditor.empty(options);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._setSelectionDialogType = function (selectionDialogType) {
|
||
this.dialogSheetName = (c_oAscSelectionDialogType.Chart === selectionDialogType ||
|
||
c_oAscSelectionDialogType.PivotTableData === selectionDialogType ||
|
||
c_oAscSelectionDialogType.PivotTableReport === selectionDialogType);
|
||
this.dialogAbsName = (c_oAscSelectionDialogType.None !== selectionDialogType &&
|
||
c_oAscSelectionDialogType.Function !== selectionDialogType);
|
||
this.dialogBookName = c_oAscSelectionDialogType.Function !== selectionDialogType && this.externalSelectionController.getExternalFormulaEditMode();
|
||
};
|
||
|
||
WorkbookView.prototype.setOleSize = function (oPr) {
|
||
this.model.setOleSize(oPr);
|
||
};
|
||
WorkbookView.prototype.setSelectionDialogMode = function (selectionDialogType, selectRange) {
|
||
var newSelectionDialogMode = c_oAscSelectionDialogType.None !== selectionDialogType;
|
||
|
||
if (newSelectionDialogMode === this.selectionDialogMode) {
|
||
return;
|
||
}
|
||
|
||
this._setSelectionDialogType(selectionDialogType);
|
||
var drawSelection = false;
|
||
var index;
|
||
if (newSelectionDialogMode) {
|
||
this.copyActiveSheet = this.wsActive;
|
||
if(c_oAscSelectionDialogType.Chart === selectionDialogType) {
|
||
var sRef = selectRange;
|
||
if(sRef.charAt(0) === '=') {
|
||
sRef = sRef.slice(1);
|
||
}
|
||
var aRefs = sRef.split(',');
|
||
var aSelectRanges = [];
|
||
var oRange, oAscRange;
|
||
var sWSName = null;
|
||
for(var nRef = 0; nRef < aRefs.length; ++nRef) {
|
||
oRange = AscCommon.parserHelp.parse3DRef(aRefs[nRef]);
|
||
if(!oRange) {
|
||
aSelectRanges.length = 0;
|
||
break;
|
||
}
|
||
if(sWSName === null) {
|
||
sWSName = oRange.sheet;
|
||
}
|
||
else {
|
||
if(sWSName !== oRange.sheet) {
|
||
aSelectRanges.length = 0;
|
||
break;
|
||
}
|
||
}
|
||
oAscRange = AscCommonExcel.g_oRangeCache.getAscRange(oRange.range);
|
||
if(oAscRange) {
|
||
aSelectRanges.push(oAscRange);
|
||
}
|
||
else {
|
||
aSelectRanges.length = 0;
|
||
break;
|
||
}
|
||
}
|
||
if(aSelectRanges.length > 0) {
|
||
var oWS = this.model.getWorksheetByName(sWSName);
|
||
if (!oWS || oWS.getHidden()) {
|
||
this.getWorksheet().cloneSelection(true, null);
|
||
} else {
|
||
index = oWS.getIndex();
|
||
if (index !== this.wsActive) {
|
||
this.showWorksheet(index);
|
||
}
|
||
this.getWorksheet().cloneSelection(true, new Asc.Range(0, 0, 0, 0));
|
||
oWS.selectionRange.assign2(aSelectRanges[0]);
|
||
for(nRef = 1; nRef < aSelectRanges.length; ++nRef) {
|
||
oWS.selectionRange.addRange();
|
||
oWS.selectionRange.getLast().assign2(aSelectRanges[nRef]);
|
||
}
|
||
oWS.selectionRange.update();
|
||
}
|
||
}
|
||
else {
|
||
this.getWorksheet().cloneSelection(true, null);
|
||
}
|
||
}
|
||
else {
|
||
var tmpSelectRange = AscCommon.parserHelp.parse3DRef(selectRange);
|
||
if (tmpSelectRange) {
|
||
var ws = this.model.getWorksheetByName(tmpSelectRange.sheet);
|
||
if (!ws || ws.getHidden()) {
|
||
tmpSelectRange = null;
|
||
} else {
|
||
index = ws.getIndex();
|
||
if (index !== this.wsActive) {
|
||
this.showWorksheet(index);
|
||
}
|
||
|
||
tmpSelectRange = tmpSelectRange.range;
|
||
}
|
||
} else {
|
||
tmpSelectRange = selectRange;
|
||
}
|
||
this.getWorksheet().cloneSelection(true, tmpSelectRange && AscCommonExcel.g_oRangeCache.getAscRange(tmpSelectRange));
|
||
}
|
||
this.selectionDialogMode = newSelectionDialogMode;
|
||
this.input.disabled = !this.isFormulaEditMode || this.isWizardMode;
|
||
drawSelection = true;
|
||
} else {
|
||
this.selectionDialogMode = newSelectionDialogMode;
|
||
this.getWorksheet().cloneSelection(false);
|
||
if (this.copyActiveSheet !== this.wsActive) {
|
||
this.showWorksheet(this.copyActiveSheet);
|
||
} else {
|
||
drawSelection = true;
|
||
}
|
||
|
||
this.copyActiveSheet = -1;
|
||
this.input.disabled = false;
|
||
}
|
||
|
||
if (drawSelection) {
|
||
this.getWorksheet()._drawSelection();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.formatPainter = function(formatPainterState, bLockDraw) {
|
||
var ws = this.getWorksheet();
|
||
if (!bLockDraw) {
|
||
ws.cleanSelection();
|
||
}
|
||
|
||
if (this.Api.getFormatPainterState()) {
|
||
this.Api.checkFormatPainterData()
|
||
} else {
|
||
this.Api.clearFormatPainterData();
|
||
this.handlers.trigger('asc_onStopFormatPainter');
|
||
}
|
||
if (!bLockDraw) {
|
||
ws.updateSelectionWithSparklines();
|
||
}
|
||
};
|
||
|
||
// Поиск текста в листе
|
||
WorkbookView.prototype.findCellText = function (options) {
|
||
this.closeCellEditor();
|
||
// Для поиска эта переменная не нужна (но она может остаться от replace)
|
||
options.selectionRange = null;
|
||
|
||
var result = this.model.findCellText(options);
|
||
if (result) {
|
||
var ws = this.getWorksheet();
|
||
var range = new Asc.Range(result.col, result.row, result.col, result.row);
|
||
options.findInSelection ? ws.setActiveCell(result) : ws.setSelection(range);
|
||
return true;
|
||
}
|
||
return null;
|
||
};
|
||
|
||
// Замена текста в листе
|
||
WorkbookView.prototype.replaceCellText = function (options) {
|
||
this.closeCellEditor();
|
||
if (!options.isMatchCase) {
|
||
options.findWhat = options.findWhat.toLowerCase();
|
||
}
|
||
options.findRegExp = AscCommonExcel.getFindRegExp(options.findWhat, options, true);
|
||
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
this.SearchEngine.replaceStart();
|
||
|
||
options.clearFindAll();
|
||
if (options.isReplaceAll) {
|
||
// На ReplaceAll ставим медленную операцию
|
||
this.Api.sync_StartAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.SlowOperation);
|
||
}
|
||
|
||
var ws = this.getWorksheet();
|
||
ws.replaceCellText(options, false, this.fReplaceCallback, true);
|
||
};
|
||
WorkbookView.prototype._replaceCellTextCallback = function(options) {
|
||
if (!options.error) {
|
||
options.updateFindAll();
|
||
if (Asc.c_oAscSearchBy.Workbook === options.scanOnOnlySheet && options.isReplaceAll) {
|
||
// Замена на всей книге
|
||
var i = ++options.sheetIndex;
|
||
if (this.model.getActive() === i) {
|
||
i = ++options.sheetIndex;
|
||
}
|
||
|
||
if (i < this.model.getWorksheetCount()) {
|
||
var ws = this.getWorksheet(i);
|
||
ws.replaceCellText(options, true, this.fReplaceCallback, true);
|
||
return;
|
||
}
|
||
options.sheetIndex = -1;
|
||
}
|
||
|
||
if (!options.isForMacros) {
|
||
this.handlers.trigger("asc_onRenameCellTextEnd", options.countFindAll, options.countReplaceAll);
|
||
options.asc_setIsForMacros(null);
|
||
}
|
||
if (options.countFindAll !== options.countReplaceAll) {
|
||
this.SearchEngine.SetCurrent(this.SearchEngine.CurId);
|
||
}
|
||
this.SearchEngine.replaceEnd();
|
||
if (options.isReplaceAll) {
|
||
this.SearchEngine.Clear();
|
||
}
|
||
} else {
|
||
this.SearchEngine.replaceEnd();
|
||
}
|
||
|
||
History.EndTransaction();
|
||
if (options.isReplaceAll) {
|
||
// Заканчиваем медленную операцию
|
||
this.Api.sync_EndAction(c_oAscAsyncActionType.BlockInteraction, c_oAscAsyncAction.SlowOperation);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getDefinedNames = function(defNameListId, excludeErrorRefNames) {
|
||
return this.model.getDefinedNamesWB(defNameListId, true, excludeErrorRefNames);
|
||
};
|
||
|
||
WorkbookView.prototype.setDefinedNames = function(defName) {
|
||
//ToDo проверка defName.ref на знак "=" в начале ссылки. знака нет тогда это либо число либо строка, так делает Excel.
|
||
|
||
this.model.setDefinesNames(defName.Name, defName.Ref, defName.Scope);
|
||
this.handlers.trigger("asc_onDefName");
|
||
|
||
};
|
||
|
||
WorkbookView.prototype.editDefinedNames = function(oldName, newName) {
|
||
//ToDo проверка defName.ref на знак "=" в начале ссылки. знака нет тогда это либо число либо строка, так делает Excel.
|
||
if (this.collaborativeEditing.getGlobalLock() || !this.canEdit()) {
|
||
return;
|
||
}
|
||
|
||
var ws = this.getWorksheet(), t = this;
|
||
|
||
var editDefinedNamesCallback = function(res) {
|
||
if (res) {
|
||
if (oldName && oldName.asc_getType() === Asc.c_oAscDefNameType.table) {
|
||
ws.model.autoFilters.changeDisplayNameTable(oldName.asc_getName(), newName.asc_getName());
|
||
} else {
|
||
t.model.editDefinesNames(oldName, newName);
|
||
}
|
||
if (oldName && newName) {
|
||
ws.model.changeSlicerCacheName(oldName.asc_getName(), newName.asc_getName());
|
||
}
|
||
t.handlers.trigger("asc_onEditDefName", oldName, newName);
|
||
//условие исключает второй вызов asc_onRefreshDefNameList(первый в unlockDefName)
|
||
if(!(t.collaborativeEditing.getCollaborativeEditing() && t.collaborativeEditing.getFast()))
|
||
{
|
||
t.handlers.trigger("asc_onRefreshDefNameList");
|
||
}
|
||
ws.traceDependentsManager && ws.traceDependentsManager.clearAll(true);
|
||
} else {
|
||
t.handlers.trigger("asc_onError", c_oAscError.ID.LockCreateDefName, c_oAscError.Level.NoCritical);
|
||
}
|
||
t._onSelectionNameChanged(ws.getSelectionName(/*bRangeText*/false));
|
||
if(ws.viewPrintLines) {
|
||
ws.updateSelection();
|
||
}
|
||
};
|
||
var defNameId;
|
||
if (oldName) {
|
||
defNameId = t.model.getDefinedName(oldName);
|
||
defNameId = defNameId ? defNameId.getNodeId() : null;
|
||
}
|
||
|
||
var callback = function() {
|
||
ws._isLockedDefNames(editDefinedNamesCallback, defNameId);
|
||
};
|
||
|
||
var tableRange;
|
||
if(oldName && oldName.type === Asc.c_oAscDefNameType.table)
|
||
{
|
||
var table = ws.model.autoFilters._getFilterByDisplayName(oldName.Name);
|
||
if(table)
|
||
{
|
||
tableRange = table.Ref;
|
||
}
|
||
} else if (oldName) {
|
||
var slicerCache = ws.model.getSlicerCacheByCacheName(oldName.Name);
|
||
if (slicerCache) {
|
||
tableRange = slicerCache.getRange();
|
||
}
|
||
}
|
||
|
||
if (tableRange) {
|
||
ws._isLockedCells( tableRange, null, callback );
|
||
} else {
|
||
callback();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.delDefinedNames = function(oldName) {
|
||
//ToDo проверка defName.ref на знак "=" в начале ссылки. знака нет тогда это либо число либо строка, так делает Excel.
|
||
if (this.collaborativeEditing.getGlobalLock() || !this.canEdit()) {
|
||
return;
|
||
}
|
||
|
||
var ws = this.getWorksheet(), t = this;
|
||
|
||
if (oldName) {
|
||
|
||
var delDefinedNamesCallback = function(res) {
|
||
if (res) {
|
||
t.model.delDefinesNames(oldName);
|
||
t.handlers.trigger("asc_onRefreshDefNameList");
|
||
ws.traceDependentsManager && ws.traceDependentsManager.clearAll(true);
|
||
} else {
|
||
t.handlers.trigger("asc_onError", c_oAscError.ID.LockCreateDefName, c_oAscError.Level.NoCritical);
|
||
}
|
||
t._onSelectionNameChanged(ws.getSelectionName(/*bRangeText*/false));
|
||
if(ws.viewPrintLines) {
|
||
ws.updateSelection();
|
||
}
|
||
};
|
||
var defNameId = t.model.getDefinedName(oldName).getNodeId();
|
||
|
||
ws._isLockedDefNames(delDefinedNamesCallback, defNameId);
|
||
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getDefaultDefinedName = function() {
|
||
//ToDo проверка defName.ref на знак "=" в начале ссылки. знака нет тогда это либо число либо строка, так делает Excel.
|
||
var val = this.getWorksheet().getDefaultDefinedNameText();
|
||
return new Asc.asc_CDefName(val, this.getWorksheet().getSelectionRangeValue(true, true), null);
|
||
|
||
};
|
||
WorkbookView.prototype.getDefaultTableStyle = function() {
|
||
return this.model.TableStyles.DefaultTableStyle;
|
||
};
|
||
WorkbookView.prototype.unlockDefName = function() {
|
||
this.model.unlockDefName();
|
||
this.handlers.trigger("asc_onRefreshDefNameList");
|
||
this.handlers.trigger("asc_onLockDefNameManager", Asc.c_oAscDefinedNameReason.OK);
|
||
};
|
||
WorkbookView.prototype.unlockCurrentDefName = function(name, sheetId) {
|
||
this.model.unlockCurrentDefName(name, sheetId);
|
||
//this.handlers.trigger("asc_onRefreshDefNameList");
|
||
//this.handlers.trigger("asc_onLockDefNameManager", Asc.c_oAscDefinedNameReason.OK);
|
||
};
|
||
|
||
WorkbookView.prototype._onCheckDefNameLock = function() {
|
||
return this.model.checkDefNameLock();
|
||
};
|
||
|
||
// Печать
|
||
WorkbookView.prototype.printSheets = function(printPagesData, pdfDocRenderer, adjustPrint) {
|
||
var pdfPrinter;
|
||
var t = this;
|
||
this._executeWithoutZoom(function () {
|
||
pdfPrinter = new AscCommonExcel.CPdfPrinter(t.fmgrGraphics[3], t.m_oFont.clone());
|
||
if (pdfDocRenderer) {
|
||
pdfPrinter.DocumentRenderer = pdfDocRenderer;
|
||
}
|
||
var ws;
|
||
if (0 === printPagesData.arrPages.length) {
|
||
// Печать пустой страницы
|
||
ws = t.getWorksheet();
|
||
ws.drawForPrint(pdfPrinter, null);
|
||
} else {
|
||
var indexWorksheet = -1;
|
||
var indexWorksheetTmp = -1;
|
||
var startIndex = adjustPrint && adjustPrint.startPageIndex != null ? adjustPrint.startPageIndex : 0;
|
||
var endIndex = adjustPrint && adjustPrint.endPageIndex != null ? adjustPrint.endPageIndex + 1 : printPagesData.arrPages.length;
|
||
if (startIndex > endIndex || startIndex > printPagesData.arrPages.length) {
|
||
//Печать пустой страницы
|
||
ws = t.getWorksheet();
|
||
ws.drawForPrint(pdfPrinter, null);
|
||
return pdfPrinter;
|
||
}
|
||
if (endIndex > printPagesData.arrPages.length) {
|
||
endIndex = printPagesData.arrPages.length;
|
||
}
|
||
for (var i = startIndex; i < endIndex; ++i) {
|
||
indexWorksheetTmp = printPagesData.arrPages[i].indexWorksheet;
|
||
if (indexWorksheetTmp !== indexWorksheet) {
|
||
ws = t.getWorksheet(indexWorksheetTmp);
|
||
indexWorksheet = indexWorksheetTmp;
|
||
}
|
||
ws.drawForPrint(pdfPrinter, printPagesData.arrPages[i], i, printPagesData.arrPages);
|
||
}
|
||
}
|
||
});
|
||
|
||
return pdfPrinter;
|
||
};
|
||
|
||
WorkbookView.prototype._executeWithoutZoom = function (runFunction) {
|
||
//TODO есть проблемы при отрисовке(не связано с печатью). сначала меняем zoom редактора,
|
||
// потом системный(открываем при системном зуме != 100%)
|
||
|
||
//change zoom on default
|
||
const trueRetinaPixelRatio = AscCommon.AscBrowser.retinaPixelRatio;
|
||
const viewZoom = this.getZoom();
|
||
if (viewZoom === 1 && trueRetinaPixelRatio === 1) {
|
||
return runFunction();
|
||
}
|
||
|
||
AscCommon.AscBrowser.retinaPixelRatio = 1;
|
||
//приходится несколько раз выполнять действия, чтобы ppi выставился правильно
|
||
//если не делать init, то не сбросится ppi от системного зума - смотри функцию DrawingContext.prototype.changeZoom
|
||
if (viewZoom !== 1) {
|
||
this.changeZoom(1, true, true);
|
||
}
|
||
this.changeZoom(null, true, true);
|
||
|
||
const oRet = runFunction();
|
||
|
||
AscCommon.AscBrowser.retinaPixelRatio = trueRetinaPixelRatio;
|
||
this.changeZoom(null, true, true);
|
||
this.changeZoom(viewZoom, true, true);
|
||
|
||
return oRet;
|
||
};
|
||
|
||
WorkbookView.prototype.executeWithoutPreview = function (runFunction) {
|
||
if (!this.printPreviewState) {
|
||
runFunction();
|
||
return;
|
||
}
|
||
|
||
let oldState = this.printPreviewState.isStart();
|
||
let oldZoom = this.getZoom();
|
||
if (oldState) {
|
||
this.printPreviewState.start = false;
|
||
if (null != this.printPreviewState.realZoom) {
|
||
this.changeZoom(this.printPreviewState.realZoom, true, true);
|
||
}
|
||
}
|
||
runFunction();
|
||
this.printPreviewState.start = oldState;
|
||
if (this.printPreviewState.start) {
|
||
this.changeZoom(oldZoom, true, true);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getSimulatePageForOleObject = function (rangeSizes, range) {
|
||
var page = new AscCommonExcel.CPagePrint();
|
||
page.indexWorksheet = 0;
|
||
page.pageClipRectHeight = rangeSizes.height;
|
||
page.pageClipRectWidth = rangeSizes.width;
|
||
page.topFieldInPx = 2;
|
||
page.leftFieldInPx = 2;
|
||
|
||
page.pageGridLines = true;
|
||
page.pageHeight = rangeSizes.height;
|
||
page.pageWidth = rangeSizes.width;
|
||
|
||
page.pageRange = range.clone();
|
||
page.scale = 1;
|
||
return page;
|
||
};
|
||
|
||
WorkbookView.prototype.printForOleObject = function (ws, oRange) {
|
||
var sizes = ws.getPrintOleRangePosition(oRange);
|
||
var page = this.getSimulatePageForOleObject(sizes, oRange);
|
||
var previewOleObjectContext = AscCommonExcel.getContext(sizes.width, sizes.height, this);
|
||
previewOleObjectContext.DocumentRenderer = AscCommonExcel.getGraphics(previewOleObjectContext);
|
||
previewOleObjectContext.isNotDrawBackground = !this.Api.frameManager.isFromSheetEditor;
|
||
let renderingSettings = ws.getRenderingSettings();
|
||
if (!renderingSettings) {
|
||
renderingSettings = ws.initRenderingSettings();
|
||
}
|
||
renderingSettings && renderingSettings.setCtxWidth(page.pageWidth);
|
||
ws.drawForPrint(previewOleObjectContext, page, 0, 1);
|
||
return previewOleObjectContext;
|
||
};
|
||
|
||
WorkbookView.prototype.getSimulatePageForCopyPaste = function (rangeSizes, range) {
|
||
var page = new AscCommonExcel.CPagePrint();
|
||
page.indexWorksheet = 0;
|
||
page.pageClipRectHeight = rangeSizes.height;
|
||
page.pageClipRectWidth = rangeSizes.width;
|
||
page.topFieldInPx = 1;
|
||
page.leftFieldInPx = 1;
|
||
|
||
page.pageGridLines = true;
|
||
page.pageHeight = rangeSizes.height;
|
||
page.pageWidth = rangeSizes.width;
|
||
|
||
page.pageRange = range.clone();
|
||
page.scale = 1;
|
||
return page;
|
||
};
|
||
|
||
WorkbookView.prototype.printForCopyPaste = function (ws, oRange, ignoreScaling) {
|
||
var sizes = ws.getRangePosition(oRange);
|
||
let scaleFactor = ignoreScaling ? AscBrowser.retinaPixelRatio /** ws.getZoom()*/ : 1;
|
||
if (sizes) {
|
||
sizes.width += 1*scaleFactor;
|
||
sizes.height += 1*scaleFactor;
|
||
}
|
||
|
||
var page = this.getSimulatePageForCopyPaste(sizes, oRange);
|
||
var previewOleObjectContext = AscCommonExcel.getContext(sizes.width/scaleFactor, sizes.height/scaleFactor, this);
|
||
previewOleObjectContext.DocumentRenderer = AscCommonExcel.getGraphics(previewOleObjectContext);
|
||
previewOleObjectContext.isNotDrawBackground = !this.Api.isFromSheetEditor;
|
||
|
||
if (scaleFactor !== 1) {
|
||
previewOleObjectContext.ppiX = previewOleObjectContext.ppiX/scaleFactor;
|
||
previewOleObjectContext.ppiY = previewOleObjectContext.ppiY/scaleFactor;
|
||
previewOleObjectContext.setTransform(1/scaleFactor, 0, 0, 1/scaleFactor, 0, 0);
|
||
previewOleObjectContext.updateTransforms && previewOleObjectContext.updateTransforms();
|
||
}
|
||
|
||
let renderingSettings = ws.getRenderingSettings();
|
||
if (!renderingSettings) {
|
||
renderingSettings = ws.initRenderingSettings();
|
||
}
|
||
renderingSettings && renderingSettings.setCtxWidth(page.pageWidth);
|
||
ws.drawForPrint(previewOleObjectContext, page, 0, 1);
|
||
return previewOleObjectContext;
|
||
};
|
||
|
||
WorkbookView.prototype.printSheetPrintPreview = function(index) {
|
||
var printPreviewState = this.printPreviewState;
|
||
var page = printPreviewState.getPage(index);
|
||
var printPreviewContext = printPreviewState.getCtx();
|
||
|
||
if (page) {
|
||
page = page.clone();
|
||
}
|
||
|
||
var kF = printPreviewState.pageZoom * AscCommon.AscBrowser.retinaPixelRatio;
|
||
//TODO 1 -
|
||
if (page) {
|
||
page.leftFieldInPx = Math.floor(page.leftFieldInPx * kF) - 1;
|
||
page.pageClipRectHeight = Math.ceil(page.pageClipRectHeight * kF);
|
||
page.pageClipRectLeft = Math.floor(page.pageClipRectLeft * kF);
|
||
page.pageClipRectTop = Math.floor(page.pageClipRectTop * kF);
|
||
page.pageClipRectWidth = Math.ceil(page.pageClipRectWidth * kF);
|
||
page.topFieldInPx = Math.floor(page.topFieldInPx * kF) - 1;
|
||
|
||
page.titleWidth = Math.floor(page.titleWidth * kF);
|
||
page.titleHeight = Math.floor(page.titleHeight * kF);
|
||
}
|
||
|
||
printPreviewContext.clear();
|
||
printPreviewContext.setFillStyle( this.defaults.worksheetView.cells.defaultState.background )
|
||
.fillRect( 0, 0, printPreviewContext.getWidth(), printPreviewContext.getHeight() );
|
||
|
||
var ws;
|
||
if (!page) {
|
||
// Печать пустой страницы
|
||
ws = this.getWorksheet();
|
||
ws.drawForPrint(printPreviewContext, null);
|
||
} else {
|
||
ws = this.getWorksheet(page.indexWorksheet);
|
||
ws.drawForPrint(printPreviewContext, page, index, printPreviewState.pages && printPreviewState.pages.arrPages);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._calcPagesPrintSheet = function (index, printPagesData, onlySelection, adjustPrint) {
|
||
var ws = this.model.getWorksheet(index);
|
||
var wsView = this.getWorksheet(index);
|
||
if (!ws.getHidden()) {
|
||
var pageOptionsMap = adjustPrint ? adjustPrint.asc_getPageOptionsMap() : null;
|
||
var pagePrintOptions = pageOptionsMap && pageOptionsMap[index] ? pageOptionsMap[index] : ws.PagePrintOptions;
|
||
wsView.calcPagesPrint(pagePrintOptions, onlySelection, index, printPagesData.arrPages, null, adjustPrint);
|
||
}
|
||
};
|
||
WorkbookView.prototype.calcPagesPrint = function (adjustPrint) {
|
||
if (!adjustPrint) {
|
||
adjustPrint = new Asc.asc_CAdjustPrint();
|
||
}
|
||
|
||
let trueFormulaFunctionToLocale;
|
||
let printOptionsJson = this.getPrintOptionsJson();
|
||
let spreadsheetLayout = printOptionsJson && printOptionsJson["spreadsheetLayout"];
|
||
if (spreadsheetLayout && spreadsheetLayout["formulaProps"] && spreadsheetLayout["formulaProps"]["translate"]) {
|
||
trueFormulaFunctionToLocale = AscCommonExcel.cFormulaFunctionToLocale;
|
||
AscCommonExcel.cFormulaFunctionToLocale = spreadsheetLayout["formulaProps"]["translate"];
|
||
}
|
||
|
||
var viewZoom = this.getZoom();
|
||
this.changeZoom(1, true, true);
|
||
|
||
var isPrintPreview = this.printPreviewState.isStart();
|
||
var nActive = isPrintPreview && null !== this.printPreviewState.realActiveSheet ? this.printPreviewState.realActiveSheet : this.model.getActive();
|
||
|
||
var printPagesData = new asc_CPrintPagesData();
|
||
var printType = adjustPrint.asc_getPrintType();
|
||
|
||
var i;
|
||
let activeSheetsArray = printType !== Asc.c_oAscPrintType.Selection ? adjustPrint.asc_getActiveSheetsArray() : null;
|
||
if (printType === Asc.c_oAscPrintType.ActiveSheets || activeSheetsArray) {
|
||
if (activeSheetsArray) {
|
||
for (i = 0; i < activeSheetsArray.length; ++i) {
|
||
if(adjustPrint.isOnlyFirstPage && i !== 0) {
|
||
break;
|
||
}
|
||
this._calcPagesPrintSheet(activeSheetsArray[i], printPagesData, false, adjustPrint);
|
||
}
|
||
} else {
|
||
this._calcPagesPrintSheet(nActive, printPagesData, false, adjustPrint);
|
||
}
|
||
} else if (printType === Asc.c_oAscPrintType.EntireWorkbook) {
|
||
// Колличество листов
|
||
var countWorksheets = this.model.getWorksheetCount();
|
||
for (i = 0; i < countWorksheets; ++i) {
|
||
if(adjustPrint.isOnlyFirstPage && i !== 0) {
|
||
break;
|
||
}
|
||
this._calcPagesPrintSheet(i, printPagesData, false, adjustPrint);
|
||
}
|
||
} else if (printType === Asc.c_oAscPrintType.Selection) {
|
||
let _activeSheetsArray = adjustPrint && adjustPrint.asc_getActiveSheetsArray && adjustPrint.asc_getActiveSheetsArray();
|
||
let activeSheet = _activeSheetsArray && _activeSheetsArray[0] != null ? _activeSheetsArray[0] : null;
|
||
this._calcPagesPrintSheet(activeSheet != null ? activeSheet : nActive, printPagesData, true, adjustPrint);
|
||
}
|
||
|
||
if (this.printPreviewState.isNeedShowError(AscCommonExcel.c_kMaxPrintPages === printPagesData.arrPages.length)) {
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.PrintMaxPagesCount, c_oAscError.Level.NoCritical);
|
||
}
|
||
|
||
this.changeZoom(viewZoom, true, true);
|
||
|
||
if (trueFormulaFunctionToLocale) {
|
||
AscCommonExcel.cFormulaFunctionToLocale = trueFormulaFunctionToLocale;
|
||
}
|
||
|
||
return printPagesData;
|
||
};
|
||
|
||
// Вызывать только для нативной печати
|
||
WorkbookView.prototype._nativeCalculate = function() {
|
||
var item;
|
||
for (var i in this.wsViews) {
|
||
item = this.wsViews[i];
|
||
item._cleanCellsTextMetricsCache();
|
||
item._prepareDrawingObjects();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.calculate = function (type) {
|
||
this.model.calculate(type);
|
||
this.drawWS();
|
||
};
|
||
|
||
WorkbookView.prototype.drawWS = function() {
|
||
this.getWorksheet().draw();
|
||
};
|
||
WorkbookView.prototype.scrollToTopLeftCell = function() {
|
||
this.getWorksheet().scrollToTopLeftCell();
|
||
};
|
||
WorkbookView.prototype.scrollToCell = function (row, column) {
|
||
this.getWorksheet().scrollToCell(row, column);
|
||
};
|
||
WorkbookView.prototype.onShowDrawingObjects = function() {
|
||
var oWSView = this.getWorksheet();
|
||
var oDrawingsRender;
|
||
if(oWSView) {
|
||
oDrawingsRender = oWSView.objectRender;
|
||
if(oDrawingsRender) {
|
||
oDrawingsRender.showDrawingObjects(null);
|
||
}
|
||
}
|
||
};
|
||
WorkbookView.prototype.handleDrawingsOnWorkbookChange = function (aRanges) {
|
||
if(!Array.isArray(aRanges) || aRanges.length === 0) {
|
||
return;
|
||
}
|
||
var aChartRefsToChange = [];
|
||
var aCharts = [];
|
||
let bHandled = false;
|
||
this.model.handleDrawings(function(oDrawing) {
|
||
switch (oDrawing.getObjectType()) {
|
||
case AscDFH.historyitem_type_ChartSpace: {
|
||
const nPrevLength = aChartRefsToChange.length;
|
||
oDrawing.collectIntersectionRefs(aRanges, aChartRefsToChange);
|
||
if(aChartRefsToChange.length > nPrevLength) {
|
||
aCharts.push(oDrawing);
|
||
bHandled = true;
|
||
}
|
||
break;
|
||
}
|
||
case AscDFH.historyitem_type_Control: {
|
||
bHandled |= oDrawing.handleChangeRanges(aRanges);
|
||
break;
|
||
}
|
||
default: {
|
||
break;
|
||
}
|
||
}
|
||
});
|
||
if(aChartRefsToChange.length > 0) {
|
||
for(var nRef = 0; nRef < aChartRefsToChange.length; ++nRef) {
|
||
aChartRefsToChange[nRef].updateCacheAndCat();
|
||
}
|
||
for(var nChart = 0; nChart < aCharts.length; ++nChart) {
|
||
aCharts[nChart].recalculate();
|
||
}
|
||
this.onShowDrawingObjects();
|
||
}
|
||
if (bHandled) {
|
||
this.onShowDrawingObjects();
|
||
}
|
||
this.Api.frameManager.updateGeneralDiagramCache(aRanges);
|
||
};
|
||
WorkbookView.prototype.handleChartsOnChangeSheetName = function (oWorksheet, sOldName, sNewName) {
|
||
//change sheet name in chart references
|
||
var oWorkbook = this.model;
|
||
var oRenameData = oWorkbook.getChartSheetRenameData(oWorksheet, sOldName);
|
||
var oThis = this;
|
||
if(oRenameData.refs.length > 0) {
|
||
oWorkbook.checkObjectsLock(oRenameData.ids, function(bNoLock) {
|
||
if(bNoLock) {
|
||
oWorkbook.changeSheetNameInRefs(oRenameData.refs, sOldName, sNewName);
|
||
}
|
||
//recalculate in any case. Some charts might depend on new chart name
|
||
oThis.recalculateDrawingObjects(null, false);
|
||
});
|
||
}
|
||
else {
|
||
//recalculate in any case. Some charts might depend on new chart name
|
||
oThis.recalculateDrawingObjects(null, false);
|
||
}
|
||
};
|
||
WorkbookView.prototype.recalculateDrawingObjects = function(oHistoryPoint, bAll) {
|
||
var aWSVies = this.wsViews;
|
||
var oWSView, oDrawingsRender;
|
||
History.Get_RecalcData(oHistoryPoint);
|
||
for (var i = 0; i < aWSVies.length; ++i) {
|
||
oWSView = aWSVies[i];
|
||
if(oWSView) {
|
||
oDrawingsRender = oWSView.objectRender;
|
||
if(oDrawingsRender) {
|
||
oDrawingsRender.recalculate(bAll);
|
||
}
|
||
}
|
||
}
|
||
this.onShowDrawingObjects();
|
||
};
|
||
|
||
WorkbookView.prototype.getRecommendedChartData = function() {
|
||
const oCurWorksheet = this.getWorksheet();
|
||
if(!oCurWorksheet) {
|
||
return null;
|
||
}
|
||
return oCurWorksheet.getRecommendedChartData();
|
||
};
|
||
WorkbookView.prototype.getChartData = function(nType) {
|
||
const oCurWorksheet = this.getWorksheet();
|
||
if(!oCurWorksheet) {
|
||
return null;
|
||
}
|
||
return oCurWorksheet.getChartData(nType);
|
||
};
|
||
WorkbookView.prototype.insertHyperlink = function(options, sheetId) {
|
||
var ws = this.getWorksheet(sheetId);
|
||
if (ws.objectRender.selectedGraphicObjectsExists()) {
|
||
if (ws.objectRender.controller.canAddHyperlink()) {
|
||
ws.objectRender.controller.insertHyperlink(options);
|
||
}
|
||
} else {
|
||
ws.setSelectionInfo("hyperlink", options);
|
||
this.restoreFocus();
|
||
}
|
||
};
|
||
WorkbookView.prototype.removeHyperlink = function() {
|
||
var ws = this.getWorksheet();
|
||
if (ws.objectRender.selectedGraphicObjectsExists()) {
|
||
ws.objectRender.controller.removeHyperlink();
|
||
} else {
|
||
ws.setSelectionInfo("rh");
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setDocumentPlaceChangedEnabled = function(val) {
|
||
this.isDocumentPlaceChangedEnabled = val;
|
||
};
|
||
|
||
WorkbookView.prototype.showComments = function (val, isShowSolved) {
|
||
if (this.isShowComments !== val || this.isShowSolved !== isShowSolved) {
|
||
this.isShowComments = val;
|
||
this.isShowSolved = isShowSolved;
|
||
this.drawWS();
|
||
}
|
||
};
|
||
WorkbookView.prototype.removeComment = function (id) {
|
||
var ws = this.getWorksheet();
|
||
ws.cellCommentator.removeComment(id);
|
||
this.cellCommentator.removeComment(id);
|
||
};
|
||
WorkbookView.prototype.removeAllComments = function (isMine, isCurrent) {
|
||
var range;
|
||
var ws = this.getWorksheet();
|
||
isMine = isMine ? (this.Api.DocInfo && this.Api.DocInfo.get_UserId()) : null;
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
if (isCurrent) {
|
||
ws._getSelection().ranges.forEach(function (item) {
|
||
ws.cellCommentator.deleteCommentsRange(item, isMine);
|
||
});
|
||
} else {
|
||
range = new Asc.Range(0, 0, AscCommon.gc_nMaxCol0, AscCommon.gc_nMaxRow0);
|
||
this.cellCommentator.deleteCommentsRange(range, isMine);
|
||
ws.cellCommentator.deleteCommentsRange(range, isMine);
|
||
}
|
||
History.EndTransaction();
|
||
};
|
||
|
||
WorkbookView.prototype.resolveAllComments = function (isMine, isCurrent) {
|
||
var range;
|
||
var ws = this.getWorksheet();
|
||
isMine = isMine ? (this.Api.DocInfo && this.Api.DocInfo.get_UserId()) : null;
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
if (isCurrent) {
|
||
ws._getSelection().ranges.forEach(function (item) {
|
||
ws.cellCommentator.resolveCommentsRange(item, isMine);
|
||
});
|
||
} else {
|
||
range = new Asc.Range(0, 0, AscCommon.gc_nMaxCol0, AscCommon.gc_nMaxRow0);
|
||
this.cellCommentator.resolveCommentsRange(range, isMine);
|
||
ws.cellCommentator.resolveCommentsRange(range, isMine);
|
||
}
|
||
History.EndTransaction();
|
||
};
|
||
|
||
/*
|
||
* @param {c_oAscRenderingModeType} mode Режим отрисовки
|
||
* @param {Boolean} isInit инициализация или нет
|
||
*/
|
||
WorkbookView.prototype.setFontRenderingMode = function(mode, isInit) {
|
||
if (mode !== this.fontRenderingMode) {
|
||
this.fontRenderingMode = mode;
|
||
if (c_oAscFontRenderingModeType.noHinting === mode) {
|
||
this._setHintsProps(false, false);
|
||
} else if (c_oAscFontRenderingModeType.hinting === mode) {
|
||
this._setHintsProps(true, false);
|
||
} else if (c_oAscFontRenderingModeType.hintingAndSubpixeling === mode) {
|
||
this._setHintsProps(true, true);
|
||
}
|
||
|
||
if (!isInit) {
|
||
this.drawWS();
|
||
this.cellEditor.setFontRenderingMode(mode);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.initFormulasList = function() {
|
||
this.formulasList = [];
|
||
var oFormulaList = AscCommonExcel.cFormulaFunctionLocalized ? AscCommonExcel.cFormulaFunctionLocalized :
|
||
AscCommonExcel.cFormulaFunction;
|
||
for (var f in oFormulaList) {
|
||
this.formulasList.push(f);
|
||
}
|
||
this.arrExcludeFormulas = [cBoolLocal.t, cBoolLocal.f];
|
||
};
|
||
|
||
WorkbookView.prototype.addToFormulasList = function(func) {
|
||
this.formulasList.push(func);
|
||
};
|
||
|
||
WorkbookView.prototype._setHintsProps = function(bIsHinting, bIsSubpixHinting) {
|
||
var manager;
|
||
for (var i = 0, length = this.fmgrGraphics.length; i < length; ++i) {
|
||
manager = this.fmgrGraphics[i];
|
||
// Последний без хинтования (только для измерения)
|
||
if (i === length - 1) {
|
||
bIsHinting = bIsSubpixHinting = false;
|
||
}
|
||
|
||
manager.SetHintsProps(bIsHinting, bIsSubpixHinting);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype._calcMaxDigitWidth = function () {
|
||
var t = this;
|
||
this.executeDefaultDpi(function () {
|
||
if (t.fmgrGraphics && t.fmgrGraphics[3] && !t.fmgrGraphics[3].m_oFont) {
|
||
AscCommonExcel.resetDrawingContextFonts();
|
||
}
|
||
// set default worksheet header font for calculations
|
||
t.buffers.main.setFont(AscCommonExcel.g_oDefaultFormat.Font);
|
||
// Измеряем в pt
|
||
t.stringRender.measureString("0123456789", new AscCommonExcel.CellFlags());
|
||
|
||
// Переводим в px и приводим к целому (int)
|
||
t.model.maxDigitWidth = t.maxDigitWidth = t.stringRender.getWidestCharWidth();
|
||
// Проверка для Calibri 11 должно быть this.maxDigitWidth = 7
|
||
|
||
if (!t.maxDigitWidth) {
|
||
throw new Error("Error: can't measure text string");
|
||
}
|
||
|
||
// Padding рассчитывается исходя из maxDigitWidth (http://social.msdn.microsoft.com/Forums/en-US/9a6a9785-66ad-4b6b-bb9f-74429381bd72/margin-padding-in-cell-excel?forum=os_binaryfile)
|
||
t.defaults.worksheetView.cells.padding = Math.max(asc.ceil(t.maxDigitWidth / 4), 2);
|
||
t.model.paddingPlusBorder = 2 * t.defaults.worksheetView.cells.padding + 1;
|
||
})
|
||
};
|
||
|
||
WorkbookView.prototype.executeDefaultDpi = function (runFunction) {
|
||
var truePPIX = this.drawingCtx.ppiX;
|
||
var truePPIY = this.drawingCtx.ppiY;
|
||
var retinaPixelRatio = AscBrowser.retinaPixelRatio;
|
||
|
||
this.drawingCtx.ppiY = 96;
|
||
this.drawingCtx.ppiX = 96;
|
||
AscBrowser.retinaPixelRatio = 1;
|
||
|
||
runFunction();
|
||
|
||
this.drawingCtx.ppiY = truePPIY;
|
||
this.drawingCtx.ppiX = truePPIX;
|
||
AscBrowser.retinaPixelRatio = retinaPixelRatio;
|
||
};
|
||
|
||
|
||
WorkbookView.prototype.getPivotMergeStyle = function (sheetMergedStyles, range, style, pivot) {
|
||
var styleInfo = pivot.asc_getStyleInfo();
|
||
var i, r, dxf, stripe1, stripe2, emptyStripe = new Asc.CTableStyleElement();
|
||
if (style) {
|
||
dxf = style.wholeTable && style.wholeTable.dxf;
|
||
if (dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(range, dxf);
|
||
}
|
||
|
||
if (styleInfo.showColStripes) {
|
||
stripe1 = style.firstColumnStripe || emptyStripe;
|
||
stripe2 = style.secondColumnStripe || emptyStripe;
|
||
if (stripe1.dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(range, stripe1.dxf,
|
||
new Asc.CTableStyleStripe(stripe1.size, stripe2.size));
|
||
}
|
||
if (stripe2.dxf && range.c1 + stripe1.size <= range.c2) {
|
||
sheetMergedStyles.setTablePivotStyle(
|
||
new Asc.Range(range.c1 + stripe1.size, range.r1, range.c2, range.r2), stripe2.dxf,
|
||
new Asc.CTableStyleStripe(stripe2.size, stripe1.size));
|
||
}
|
||
}
|
||
if (styleInfo.showRowStripes) {
|
||
stripe1 = style.firstRowStripe || emptyStripe;
|
||
stripe2 = style.secondRowStripe || emptyStripe;
|
||
if (stripe1.dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(range, stripe1.dxf,
|
||
new Asc.CTableStyleStripe(stripe1.size, stripe2.size, true));
|
||
}
|
||
if (stripe2.dxf && range.r1 + stripe1.size <= range.r2) {
|
||
sheetMergedStyles.setTablePivotStyle(
|
||
new Asc.Range(range.c1, range.r1 + stripe1.size, range.c2, range.r2), stripe2.dxf,
|
||
new Asc.CTableStyleStripe(stripe2.size, stripe1.size, true));
|
||
}
|
||
}
|
||
|
||
dxf = style.firstColumn && style.firstColumn.dxf;
|
||
if (styleInfo.showRowHeaders && dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(new Asc.Range(range.c1, range.r1, range.c1, range.r2), dxf);
|
||
}
|
||
|
||
dxf = style.headerRow && style.headerRow.dxf;
|
||
if (styleInfo.showColHeaders && dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(new Asc.Range(range.c1, range.r1, range.c2, range.r1), dxf);
|
||
}
|
||
|
||
dxf = style.firstHeaderCell && style.firstHeaderCell.dxf;
|
||
if (styleInfo.showColHeaders && styleInfo.showRowHeaders && dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(new Asc.Range(range.c1, range.r1, range.c1, range.r1), dxf);
|
||
}
|
||
|
||
if (pivot.asc_getColGrandTotals()) {
|
||
dxf = style.lastColumn && style.lastColumn.dxf;
|
||
if (dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(new Asc.Range(range.c2, range.r1, range.c2, range.r2), dxf);
|
||
}
|
||
}
|
||
|
||
if (styleInfo.showRowHeaders) {
|
||
for (i = range.r1 + 1; i < range.r2; ++i) {
|
||
r = i - (range.r1 + 1);
|
||
if (0 === r % 3) {
|
||
dxf = style.firstRowSubheading;
|
||
}
|
||
if (dxf = (dxf && dxf.dxf)) {
|
||
sheetMergedStyles.setTablePivotStyle(new Asc.Range(range.c1, i, range.c2, i), dxf);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pivot.asc_getRowGrandTotals()) {
|
||
dxf = style.totalRow && style.totalRow.dxf;
|
||
if (dxf) {
|
||
sheetMergedStyles.setTablePivotStyle(new Asc.Range(range.c1, range.r2, range.c2, range.r2), dxf);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getTableStyles = function (props, bPivotTable) {
|
||
var wb = this.model;
|
||
var t = this;
|
||
|
||
var result = [];
|
||
var canvas = document.createElement('canvas');
|
||
var tableStyleInfo;
|
||
var pivotStyleInfo;
|
||
|
||
var defaultStyles, styleThumbnailHeight, row, col = 5;
|
||
var styleThumbnailWidth = window["IS_NATIVE_EDITOR"] ? 90 : 60;
|
||
if(bPivotTable)
|
||
{
|
||
styleThumbnailHeight = 49;
|
||
row = 8;
|
||
defaultStyles = wb.TableStyles.DefaultStylesPivot;
|
||
pivotStyleInfo = props;
|
||
}
|
||
else
|
||
{
|
||
styleThumbnailHeight = window["IS_NATIVE_EDITOR"] ? 48 : 44;
|
||
row = 5;
|
||
defaultStyles = wb.TableStyles.DefaultStyles;
|
||
tableStyleInfo = new AscCommonExcel.TableStyleInfo();
|
||
if (props) {
|
||
tableStyleInfo.ShowColumnStripes = props.asc_getBandVer();
|
||
tableStyleInfo.ShowFirstColumn = props.asc_getFirstCol();
|
||
tableStyleInfo.ShowLastColumn = props.asc_getLastCol();
|
||
tableStyleInfo.ShowRowStripes = props.asc_getBandHor();
|
||
tableStyleInfo.HeaderRowCount = props.asc_getFirstRow();
|
||
tableStyleInfo.TotalsRowCount = props.asc_getLastRow();
|
||
} else {
|
||
tableStyleInfo.ShowColumnStripes = false;
|
||
tableStyleInfo.ShowFirstColumn = false;
|
||
tableStyleInfo.ShowLastColumn = false;
|
||
tableStyleInfo.ShowRowStripes = true;
|
||
tableStyleInfo.HeaderRowCount = true;
|
||
tableStyleInfo.TotalsRowCount = false;
|
||
}
|
||
}
|
||
|
||
styleThumbnailWidth = AscCommon.AscBrowser.convertToRetinaValue(styleThumbnailWidth, true);
|
||
styleThumbnailHeight = AscCommon.AscBrowser.convertToRetinaValue(styleThumbnailHeight, true);
|
||
|
||
canvas.width = styleThumbnailWidth;
|
||
canvas.height = styleThumbnailHeight;
|
||
var sizeInfo = {w: styleThumbnailWidth, h: styleThumbnailHeight, row: row, col: col};
|
||
|
||
var ctx = new Asc.DrawingContext({canvas: canvas, units: 0/*px*/, fmgrGraphics: this.fmgrGraphics, font: this.m_oFont});
|
||
|
||
var addStyles = function(styles, type, bEmptyStyle)
|
||
{
|
||
var style;
|
||
for (var i in styles)
|
||
{
|
||
if ((bPivotTable && styles[i].pivot) || (!bPivotTable && styles[i].table))
|
||
{
|
||
if (window["IS_NATIVE_EDITOR"]) {
|
||
//TODO empty style?
|
||
window["native"]["BeginDrawStyle"](type, i);
|
||
}
|
||
t._drawTableStyle(ctx, styles[i], tableStyleInfo, pivotStyleInfo, sizeInfo);
|
||
if (window["IS_NATIVE_EDITOR"]) {
|
||
window["native"]["EndDrawStyle"]();
|
||
} else {
|
||
style = new AscCommon.CStyleImage();
|
||
style.name = bEmptyStyle ? null : i;
|
||
style.displayName = styles[i].displayName;
|
||
style.type = type;
|
||
style.image = canvas.toDataURL("image/png");
|
||
result.push(style);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
addStyles(wb.TableStyles.CustomStyles, AscCommon.c_oAscStyleImage.Document);
|
||
if (props) {
|
||
//None style
|
||
var emptyStyle = new Asc.CTableStyle();
|
||
emptyStyle.displayName = AscCommon.translateManager.getValue("None");
|
||
emptyStyle.pivot = bPivotTable;
|
||
addStyles({null: emptyStyle}, AscCommon.c_oAscStyleImage.Default, true);
|
||
}
|
||
addStyles(defaultStyles, AscCommon.c_oAscStyleImage.Default);
|
||
|
||
return result;
|
||
};
|
||
|
||
WorkbookView.prototype._drawTableStyle = function (ctx, style, tableStyleInfo, pivotStyleInfo, size) {
|
||
ctx.clear();
|
||
|
||
var w = size.w;
|
||
var h = size.h;
|
||
var row = size.row;
|
||
var col = size.col;
|
||
|
||
var startX = 1;
|
||
var startY = 1;
|
||
|
||
var ySize = (h - 1) - 2 * startY;
|
||
var xSize = w - 2 * startX;
|
||
|
||
var stepY = (ySize) / row;
|
||
var stepX = (xSize) / col;
|
||
var lineStepX = (xSize - 1) / 5;
|
||
|
||
var whiteColor = new CColor(255, 255, 255);
|
||
var blackColor = new CColor(0, 0, 0);
|
||
|
||
var defaultColor;
|
||
if (!style || !style.wholeTable || !style.wholeTable.dxf.font) {
|
||
defaultColor = blackColor;
|
||
} else {
|
||
defaultColor = style.wholeTable.dxf.font.getColor();
|
||
}
|
||
|
||
ctx.setFillStyle(whiteColor);
|
||
ctx.fillRect(0, 0, xSize + 2 * startX, ySize + 2 * startY);
|
||
|
||
var calculateLineVer = function(color, x, y1, y2)
|
||
{
|
||
ctx.beginPath();
|
||
ctx.setStrokeStyle(color);
|
||
|
||
ctx.lineVer(x + startX, y1 + startY, y2 + startY);
|
||
|
||
ctx.stroke();
|
||
ctx.closePath();
|
||
};
|
||
|
||
var calculateLineHor = function(color, x1, y, x2)
|
||
{
|
||
ctx.beginPath();
|
||
ctx.setStrokeStyle(color);
|
||
|
||
ctx.lineHor(x1 + startX, y + startY, x2 + startX);
|
||
|
||
ctx.stroke();
|
||
ctx.closePath();
|
||
};
|
||
|
||
var calculateRect = function(color, x1, y1, w, h)
|
||
{
|
||
ctx.beginPath();
|
||
ctx.setFillStyle(color);
|
||
ctx.fillRect(x1 + startX, y1 + startY, w, h);
|
||
ctx.closePath();
|
||
};
|
||
|
||
var bbox = new Asc.Range(0, 0, col - 1, row - 1);
|
||
var sheetMergedStyles = new AscCommonExcel.SheetMergedStyles();
|
||
var hiddenManager = new AscCommonExcel.HiddenManager(null);
|
||
|
||
if(pivotStyleInfo)
|
||
{
|
||
this.getPivotMergeStyle(sheetMergedStyles, bbox, style, pivotStyleInfo);
|
||
}
|
||
else if(tableStyleInfo)
|
||
{
|
||
style.initStyle(sheetMergedStyles, bbox, tableStyleInfo,
|
||
null !== tableStyleInfo.HeaderRowCount ? tableStyleInfo.HeaderRowCount : 1,
|
||
null !== tableStyleInfo.TotalsRowCount ? tableStyleInfo.TotalsRowCount : 0);
|
||
}
|
||
|
||
var compiledStylesArr = [];
|
||
for (var i = 0; i < row; i++)
|
||
{
|
||
for (var j = 0; j < col; j++) {
|
||
var color = null, prevStyle;
|
||
var curStyle = AscCommonExcel.getCompiledStyle(sheetMergedStyles, hiddenManager, i, j);
|
||
|
||
if(!compiledStylesArr[i])
|
||
{
|
||
compiledStylesArr[i] = [];
|
||
}
|
||
compiledStylesArr[i][j] = curStyle;
|
||
|
||
//fill
|
||
color = curStyle && curStyle.fill && curStyle.fill.bg();
|
||
if(color)
|
||
{
|
||
calculateRect(color, j * stepX, i * stepY, stepX, stepY);
|
||
}
|
||
|
||
//borders
|
||
//left
|
||
prevStyle = (j - 1 >= 0) ? compiledStylesArr[i][j - 1] : null;
|
||
color = AscCommonExcel.getMatchingBorder(prevStyle && prevStyle.border && prevStyle.border.r, curStyle && curStyle.border && curStyle.border.l);
|
||
if(color && color.w > 0)
|
||
{
|
||
calculateLineVer(color.getColorOrDefault(), j * lineStepX, i * stepY, (i + 1) * stepY);
|
||
}
|
||
//right
|
||
color = curStyle && curStyle.border && curStyle.border.r;
|
||
if(color && color.w > 0)
|
||
{
|
||
calculateLineVer(color.getColorOrDefault(), (j + 1) * lineStepX, i * stepY, (i + 1) * stepY);
|
||
}
|
||
//top
|
||
prevStyle = (i - 1 >= 0) ? compiledStylesArr[i - 1][j] : null;
|
||
color = AscCommonExcel.getMatchingBorder(prevStyle && prevStyle.border && prevStyle.border.b, curStyle && curStyle.border && curStyle.border.t);
|
||
if(color && color.w > 0)
|
||
{
|
||
calculateLineHor(color.getColorOrDefault(), j * stepX, i * stepY, (j + 1) * stepX);
|
||
}
|
||
//bottom
|
||
color = curStyle && curStyle.border && curStyle.border.b;
|
||
if(color && color.w > 0)
|
||
{
|
||
calculateLineHor(color.getColorOrDefault(), j * stepX, (i + 1) * stepY, (j + 1) * stepX);
|
||
}
|
||
|
||
//marks
|
||
color = (curStyle && curStyle.font && curStyle.font.c) || defaultColor;
|
||
calculateLineHor(color, j * lineStepX + 3, (i + 1) * stepY - stepY / 2, (j + 1) * lineStepX - 2);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.IsSelectionUse = function () {
|
||
return !this.getWorksheet().getSelectionShape();
|
||
};
|
||
WorkbookView.prototype.GetSelectionRectsBounds = function (checkVisibleRange) {
|
||
var ws = this.getWorksheet();
|
||
if (ws.getSelectionShape()) {
|
||
return null;
|
||
}
|
||
|
||
var range = ws.model.getSelection().getLast();
|
||
if (checkVisibleRange && !range.intersectionSimple(ws.visibleRange)) {
|
||
return null;
|
||
}
|
||
var type = range.getType();
|
||
var l = ws.getCellLeft(range.c1, 3) - ws.getHorizontalScrollCorrect(3);
|
||
var t = ws.getCellTop(range.r1, 3) - ws.getScrollCorrect(3);
|
||
|
||
var offset = ws.getCellsOffset(3);
|
||
|
||
return {
|
||
X: asc.c_oAscSelectionType.RangeRow === type ? -offset.left : l - offset.left,
|
||
Y: asc.c_oAscSelectionType.RangeCol === type ? -offset.top : t - offset.top,
|
||
W: asc.c_oAscSelectionType.RangeRow === type ? offset.left :
|
||
ws.getCellLeft(range.c2, 3) - l + ws.getColumnWidth(range.c2, 3) - ws.getHorizontalScrollCorrect(3),
|
||
H: asc.c_oAscSelectionType.RangeCol === type ? offset.top :
|
||
ws.getCellTop(range.r2, 3) - t + ws.getRowHeight(range.r2, 3) - ws.getScrollCorrect(3),
|
||
T: type
|
||
};
|
||
};
|
||
WorkbookView.prototype.GetCaptionSize = function()
|
||
{
|
||
var offset = this.getWorksheet().getCellsOffset(3);
|
||
return {
|
||
W: offset.left,
|
||
H: offset.top
|
||
};
|
||
};
|
||
WorkbookView.prototype.ConvertXYToLogic = function (x, y) {
|
||
return this.getWorksheet().ConvertXYToLogic(x, y);
|
||
};
|
||
WorkbookView.prototype.ConvertLogicToXY = function (xL, yL) {
|
||
return this.getWorksheet().ConvertLogicToXY(xL, yL)
|
||
};
|
||
WorkbookView.prototype.changeFormatTableInfo = function (tableName, optionType, val) {
|
||
var ws = this.getWorksheet();
|
||
return ws.af_changeFormatTableInfo(tableName, optionType, val);
|
||
};
|
||
|
||
WorkbookView.prototype.applyAutoCorrectOptions = function (val) {
|
||
|
||
var api = window["Asc"]["editor"];
|
||
var prevProps;
|
||
switch (val) {
|
||
case Asc.c_oAscAutoCorrectOptions.UndoTableAutoExpansion: {
|
||
prevProps = {
|
||
props: this.autoCorrectStore.props,
|
||
cell: this.autoCorrectStore.cell,
|
||
wsId: this.autoCorrectStore.wsId
|
||
};
|
||
api.asc_Undo();
|
||
this.autoCorrectStore = prevProps;
|
||
this.autoCorrectStore.props[0] = Asc.c_oAscAutoCorrectOptions.RedoTableAutoExpansion;
|
||
this.toggleAutoCorrectOptions(true);
|
||
break;
|
||
}
|
||
case Asc.c_oAscAutoCorrectOptions.RedoTableAutoExpansion: {
|
||
prevProps = {
|
||
props: this.autoCorrectStore.props,
|
||
cell: this.autoCorrectStore.cell,
|
||
wsId: this.autoCorrectStore.wsId
|
||
};
|
||
api.asc_Redo();
|
||
this.autoCorrectStore = prevProps;
|
||
this.autoCorrectStore.props[0] = Asc.c_oAscAutoCorrectOptions.UndoTableAutoExpansion;
|
||
this.toggleAutoCorrectOptions(true);
|
||
break;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
};
|
||
|
||
WorkbookView.prototype.toggleAutoCorrectOptions = function (isSwitch, val) {
|
||
if (isSwitch) {
|
||
if (val) {
|
||
this.autoCorrectStore = val;
|
||
var options = new Asc.asc_CAutoCorrectOptions();
|
||
options.asc_setOptions(this.autoCorrectStore.props);
|
||
options.asc_setCellCoord(
|
||
this.getWorksheet().getCellCoord(this.autoCorrectStore.cell.c1, this.autoCorrectStore.cell.r1));
|
||
|
||
this.handlers.trigger("asc_onToggleAutoCorrectOptions", options);
|
||
} else if (this.autoCorrectStore) {
|
||
if (this.autoCorrectStore.wsId === this.model.getActiveWs().getId()) {
|
||
var options = new Asc.asc_CAutoCorrectOptions();
|
||
options.asc_setOptions(this.autoCorrectStore.props);
|
||
options.asc_setCellCoord(
|
||
this.getWorksheet().getCellCoord(this.autoCorrectStore.cell.c1, this.autoCorrectStore.cell.r1));
|
||
|
||
this.handlers.trigger("asc_onToggleAutoCorrectOptions", options);
|
||
} else {
|
||
this.handlers.trigger("asc_onToggleAutoCorrectOptions");
|
||
}
|
||
}
|
||
} else {
|
||
if(this.autoCorrectStore) {
|
||
if (val) {
|
||
this.autoCorrectStore = null;
|
||
}
|
||
this.handlers.trigger("asc_onToggleAutoCorrectOptions");
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.savePagePrintOptions = function (arrPagesPrint) {
|
||
var t = this;
|
||
var viewMode = !this.canEdit();
|
||
|
||
if(!arrPagesPrint) {
|
||
return;
|
||
}
|
||
|
||
var callback = function (isSuccess) {
|
||
if (false === isSuccess) {
|
||
return;
|
||
}
|
||
|
||
for(var i in arrPagesPrint) {
|
||
var ws = t.getWorksheet(parseInt(i));
|
||
ws.savePageOptions(arrPagesPrint[i], viewMode);
|
||
window["Asc"]["editor"]._onUpdateLayoutMenu(ws.model.Id);
|
||
}
|
||
};
|
||
|
||
//разом лочу и настройки и колонтитулы. будут проблема - можно раъединить
|
||
var lockInfoArr = [];
|
||
var lockInfo;
|
||
for(var i in arrPagesPrint) {
|
||
lockInfo = this.getWorksheet(parseInt(i)).getLayoutLockInfo();
|
||
lockInfoArr.push(lockInfo);
|
||
if (arrPagesPrint[i].pageSetup && arrPagesPrint[i].pageSetup.headerFooter) {
|
||
lockInfo = this.getWorksheet(parseInt(i)).getHeaderFooterLockInfo();
|
||
lockInfoArr.push(lockInfo);
|
||
}
|
||
}
|
||
|
||
if(viewMode) {
|
||
callback();
|
||
} else {
|
||
this.collaborativeEditing.lock(lockInfoArr, callback);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.cleanCutData = function (bDrawSelection, bCleanBuffer) {
|
||
if(this.cutIdSheet) {
|
||
var activeWs = this.wsViews[this.wsActive];
|
||
var ws = this.getWorksheetById(this.cutIdSheet);
|
||
|
||
if(bDrawSelection && activeWs && ws && activeWs.model.Id === ws.model.Id) {
|
||
activeWs.cleanSelection();
|
||
}
|
||
|
||
if(ws) {
|
||
ws.setCutRange(null);
|
||
}
|
||
this.cutIdSheet = null;
|
||
|
||
if(bDrawSelection && activeWs && ws && activeWs.model.Id === ws.model.Id) {
|
||
activeWs.updateSelection();
|
||
}
|
||
//ms чистит буфер, если происходят какие-то изменения в документе с посвеченной областью вырезать
|
||
//мы в данном случае не можем так делать, поскольку не можем прочесть информацию из буфера и убедиться, что
|
||
//там именно тот вырезанный фрагмент. тем самым можем затереть какую-то важную информацию
|
||
if(bCleanBuffer) {
|
||
AscCommon.g_clipboardBase.ClearBuffer();
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.cleanCopyData = function (bDrawSelection, bCleanBuffer) {
|
||
if(this.cutIdSheet == null) {
|
||
var activeWs = this.wsViews[this.wsActive];
|
||
|
||
var needUpdateSelection = bDrawSelection && activeWs && activeWs.getCutRange();
|
||
if(needUpdateSelection) {
|
||
activeWs.cleanSelection();
|
||
}
|
||
|
||
var isCopyHighlighted = false;
|
||
for(var i in this.wsViews) {
|
||
if (this.wsViews[i].getCutRange() != null) {
|
||
isCopyHighlighted = true;
|
||
this.wsViews[i].setCutRange(null);
|
||
}
|
||
}
|
||
|
||
if(needUpdateSelection) {
|
||
activeWs.updateSelection();
|
||
}
|
||
|
||
//ms чистит буфер, если происходят какие-то изменения в документе с посвеченной областью вырезать
|
||
//мы в данном случае не можем так делать, поскольку не можем прочесть информацию из буфера и убедиться, что
|
||
//там именно тот вырезанный фрагмент. тем самым можем затереть какую-то важную информацию
|
||
if(bCleanBuffer && isCopyHighlighted) {
|
||
AscCommon.g_clipboardBase.ClearBuffer();
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.updateGroupData = function () {
|
||
this.getWorksheet()._updateGroups(true);
|
||
this.getWorksheet()._updateGroups(null);
|
||
};
|
||
|
||
WorkbookView.prototype.pasteSheets = function (arrSheets, insertBefore, arrNames) {
|
||
var t = this;
|
||
var pasteProcessor = AscCommonExcel.g_clipboardExcel.pasteProcessor;
|
||
var newFonts = {}, aPastedImages = [], pastedWorksheets = [];
|
||
for (let i = 0; i < arrSheets.length; i++) {
|
||
let sheet_data = arrSheets[i];
|
||
|
||
var tempWorkbook, pastedWs, base64;
|
||
if (typeof (sheet_data) === "string") {
|
||
base64 = sheet_data;
|
||
tempWorkbook = new AscCommonExcel.Workbook(undefined, undefined, false);
|
||
tempWorkbook.DrawingDocument = Asc.editor.wbModel.DrawingDocument;
|
||
tempWorkbook.setCommonIndexObjectsFrom(this.model);
|
||
aPastedImages = aPastedImages.concat(pasteProcessor._readExcelBinary(base64.split('xslData;')[1], tempWorkbook, true));
|
||
pastedWs = tempWorkbook.aWorksheets[0];
|
||
} else {
|
||
pastedWs = sheet_data;
|
||
tempWorkbook = sheet_data.workbook;
|
||
}
|
||
|
||
pastedWorksheets.push(pastedWs);
|
||
|
||
newFonts = Object.assign(newFonts, tempWorkbook.generateFontMap2());
|
||
newFonts = pasteProcessor._convertFonts(newFonts);
|
||
for (let j = 0; j < pastedWs.Drawings.length; j++) {
|
||
pastedWs.Drawings[j].graphicObject.getAllFonts(newFonts);
|
||
}
|
||
}
|
||
|
||
var doCopy = function() {
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
let scale = api.asc_getZoom();
|
||
let renameParamsArr = [];
|
||
let renameSheetMap = {};
|
||
for (let i = 0; i < pastedWorksheets.length; i++) {
|
||
if (i !== 0) {
|
||
insertBefore++;
|
||
}
|
||
var renameParams = t.model.copyWorksheet(0, insertBefore, arrNames[i], undefined, undefined, undefined, pastedWorksheets[i], base64);
|
||
//TODO ошибку по срезам добавил в renameParams. необходимо пересмотреть
|
||
//переименовать эту переменную, либо не добавлять copySlicerError и посылать ошибку в другом месте
|
||
if (renameParams && renameParams.copySlicerError) {
|
||
t.handlers.trigger("asc_onError", c_oAscError.ID.MoveSlicerError, c_oAscError.Level.NoCritical);
|
||
}
|
||
|
||
renameParamsArr.push(renameParams);
|
||
renameSheetMap[renameParams.lastName] = renameParams.newName;
|
||
api.asc_showWorksheet(insertBefore);
|
||
api.asc_setZoom(scale);
|
||
}
|
||
|
||
//парсинг формул после вставки всех листов, поскольку внутри одного листа может быть ссылка в формуле на другой лист который ещё не вставился
|
||
//поэтому дожидаемся вставку всех листов
|
||
for(var j = 0; j < renameParamsArr.length; j++) {
|
||
var newSheet = t.model.getWorksheetByName(renameParamsArr[j].newName);
|
||
newSheet.copyFromFormulas(renameParamsArr[j], renameSheetMap);
|
||
}
|
||
|
||
// Делаем активным скопированный
|
||
t.model.setActive(insertBefore);
|
||
t.updateWorksheetByModel();
|
||
t.showWorksheet();
|
||
History.EndTransaction();
|
||
// Посылаем callback об изменении списка листов
|
||
api.sheetsChanged();
|
||
};
|
||
|
||
var api = window["Asc"]["editor"];
|
||
api._loadFonts(newFonts, function () {
|
||
if (aPastedImages && aPastedImages.length) {
|
||
pasteProcessor._loadImagesOnServer(aPastedImages, function () {
|
||
doCopy();
|
||
});
|
||
} else {
|
||
doCopy();
|
||
}
|
||
});
|
||
|
||
};
|
||
|
||
WorkbookView.prototype.pasteSheet = function (sheet_data, insertBefore, name, callback) {
|
||
|
||
var t = this;
|
||
var pasteProcessor = AscCommonExcel.g_clipboardExcel.pasteProcessor;
|
||
var aPastedImages, tempWorkbook, pastedWs, base64;
|
||
if (typeof (sheet_data) === "string") {
|
||
base64 = sheet_data;
|
||
tempWorkbook = new AscCommonExcel.Workbook(undefined, undefined, false);
|
||
tempWorkbook.DrawingDocument = Asc.editor.wbModel.DrawingDocument;
|
||
tempWorkbook.setCommonIndexObjectsFrom(this.model);
|
||
aPastedImages = pasteProcessor._readExcelBinary(base64.split('xslData;')[1], tempWorkbook, true);
|
||
pastedWs = tempWorkbook.aWorksheets[0];
|
||
} else {
|
||
pastedWs = sheet_data;
|
||
tempWorkbook = sheet_data.workbook;
|
||
}
|
||
|
||
var newFonts = {};
|
||
newFonts = tempWorkbook.generateFontMap2();
|
||
newFonts = pasteProcessor._convertFonts(newFonts);
|
||
for (var i = 0; i < pastedWs.Drawings.length; i++) {
|
||
pastedWs.Drawings[i].graphicObject.getAllFonts(newFonts);
|
||
}
|
||
|
||
var doCopy = function() {
|
||
History.Create_NewPoint();
|
||
var renameParams = t.model.copyWorksheet(0, insertBefore, name, undefined, undefined, undefined, pastedWs, base64);
|
||
//TODO ошибку по срезам добавил в renameParams. необходимо пересмотреть
|
||
//переименовать эту переменную, либо не добавлять copySlicerError и посылать ошибку в другом месте
|
||
if (renameParams && renameParams.copySlicerError) {
|
||
t.handlers.trigger("asc_onError", c_oAscError.ID.MoveSlicerError, c_oAscError.Level.NoCritical);
|
||
}
|
||
callback(renameParams);
|
||
};
|
||
|
||
var api = window["Asc"]["editor"];
|
||
api._loadFonts(newFonts, function () {
|
||
if (aPastedImages && aPastedImages.length) {
|
||
pasteProcessor._loadImagesOnServer(aPastedImages, function () {
|
||
doCopy();
|
||
});
|
||
} else {
|
||
doCopy();
|
||
}
|
||
});
|
||
};
|
||
|
||
WorkbookView.prototype.beforeInsertSlicer = function () {
|
||
return this.getWorksheet().beforeInsertSlicer();
|
||
};
|
||
|
||
WorkbookView.prototype.insertSlicers = function (arr) {
|
||
return this.getWorksheet().insertSlicers(arr);
|
||
};
|
||
|
||
WorkbookView.prototype.setFilterValuesFromSlicer = function (name, val) {
|
||
var slicer = this.model.getSlicerByName(name);
|
||
//нам нужно получить индекс листа где находится кэш данного среза
|
||
var sheetIndex = slicer.getIndexSheetCache();
|
||
if (sheetIndex !== null) {
|
||
var ws = this.getWorksheet(sheetIndex);
|
||
if (ws) {
|
||
ws.setFilterValuesFromSlicer(slicer, val);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.deleteSlicer = function (name) {
|
||
for(var i in this.wsViews) {
|
||
this.wsViews[i].deleteSlicer(name);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.deleteSlicers = function (names) {
|
||
var slicers = [];
|
||
for(var j = 0; j < names.length; j++) {
|
||
for (var i in this.wsViews) {
|
||
var slicer = this.wsViews[i].model.getSlicerByName(names[j]);
|
||
if (slicer) {
|
||
slicers.push({ws: this.wsViews[i], slicer: slicer});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
var oThis = this;
|
||
var callback = function (success) {
|
||
var oWSView = oThis.getWorksheet();
|
||
if (!success) {
|
||
History.EndTransaction();
|
||
oWSView.handlers.trigger("selectionChanged");
|
||
return;
|
||
}
|
||
History.StartTransaction();
|
||
|
||
for (var i = 0; i < slicers.length; i++) {
|
||
slicers[i].ws.model.deleteSlicer(slicers[i].slicer.name);
|
||
}
|
||
|
||
History.EndTransaction();
|
||
History.EndTransaction();
|
||
oWSView.handlers.trigger("selectionChanged");
|
||
};
|
||
|
||
if (slicers && slicers.length) {
|
||
this.checkLockSlicers(slicers, true, callback);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setSlicer = function (name, obj) {
|
||
for(var i in this.wsViews) {
|
||
var slicer = this.wsViews[i].model.getSlicerByName(name);
|
||
if (slicer) {
|
||
this.wsViews[i].setSlicer(slicer, obj);
|
||
break;
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setSlicers = function (names, obj) {
|
||
var slicers = [];
|
||
for(var j = 0; j < names.length; j++) {
|
||
for (var i in this.wsViews) {
|
||
var slicer = this.wsViews[i].model.getSlicerByName(names[j]);
|
||
if (slicer) {
|
||
slicers.push({ws: this.wsViews[i], slicer: slicer});
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
var oThis = this;
|
||
var callback = function (success) {
|
||
var oWSView = oThis.getWorksheet();
|
||
if (!success) {
|
||
oWSView.handlers.trigger("selectionChanged");
|
||
//Transaction was started in applyDrawingProps in order to prevent save between applyDrawingProps and asc_setSlicers
|
||
History.EndTransaction();
|
||
return;
|
||
}
|
||
History.StartTransaction();
|
||
for (var i = 0; i < slicers.length; i++) {
|
||
slicers[i].slicer.set(obj);
|
||
}
|
||
History.EndTransaction();
|
||
//Transaction was started in applyDrawingProps in order to prevent save between applyDrawingProps and asc_setSlicers
|
||
History.EndTransaction();
|
||
oWSView.handlers.trigger("selectionChanged");
|
||
};
|
||
|
||
if (slicers && slicers.length) {
|
||
this.checkLockSlicers(slicers, true, callback);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.checkLockSlicers = function (slicers, doLockRange, callback) {
|
||
var t = this;
|
||
var _lockMap = [];
|
||
var lockInfoArr = [];
|
||
var lockRanges = [];
|
||
var cache, defNameId, lockInfo, lockRange, sheetId;
|
||
for (var i = 0; i < slicers.length; i++) {
|
||
cache = slicers[i].slicer.getCacheDefinition();
|
||
sheetId = slicers[i].ws.model.getId();
|
||
if (!_lockMap[cache.name]) {
|
||
_lockMap[cache.name] = 1;
|
||
defNameId = this.model.dependencyFormulas.getDefNameByName(cache.name, sheetId);
|
||
defNameId = defNameId ? defNameId.getNodeId() : null;
|
||
lockInfo = this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Object, null, -1, defNameId);
|
||
lockInfoArr.push(lockInfo);
|
||
if (doLockRange) {
|
||
lockRange = cache.getRange();
|
||
if (lockRange) {
|
||
lockRanges.push(this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Range, null, sheetId,
|
||
new AscCommonExcel.asc_CCollaborativeRange(lockRange.c1, lockRange.r1, lockRange.c2, lockRange.r2)));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
var _callback = function (success) {
|
||
if (!success && callback) {
|
||
callback(false);
|
||
}
|
||
|
||
if (lockRanges && lockRanges.length) {
|
||
t.collaborativeEditing.lock(lockRanges, callback);
|
||
} else {
|
||
callback(true);
|
||
}
|
||
};
|
||
|
||
if (lockInfoArr && lockInfoArr.length) {
|
||
this.collaborativeEditing.lock(lockInfoArr, _callback);
|
||
} else {
|
||
_callback(true);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.updateSkin = function () {
|
||
this.defaults.worksheetView.updateStyle();
|
||
};
|
||
|
||
WorkbookView.prototype.executeWithCurrentTopLeftCell = function (runFunction) {
|
||
var i, oWS;
|
||
var aTrueTopLeftCell = {};
|
||
for(i in this.wsViews) {
|
||
oWS = this.wsViews[i];
|
||
if (oWS) {
|
||
aTrueTopLeftCell[i] = oWS.model.getTopLeftCell();
|
||
oWS.model.setTopLeftCell(oWS.getCurrentTopLeftCell());
|
||
}
|
||
}
|
||
runFunction();
|
||
for(i in this.wsViews) {
|
||
oWS = this.wsViews[i];
|
||
if (oWS) {
|
||
oWS.model.setTopLeftCell(aTrueTopLeftCell[i]);
|
||
}
|
||
}
|
||
};
|
||
WorkbookView.prototype.convertEquationToMath = function (oEquation, isAll) {
|
||
this.model.convertEquationToMath(oEquation, isAll);
|
||
};
|
||
WorkbookView.prototype.removeHandlersList = function () {
|
||
var eventList = ["changeSheetViewSettings", "cleanCellCache", "changeWorksheetUpdate", "changeDocument",
|
||
"showWorksheet", "setSelection", "getSelectionState", "setSelectionState", "drawWS", "scrollToTopLeftCell",
|
||
"showDrawingObjects", "setCanUndo", "setCanRedo", "setDocumentModified", "updateWorksheetByModel",
|
||
"undoRedoAddRemoveRowCols", "undoRedoHideSheet", "updateSelection", "asc_onLockDefNameManager", 'addComment',
|
||
'removeComment', 'hiddenComments', 'showSolved', "hideSpecialPasteOptions", "toggleAutoCorrectOptions",
|
||
"cleanCutData", "cleanCopyData", "updateGroupData", "updatePrintPreview", "clearFindResults", "updateCellWatches",
|
||
"changeCellWatches", "onChangePageSetupProps", "changeUpdateLinks", "updateScrollVisibility"];
|
||
|
||
for (var i = 0; i < eventList.length; i++) {
|
||
this.handlers.remove(eventList[i]);
|
||
}
|
||
};
|
||
WorkbookView.prototype.Document_UpdateUndoRedoState = function()
|
||
{
|
||
if (true === this.TurnOffInterfaceEvents)
|
||
return;
|
||
|
||
if (true === AscCommon.CollaborativeEditing.Get_GlobalLockSelection())
|
||
return;
|
||
|
||
// TODO: Возможно стоит перенсти эту проверку в класс CHistory и присылать
|
||
// данные события при изменении значения History.Index
|
||
|
||
// Проверяем состояние Undo/Redo
|
||
|
||
var bCanUndo = History.Can_Undo();
|
||
if (true !== bCanUndo && this.Api && this.CollaborativeEditing && true === this.CollaborativeEditing.Is_Fast() && true !== this.CollaborativeEditing.Is_SingleUser())
|
||
bCanUndo = this.CollaborativeEditing.CanUndo();
|
||
|
||
this.Api.sync_CanUndoCallback(bCanUndo);
|
||
this.Api.sync_CanRedoCallback(History.Can_Redo());
|
||
this.Api.CheckChangedDocument();
|
||
};
|
||
|
||
WorkbookView.prototype.sendCursor = function (needSend) {
|
||
var CurTime = new Date().getTime();
|
||
if (needSend || (true === this.NeedUpdateTargetForCollaboration && (CurTime - this.LastUpdateTargetTime > 1000)))
|
||
{
|
||
this.NeedUpdateTargetForCollaboration = false;
|
||
var HaveChanges = History.Have_Changes(true);
|
||
if (true !== HaveChanges)
|
||
{
|
||
var CursorInfo = this.getCursorInfo();
|
||
if (null !== CursorInfo)
|
||
{
|
||
this.Api.CoAuthoringApi.sendCursor(CursorInfo);
|
||
this.LastUpdateTargetTime = CurTime;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
this.LastUpdateTargetTime = CurTime;
|
||
}
|
||
}
|
||
};
|
||
WorkbookView.prototype.updateTargetForCollaboration = function () {
|
||
this.NeedUpdateTargetForCollaboration = true;
|
||
};
|
||
|
||
WorkbookView.prototype.Update_ForeignCursor = function (CursorInfo, UserId, Show, UserShortId) {
|
||
if (UserId === this.Api.CoAuthoringApi.getUserConnectionId())
|
||
return;
|
||
|
||
// "" - это означает, что курсор нужно удалить
|
||
if (!CursorInfo || "" === CursorInfo) {
|
||
this.Remove_ForeignCursor(UserId);
|
||
return;
|
||
}
|
||
|
||
|
||
//AscCommon.getUserColorById(this.ShortId, null, true)
|
||
|
||
//var CursorPos = [{Class : Run, Position : InRunPos}];
|
||
var aCursorInfo = CursorInfo.split(",");
|
||
var sDrawingData = aCursorInfo[0];
|
||
var oWsView = this.getWorksheet();
|
||
var oDrawingsController = null;
|
||
if (oWsView && oWsView.objectRender) {
|
||
oDrawingsController = oWsView.objectRender.controller;
|
||
}
|
||
|
||
this.getWorksheet().cleanSelection();
|
||
AscFormat.drawingsUpdateForeignCursor(oDrawingsController, Asc.editor.wbModel.DrawingDocument, sDrawingData, UserId, Show, UserShortId);
|
||
|
||
var selectionInfo = aCursorInfo[1];
|
||
if (sDrawingData || !selectionInfo) {
|
||
this.collaborativeEditing.Remove_ForeignCursor(UserId);
|
||
this.getWorksheet()._drawSelection();
|
||
return;
|
||
}
|
||
|
||
var Changes = new AscCommon.CCollaborativeChanges();
|
||
var Reader = Changes.GetStream(selectionInfo);
|
||
|
||
var sheetId = Reader.GetString2();
|
||
var isEdit = Reader.GetBool();
|
||
var sRanges = Reader.GetString2();
|
||
|
||
var newCursorInfo = {sheetId: sheetId, isEdit: isEdit};
|
||
var i = 0;
|
||
var ranges = sRanges.split(",");
|
||
while (i < ranges.length) {
|
||
if (!newCursorInfo.ranges) {
|
||
newCursorInfo.ranges = [];
|
||
}
|
||
if (i + 4 < ranges.length) {
|
||
var _c1 = ranges[i] - 0;
|
||
var _r1 = ranges[i + 1] - 0;
|
||
var _c2 = ranges[i + 2] - 0;
|
||
var _r2 = ranges[i + 3] - 0;
|
||
|
||
newCursorInfo.ranges.push(new Asc.Range(_c1, _r1, _c2, _r2));
|
||
}
|
||
i += 4;
|
||
}
|
||
|
||
if (this.collaborativeEditing.Add_ForeignCursor(UserId, newCursorInfo, UserShortId)) {
|
||
newCursorInfo.needDrawLabel = true;
|
||
}
|
||
this.getWorksheet()._drawSelection();
|
||
|
||
//if (true === Show)
|
||
//this.CollaborativeEditing.Update_ForeignCursorPosition(UserId, Run, InRunPos, true);
|
||
};
|
||
WorkbookView.prototype.Remove_ForeignCursor = function (UserId) {
|
||
this.model.DrawingDocument.Collaborative_RemoveTarget(UserId);
|
||
AscCommon.CollaborativeEditing.Remove_ForeignCursor(UserId);
|
||
|
||
this.getWorksheet().cleanSelection();
|
||
this.collaborativeEditing.Remove_ForeignCursor(UserId);
|
||
this.Api.hideForeignSelectLabel(UserId);
|
||
this.getWorksheet()._drawSelection();
|
||
};
|
||
WorkbookView.prototype.getCursorInfo = function () {
|
||
var sSelectionInfo = "";
|
||
var sDrawingData = "";
|
||
var oWsView = this.getWorksheet();
|
||
if (oWsView && oWsView.isSelectOnShape) {
|
||
if (oWsView.objectRender) {
|
||
sDrawingData = oWsView.objectRender.getDocumentPositionBinary();
|
||
}
|
||
} else {
|
||
sSelectionInfo = this.getCursorInfoBinary();
|
||
}
|
||
return sDrawingData + "," + sSelectionInfo;
|
||
};
|
||
|
||
WorkbookView.prototype.getCursorInfoBinary = function () {
|
||
|
||
var oWs = this.getActiveWS();
|
||
if (!oWs) {
|
||
return "";
|
||
}
|
||
var id = oWs.getId();
|
||
var selection = oWs.getSelection();
|
||
var isEdit = this.getCellEditMode();
|
||
|
||
var rangeStr = "";
|
||
for (var i = 0; i < selection.ranges.length; i++) {
|
||
var _range = selection.ranges[i];
|
||
rangeStr += _range.c1 + "," + _range.r1 + "," + _range.c2 + "," + _range.r2 + ",";
|
||
}
|
||
|
||
var oWriter = new AscCommon.CMemory(true);
|
||
oWriter.CheckSize(50);
|
||
|
||
var BinaryPos = oWriter.GetCurPosition();
|
||
oWriter.WriteString2(id);
|
||
oWriter.WriteBool(isEdit);
|
||
oWriter.WriteString2(rangeStr);
|
||
var BinaryLen = oWriter.GetCurPosition() - BinaryPos;
|
||
return (BinaryLen + ";" + oWriter.GetBase64Memory2(BinaryPos, BinaryLen));
|
||
};
|
||
|
||
WorkbookView.prototype.updatePrintPreview = function () {
|
||
if (!this.printPreviewState || !this.printPreviewState.isStart()) {
|
||
return;
|
||
}
|
||
for (var i in this.wsViews) {
|
||
this.wsViews[i]._recalculate();
|
||
}
|
||
if (!this.printPreviewState.isDrawPrintPreview) {
|
||
var needUpdate;
|
||
//if (this.workbook.printPreviewState.isNeedUpdate(this.model, this.getMaxRowColWithData())) {
|
||
//возможно стоит добавить эвент об изменении количетсва страниц
|
||
needUpdate = true;
|
||
//}
|
||
this.model.handlers.trigger("asc_onPrintPreviewSheetDataChanged", needUpdate);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setPrintOptionsJson = function (val) {
|
||
//протаскиваю временные опции для печати
|
||
//из данных опций пока испольуются только колонтитулы
|
||
this.printOptionsJson = val;
|
||
};
|
||
|
||
WorkbookView.prototype.getPrintOptionsJson = function () {
|
||
return this.printOptionsJson;
|
||
};
|
||
|
||
WorkbookView.prototype.getPrintHeaderFooterFromJson = function (index) {
|
||
var res = null;
|
||
if (this.printOptionsJson) {
|
||
let sheetsProps = this.printOptionsJson["spreadsheetLayout"] && this.printOptionsJson["spreadsheetLayout"]["sheetsProps"];
|
||
var ws = this.model.getWorksheet(index);
|
||
res = new Asc.CHeaderFooter(ws);
|
||
if (sheetsProps && sheetsProps[index] && sheetsProps[index]["pageSetup"] && sheetsProps[index]["pageSetup"]["headerFooter"]) {
|
||
res.initFromJson(sheetsProps[index]["pageSetup"]["headerFooter"]);
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
|
||
//***searchEngine
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
// Search
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
WorkbookView.prototype.Search = function (oProps) {
|
||
if (!this.SearchEngine) {
|
||
return;
|
||
}
|
||
if (this.SearchEngine.Compare(oProps) && !oProps.isNeedRecalc && !(oProps.lastSearchElem && this.SearchEngine.modifiedDocument)) {
|
||
return this.SearchEngine;
|
||
}
|
||
oProps.isNeedRecalc = null;
|
||
|
||
this.SearchEngine._lastNotEmpty = this.SearchEngine.isNotEmpty();
|
||
|
||
this.SearchEngine.Clear();
|
||
this.SearchEngine.Set(oProps);
|
||
|
||
if (oProps.isNotSearchEmptyCells && oProps.findWhat === "") {
|
||
this.model.handlers.trigger("drawWS");
|
||
} else {
|
||
//далее дёргаем в CDocumentSearchExcel -> Add
|
||
this.model.findCellText(oProps, this.SearchEngine);
|
||
}
|
||
|
||
return this.SearchEngine;
|
||
};
|
||
|
||
WorkbookView.prototype.GetSearchElementId = function (bNext) {
|
||
if (!this.SearchEngine) {
|
||
return;
|
||
}
|
||
|
||
this.SearchEngine.SetDirection(bNext);
|
||
return this.SearchEngine.GetNextElement();
|
||
};
|
||
|
||
|
||
/*this.closeCellEditor();
|
||
// Для поиска эта переменная не нужна (но она может остаться от replace)
|
||
options.selectionRange = null;
|
||
var result = this.model.findCellText(options);
|
||
if (result) {
|
||
var ws = this.getWorksheet();
|
||
var range = new Asc.Range(result.col, result.row, result.col, result.row);
|
||
options.findInSelection ? ws.setActiveCell(result) : ws.setSelection(range);
|
||
return true;
|
||
}
|
||
return null;*/
|
||
|
||
WorkbookView.prototype.SelectSearchElement = function (Id) {
|
||
if (!this.SearchEngine) {
|
||
return;
|
||
}
|
||
this.SearchEngine.Select(Id, true);
|
||
};
|
||
|
||
WorkbookView.prototype.inFindResults = function (ws, row, col) {
|
||
if (!this.SearchEngine) {
|
||
return;
|
||
}
|
||
return this.SearchEngine.inFindResults(ws, row, col);
|
||
};
|
||
|
||
WorkbookView.prototype.selectAll = function () {
|
||
if (this.getCellEditMode()) {
|
||
this.cellEditor.selectAll()
|
||
} else {
|
||
var ws = this.getWorksheet();
|
||
var selectedDrawings = ws && ws.objectRender && ws.objectRender.getSelectedGraphicObjects();
|
||
if (selectedDrawings && selectedDrawings.length > 0) {
|
||
ws.objectRender.controller.selectAll();
|
||
ws.objectRender.controller.drawingObjects.sendGraphicObjectProps();
|
||
} else {
|
||
this.controller.handlers.trigger("selectColumnsByRange");
|
||
this.controller.handlers.trigger("selectRowsByRange");
|
||
}
|
||
}
|
||
};
|
||
//external reference
|
||
WorkbookView.prototype.getExternalReferences = function () {
|
||
return this.model.getExternalReferences();
|
||
};
|
||
|
||
WorkbookView.prototype.changeUpdateLinks = function () {
|
||
let val = this.model.workbookPr && this.model.workbookPr.getUpdateLinks();
|
||
if (!val) {
|
||
this.clearExternalReferenceUpdateTimer();
|
||
} else {
|
||
this.initExternalReferenceUpdateTimer();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.initExternalReferenceUpdateTimer = function (clear) {
|
||
let val = this.model.workbookPr && this.model.workbookPr.getUpdateLinks();
|
||
let oThis = this;
|
||
if (clear) {
|
||
this.clearExternalReferenceUpdateTimer();
|
||
}
|
||
if (val) {
|
||
let timeout = 30000;
|
||
oThis.externalReferenceUpdateTimer = setTimeout(function () {
|
||
oThis.updateExternalReferences(oThis.getExternalReferences());
|
||
//we are waiting update, after reinit timer
|
||
oThis.clearExternalReferenceUpdateTimer();
|
||
}, timeout);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.clearExternalReferenceUpdateTimer = function () {
|
||
if (this.externalReferenceUpdateTimer) {
|
||
clearTimeout(this.externalReferenceUpdateTimer);
|
||
this.externalReferenceUpdateTimer = null;
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.clearSearchOnRecalculate = function (index) {
|
||
if (this.SearchEngine) {
|
||
var isPrevSearch = this.SearchEngine.Count > 0;
|
||
|
||
this.SearchEngine.Clear(index);
|
||
|
||
if (isPrevSearch && !this.SearchEngine.isReplacingText) {
|
||
this.Api.sync_SearchEndCallback();
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.updateSearchOnRecalculate = function (index) {
|
||
//обновился документ
|
||
//не стираем информацию о найденном
|
||
//отправляем в интерфейс событие, чтобы показать инф. о том, что документ был изменен
|
||
if (this.SearchEngine && !this.SearchEngine.isReplacingText) {
|
||
var isPrevSearch = this.SearchEngine.Count > 0;
|
||
if (isPrevSearch) {
|
||
this.handlers.trigger("asc_onModifiedDocument");
|
||
//this.SearchEngine.Clear(null, true);
|
||
this.SearchEngine.setModifiedDocument(true);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setDate1904 = function (val) {
|
||
// Проверка глобального лока
|
||
if (this.collaborativeEditing.getGlobalLock() || !window["Asc"]["editor"].canEdit()) {
|
||
return;
|
||
}
|
||
|
||
if ((!this.model.workbookPr && !val) || (this.model.workbookPr && this.model.workbookPr.getDate1904() === val)) {
|
||
return;
|
||
}
|
||
|
||
var ws = this.getWorksheet(), t = this;
|
||
var callback = function (isSuccess) {
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
t.model.setDate1904(val, true);
|
||
|
||
History.EndTransaction();
|
||
|
||
AscCommon.oNumFormatCache.cleanCache();
|
||
|
||
ws._updateRange(new Asc.Range(0, 0, ws.model.getColsCount(), ws.model.getRowsCount()), true);
|
||
ws.draw();
|
||
};
|
||
|
||
callback();
|
||
};
|
||
|
||
WorkbookView.prototype.sendUpdateCellWatches = function (recalcAll) {
|
||
if (!this.handlers.hasTrigger("asc_onUpdateCellWatches")) {
|
||
this.changedCellWatchesSheets = null;
|
||
return;
|
||
}
|
||
|
||
if (this.changedCellWatchesSheets || recalcAll) {
|
||
this.handlers.trigger("asc_onUpdateCellWatches");
|
||
} else {
|
||
var needUpdateMap = this.getChangedCellWatches();
|
||
if (needUpdateMap) {
|
||
this.handlers.trigger("asc_onUpdateCellWatches",needUpdateMap);
|
||
}
|
||
}
|
||
|
||
this.changedCellWatchesSheets = null;
|
||
};
|
||
|
||
WorkbookView.prototype.getChangedCellWatches = function () {
|
||
return this.model.recalculateCellWatches(true);
|
||
};
|
||
|
||
|
||
|
||
|
||
WorkbookView.prototype.getDrawRestriction = function (val) {
|
||
return this.drawRestrictions && this.drawRestrictions[val];
|
||
};
|
||
|
||
WorkbookView.prototype.setDrawRestriction = function (val) {
|
||
if (!this.drawRestrictions) {
|
||
this.drawRestrictions = {};
|
||
}
|
||
|
||
this.drawRestrictions[val] = true;
|
||
if (val === "groups" && this.wsViews) {
|
||
for(var i in this.wsViews) {
|
||
var oWS = this.wsViews[i];
|
||
if(oWS) {
|
||
oWS._updateGroups();
|
||
oWS._initCellsArea(0);
|
||
}
|
||
}
|
||
var activeWs = this.getWorksheet();
|
||
if (activeWs) {
|
||
activeWs.draw();
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.EnterText = function (codePoints, skipCellEditor) {
|
||
this.controller.EnterText(codePoints);
|
||
if (this.isCellEditMode && !skipCellEditor) {
|
||
return this.cellEditor.EnterText(codePoints);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.CorrectEnterText = function (oldValue, newValue) {
|
||
if (undefined === oldValue || null === oldValue || (Array.isArray(oldValue) && !oldValue.length)) {
|
||
return this.EnterText(newValue);
|
||
}
|
||
|
||
if (!this.isCellEditMode || !this.cellEditor) {
|
||
return;
|
||
}
|
||
|
||
let newCodePoints = typeof (newValue) === "string" ? newValue.codePointsArray() : newValue;
|
||
let oldCodePoints = typeof (oldValue) === "string" ? oldValue.codePointsArray() : oldValue;
|
||
|
||
if (undefined === newCodePoints || null === newCodePoints) {
|
||
newCodePoints = [];
|
||
} else if (!Array.isArray(newCodePoints)) {
|
||
newCodePoints = [newCodePoints];
|
||
}
|
||
|
||
let oldText = "";
|
||
for (let index = 0, count = oldCodePoints.length; index < count; ++index) {
|
||
oldText += String.fromCodePoint(oldCodePoints[index]);
|
||
}
|
||
|
||
let curPos = this.cellEditor.cursorPos;
|
||
let maxShifts = oldCodePoints.length;
|
||
let selectedText = this.cellEditor.getText(curPos - maxShifts, maxShifts);
|
||
|
||
if (selectedText !== oldText) {
|
||
return false;
|
||
}
|
||
|
||
//TODO Replace_CompositeText
|
||
this.cellEditor.replaceText(curPos - maxShifts, maxShifts, newCodePoints);
|
||
|
||
return true;
|
||
};
|
||
|
||
WorkbookView.prototype.removeExternalReferences = function (arr) {
|
||
this.model.removeExternalReferences(arr);
|
||
};
|
||
|
||
WorkbookView.prototype.addExternalReferences = function (arr) {
|
||
this.model.addExternalReferences(arr);
|
||
};
|
||
|
||
WorkbookView.prototype.changeExternalReference = function (eR, to) {
|
||
if (!eR || !eR.externalReference) {
|
||
return;
|
||
}
|
||
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
let index = this.model.getExternalLinkIndexByName(eR.externalReference.Id);
|
||
let toER = eR.externalReference.clone(true);
|
||
toER.initFromObj(to);
|
||
this.model.changeExternalReference(index, toER);
|
||
|
||
History.EndTransaction();
|
||
|
||
this.model.handlers && this.model.handlers.trigger("asc_onUpdateExternalReferenceList");
|
||
};
|
||
|
||
//external requests
|
||
WorkbookView.prototype.doUpdateExternalReference = function (externalReferences, callback, forceUpdate) {
|
||
var t = this;
|
||
|
||
if (externalReferences && externalReferences.length) {
|
||
|
||
//ответ от портала -массив таких объектов
|
||
// setReferenceData({
|
||
// //Id идентификатор источника (?)
|
||
// url: string, // ссылка на файл,
|
||
// key: string, // идентификатор файла для получения данных из совместки
|
||
// referenceData: object, // положить в ooxml
|
||
// link: string, // для редактора формул path: string, // имя или путь(?) файла для редактора формул
|
||
// error: string, // для отображения ошибки
|
||
// })
|
||
|
||
|
||
let isLocalDesktop = window["AscDesktopEditor"] && window["AscDesktopEditor"]["IsLocalFile"]();
|
||
const doUpdateData = function (_arrAfterPromise) {
|
||
if (!_arrAfterPromise.length) {
|
||
callback && callback(true);
|
||
t.changeUpdateLinks();
|
||
t.model.handlers.trigger("asc_onStartUpdateExternalReference", false);
|
||
return;
|
||
}
|
||
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
let updatedReferences = [];
|
||
for (let i = 0; i < _arrAfterPromise.length; i++) {
|
||
// eR - current External Reference
|
||
let eRId = _arrAfterPromise[i].externalReferenceId;
|
||
let stream = _arrAfterPromise[i].stream;
|
||
|
||
let oPortalData = _arrAfterPromise[i].data;
|
||
let path = oPortalData && oPortalData["path"];
|
||
let referenceData = oPortalData && oPortalData.referenceData;
|
||
|
||
//if after update get short path, check on added such link
|
||
let eR = referenceData && t.model.getExternalReferenceByReferenceData(referenceData);
|
||
let noRefDataER = t.model.getExternalReferenceById(eRId);
|
||
|
||
if (!eR && noRefDataER) {
|
||
eR = noRefDataER;
|
||
}
|
||
|
||
let externalReferenceId = eRId;
|
||
if (path && externalReferenceId !== path) {
|
||
let isNotUpdate = (AscCommonExcel.importRangeLinksState && AscCommonExcel.importRangeLinksState.notUpdateIdMap && AscCommonExcel.importRangeLinksState.notUpdateIdMap[this.Id]) || this.notUpdateId;
|
||
if (!isNotUpdate) {
|
||
// eR = t.model.getExternalReferenceById(path);
|
||
/*
|
||
next we need to remove the added new link with the same identifier externalReferenceId
|
||
change the index of an already added link for which a promise has not yet been received
|
||
we get the link that we wrote down before receiving the promise
|
||
so we are looking for a link without referenceData, but with the same name
|
||
*/
|
||
let eRAdded = t.model.getExternalReferenceWithoutRefData(externalReferenceId);
|
||
if (eR && eRAdded) {
|
||
let indexFrom = t.model.getExternalReferenceById(externalReferenceId, true);
|
||
let indexTo = t.model.getExternalReferenceById(path, true);
|
||
|
||
if (indexFrom !== null && indexTo !== null) {
|
||
for (let wsName in eRAdded.worksheets) {
|
||
let existedWs = eR.worksheets[wsName];
|
||
let prepared = t.model.dependencyFormulas.prepareChangeSheet(eRAdded.worksheets[wsName].getId(), {from: indexFrom + 1, to: indexTo + 1});
|
||
|
||
prepared.existedWs = existedWs;
|
||
t.model.dependencyFormulas.changeExternalLink(prepared);
|
||
|
||
//add to history after updated formula
|
||
for (let listenerId in prepared.listeners) {
|
||
let formula = prepared.listeners[listenerId];
|
||
let parent = formula.parent;
|
||
if (parent instanceof AscCommonExcel.CCellWithFormula) {
|
||
let range = formula.ref
|
||
? parent.ws.getRange3(formula.ref.r1, formula.ref.c1, formula.ref.r2, formula.ref.c2)
|
||
: (parent.ws && parent.ws.getCell3(parent.nRow, parent.nCol));
|
||
|
||
if (range) {
|
||
let sF = prepared.listeners[listenerId].assemble();
|
||
if (sF) {
|
||
range.setValue("=" + sF, null, null, formula.ref);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
eR.addDataSetFrom(eRAdded);
|
||
t.model.removeExternalReferences([eRAdded.getAscLink()]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
if (stream && eR) {
|
||
updatedReferences.push(eR);
|
||
//TODO если внутри не zip, отправляем на конвертацию в xlsx, далее повторно обрабатываем - позже реализовать
|
||
//использую общий wb для externalReferences. поскольку внутри
|
||
//хранится sharedStrings, возмжно придтся использовать для каждого листа свою книгу
|
||
//необходимо проверить, ссылкой на 2 листа одной книги
|
||
let wb = eR.getWb();
|
||
let _updateData = function (_aWs, _aAfterPromiseData, _model) {
|
||
//g_DefNameWorksheet use on parse def name ref. here need use external ws.
|
||
let RealDefNameWorksheet = AscCommonExcel.g_DefNameWorksheet;
|
||
AscCommonExcel.g_DefNameWorksheet = new AscCommonExcel.Worksheet(wb, -1);
|
||
wb.dependencyFormulas.initOpen();
|
||
AscCommonExcel.g_DefNameWorksheet = RealDefNameWorksheet;
|
||
if (_aWs) {
|
||
eR && eR.updateData(_aWs, _aAfterPromiseData, null, _model);
|
||
}
|
||
};
|
||
|
||
let editor;
|
||
if (!t.Api["asc_isSupportFeature"]("ooxml") || isLocalDesktop) {
|
||
//в этом случае запрашиваем бинарник
|
||
// в ответ приходит архив - внутри должен лежать 1 файл "Editor.bin"
|
||
|
||
let binaryData = stream;
|
||
if (!isLocalDesktop) {
|
||
//xlst
|
||
binaryData = null;
|
||
let jsZlib = new AscCommon.ZLib();
|
||
if (!jsZlib.open(stream)) {
|
||
t.model.handlers.trigger("asc_onErrorUpdateExternalReference", eR.Id);
|
||
continue;
|
||
}
|
||
|
||
if (jsZlib.files && jsZlib.files.length) {
|
||
binaryData = jsZlib.getFile(jsZlib.files[0]);
|
||
}
|
||
}
|
||
|
||
if (binaryData) {
|
||
editor = AscCommon.getEditorByBinSignature(binaryData);
|
||
if (editor !== AscCommon.c_oEditorId.Spreadsheet) {
|
||
continue;
|
||
}
|
||
|
||
//заполняем через банарник
|
||
var oBinaryFileReader = new AscCommonExcel.BinaryFileReader(true);
|
||
//чтобы лишнего не читать, проставляю флаг копипаст
|
||
oBinaryFileReader.InitOpenManager.copyPasteObj = {
|
||
isCopyPaste: true, activeRange: null, selectAllSheet: true
|
||
};
|
||
|
||
if (!wb) {
|
||
wb = new AscCommonExcel.Workbook(null, window["Asc"]["editor"], false);
|
||
wb.DrawingDocument = Asc.editor.wbModel.DrawingDocument;
|
||
}
|
||
AscFormat.ExecuteNoHistory(function () {
|
||
AscCommonExcel.executeInR1C1Mode(false, function () {
|
||
oBinaryFileReader.Read(binaryData, wb);
|
||
});
|
||
});
|
||
_updateData(wb.aWorksheets, _arrAfterPromise[i].data, null, t.model);
|
||
}
|
||
|
||
} else {
|
||
editor = AscCommon.getEditorByOOXMLSignature(stream);
|
||
if (editor !== AscCommon.c_oEditorId.Spreadsheet) {
|
||
continue;
|
||
}
|
||
const oMockWb = wb ? wb : t.model;
|
||
let updatedData = oMockWb.getExternalReferenceSheetsFromZip(stream);
|
||
_updateData(updatedData, _arrAfterPromise[i].data, t.model /* working file workbook */);
|
||
}
|
||
} else if (eR) {
|
||
/*
|
||
if we haven't received data from an external source
|
||
leave the link in the wb.externalReferernces array and assign the values as an error #REF
|
||
*/
|
||
|
||
if (eR.worksheets) {
|
||
let arr = [];
|
||
for (let i in eR.worksheets) {
|
||
arr.push(eR.worksheets[i]);
|
||
}
|
||
|
||
eR.updateData(arr, _arrAfterPromise[i].data, /* noData */ true);
|
||
}
|
||
|
||
t.model.handlers.trigger("asc_onErrorUpdateExternalReference", eR.Id);
|
||
}
|
||
}
|
||
|
||
History.EndTransaction();
|
||
|
||
//TODO
|
||
//кроме пересчёта нужно изменить ссылку на лист во всех диапазонах, которые используют данную ссылку
|
||
/*for (let j = 0; j < updatedReferences.length; j++) {
|
||
for (let n in updatedReferences[j].worksheets) {
|
||
let prepared = t.model.dependencyFormulas.prepareChangeSheet(updatedReferences[j].worksheets[n].getId());
|
||
t.model.dependencyFormulas.dependencyFormulas.changeSheet(prepared);
|
||
}
|
||
}*/
|
||
|
||
//if update all, reinit timer
|
||
t.changeUpdateLinks();
|
||
|
||
//t.model.dependencyFormulas.calcTree();
|
||
let ws = t.getWorksheet();
|
||
ws.draw();
|
||
|
||
callback && callback(true);
|
||
t.model.handlers.trigger("asc_onStartUpdateExternalReference", false);
|
||
};
|
||
|
||
this.model.handlers.trigger("asc_onStartUpdateExternalReference", true);
|
||
|
||
const oDataUpdater = new AscCommon.CExternalDataLoader(externalReferences, this.Api, doUpdateData);
|
||
oDataUpdater.props = {forceUpdate: forceUpdate};
|
||
oDataUpdater.updateExternalData();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.updateExternalReferences = function (arr, callback) {
|
||
this.doUpdateExternalReference(arr, callback);
|
||
};
|
||
|
||
//*****user range protect*****
|
||
WorkbookView.prototype.changeUserProtectedRanges = function(oldObj, newObj) {
|
||
//ToDo проверка defName.ref на знак "=" в начале ссылки. знака нет тогда это либо число либо строка, так делает Excel.
|
||
if (this.collaborativeEditing.getGlobalLock() || !this.canEdit()) {
|
||
return;
|
||
}
|
||
|
||
var t = this;
|
||
if ((oldObj && !oldObj._ws) || (newObj && !newObj._ws)) {
|
||
return;
|
||
}
|
||
|
||
if (newObj._ws.isIntersectionOtherUserProtectedRanges(newObj.ref)) {
|
||
//error
|
||
this.handlers.trigger("asc_onError", c_oAscError.ID.ProtectedRangeByOtherUser, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
|
||
var callback = function(success) {
|
||
if (!success) {
|
||
return;
|
||
}
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
if (oldObj && newObj) {
|
||
//change obj
|
||
if (oldObj._ws === newObj._ws && oldObj._ws && newObj._ws) {
|
||
//change
|
||
newObj._ws.editUserProtectedRanges(oldObj, newObj, true);
|
||
} else {
|
||
//remove
|
||
oldObj._ws.editUserProtectedRanges(oldObj, null, true);
|
||
//add
|
||
newObj._ws.editUserProtectedRanges(null, newObj, true);
|
||
}
|
||
} else if (oldObj && oldObj._ws) {
|
||
//remove
|
||
oldObj._ws.editUserProtectedRanges(oldObj, null, true);
|
||
} else if (newObj && newObj._ws) {
|
||
//add
|
||
newObj._ws.editUserProtectedRanges(null, newObj, true);
|
||
}
|
||
|
||
History.EndTransaction();
|
||
|
||
//условие исключает второй вызов asc_onRefreshDefNameList(первый в unlockDefName)
|
||
if (!(t.collaborativeEditing.getCollaborativeEditing() && t.collaborativeEditing.getFast())) {
|
||
t.handlers.trigger("asc_onRefreshUserProtectedRangesList");
|
||
}
|
||
};
|
||
|
||
//когда меняем диапазон с одного листа на другой, два раза нужно лочить, вначале на одном листе, потом на другом
|
||
let wsFrom = oldObj ? oldObj._ws : null;
|
||
let wsTo = newObj ? newObj._ws : null;
|
||
|
||
let lockRangeFrom = oldObj ? oldObj.ref : null;
|
||
let lockRangeTo = newObj ? newObj.ref : null;
|
||
|
||
//object locks info
|
||
let aLocksInfo = [];
|
||
let aLockIds = [];
|
||
if (wsFrom && oldObj) {
|
||
aLockIds.push({id: oldObj.Id, ws: wsFrom});
|
||
}
|
||
if (wsTo && newObj) {
|
||
aLockIds.push({id: newObj.Id, ws: wsTo});
|
||
}
|
||
this._getLockedUserProtectedRange(aLockIds, aLocksInfo);
|
||
|
||
//cells locks info
|
||
if (wsFrom && lockRangeFrom) {
|
||
aLocksInfo.push(this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Range,
|
||
null, wsFrom.getId(),
|
||
new AscCommonExcel.asc_CCollaborativeRange(lockRangeFrom.c1,
|
||
lockRangeFrom.r1, lockRangeFrom.c2, lockRangeFrom.r2)));
|
||
}
|
||
if (wsTo && lockRangeTo) {
|
||
aLocksInfo.push(this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Range,
|
||
null, wsTo.getId(),
|
||
new AscCommonExcel.asc_CCollaborativeRange(lockRangeTo.c1,
|
||
lockRangeTo.r1, lockRangeTo.c2, lockRangeTo.r2)));
|
||
}
|
||
|
||
this.collaborativeEditing.lock(aLocksInfo, callback);
|
||
};
|
||
|
||
WorkbookView.prototype.deleteUserProtectedRanges = function(arr) {
|
||
//ToDo проверка defName.ref на знак "=" в начале ссылки. знака нет тогда это либо число либо строка, так делает Excel.
|
||
if (this.collaborativeEditing.getGlobalLock() || !this.canEdit()) {
|
||
return;
|
||
}
|
||
|
||
var t = this;
|
||
|
||
var doEdit = function(res) {
|
||
if (res) {
|
||
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
for (let i = 0; i < arr.length; i++) {
|
||
arr[i]._ws.editUserProtectedRanges(arr[i], null, true);
|
||
}
|
||
|
||
History.EndTransaction();
|
||
|
||
//t.handlers.trigger("asc_onEditDefName", oldName, newName);
|
||
|
||
//условие исключает второй вызов asc_onRefreshDefNameList(первый в unlockDefName)
|
||
if (!(t.collaborativeEditing.getCollaborativeEditing() && t.collaborativeEditing.getFast())) {
|
||
t.handlers.trigger("asc_onRefreshUserProtectedRangesList");
|
||
}
|
||
|
||
} else {
|
||
t.handlers.trigger("asc_onError", c_oAscError.ID.LockCreateDefName, c_oAscError.Level.NoCritical);
|
||
}
|
||
};
|
||
|
||
let aLockInfo = [];
|
||
for (let i = 0; i < arr.length; i++) {
|
||
aLockInfo.push({id: arr[i].Id, ws: arr[i]._ws});
|
||
}
|
||
|
||
//lock only ranges by id
|
||
this._isLockedUserProtectedRange(doEdit, aLockInfo);
|
||
|
||
};
|
||
|
||
WorkbookView.prototype.unlockUserProtectedRanges = function() {
|
||
this.model.unlockUserProtectedRanges();
|
||
this.handlers.trigger("asc_onRefreshUserProtectedRangesList");
|
||
//this.handlers.trigger("asc_onLockDefNameManager", Asc.c_oAscDefinedNameReason.OK);
|
||
};
|
||
|
||
WorkbookView.prototype._isLockedUserProtectedRange = function (callback, aIds) {
|
||
let aLockInfo = [];
|
||
this._getLockedUserProtectedRange(aIds, aLockInfo);
|
||
this.collaborativeEditing.lock(aLockInfo, callback);
|
||
};
|
||
|
||
WorkbookView.prototype._getLockedUserProtectedRange = function (aIds, aLockInfo) {
|
||
if (!aIds && !aLockInfo) {
|
||
return;
|
||
}
|
||
let lockInfo;
|
||
for (let i = 0; i < aIds.length; i++) {
|
||
lockInfo = this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Object,
|
||
AscCommonExcel.c_oAscLockTypeElemSubType.UserProtectedRange, aIds[i].ws.getId(), aIds[i].id);
|
||
aLockInfo.push(lockInfo);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.cleanCache = function() {
|
||
for(var i in this.wsViews) {
|
||
let ws = this.wsViews[i];
|
||
ws && ws._cleanCache(new Asc.Range(0, 0, ws.cols.length - 1, ws.rows.length - 1));
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getSelectionState = function() {
|
||
let res = null;
|
||
let ws = this.getWorksheet();
|
||
if (ws.objectRender.selectedGraphicObjectsExists()) {
|
||
res = ws.objectRender.controller.getSelectionState();
|
||
} else {
|
||
if (!this.getCellEditMode()) {
|
||
res = ws && ws.getSelectionState();
|
||
} else {
|
||
res = this.cellEditor.getSelectionState();
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
|
||
WorkbookView.prototype.getSpeechDescription = function(prevState, curState, action) {
|
||
let res = null;
|
||
let ws = this.getWorksheet();
|
||
if (ws.objectRender.selectedGraphicObjectsExists()) {
|
||
return AscCommon.getSpeechDescription(prevState, curState, action);
|
||
} else {
|
||
if (!this.getCellEditMode()) {
|
||
res = ws && ws.getSpeechDescription(prevState, curState, action);
|
||
} else {
|
||
res = this.cellEditor.getSpeechDescription(prevState, curState, action);
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
|
||
//******GOAL SEEK******
|
||
WorkbookView.prototype.startGoalSeek = function(sFormulaCell, sExpectedValue, sChangingCell) {
|
||
let sSheetName;
|
||
let wsFormula = this.model.getActiveWs();
|
||
let wsChangingCell = wsFormula;
|
||
|
||
if (~sFormulaCell.indexOf(",")) {
|
||
sFormulaCell = sFormulaCell.slice(0, sFormulaCell.indexOf(","));
|
||
}
|
||
if (~sFormulaCell.indexOf("!")) {
|
||
sSheetName = sFormulaCell.split("!")[0].replace(/'/g, "");
|
||
sFormulaCell = sFormulaCell.split("!")[1];
|
||
if (sSheetName !== wsFormula.getName()) {
|
||
wsFormula = this.model.getWorksheetByName(sSheetName);
|
||
}
|
||
}
|
||
if (~sChangingCell.indexOf(",")) {
|
||
sChangingCell = sChangingCell.slice(0, sChangingCell.indexOf(","));
|
||
}
|
||
if (~sChangingCell.indexOf("!")) {
|
||
sSheetName = sChangingCell.split("!")[0].replace(/'/g, "");
|
||
sChangingCell = sChangingCell.split("!")[1];
|
||
if (sSheetName !== wsChangingCell.getName()) {
|
||
wsChangingCell = this.model.getWorksheetByName(sSheetName);
|
||
}
|
||
}
|
||
sExpectedValue = sExpectedValue.replace(/,/g, ".");
|
||
|
||
let t = this;
|
||
let callback = function (isSuccess) {
|
||
if (!isSuccess) {
|
||
t.handlers.trigger("asc_onError", c_oAscError.ID.LockedCellGoalSeek, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
//open history point
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
t.model.startGoalSeek(sFormulaCell, sExpectedValue, sChangingCell, wsFormula, wsChangingCell);
|
||
};
|
||
|
||
//need lock
|
||
let aLocksInfo = [];
|
||
//cells locks info
|
||
let oChangingCell = wsChangingCell && wsChangingCell.getRange2(sChangingCell);
|
||
if (oChangingCell) {
|
||
aLocksInfo.push(this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Range, null, wsChangingCell.getId(),
|
||
new AscCommonExcel.asc_CCollaborativeRange(oChangingCell.bbox.c1, oChangingCell.bbox.r1, oChangingCell.bbox.c2, oChangingCell.bbox.r2)));
|
||
}
|
||
|
||
let oFormulaCell = wsFormula && wsFormula.getRange2(sFormulaCell);
|
||
if (oFormulaCell) {
|
||
aLocksInfo.push(this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Range, null, wsFormula.getId(),
|
||
new AscCommonExcel.asc_CCollaborativeRange(oFormulaCell.bbox.c1, oFormulaCell.bbox.r1, oFormulaCell.bbox.c2, oFormulaCell.bbox.r2)));
|
||
}
|
||
|
||
this.collaborativeEditing.lock(aLocksInfo, callback);
|
||
};
|
||
|
||
WorkbookView.prototype.closeGoalSeek = function (bSave) {
|
||
let oGoalSeek = this.model.getGoalSeek();
|
||
let oChangedCell = oGoalSeek && oGoalSeek.getChangingCell();
|
||
|
||
bSave ? this.model.saveGoalSeek() : this.model.closeGoalSeek();
|
||
//close history point
|
||
History.EndTransaction();
|
||
|
||
if (oChangedCell) {
|
||
//update
|
||
let ws = this.getWorksheetById(oChangedCell.worksheet.Id);
|
||
ws._updateRange(oChangedCell.bbox);
|
||
ws.draw();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.pauseGoalSeek = function() {
|
||
this.model.pauseGoalSeek();
|
||
};
|
||
|
||
WorkbookView.prototype.continueGoalSeek = function() {
|
||
this.model.continueGoalSeek();
|
||
};
|
||
|
||
WorkbookView.prototype.stepGoalSeek = function() {
|
||
this.model.stepGoalSeek();
|
||
};
|
||
|
||
// Solver
|
||
/**
|
||
* Returns solver parameters and options object.
|
||
* @memberof WorkbookView
|
||
* @returns {asc_CSolverParams}
|
||
*/
|
||
WorkbookView.prototype.getSolverParams = function() {
|
||
//open history point
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
const solverParams = new AscCommonExcel.asc_CSolverParams();
|
||
solverParams.getDefNames(this.model);
|
||
|
||
return solverParams;
|
||
}
|
||
/**
|
||
* Starts find optimal solution.
|
||
* @memberof WorkbookView
|
||
* @param {asc_CSolverParams} oSolverParams
|
||
*/
|
||
WorkbookView.prototype.startSolver = function(oSolverParams) {
|
||
if (!this.model) {
|
||
return;
|
||
}
|
||
|
||
const CSolver = AscCommonExcel.CSolver;
|
||
const wbModel = this.model;
|
||
const ws = wbModel.getActiveWs();
|
||
const t = this;
|
||
let oSolver;
|
||
|
||
const callback = function (isSuccess) {
|
||
if (!isSuccess) {
|
||
t.handlers.trigger("asc_onError", c_oAscError.ID.LockedCellSolver, c_oAscError.Level.NoCritical);
|
||
return;
|
||
}
|
||
//open history point
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
// Init CSolver object
|
||
wbModel.setSolver(new CSolver(oSolverParams, ws))
|
||
oSolver = wbModel.getSolver();
|
||
oSolver.prepare();
|
||
// Run solver
|
||
if (oSolverParams.getOptions().getShowIterResults()) {
|
||
oSolver.step();
|
||
} else {
|
||
oSolver.setIntervalId(setInterval(function () {
|
||
let bIsFinish = oSolver.calculate();
|
||
if (bIsFinish) {
|
||
clearInterval(oSolver.getIntervalId());
|
||
}
|
||
}, oSolver.getDelay()));
|
||
}
|
||
};
|
||
|
||
//need lock
|
||
const aLocksInfo = [];
|
||
//cells locks info
|
||
const wsChangingCell = AscCommonExcel.actualWsByRef(oSolverParams.getChangingCells(), ws);
|
||
const sChangingCell = AscCommonExcel.convertToAbsoluteRef(oSolverParams.getChangingCells());
|
||
const oChangingCell = wsChangingCell && wsChangingCell.getRange2(sChangingCell);
|
||
if (oChangingCell) {
|
||
aLocksInfo.push(this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Range, null, wsChangingCell.getId(),
|
||
new AscCommonExcel.asc_CCollaborativeRange(oChangingCell.bbox.c1, oChangingCell.bbox.r1, oChangingCell.bbox.c2, oChangingCell.bbox.r2)));
|
||
}
|
||
|
||
const wsFormula = AscCommonExcel.actualWsByRef(oSolverParams.getObjectiveFunction(), ws);
|
||
const sFormulaCell = AscCommonExcel.convertToAbsoluteRef(oSolverParams.getObjectiveFunction());
|
||
const oFormulaCell = wsFormula && wsFormula.getRange2(sFormulaCell);
|
||
if (oFormulaCell) {
|
||
aLocksInfo.push(this.collaborativeEditing.getLockInfo(AscCommonExcel.c_oAscLockTypeElem.Range, null, wsFormula.getId(),
|
||
new AscCommonExcel.asc_CCollaborativeRange(oFormulaCell.bbox.c1, oFormulaCell.bbox.r1, oFormulaCell.bbox.c2, oFormulaCell.bbox.r2)));
|
||
}
|
||
|
||
this.collaborativeEditing.lock(aLocksInfo, callback);
|
||
|
||
const oChangedCell = oSolver && oSolver.getChangingCell();
|
||
if (oChangedCell) {
|
||
// update worksheet field
|
||
let ws = this.getWorksheetById(oChangedCell.worksheet.Id);
|
||
ws._updateRange(oChangedCell.bbox);
|
||
ws.draw();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @memberof WorkbookView
|
||
* @param {boolean} bSave true - save result of calculation, false - discard changes.
|
||
* @param {asc_CSolverParams} oSolverParams - uses for saving Solver parameters.
|
||
*/
|
||
WorkbookView.prototype.closeSolver = function(bSave, oSolverParams) {
|
||
if (!this.model) {
|
||
return;
|
||
}
|
||
|
||
const oSolver = this.model.getSolver();
|
||
const oChangedCells = oSolver && oSolver.getChangingCell();
|
||
|
||
if (!bSave) {
|
||
const oStartChangedCells = oSolver && oSolver.getStartChangingCells();
|
||
oChangedCells && oChangedCells._foreachNoEmpty(function (oCell) {
|
||
const sOriginalValue = oStartChangedCells[oCell.getName()];
|
||
oCell.setValue(sOriginalValue);
|
||
});
|
||
}
|
||
oSolverParams.createDefNames(this.model);
|
||
if (oSolver) {
|
||
this.model.setSolver(null);
|
||
}
|
||
|
||
// close history point
|
||
History.EndTransaction();
|
||
|
||
if (oChangedCells) {
|
||
// update worksheet field
|
||
let ws = this.getWorksheetById(oChangedCells.worksheet.Id);
|
||
ws._updateRange(oChangedCells.bbox);
|
||
ws.draw();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Runs only one iteration of solver calculation.
|
||
* Uses when "Show iteration results" option is enabled.
|
||
* @memberof WorkbookView
|
||
*/
|
||
WorkbookView.prototype.stepSolver = function() {
|
||
if (!this.model) {
|
||
return;
|
||
}
|
||
|
||
const oSolver = this.model.getSolver();
|
||
const oChangedCells = oSolver && oSolver.getChangingCell();
|
||
|
||
oSolver && oSolver.step();
|
||
if (oChangedCells) {
|
||
// update worksheet field
|
||
let ws = this.getWorksheetById(oChangedCells.worksheet.Id);
|
||
ws._updateRange(oChangedCells.bbox);
|
||
ws.draw();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.addToHistoryChangedRanges = function(sheetId, range, userColor) {
|
||
if (!range) {
|
||
return;
|
||
}
|
||
if (Array.isArray(range)) {
|
||
for (let i in range) {
|
||
this._addToHistoryChangedRanges(sheetId, range[i], userColor);
|
||
}
|
||
} else {
|
||
this._addToHistoryChangedRanges(sheetId, range, userColor);
|
||
}
|
||
};
|
||
WorkbookView.prototype._addToHistoryChangedRanges = function(sheetId, range, userColor) {
|
||
if (!range) {
|
||
return;
|
||
}
|
||
if (!this.historyChangedRanges) {
|
||
this.historyChangedRanges = {};
|
||
}
|
||
if (!this.historyChangedRanges[sheetId]) {
|
||
this.historyChangedRanges[sheetId] = [];
|
||
}
|
||
let changedRanges = this.historyChangedRanges[sheetId];
|
||
if (changedRanges.length) {
|
||
for (let i in changedRanges) {
|
||
if (!changedRanges[i]) {
|
||
continue;
|
||
}
|
||
let _addedRange = changedRanges[i].range;
|
||
let _addedColor = changedRanges[i].color;
|
||
if (!_addedRange || !_addedColor || (userColor && userColor.IsEqual && !userColor.IsEqual(_addedColor))) {
|
||
continue;
|
||
}
|
||
if (_addedRange.isEqual(range)) {
|
||
return;
|
||
} else if (_addedRange.intersection(range)) {
|
||
let _difference = _addedRange.difference(range);
|
||
if (_difference) {
|
||
for (let j in _difference) {
|
||
changedRanges.push({range: _difference[j], color: userColor});
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
changedRanges.push({range: range, color: userColor});
|
||
};
|
||
|
||
WorkbookView.prototype.addCustomFunction = function(func, options) {
|
||
if (!this.customFunctionEngine) {
|
||
this.initCustomEngine();
|
||
}
|
||
this.customFunctionEngine.add(func, options);
|
||
};
|
||
/**
|
||
* Updates calculating settings properties
|
||
* @memberof WorkbookView
|
||
* @param {asc_CCalcSettings} oCalcSettings
|
||
*/
|
||
WorkbookView.prototype.updateCalcSettings = function (oCalcSettings) {
|
||
if (this.collaborativeEditing.getGlobalLock() || !window["Asc"]["editor"].canEdit()) {
|
||
return;
|
||
}
|
||
const oCalcPr = this.model.calcPr;
|
||
if (!oCalcSettings || oCalcSettings.asc_isEqual(oCalcPr)) {
|
||
return;
|
||
}
|
||
|
||
const ws = this.getWorksheet();
|
||
const oThis = this;
|
||
const callback = function (isSuccess) {
|
||
const g_cCalcRecursion = AscCommonExcel.g_cCalcRecursion;
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
oCalcPr.updateCalcProperties(oCalcSettings, oThis.model);
|
||
g_cCalcRecursion.initCalcProperties(oCalcPr);
|
||
History.EndTransaction();
|
||
|
||
ws._updateRange(new Asc.Range(0, 0, ws.model.getColsCount(), ws.model.getRowsCount()), true);
|
||
ws.draw();
|
||
};
|
||
|
||
callback();
|
||
};
|
||
|
||
WorkbookView.prototype.initCustomEngine = function() {
|
||
if (!this.customFunctionEngine) {
|
||
this.customFunctionEngine = new AscCommonExcel.CCustomFunctionEngine(this);
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setSmoothScrolling = function(val) {
|
||
if (this.smoothScroll !== val) {
|
||
this.smoothScroll = val;
|
||
for (var i in this.wsViews) {
|
||
var item = this.wsViews[i];
|
||
item.setScrollCorrect(null);
|
||
item.setHorizontalScrollCorrect(null);
|
||
item.scrollType |= AscCommonExcel.c_oAscScrollType.ScrollVertical;
|
||
item.scrollType |= AscCommonExcel.c_oAscScrollType.ScrollHorizontal;
|
||
item._reinitializeScroll();
|
||
}
|
||
var ws = this.getWorksheet();
|
||
ws.draw();
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.getSmoothScrolling = function() {
|
||
return this.smoothScroll;
|
||
};
|
||
|
||
WorkbookView.prototype.checkScrollRtl = function(val) {
|
||
let controller = this.controller;
|
||
let hsbApi = controller && controller.hsbApi;
|
||
let ctx = hsbApi && hsbApi.context;
|
||
if (ctx) {
|
||
if (val) {
|
||
ctx.setTransform(-1,0,0,1,hsbApi.canvasW,0);
|
||
} else {
|
||
ctx.setTransform(1,0,0,1,0,0);
|
||
}
|
||
}
|
||
};
|
||
|
||
WorkbookView.prototype.setDefaultDirection = function(val) {
|
||
this.model.setDefaultDirection(val);
|
||
};
|
||
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// Collaborative editing
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
WorkbookView.prototype.PauseRecalculate = function() {};
|
||
WorkbookView.prototype.EndPreview_MailMergeResult = function() {};
|
||
WorkbookView.prototype.Get_SelectionState2 = function() {};
|
||
WorkbookView.prototype.Save_DocumentStateBeforeLoadChanges = function() {};
|
||
WorkbookView.prototype.Load_DocumentStateAfterLoadChanges = function() {};
|
||
WorkbookView.prototype.Check_MergeData = function() {};
|
||
WorkbookView.prototype.Set_SelectionState2 = function() {};
|
||
WorkbookView.prototype.ResumeRecalculate = function() {};
|
||
WorkbookView.prototype.RecalculateByChanges = function(arrChanges, nStartIndex, nEndIndex) {
|
||
//todo
|
||
};
|
||
WorkbookView.prototype.UpdateTracks = function() {};
|
||
WorkbookView.prototype.GetOFormDocument = function() {};
|
||
WorkbookView.prototype.Continue_FastCollaborativeEditing = function() {
|
||
if (true === this.CollaborativeEditing.Get_GlobalLock())
|
||
{
|
||
if (this.Api.forceSaveUndoRequest)
|
||
this.Api.asc_Save(true);
|
||
|
||
return;
|
||
}
|
||
|
||
if (this.Api.isLongAction())
|
||
return;
|
||
|
||
if (true !== this.CollaborativeEditing.Is_Fast() || true === this.CollaborativeEditing.Is_SingleUser())
|
||
return;
|
||
|
||
var HaveChanges = this.History.Have_Changes(true);
|
||
if (true !== HaveChanges && (true === this.CollaborativeEditing.Have_OtherChanges() || 0 !== this.CollaborativeEditing.getOwnLocksLength()))
|
||
{
|
||
// Принимаем чужие изменения. Своих нет, но функцию отсылки надо вызвать, чтобы снять локи.
|
||
this.CollaborativeEditing.Apply_Changes();
|
||
this.CollaborativeEditing.Send_Changes();
|
||
}
|
||
else if (true === HaveChanges || true === this.CollaborativeEditing.Have_OtherChanges())
|
||
{
|
||
this.Api.asc_Save(true);
|
||
}
|
||
|
||
this.sendCursor();
|
||
};
|
||
WorkbookView.prototype.private_UpdateTargetForCollaboration = function(bForce) {
|
||
this.NeedUpdateTargetForCollaboration = true;
|
||
if (bForce) {
|
||
this.NeedUpdateTargetForCollaborationForce = bForce;
|
||
}
|
||
};
|
||
WorkbookView.prototype.Get_DocumentPositionInfoForCollaborative = function() {
|
||
//todo
|
||
};
|
||
// WorkbookView.prototype.Update_ForeignCursor = function(CursorInfo, UserId, Show, UserShortId) {
|
||
// };
|
||
WorkbookView.prototype.Draw_ForeingSelection = function(nDrawPage) {
|
||
//todo
|
||
};
|
||
WorkbookView.prototype.Show_ForeignSelectedObjectLabel = function(userId, foreignSelectObj, color) {
|
||
//todo
|
||
};
|
||
// WorkbookView.prototype.Remove_ForeignCursor = function(UserId, oObject) {
|
||
// this.CollaborativeEditing.Remove_ForeignCursor(UserId);
|
||
// this.CollaborativeEditing.Remove_FiregnSelectedObject(UserId, oObject);
|
||
// };
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// Required extensions
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
WorkbookView.prototype.IsDocumentEditor = function() {return false};
|
||
WorkbookView.prototype.Is_Inline = function() {};
|
||
WorkbookView.prototype.OnChangeForm = function() {};
|
||
WorkbookView.prototype.TurnOffCheckChartSelection = function() {};
|
||
WorkbookView.prototype.TurnOnCheckChartSelection = function() {};
|
||
WorkbookView.prototype.UpdateRulers = function() {};
|
||
WorkbookView.prototype.UpdateSelection = function() {};
|
||
WorkbookView.prototype.UpdateInterface = function() {};
|
||
WorkbookView.prototype.Get_Api = function() {
|
||
return Asc.editor;
|
||
};
|
||
WorkbookView.prototype.sendEvent = function() {
|
||
if (!this.Api)
|
||
return;
|
||
|
||
this.Api.sendEvent.apply(this.Api, arguments);
|
||
};
|
||
WorkbookView.prototype.setShowVerticalScroll = function(val) {
|
||
// Проверка глобального лока
|
||
if (this.collaborativeEditing.getGlobalLock() || !window["Asc"]["editor"].canEdit()) {
|
||
return;
|
||
}
|
||
|
||
let t = this;
|
||
let verticalScroll = this.model.getShowVerticalScroll();
|
||
let configVal = this.Api.DocInfo && this.Api.DocInfo.asc_getShowVerticalScroll();
|
||
|
||
let fromWithDefault = verticalScroll == null || verticalScroll === true;
|
||
let valWithDefault = val === true || val == null;
|
||
|
||
if ((fromWithDefault !== valWithDefault) || (verticalScroll == null && configVal !== null)) {
|
||
var callback = function () {
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
t.model.setShowVerticalScroll(val, true);
|
||
|
||
History.EndTransaction();
|
||
};
|
||
callback();
|
||
}
|
||
};
|
||
WorkbookView.prototype.getShowVerticalScroll = function() {
|
||
let val = this.model.getShowVerticalScroll();
|
||
if (val == null) {
|
||
val = this.Api.DocInfo && this.Api.DocInfo.asc_getShowVerticalScroll();
|
||
}
|
||
return val === true || val == null;
|
||
};
|
||
WorkbookView.prototype.setShowHorizontalScroll = function(val) {
|
||
// Проверка глобального лока
|
||
if (this.collaborativeEditing.getGlobalLock() || !window["Asc"]["editor"].canEdit()) {
|
||
return;
|
||
}
|
||
|
||
let t = this;
|
||
let horizontalScroll = this.model.getShowHorizontalScroll();
|
||
let configVal = this.Api.DocInfo && this.Api.DocInfo.asc_getShowHorizontalScroll();
|
||
|
||
let fromWithDefault = horizontalScroll == null || horizontalScroll === true;
|
||
let valWithDefault = val === true || val == null;
|
||
|
||
if ((fromWithDefault !== valWithDefault) || (horizontalScroll == null && configVal !== null)) {
|
||
var callback = function () {
|
||
History.Create_NewPoint();
|
||
History.StartTransaction();
|
||
|
||
t.model.setShowHorizontalScroll(val, true);
|
||
|
||
History.EndTransaction();
|
||
};
|
||
callback();
|
||
}
|
||
};
|
||
WorkbookView.prototype.getShowHorizontalScroll = function() {
|
||
let val = this.model.getShowHorizontalScroll();
|
||
if (val == null) {
|
||
val = this.Api.DocInfo && this.Api.DocInfo.asc_getShowHorizontalScroll();
|
||
}
|
||
return val === true || val == null;
|
||
};
|
||
WorkbookView.prototype.removeAllInks = function() {
|
||
const oThis = this;
|
||
const oCurrentWs = this.getWorksheet();
|
||
|
||
const oCurrentController = oCurrentWs.objectRender && oCurrentWs.objectRender.controller;
|
||
if (oCurrentController) {
|
||
const oWbModel = this.model;
|
||
const arrInks = oWbModel.getAllInks();
|
||
if (arrInks.length > 0) {
|
||
oCurrentController.checkObjectsAndCallback(function() {
|
||
for (let i = 0; i < oWbModel.aWorksheets.length; i++) {
|
||
const oWs = oThis.getWorksheet(i);
|
||
oWs.removeAllInks();
|
||
}
|
||
oCurrentController.updateSelectionState();
|
||
oCurrentController.updateOverlay();
|
||
}, [], false, AscDFH.historydescription_RemoveAllInks, arrInks);
|
||
}
|
||
}
|
||
};
|
||
WorkbookView.prototype.StartAction = function(nDescription, additional)
|
||
{
|
||
this.Api.sendEvent("asc_onUserActionStart");
|
||
this.Api.getMacroRecorder().onAction(nDescription, additional);
|
||
};
|
||
WorkbookView.prototype.MacrosAddData = function(nDescription, additional)
|
||
{
|
||
this.Api.getMacroRecorder().addStepData(nDescription, additional);
|
||
};
|
||
WorkbookView.prototype.FinalizeAction = function(nDescription, additional)
|
||
{
|
||
this.Api.sendEvent("asc_onUserActionEnd");
|
||
this.Api.getMacroRecorder().onAction(nDescription, additional);
|
||
};
|
||
|
||
|
||
//временно добавляю сюда. в идеале - использовать общий класс из документов(или сделать базовый, от него наследоваться) - CDocumentSearch
|
||
function CDocumentSearchExcel(wb) {
|
||
this.wb = wb;
|
||
this.props = null;
|
||
//this.Pattern = new AscCommonWord.CSearchPatternEngine();
|
||
|
||
this.Id = 0;
|
||
this.Count = 0;
|
||
this.Elements = {};
|
||
this.CurId = -1;
|
||
this.Direction = true; // направление true - вперед, false - назад
|
||
|
||
//this.ClearOnRecalc = true; // Флаг, говорящий о том, запустился ли пересчет из-за Replace
|
||
|
||
this.ReplacedId = [];
|
||
this.mapFindCells = {};
|
||
this.isReplacingText = null;
|
||
|
||
this.changedSelection = null;
|
||
this._lastNotEmpty = null;
|
||
|
||
this.modifiedDocument = null;
|
||
|
||
this.changingSelection = null;
|
||
}
|
||
|
||
CDocumentSearchExcel.prototype.Reset = function () {
|
||
this.props = null;
|
||
};
|
||
/**
|
||
* @param {AscCommon.CSearchSettings} oProps
|
||
*/
|
||
CDocumentSearchExcel.prototype.Compare = function (oProps) {
|
||
return oProps && this.props && this.props.isEqual2(oProps) && this.props.scanOnOnlySheet === oProps.scanOnOnlySheet;
|
||
};
|
||
CDocumentSearchExcel.prototype.Clear = function (index, doNotSendInterface) {
|
||
if (this.isReplacingText) {
|
||
return;
|
||
}
|
||
|
||
this.Reset();
|
||
|
||
// Очищаем предыдущие элементы поиска
|
||
if (index != null) {
|
||
for (let Id in this.Elements) {
|
||
if (this.Elements[Id].index === index) {
|
||
let key = this.Elements[Id].index + "-" + this.Elements[Id].col + "-" + this.Elements[Id].row;
|
||
delete this.mapFindCells[key];
|
||
delete this.Elements[Id];
|
||
}
|
||
}
|
||
} else {
|
||
this.Elements = {};
|
||
this.mapFindCells = {};
|
||
}
|
||
|
||
this.Id = 0;
|
||
this.Count = 0;
|
||
//this.Elements = {};
|
||
this.CurId = -1;
|
||
this.Direction = true;
|
||
|
||
this.ReplacedId = [];
|
||
|
||
this.isReplacingText = null;
|
||
|
||
this.changedSelection = null;
|
||
|
||
this.TextAroundUpdate = true;
|
||
if (!doNotSendInterface) {
|
||
this.StopTextAround();
|
||
this.SendClearAllTextAround();
|
||
}
|
||
|
||
this.modifiedDocument = null;
|
||
};
|
||
CDocumentSearchExcel.prototype.setModifiedDocument = function (val) {
|
||
this.modifiedDocument = val;
|
||
};
|
||
CDocumentSearchExcel.prototype.Add = function (r, c, cell, container, options) {
|
||
|
||
let byCols = options && !options.scanByRows;
|
||
let dN = new Asc.Range(byCols ? r : c, byCols ? c : r, byCols ? r : c, byCols ? c : r, true);
|
||
let defName = cell.ws ? AscCommon.parserHelp.get3DRef(cell.ws.getName(), dN.getAbsName()) : null;
|
||
defName = defName && cell.ws ? cell.ws.workbook.findDefinesNames(defName, cell.ws.getId(), true) : null;
|
||
|
||
if (container) {
|
||
container.add(r, c,
|
||
{sheet: cell.ws.sName, name: defName ? defName : null, cell: dN.getName(), text: cell.getValue(), formula: cell.getFormula(), col: r, row: c, index: cell.ws.index});
|
||
} else {
|
||
this.Count++;
|
||
//[sheet, name, cell, value,formula]
|
||
this.Elements[this.Id++] =
|
||
cell.ws ? {sheet: cell.ws.sName, name: defName ? defName : null, cell: dN.getName(), text: cell.getValue(), formula: cell.getFormula(), col: c, row: r, index: cell.ws.index} :
|
||
cell;
|
||
let key = this.Elements[this.Id - 1].index + "-" + c + "-" + r;
|
||
this.mapFindCells[key] = this.Id - 1;
|
||
|
||
return (this.Id - 1);
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.endAdd = function (findResult) {
|
||
//использую findResult для случая, если нужно искать по столбцам, а не по строкам. в дальнейшем можно избавиться от findResult и использовать временный объект
|
||
if (findResult && findResult.values) {
|
||
for (let i in findResult.values) {
|
||
if (!findResult.values[i]) {
|
||
continue;
|
||
}
|
||
for (let j in findResult.values[i]) {
|
||
this.Add(j, i, findResult.values[i][j]);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.Select = function (nId) {
|
||
let elem = this.Elements[nId];
|
||
if (elem) {
|
||
let ws = this.wb.getWorksheet();
|
||
if (elem.index !== ws.model.index) {
|
||
this.wb.model.handlers.trigger('undoRedoHideSheet', elem.index);
|
||
ws = this.wb.getWorksheet(elem.index);
|
||
}
|
||
|
||
if (ws) {
|
||
this.changingSelection = true;
|
||
let range = new Asc.Range(elem.col, elem.row, elem.col, elem.row);
|
||
let selection = ws.model.getSelection();
|
||
let ar = selection.getLast();
|
||
//options.findInSelection ? ws.setActiveCell(result) : ws.setSelection(range);
|
||
if (ar.contains(elem.col, elem.row)) {
|
||
let activeCell = new AscCommon.CellBase(elem.row, elem.col);
|
||
ws.setActiveCell(activeCell);
|
||
} else {
|
||
ws.setSelection(range);
|
||
}
|
||
this.changingSelection = false;
|
||
|
||
this.SetCurrent(nId);
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.SetCurrent = function (nId) {
|
||
this.CurId = undefined !== nId ? nId : -1;
|
||
let nIndex = -1 !== this.CurId ? this.GetElementIndexById(this.CurId) : -1;
|
||
let oApi = window["Asc"]["editor"];
|
||
oApi.sync_setSearchCurrent(nIndex, this.Count);
|
||
};
|
||
CDocumentSearchExcel.prototype.GetElementIndexById = function (nId) {
|
||
for (let nPos = 0, nCount = this.ReplacedId.length; nPos < nCount; ++nPos) {
|
||
if (this.ReplacedId[nPos] > nId) {
|
||
return (nId - nPos);
|
||
} else if (this.ReplacedId[nPos] === nId) {
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
return (nId - this.ReplacedId.length);
|
||
};
|
||
CDocumentSearchExcel.prototype.private_AddReplacedId = function (nId) {
|
||
for (let nPos = 0, nCount = this.ReplacedId.length; nPos < nCount; ++nPos) {
|
||
if (this.ReplacedId[nPos] > nId) {
|
||
return this.ReplacedId.splice(nPos, 0, nId);
|
||
}
|
||
}
|
||
|
||
this.ReplacedId.push(nId);
|
||
};
|
||
CDocumentSearchExcel.prototype.ResetCurrent = function (changeSelection) {
|
||
if (changeSelection) {
|
||
this.changedSelection = true;
|
||
}
|
||
this.SetCurrent(-1);
|
||
};
|
||
CDocumentSearchExcel.prototype.GetCount = function () {
|
||
return this.Count;
|
||
};
|
||
CDocumentSearchExcel.prototype.GetCurrent = function () {
|
||
return this.CurId;
|
||
};
|
||
CDocumentSearchExcel.prototype.GetCurrentElem = function () {
|
||
return this.Elements && this.Elements[this.CurId];
|
||
};
|
||
CDocumentSearchExcel.prototype.forEachElementsBySheet = function (index, callback) {
|
||
if (this.Elements) {
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i].index === index) {
|
||
callback(this.Elements[i]);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.GetNextElement = function () {
|
||
let id;
|
||
|
||
if (this.props.lastSearchElem) {
|
||
//временно переставляем селект на данный элемент и ставим CurId - 1
|
||
this.CurId = -1;
|
||
}
|
||
|
||
if (-1 === this.CurId) {
|
||
id = this.findNearestElement();
|
||
this.props.lastSearchElem = null;
|
||
this.modifiedDocument = null;
|
||
} else {
|
||
id = this.Direction ? this.CurId + 1 : this.CurId - 1;
|
||
}
|
||
|
||
this.changedSelection = null;
|
||
|
||
let needElem = this.Elements[id];
|
||
if (!needElem && this.Count) {
|
||
//лиюо следующий, либо первый
|
||
//нужно вернуться к первому, если такой есть
|
||
let i;
|
||
if (this.Direction) {
|
||
let firstElem, firstElemId;
|
||
for (i = 0; i < this.ReplacedId.length + this.Count; i++) {
|
||
if (this.Elements[i]) {
|
||
if (!firstElem) {
|
||
firstElem = this.Elements[i];
|
||
firstElemId = i;
|
||
}
|
||
if (i > id) {
|
||
needElem = this.Elements[i];
|
||
id = i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (!needElem) {
|
||
needElem = firstElem;
|
||
id = firstElemId;
|
||
}
|
||
} else {
|
||
let lastElem, lastElemId;
|
||
for (i = this.ReplacedId.length + this.Count; i >= 0; i--) {
|
||
if (this.Elements[i]) {
|
||
if (!lastElem) {
|
||
lastElem = this.Elements[i];
|
||
lastElemId = i;
|
||
}
|
||
if (i < id) {
|
||
needElem = this.Elements[i];
|
||
id = i;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!needElem) {
|
||
needElem = lastElem;
|
||
id = lastElemId;
|
||
}
|
||
}
|
||
|
||
}
|
||
return needElem ? id : null;
|
||
};
|
||
CDocumentSearchExcel.prototype.findNearestElement = function () {
|
||
let t = this;
|
||
if (-1 !== this.CurId) {
|
||
return this.Direction ? this.CurId + 1 : this.CurId - 1;
|
||
} else {
|
||
// it's necessary because into the docbuilder "this.wb.wsActive" is "-1" and search doesn't work
|
||
let ws = this.wb.model.getActiveWs();
|
||
if (!ws) {
|
||
ws = this.wb && this.wb.model && this.wb.model.getActiveWs && this.wb.model.getActiveWs();
|
||
}
|
||
let selectionRange = (this.props && this.props.selectionRange) || (ws && ws.selectionRange) || (ws && ws.copySelection);
|
||
|
||
let activeCell = this.props.activeCell ? this.props.activeCell : selectionRange.activeCell;
|
||
if (this.props && this.props.lastSearchElem) {
|
||
let cell = this.props.lastSearchElem[3];
|
||
if (cell) {
|
||
let range = AscCommonExcel.g_oRangeCache.getAscRange(cell);
|
||
activeCell = {row: range.r1, col: range.c1};
|
||
}
|
||
}
|
||
|
||
let bReverse = !t.Direction;
|
||
|
||
//получаем массив из индексов
|
||
let i;
|
||
let indexArr = [];
|
||
for (i in this.Elements) {
|
||
if (this.Elements.hasOwnProperty(i)) {
|
||
indexArr.push(parseInt(i));
|
||
}
|
||
}
|
||
|
||
//чтобе не делать разные ветки для получения row/col
|
||
let getRowCol = function (obj, changeColOnRow) {
|
||
if (!obj) {
|
||
return;
|
||
}
|
||
if (changeColOnRow) {
|
||
return t.props && t.props.scanByRows ? obj.col : obj.row;
|
||
} else {
|
||
return t.props && t.props.scanByRows ? obj.row : obj.col;
|
||
}
|
||
};
|
||
|
||
let sheetArr = [];
|
||
let checkElem = function (indexElem, index) {
|
||
//нужный нам лист
|
||
if (ws && ws.sName === t.Elements[indexElem].sheet) {
|
||
|
||
let prevNextI = bReverse ? indexArr[index - 1] : indexArr[index + 1];
|
||
let prevNextElemRowCol = getRowCol(t.Elements[prevNextI]);
|
||
|
||
let elemRowCol = getRowCol(t.Elements[indexElem]);
|
||
let activeCellRowCol = getRowCol(activeCell);
|
||
let elemColRow = getRowCol(t.Elements[indexElem], true);
|
||
let activeCellColRow = getRowCol(activeCell, true);
|
||
|
||
if (elemRowCol === activeCellRowCol) {
|
||
//если это данная строка, нужно найти колонку/строку с равным индексом или большим/меньшим, если таких нет, то берём следующий/предыдущий элемент
|
||
if ((bReverse && elemColRow <= activeCellColRow) || (!bReverse && elemColRow >= activeCellColRow)) {
|
||
return elemColRow === activeCellColRow && t.changedSelection ? prevNextI : indexElem;
|
||
} else if (t.Elements[prevNextI] && ws.sName === t.Elements[prevNextI].sheet && prevNextElemRowCol === activeCellRowCol) {
|
||
//если следующий/предыдущий элемент на том же листе и на той же строке, то продолжаем
|
||
} else if (t.Elements[prevNextI]) {
|
||
//если следующий/предыдущий элемент на другой строке(столбце)/другом листе, берём его
|
||
return prevNextI;
|
||
} else {
|
||
//если это последний/первый элемент в списке
|
||
//тогда берём первый/последний
|
||
return bReverse ? indexArr[indexArr.length - 1] : indexArr[0];
|
||
}
|
||
} else if ((bReverse && elemRowCol < activeCellRowCol) || (!bReverse && elemRowCol > activeCellRowCol)) {
|
||
//если это следующая/предыдущая строка/столбец - берём первый элемент
|
||
return indexElem;
|
||
} else if (t.Elements[prevNextI] && ws.sName !== t.Elements[prevNextI].sheet) {
|
||
//если следующий/предыдущий элемент на другом листе - берём его
|
||
return prevNextI;
|
||
} else if (!t.Elements[prevNextI]){
|
||
return bReverse ? indexArr[indexArr.length - 1] : indexArr[0];
|
||
}
|
||
} else {
|
||
if (sheetArr[t.Elements[indexElem].sheet] == null) {
|
||
sheetArr[t.Elements[indexElem].sheet] = indexElem;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
};
|
||
|
||
let res;
|
||
for (let j = bReverse ? indexArr.length - 1 : 0; bReverse ? j >= 0 : j < indexArr.length; bReverse ? j-- : j++) {
|
||
i = indexArr[j];
|
||
res = checkElem(i, j);
|
||
if (res !== null) {
|
||
return res;
|
||
}
|
||
}
|
||
|
||
let start = this.wb.model.nActive;
|
||
let end = this.wb.model.aWorksheets.length + start;
|
||
for (i = bReverse ? end - 1 : start; bReverse ? i >= start : i < end; bReverse ? i-- : ++i) {
|
||
let index = i >= this.wb.model.aWorksheets.length - 1 ? i - this.wb.model.nActive : i;
|
||
|
||
if (this.wb.model.aWorksheets[index] && null != sheetArr[this.wb.model.aWorksheets[index].sName]) {
|
||
return sheetArr[this.wb.model.aWorksheets[index].sName];
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
CDocumentSearchExcel.prototype.changeDocument = function (prop, arg1, arg2) {
|
||
switch (prop) {
|
||
case AscCommonExcel.docChangedType.cellValue:
|
||
this.changeCellValue(arg1);
|
||
break;
|
||
case AscCommonExcel.docChangedType.rangeValues:
|
||
this.changeRangeValue(arg1, arg2);
|
||
break;
|
||
case AscCommonExcel.docChangedType.removeRows:
|
||
this.changeRemoveRows(arg1, arg2);
|
||
break;
|
||
case AscCommonExcel.docChangedType.sheetContent:
|
||
this.changeSheetContent(arg1, arg2);
|
||
break;
|
||
case AscCommonExcel.docChangedType.sheetRemove:
|
||
this.removeSheet(arg1);
|
||
break;
|
||
case AscCommonExcel.docChangedType.sheetRename:
|
||
this.renameSheet(arg1, arg2);
|
||
break;
|
||
case AscCommonExcel.docChangedType.sheetChangeIndex:
|
||
this.changeSheetIndex(arg1, arg2);
|
||
break;
|
||
case AscCommonExcel.docChangedType.markModifiedSearch:
|
||
if (this.wb.Api.selectSearchingResults && this.props && !this.modifiedDocument) {
|
||
this.wb.handlers.trigger("asc_onModifiedDocument");
|
||
this.setModifiedDocument(true);
|
||
}
|
||
|
||
break;
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.changeCellValue = function (cell) {
|
||
if (this.wb.Api.selectSearchingResults && this.props) {
|
||
let key = cell.ws.index + "-" + cell.nCol + "-" + cell.nRow;
|
||
if (null != this.mapFindCells[key]) {
|
||
let id = this.mapFindCells[key];
|
||
if (!cell.isEqual(this.props)) {
|
||
this._removeFromSearchElems(key, id);
|
||
}
|
||
} else if (!this.modifiedDocument && cell.isEqual(this.props)) {
|
||
this.wb.handlers.trigger("asc_onModifiedDocument");
|
||
this.setModifiedDocument(true);
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.changeRemoveRows = function (ws, range) {
|
||
if (this.isNotEmpty()) {
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i].index === ws.index && this.Elements[i].row > range.r2) {
|
||
let keyOld = this.Elements[i].index + "-" + this.Elements[i].col + "-" + this.Elements[i].row;
|
||
|
||
this.Elements[i].row = this.Elements[i].row - (range.r2 - range.r1 + 1);
|
||
|
||
let keyNew = this.Elements[i].index + "-" + this.Elements[i].col + "-" + this.Elements[i].row;
|
||
let oldId = this.mapFindCells[keyOld];
|
||
delete this.mapFindCells[keyOld];
|
||
this.mapFindCells[keyNew] = oldId;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.changeRangeValue = function (bbox, ws) {
|
||
if (this.wb.Api.selectSearchingResults && bbox && this.props) {
|
||
let t = this;
|
||
|
||
let newCell = new AscCommonExcel.Cell(ws);
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i].index === ws.index && bbox.contains(this.Elements[i].col, this.Elements[i].row)) {
|
||
newCell.nCol = this.Elements[i].col;
|
||
newCell.nRow = this.Elements[i].row;
|
||
this.changeCellValue(newCell);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.changeSheetContent = function (ws, range) {
|
||
if (this.wb.Api.selectSearchingResults && ws && this.props) {
|
||
if (this.isNotEmpty()) {
|
||
if (range) {
|
||
this.changeRangeValue(range, ws);
|
||
} else {
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i] && ws.index === this.Elements[i].index) {
|
||
this.wb.handlers.trigger("asc_onModifiedDocument");
|
||
this.setModifiedDocument(true);
|
||
this.mapFindCells = {};
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.removeSheet = function (index) {
|
||
//TODO так же сделать события для изменения названия листа + индекса листа
|
||
if (this.isNotEmpty()) {
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i] && index === this.Elements[i].index) {
|
||
let key = index + "-" + this.Elements[i].col + "-" + this.Elements[i].row;
|
||
if (null != this.mapFindCells[key]) {
|
||
this._removeFromSearchElems(key, this.mapFindCells[key]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.renameSheet = function (index, val) {
|
||
let arrResult = [];
|
||
if (this.isNotEmpty()) {
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i] && index === this.Elements[i].index) {
|
||
this.Elements[i].sheet = val
|
||
arrResult.push([parseInt(i), this.Elements[i].sheet, this.Elements[i].name, this.Elements[i].cell, this.Elements[i].text, this.Elements[i].formula]);
|
||
}
|
||
}
|
||
}
|
||
if (arrResult.length) {
|
||
let oApi = window["Asc"]["editor"];
|
||
oApi.sync_changedElements(arrResult);
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.changeSheetIndex = function (from ,to) {
|
||
if (from === to) {
|
||
return;
|
||
}
|
||
if (this.isNotEmpty()) {
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i] && from === this.Elements[i].index) {
|
||
this.Elements[i].index = to;
|
||
let keyOld = from + "-" + this.Elements[i].col + "-" + this.Elements[i].row;
|
||
let keyNew = to + "-" + this.Elements[i].col + "-" + this.Elements[i].row;
|
||
let oldId = this.mapFindCells[keyOld];
|
||
delete this.mapFindCells[keyOld];
|
||
this.mapFindCells[keyNew] = oldId;
|
||
}
|
||
}
|
||
}
|
||
};
|
||
/*CDocumentSearchExcel.prototype.updateMapFindCells = function () {
|
||
if (this.isNotEmpty()) {
|
||
this.mapFindCells = {};
|
||
for (let i in this.Elements) {
|
||
if (this.Elements[i]) {
|
||
let key = this.Elements[i].index + "-" + this.Elements[i].col + "-" + this.Elements[i].row;
|
||
this.mapFindCells[key] = i - 1;
|
||
}
|
||
}
|
||
}
|
||
};*/
|
||
CDocumentSearchExcel.prototype.removeFromSearchElems = function (col, row, ws) {
|
||
let key = ws.index + "-" + col + "-" + row;
|
||
if (null != this.mapFindCells[key]) {
|
||
let id = this.mapFindCells[key];
|
||
this._removeFromSearchElems(key, id);
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype._removeFromSearchElems = function (key, id) {
|
||
if (this.Elements[id]) {
|
||
let oApi = window["Asc"]["editor"];
|
||
oApi.sync_removeTextAroundSearch(id);
|
||
delete this.Elements[id];
|
||
}
|
||
delete this.mapFindCells[key];
|
||
this.Count--;
|
||
this.private_AddReplacedId(id);
|
||
};
|
||
CDocumentSearchExcel.prototype.Replace = function (sReplaceString, Id, bRestorePos) {
|
||
};
|
||
CDocumentSearchExcel.prototype.replaceStart = function () {
|
||
this.isReplacingText = true;
|
||
};
|
||
CDocumentSearchExcel.prototype.replaceEnd = function () {
|
||
this.isReplacingText = false;
|
||
};
|
||
/**
|
||
* @param {AscCommon.CSearchSettings} oProps
|
||
*/
|
||
CDocumentSearchExcel.prototype.Set = function (oProps) {
|
||
if (!oProps) {
|
||
return;
|
||
}
|
||
|
||
this.props = oProps.clone();
|
||
};
|
||
CDocumentSearchExcel.prototype.SetDirection = function (bDirection) {
|
||
if (bDirection != null) {
|
||
this.Direction = bDirection;
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.inFindResults = function (ws, row, col) {
|
||
let key = ws.model.index + "-" + col + "-" + row;
|
||
return this.mapFindCells && this.mapFindCells[key];
|
||
};
|
||
|
||
CDocumentSearchExcel.prototype.StartTextAround = function () {
|
||
if (!this.TextAroundUpdate) {
|
||
return this.SendAllTextAround();
|
||
}
|
||
|
||
this.TextAroundUpdate = false;
|
||
this.StopTextAround();
|
||
|
||
this.TextAroundId = 0;
|
||
|
||
let oApi = window["Asc"]["editor"];
|
||
oApi.sync_startTextAroundSearch();
|
||
|
||
let oThis = this;
|
||
this.TextAroundTimer = setTimeout(function () {
|
||
oThis.ContinueGetTextAround()
|
||
}, 20);
|
||
|
||
this.TextArround = [];
|
||
};
|
||
CDocumentSearchExcel.prototype.ContinueGetTextAround = function () {
|
||
let arrResult = [];
|
||
|
||
let nStartTime = performance.now();
|
||
while (performance.now() - nStartTime < 20) {
|
||
if (this.TextAroundId >= this.Id) {
|
||
break;
|
||
}
|
||
|
||
let sId = this.TextAroundId++;
|
||
|
||
if (!this.Elements[sId]) {
|
||
continue;
|
||
}
|
||
|
||
let sText = this.Elements[sId].text;
|
||
this.TextArround[sId] = sText;
|
||
//[id, sheet, name, cell, value,formula]
|
||
arrResult.push([sId, this.Elements[sId].sheet, this.Elements[sId].name, this.Elements[sId].cell, sText, this.Elements[sId].formula]);
|
||
}
|
||
|
||
let oApi = window["Asc"]["editor"];
|
||
oApi.sync_getTextAroundSearchPack(arrResult);
|
||
|
||
let oThis = this;
|
||
if (this.TextAroundId >= 0 && this.TextAroundId < this.Id) {
|
||
this.TextAroundTimer = setTimeout(function () {
|
||
oThis.ContinueGetTextAround();
|
||
}, 20);
|
||
} else {
|
||
this.TextAroundId = -1;
|
||
this.TextAroundTimer = null;
|
||
oApi.sync_endTextAroundSearch();
|
||
}
|
||
};
|
||
CDocumentSearchExcel.prototype.StopTextAround = function () {
|
||
if (this.TextAroundTimer) {
|
||
let oApi = window["Asc"]["editor"];
|
||
clearTimeout(this.TextAroundTimer);
|
||
oApi.sync_endTextAroundSearch();
|
||
}
|
||
|
||
this.TextAroundTimer = null;
|
||
this.TextAroundId = -1;
|
||
};
|
||
CDocumentSearchExcel.prototype.SendAllTextAround = function () {
|
||
if (this.TextAroundTimer) {
|
||
return;
|
||
}
|
||
|
||
let arrResult = [];
|
||
for (let nId = 0; nId < this.Id; ++nId) {
|
||
if (!this.Elements[nId] || null == this.TextArround || undefined === this.TextArround[nId]) {
|
||
continue;
|
||
}
|
||
|
||
arrResult.push([nId, this.Elements[nId].sheet, this.Elements[nId].name, this.Elements[nId].cell, this.Elements[nId].text, this.Elements[nId].formula]);
|
||
}
|
||
|
||
let oApi = window["Asc"]["editor"];
|
||
oApi.sync_startTextAroundSearch();
|
||
oApi.sync_getTextAroundSearchPack(arrResult);
|
||
oApi.sync_endTextAroundSearch();
|
||
};
|
||
CDocumentSearchExcel.prototype.SendClearAllTextAround = function () {
|
||
let oApi = window["Asc"]["editor"];
|
||
oApi.sync_startTextAroundSearch();
|
||
oApi.sync_endTextAroundSearch();
|
||
};
|
||
|
||
CDocumentSearchExcel.prototype.isNotEmpty = function () {
|
||
return this.Count > 0;
|
||
};
|
||
|
||
CDocumentSearchExcel.prototype.getSpecificRange = function () {
|
||
return this.props && this.props.specificRange && AscCommonExcel.g_oRangeCache.getAscRange(this.props.specificRange);
|
||
};
|
||
|
||
CDocumentSearchExcel.prototype.isSpecificRange = function () {
|
||
return this.props && this.props.specificRange;
|
||
};
|
||
|
||
CDocumentSearchExcel.prototype.checkMaxReplacedCells = function () {
|
||
return this.Count > 1000;
|
||
};
|
||
|
||
|
||
/**
|
||
* Controller for handling external selection and formula editing between worksheets/workbooks
|
||
* @constructor
|
||
* @param {WorkbookView} wb - Workbook view instance
|
||
*/
|
||
function CExternalSelectionController(wb) {
|
||
this.wb = wb;
|
||
this.externalFormulaEditMode = null;
|
||
|
||
this.activeTabFormula = null;
|
||
this.selfActiveTabFormula = null;
|
||
|
||
this.dontSendChangeEditMode = false;//only for supportVisibilityChangeOption = true mode
|
||
this.lockSendChangeSelection = false;//do not apply unnecessary change selection event
|
||
this.lockApplyChangeSelection = false;//do not send unnecessary change selection event
|
||
|
||
// Flag to enable handling of document visibility changes
|
||
this.supportVisibilityChangeOption = false;
|
||
}
|
||
|
||
/**
|
||
* Cleans up controller state
|
||
*/
|
||
CExternalSelectionController.prototype.clean = function() {
|
||
this.lockApplyChangeSelection = false;
|
||
this.activeTabFormula = null;
|
||
this.selfActiveTabFormula = null;
|
||
this.lockSendChangeSelection = false;
|
||
};
|
||
|
||
/**
|
||
* Initializes the controller with event handlers
|
||
*/
|
||
CExternalSelectionController.prototype.init = function() {
|
||
let oThis = this;
|
||
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
|
||
if (this.supportVisibilityChangeOption) {
|
||
document.addEventListener && document.addEventListener("visibilitychange", function() {
|
||
if (document.hidden === false) {
|
||
// Document has become visible
|
||
if (!oThis.getExternalFormulaEditMode()) {
|
||
return;
|
||
}
|
||
|
||
oThis.setSelfActiveTabFormula(oThis.activeTabFormula);
|
||
|
||
if (!oThis.wb.getCellEditMode()) {
|
||
oThis.onOpenCellEditor();
|
||
} else {
|
||
// Update existing editor with the formula state
|
||
oThis.wb.skipHelpSelector = true;
|
||
let val = "=" + (oThis.activeTabFormula ? oThis.activeTabFormula.range : "");
|
||
oThis.wb.cellEditor.selectAll();
|
||
oThis.wb.cellEditor._addChars(val);
|
||
oThis.wb.cellEditor.setSelectionState(oThis.activeTabFormula);
|
||
oThis.wb.skipHelpSelector = false;
|
||
oThis.wb.setFormulaEditMode(true);
|
||
}
|
||
} else {
|
||
// Document has become hidden
|
||
if (oThis.getExternalFormulaEditMode() && oThis.wb.getCellEditMode()) {
|
||
oThis.dontSendChangeEditMode = true;
|
||
|
||
// Temporarily turn off formula mode, close editor, and restore formula mode
|
||
let tmpMode = oThis.getExternalFormulaEditMode();
|
||
oThis.setExternalFormulaEditMode(false);
|
||
oThis.wb.closeCellEditor(true);
|
||
oThis.setExternalFormulaEditMode(tmpMode);
|
||
|
||
oThis.dontSendChangeEditMode = false;
|
||
|
||
// Save state to restore when visible again
|
||
oThis.setActiveTabFormula(oThis.selfActiveTabFormula);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
// Handle page unload when in formula mode
|
||
let isClosing = false;
|
||
window.addEventListener && window.addEventListener('beforeunload', function(event) {
|
||
if (!!oThis.getExternalFormulaEditMode()) {
|
||
isClosing = true;
|
||
event.preventDefault();
|
||
event.returnValue = '';
|
||
}
|
||
});
|
||
|
||
window.addEventListener && window.addEventListener('unload', function() {
|
||
if (isClosing) {
|
||
oThis.sendExternalCloseEditor();
|
||
}
|
||
});
|
||
};
|
||
|
||
/**
|
||
* Opens the cell editor for external formula editing
|
||
*/
|
||
CExternalSelectionController.prototype.onOpenCellEditor = function() {
|
||
if (this.wb.getCellEditMode()) {
|
||
return;
|
||
}
|
||
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
|
||
let oThis = this;
|
||
let editorEnterOptions = new AscCommonExcel.CEditorEnterOptions();
|
||
editorEnterOptions.newText = "=" + (oThis.activeTabFormula ? oThis.activeTabFormula.range : "");
|
||
|
||
oThis.lockApplyChangeSelection = true;
|
||
oThis.wb.input && oThis.wb.input.focus();
|
||
oThis.wb.setCellEditMode(true);
|
||
|
||
let ws = oThis.wb.getWorksheet();
|
||
let selectionRange = ws.model.selectionRange && ws.model.selectionRange.clone();
|
||
|
||
oThis.lockSendChangeSelection = true;
|
||
ws.openCellEditor(oThis.wb.cellEditor, editorEnterOptions, selectionRange);
|
||
oThis.wb.setFormulaEditMode(true);
|
||
//oThis.wb.cellEditor._topLineGotFocus();
|
||
oThis.wb.cellEditor.setSelectionState(oThis.activeTabFormula);
|
||
oThis.lockSendChangeSelection = false;
|
||
|
||
oThis.wb.input.disabled = false;
|
||
oThis.lockApplyChangeSelection = false;
|
||
};
|
||
|
||
/**
|
||
* Handles selection changes from external source
|
||
* @param {Object} data - Selection state data containing range, cell positions, and cursor information
|
||
*/
|
||
CExternalSelectionController.prototype.onExternalChangeSelection = function(data) {
|
||
if (this.lockApplyChangeSelection) {
|
||
return;
|
||
}
|
||
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
|
||
this.setActiveTabFormula(data);
|
||
|
||
if (!this.wb.isCellEditMode || this.wb.isWizardMode) {
|
||
return;
|
||
}
|
||
|
||
this.lockSendChangeSelection = true;
|
||
if ((!this.getExternalFormulaEditMode() && !this._isEqualEditorState(data)) || !this.supportVisibilityChangeOption) {
|
||
this.wb.setFormulaEditMode(true);
|
||
this.wb.skipHelpSelector = true;
|
||
|
||
if (!this.supportVisibilityChangeOption) {
|
||
this.wb.cellEditor.selectAll();
|
||
this.wb.cellEditor._addChars("=" + data.range);
|
||
this.wb.cellEditor.setSelectionState(data);
|
||
}
|
||
this.wb.cellEditor._draw();
|
||
this.wb.skipHelpSelector = false;
|
||
}
|
||
this.lockSendChangeSelection = false;
|
||
};
|
||
|
||
/**
|
||
* Handles external formula mode setting
|
||
* @param {Object} data - Formula mode parameters including isClose flag and document ID
|
||
*/
|
||
CExternalSelectionController.prototype.onExternalSetFormulaMode = function(data) {
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
const isExternalFormulaEditMode = this.getExternalFormulaEditMode();
|
||
this.setExternalFormulaEditMode(!data.isClose ? {id: data.id} : null);
|
||
|
||
if (this.wb.getCellEditMode() && data.isClose && (isExternalFormulaEditMode || !this.supportVisibilityChangeOption)) {
|
||
this.wb.closeCellEditor(!data.saveValue);
|
||
this.clean();
|
||
} else if (!this.supportVisibilityChangeOption && !this.wb.getCellEditMode() && !data.isClose) {
|
||
this.onOpenCellEditor();
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Captures current editor state and sends it to external subscribers
|
||
*/
|
||
CExternalSelectionController.prototype.sendExternalChangeSelection = function() {
|
||
if (this.lockSendChangeSelection) {
|
||
return;
|
||
}
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
|
||
const ws = this.wb.model.getActiveWs();
|
||
if (!this.wb.isFormulaEditMode || !this.wb.isCellEditMode || !this.wb.cellEditor) {
|
||
return;
|
||
}
|
||
|
||
let isDesktopSavedFile = window["AscDesktopEditor"] && window["AscDesktopEditor"]["IsLocalFile"]() && window["AscDesktopEditor"]["LocalFileGetSaved"]();
|
||
let data = {
|
||
type: "ExternalChangeSelection",
|
||
id: this.wb.Api.DocInfo.Id,
|
||
range: this.wb.cellEditor.getText().substring(1),
|
||
worksheet: ws.sName,
|
||
bookName: this.wb.Api.DocInfo.Title,
|
||
selectionBegin: this.wb.cellEditor.selectionBegin,
|
||
selectionEnd: this.wb.cellEditor.selectionEnd,
|
||
lastRangePos: this.wb.cellEditor.lastRangePos,
|
||
lastRangeLength: this.wb.cellEditor.lastRangeLength,
|
||
cursorPos: this.wb.cellEditor.cursorPos,
|
||
path: isDesktopSavedFile ? window["AscDesktopEditor"]["LocalFileGetSourcePath"]() : null
|
||
};
|
||
|
||
this.setSelfActiveTabFormula(data);
|
||
this.sendExternalEvent(data);
|
||
};
|
||
|
||
/**
|
||
* Notifies external subscribers to close the editor
|
||
* @param {boolean} saveValue - Whether to save the value when closing
|
||
*/
|
||
CExternalSelectionController.prototype.sendExternalCloseEditor = function(saveValue) {
|
||
if (this.dontSendChangeEditMode) {
|
||
return;
|
||
}
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
|
||
if (!this.supportVisibilityChangeOption) {
|
||
this.clean();
|
||
this.sendExternalEvent({
|
||
type: "SetFormulaEditMode",
|
||
id: this.wb.Api.DocInfo.Id,
|
||
isClose: true,
|
||
saveValue: saveValue
|
||
});
|
||
} else {
|
||
if (!this.getExternalFormulaEditMode()) {
|
||
this.sendExternalEvent({
|
||
type: "SetFormulaEditMode",
|
||
id: this.wb.Api.DocInfo.Id,
|
||
isClose: true
|
||
});
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Sets formula edit mode externally
|
||
*/
|
||
CExternalSelectionController.prototype.sendExternalSetFormulaEditMode = function() {
|
||
if (this.dontSendChangeEditMode) {
|
||
return;
|
||
}
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
|
||
if (!this.getExternalFormulaEditMode()) {
|
||
this.sendExternalEvent({
|
||
type: "SetFormulaEditMode",
|
||
id: this.wb.Api.DocInfo.Id
|
||
});
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Sends event through broadcast channel
|
||
* @param {Object} data - Event data to send
|
||
*/
|
||
CExternalSelectionController.prototype.sendExternalEvent = function(data) {
|
||
if (!this._checkDesktop()) {
|
||
return;
|
||
}
|
||
if (this.wb.Api && this.wb.Api.broadcastChannel) {
|
||
this.wb.Api.broadcastChannel.postMessage(data);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Sets the active tab formula state received from external source
|
||
* @param {Object} data - Formula data including range and selection state
|
||
*/
|
||
CExternalSelectionController.prototype.setActiveTabFormula = function(data) {
|
||
this.activeTabFormula = data;
|
||
};
|
||
|
||
/**
|
||
* Sets the self active tab formula state for this instance
|
||
* @param {Object} data - Formula data including range and selection state
|
||
*/
|
||
CExternalSelectionController.prototype.setSelfActiveTabFormula = function(data) {
|
||
this.selfActiveTabFormula = data;
|
||
};
|
||
|
||
/**
|
||
* Sets the external formula edit mode state
|
||
* @param {Object|null} val - Formula edit mode data or null to disable
|
||
*/
|
||
CExternalSelectionController.prototype.setExternalFormulaEditMode = function(val) {
|
||
this.externalFormulaEditMode = val;
|
||
};
|
||
|
||
/**
|
||
* Gets the current external formula edit mode state
|
||
* @returns {Object|null} Current formula edit mode state
|
||
*/
|
||
CExternalSelectionController.prototype.getExternalFormulaEditMode = function() {
|
||
return this.externalFormulaEditMode;
|
||
};
|
||
|
||
CExternalSelectionController.prototype._checkDesktop = function() {
|
||
return !window["AscDesktopEditor"] || (window["AscDesktopEditor"]["IsLocalFile"]() && window["AscDesktopEditor"]["LocalFileGetSaved"]());
|
||
};
|
||
|
||
/**
|
||
* Checks if editor state matches the provided data
|
||
* @param {Object} data - Editor state to compare
|
||
* @returns {boolean} True if states match
|
||
*/
|
||
CExternalSelectionController.prototype._isEqualEditorState = function(data) {
|
||
if (!data) {
|
||
return false;
|
||
}
|
||
|
||
const editor = this.wb.cellEditor;
|
||
if (!editor) {
|
||
return false;
|
||
}
|
||
|
||
let editorText = editor.getText();
|
||
if (!editorText) {
|
||
return false;
|
||
}
|
||
|
||
editorText = editorText.substring(1);
|
||
|
||
return data.range === editorText &&
|
||
editor.selectionBegin === data.selectionBegin &&
|
||
editor.selectionEnd === data.selectionEnd &&
|
||
editor.lastRangePos === data.lastRangePos &&
|
||
editor.lastRangeLength === data.lastRangeLength &&
|
||
editor.cursorPos === data.cursorPos;
|
||
};
|
||
|
||
|
||
//------------------------------------------------------------export---------------------------------------------------
|
||
window['AscCommonExcel'] = window['AscCommonExcel'] || {};
|
||
window["AscCommonExcel"].WorkbookView = WorkbookView;
|
||
window["AscCommonExcel"].CCellFormatPasteData = CCellFormatPasteData;
|
||
})(window);
|