Yajbir Singh
6454 lines
218 KiB
JavaScript
6454 lines
218 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_oAscLockTypeElem = AscCommonExcel.c_oAscLockTypeElem;
|
|
var c_oAscInsertOptions = Asc.c_oAscInsertOptions;
|
|
var c_oAscDeleteOptions = Asc.c_oAscDeleteOptions;
|
|
|
|
var gc_nMaxRow0 = AscCommon.gc_nMaxRow0;
|
|
var gc_nMaxCol0 = AscCommon.gc_nMaxCol0;
|
|
|
|
var c_oUndoRedoSerializeType = {
|
|
Null: 0, Undefined: 1, SByte: 2, Byte: 3, Bool: 4, Long: 5, ULong: 6, Double: 7, String: 8, Object: 9, Array: 10
|
|
};
|
|
|
|
function DrawingCollaborativeData() {
|
|
this.oClass = null;
|
|
this.oBinaryReader = null;
|
|
this.nPos = null;
|
|
this.sChangedObjectId = null;
|
|
this.isDrawingCollaborativeData = true;
|
|
}
|
|
|
|
//главный обьект для пересылки изменений
|
|
function UndoRedoItemSerializable(oClass, nActionType, nSheetId, oRange, oData, LocalChange) {
|
|
AscDFH.CChangesBase.call(this, this);
|
|
|
|
this.oClass = oClass;
|
|
this.nActionType = nActionType;
|
|
this.nSheetId = nSheetId;
|
|
this.oRange = oRange;
|
|
this.oData = oData;
|
|
this.LocalChange = LocalChange;
|
|
}
|
|
UndoRedoItemSerializable.prototype = Object.create(AscDFH.CChangesBase.prototype);
|
|
UndoRedoItemSerializable.prototype.Serialize = function (oBinaryWriter, collaborativeEditing) {
|
|
if ((this.oClass && this.oData && this.oData.getType) || (this.oClass && (this.oClass.Save_Changes || this.oClass.WriteToBinary))) {
|
|
var oThis = this;
|
|
var oBinaryCommonWriter = new AscCommon.BinaryCommonWriter(oBinaryWriter);
|
|
oBinaryCommonWriter.WriteItemWithLength(function () {
|
|
oThis.SerializeInner(oBinaryWriter, collaborativeEditing);
|
|
});
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.SerializeInner = function (oBinaryWriter, collaborativeEditing) {
|
|
//nClassType
|
|
if (!this.oClass.WriteToBinary) {
|
|
oBinaryWriter.WriteBool(true);
|
|
var nClassType = this.oClass.getClassType();
|
|
oBinaryWriter.WriteByte(nClassType);
|
|
//nActionType
|
|
oBinaryWriter.WriteByte(this.nActionType);
|
|
//nSheetId
|
|
if (null != this.nSheetId) {
|
|
oBinaryWriter.WriteBool(true);
|
|
oBinaryWriter.WriteString2(this.nSheetId.toString());
|
|
} else {
|
|
oBinaryWriter.WriteBool(false);
|
|
}
|
|
//oRange
|
|
if (null != this.oRange) {
|
|
oBinaryWriter.WriteBool(true);
|
|
var c1 = this.oRange.c1;
|
|
var c2 = this.oRange.c2;
|
|
var r1 = this.oRange.r1;
|
|
var r2 = this.oRange.r2;
|
|
if (null != this.nSheetId && (0 != c1 || gc_nMaxCol0 != c2)) {
|
|
c1 = collaborativeEditing.getLockMeColumn2(this.nSheetId, c1);
|
|
c2 = collaborativeEditing.getLockMeColumn2(this.nSheetId, c2);
|
|
}
|
|
if (null != this.nSheetId && (0 != r1 || gc_nMaxRow0 != r2)) {
|
|
r1 = collaborativeEditing.getLockMeRow2(this.nSheetId, r1);
|
|
r2 = collaborativeEditing.getLockMeRow2(this.nSheetId, r2);
|
|
}
|
|
oBinaryWriter.WriteLong(c1);
|
|
oBinaryWriter.WriteLong(r1);
|
|
oBinaryWriter.WriteLong(c2);
|
|
oBinaryWriter.WriteLong(r2);
|
|
} else {
|
|
oBinaryWriter.WriteBool(false);
|
|
}
|
|
//oData
|
|
this.SerializeDataObject(oBinaryWriter, this.oData, this.nSheetId, collaborativeEditing);
|
|
|
|
} else {
|
|
oBinaryWriter.WriteBool(false);
|
|
var Class;
|
|
Class = this.oClass.GetClass();
|
|
oBinaryWriter.WriteString2(Class.Get_Id());
|
|
oBinaryWriter.WriteLong(this.oClass.Type);
|
|
this.oClass.WriteToBinary(oBinaryWriter);
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.SerializeDataObject =
|
|
function (oBinaryWriter, oData, nSheetId, collaborativeEditing) {
|
|
var oThis = this;
|
|
if (oData.getType) {
|
|
var nDataType = oData.getType();
|
|
//не далаем копию oData, а сдвигаем в ней, потому что все равно после сериализации изменения потруться
|
|
// if (null != oData.applyCollaborative) {
|
|
// oData.applyCollaborative(nSheetId, collaborativeEditing);
|
|
// }
|
|
oBinaryWriter.WriteByte(nDataType);
|
|
var oBinaryCommonWriter = new AscCommon.BinaryCommonWriter(oBinaryWriter);
|
|
if (oData.Write_ToBinary2) {
|
|
oBinaryCommonWriter.WriteItemWithLength(function () {
|
|
oData.Write_ToBinary2(oBinaryWriter)
|
|
});
|
|
} else {
|
|
oBinaryCommonWriter.WriteItemWithLength(function () {
|
|
oThis.SerializeDataInnerObject(oBinaryWriter, oData, nSheetId, collaborativeEditing);
|
|
});
|
|
}
|
|
} else {
|
|
oBinaryWriter.WriteByte(UndoRedoDataTypes.Unknown);
|
|
oBinaryWriter.WriteLong(0);
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.SerializeDataInnerObject =
|
|
function (oBinaryWriter, oData, nSheetId, collaborativeEditing) {
|
|
var oProperties = oData.getProperties();
|
|
for (var i in oProperties) {
|
|
var nItemType = oProperties[i];
|
|
var oItem = oData.getProperty(nItemType, nSheetId);
|
|
this.SerializeDataInner(oBinaryWriter, nItemType, oItem, nSheetId, collaborativeEditing);
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.SerializeDataInnerArray =
|
|
function (oBinaryWriter, oData, nSheetId, collaborativeEditing) {
|
|
for (var i = 0; i < oData.length; ++i) {
|
|
this.SerializeDataInner(oBinaryWriter, 0, oData[i], nSheetId, collaborativeEditing);
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.SerializeDataInner =
|
|
function (oBinaryWriter, nItemType, oItem, nSheetId, collaborativeEditing) {
|
|
var oThis = this;
|
|
var sTypeOf;
|
|
if (null === oItem) {
|
|
sTypeOf = "null";
|
|
} else if (oItem instanceof Array) {
|
|
sTypeOf = "array";
|
|
} else {
|
|
sTypeOf = typeof (oItem);
|
|
}
|
|
switch (sTypeOf) {
|
|
case "object":
|
|
oBinaryWriter.WriteByte(nItemType);
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Object);
|
|
this.SerializeDataObject(oBinaryWriter, oItem, nSheetId, collaborativeEditing);
|
|
break;
|
|
case "array":
|
|
oBinaryWriter.WriteByte(nItemType);
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Array);
|
|
var oBinaryCommonWriter = new AscCommon.BinaryCommonWriter(oBinaryWriter);
|
|
oBinaryCommonWriter.WriteItemWithLength(function () {
|
|
oThis.SerializeDataInnerArray(oBinaryWriter, oItem, nSheetId, collaborativeEditing);
|
|
});
|
|
break;
|
|
case "number":
|
|
oBinaryWriter.WriteByte(nItemType);
|
|
var nFlorItem = Math.floor(oItem);
|
|
if (nFlorItem == oItem) {
|
|
if (-128 <= oItem && oItem <= 127) {
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.SByte);
|
|
oBinaryWriter.WriteSByte(oItem);
|
|
} else if (127 < oItem && oItem <= 255) {
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Byte);
|
|
oBinaryWriter.WriteByte(oItem);
|
|
} else if (-0x80000000 <= oItem && oItem <= 0x7FFFFFFF) {
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Long);
|
|
oBinaryWriter.WriteLong(oItem);
|
|
} else if (0x7FFFFFFF < oItem && oItem <= 0xFFFFFFFF) {
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.ULong);
|
|
oBinaryWriter.WriteLong(oItem);
|
|
} else {
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Double);
|
|
oBinaryWriter.WriteDouble2(oItem);
|
|
}
|
|
} else {
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Double);
|
|
oBinaryWriter.WriteDouble2(oItem);
|
|
}
|
|
break;
|
|
case "boolean":
|
|
oBinaryWriter.WriteByte(nItemType);
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Bool);
|
|
oBinaryWriter.WriteBool(oItem);
|
|
break;
|
|
case "string":
|
|
oBinaryWriter.WriteByte(nItemType);
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.String);
|
|
oBinaryWriter.WriteString2(oItem);
|
|
break;
|
|
case "null":
|
|
oBinaryWriter.WriteByte(nItemType);
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Null);
|
|
break;
|
|
case "undefined":
|
|
oBinaryWriter.WriteByte(nItemType);
|
|
oBinaryWriter.WriteByte(c_oUndoRedoSerializeType.Undefined);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.Deserialize = function (oBinaryReader) {
|
|
var res = AscCommon.c_oSerConstants.ReadOk;
|
|
res = oBinaryReader.EnterFrame(4);
|
|
var nLength = oBinaryReader.GetULongLE();
|
|
res = oBinaryReader.EnterFrame(nLength);
|
|
if (AscCommon.c_oSerConstants.ReadOk != res || 0 === nLength) {
|
|
return res;
|
|
}
|
|
var bNoDrawing = oBinaryReader.GetBool();
|
|
if (bNoDrawing) {
|
|
var nClassType = oBinaryReader.GetUChar();
|
|
this.oClass = UndoRedoClassTypes.Create(nClassType);
|
|
this.nActionType = oBinaryReader.GetUChar();
|
|
var bSheetId = oBinaryReader.GetBool();
|
|
if (bSheetId) {
|
|
this.nSheetId = oBinaryReader.GetString2LE(oBinaryReader.GetULongLE());
|
|
}
|
|
var bRange = oBinaryReader.GetBool();
|
|
if (bRange) {
|
|
var nC1 = oBinaryReader.GetULongLE();
|
|
var nR1 = oBinaryReader.GetULongLE();
|
|
var nC2 = oBinaryReader.GetULongLE();
|
|
var nR2 = oBinaryReader.GetULongLE();
|
|
this.oRange = new Asc.Range(nC1, nR1, nC2, nR2);
|
|
} else {
|
|
this.oRange = null;
|
|
}
|
|
this.oData = this.DeserializeData(oBinaryReader);
|
|
} else {
|
|
var changedObjectId = oBinaryReader.GetString2();
|
|
this.nActionType = 1;
|
|
this.oData = new DrawingCollaborativeData();
|
|
this.oData.sChangedObjectId = changedObjectId;
|
|
this.oData.oBinaryReader = oBinaryReader;
|
|
this.oData.nPos = oBinaryReader.cur;
|
|
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.DeserializeData = function (oBinaryReader) {
|
|
var nDataClassType = oBinaryReader.GetUChar();
|
|
var nLength = oBinaryReader.GetULongLE();
|
|
var oDataObject = UndoRedoDataTypes.Create(nDataClassType);
|
|
if (null != oDataObject) {
|
|
if (null != oDataObject.Read_FromBinary2) {
|
|
oDataObject.Read_FromBinary2(oBinaryReader);
|
|
} else if (null != oDataObject.Read_FromBinary2AndReplace) {
|
|
oDataObject = oDataObject.Read_FromBinary2AndReplace(oBinaryReader);
|
|
} else {
|
|
this.DeserializeDataInner(oBinaryReader, oDataObject, nLength, false);
|
|
}
|
|
} else {
|
|
oBinaryReader.Skip(nLength);
|
|
}
|
|
return oDataObject;
|
|
};
|
|
UndoRedoItemSerializable.prototype.DeserializeDataInner = function (oBinaryReader, oDataObject, nLength, bIsArray) {
|
|
var nStartPos = oBinaryReader.GetCurPos();
|
|
var nCurPos = nStartPos;
|
|
while (nCurPos - nStartPos < nLength && nCurPos < oBinaryReader.GetSize() - 1) {
|
|
var nMemeberType = oBinaryReader.GetUChar();
|
|
var nDataType = oBinaryReader.GetUChar();
|
|
var nUnknownType = false;
|
|
var oNewValue = null;
|
|
switch (nDataType) {
|
|
case c_oUndoRedoSerializeType.Null:
|
|
oNewValue = null;
|
|
break;
|
|
case c_oUndoRedoSerializeType.Undefined:
|
|
oNewValue = undefined;
|
|
break;
|
|
case c_oUndoRedoSerializeType.Bool:
|
|
oNewValue = oBinaryReader.GetBool();
|
|
break;
|
|
case c_oUndoRedoSerializeType.SByte:
|
|
oNewValue = oBinaryReader.GetChar();
|
|
break;
|
|
case c_oUndoRedoSerializeType.Byte:
|
|
oNewValue = oBinaryReader.GetUChar();
|
|
break;
|
|
case c_oUndoRedoSerializeType.Long:
|
|
oNewValue = oBinaryReader.GetLongLE();
|
|
break;
|
|
case c_oUndoRedoSerializeType.ULong:
|
|
oNewValue = AscFonts.FT_Common.IntToUInt(oBinaryReader.GetULongLE());
|
|
break;
|
|
case c_oUndoRedoSerializeType.Double:
|
|
oNewValue = oBinaryReader.GetDoubleLE();
|
|
break;
|
|
case c_oUndoRedoSerializeType.String:
|
|
oNewValue = oBinaryReader.GetString2LE(oBinaryReader.GetULongLE());
|
|
break;
|
|
case c_oUndoRedoSerializeType.Object:
|
|
oNewValue = this.DeserializeData(oBinaryReader);
|
|
break;
|
|
case c_oUndoRedoSerializeType.Array:
|
|
var aNewArray = [];
|
|
var nNewLength = oBinaryReader.GetULongLE();
|
|
this.DeserializeDataInner(oBinaryReader, aNewArray, nNewLength, true);
|
|
oNewValue = aNewArray;
|
|
break;
|
|
default:
|
|
nUnknownType = true;
|
|
break;
|
|
}
|
|
if (false == nUnknownType) {
|
|
if (bIsArray) {
|
|
oDataObject.push(oNewValue);
|
|
} else {
|
|
oDataObject.setProperty(nMemeberType, oNewValue);
|
|
}
|
|
}
|
|
nCurPos = oBinaryReader.GetCurPos();
|
|
}
|
|
};
|
|
|
|
UndoRedoItemSerializable.prototype.GetChangedRange = function () {
|
|
let res = null;
|
|
let nActionType = this.nActionType;
|
|
let classType = this.oClass.nType;
|
|
if (classType === AscCommonExcel.g_oUndoRedoCell.nType) {
|
|
res = this.oRange;
|
|
} else if (classType === AscCommonExcel.g_oUndoRedoWorksheet.nType) {
|
|
if (nActionType === AscCH.historyitem_Worksheet_Sort) {
|
|
if (this.oData.bbox) {
|
|
res = new Asc.Range(this.oData.bbox.c1, this.oData.bbox.r1, this.oData.bbox.c2, this.oData.bbox.r2);
|
|
}
|
|
} else if (nActionType === AscCH.historyitem_Worksheet_MoveRange) {
|
|
//TODO all cols/rows in this.oRange
|
|
if (this.oData) {
|
|
res = [];
|
|
if (this.oData.from) {
|
|
res.push(new Asc.Range(this.oData.from.c1, this.oData.from.r1, this.oData.from.c2, this.oData.from.r2));
|
|
}
|
|
if (this.oData.to) {
|
|
res.push(new Asc.Range(this.oData.to.c1, this.oData.to.r1, this.oData.to.c2, this.oData.to.r2));
|
|
}
|
|
}
|
|
}
|
|
} else if (classType === AscCommonExcel.g_oUndoRedoComment.nType) {
|
|
res = new Asc.Range(this.oData.nCol, this.oData.nRow, this.oData.nCol, this.oData.nRow);
|
|
} else if (classType === AscCommonExcel.g_oUndoRedoSortState.nType) {
|
|
} else if (classType === AscCommonExcel.g_oUndoRedoCF.nType) {
|
|
} else if (classType === AscCommonExcel.g_oUndoRedoAutoFilters.nType) {
|
|
} else if (classType === AscCommonExcel.g_oUndoRedoCol.nType) {
|
|
} else if (classType === AscCommonExcel.g_oUndoRedoRow.nType) {
|
|
}
|
|
|
|
return res;
|
|
};
|
|
UndoRedoItemSerializable.prototype.Copy = function () {
|
|
let oClass = this.oClass;
|
|
if (this.oClass && this.oClass.Copy) {
|
|
oClass = this.oClass.Copy();
|
|
}
|
|
//todo clone oRange oData
|
|
return new UndoRedoItemSerializable(oClass, this.nActionType, this.nSheetId, this.oRange, this.oData, this.LocalChange, null);
|
|
};
|
|
UndoRedoItemSerializable.prototype.ConvertToSimpleActions = function()
|
|
{
|
|
if (this.oClass) {
|
|
if (this.oClass.ConvertToSimpleActions) {
|
|
return this.oClass.ConvertToSimpleActions();
|
|
} else if (this.oClass.ConvertToSimpleActionsSpreadsheet) {
|
|
return this.oClass.ConvertToSimpleActionsSpreadsheet(this.nActionType, this.oData);
|
|
}
|
|
}
|
|
var arrActions = [];
|
|
return arrActions;
|
|
};
|
|
UndoRedoItemSerializable.prototype.ConvertToSimpleChanges = function()
|
|
{
|
|
if (this.oClass) {
|
|
if (this.oClass.ConvertToSimpleChanges) {
|
|
return this.oClass.ConvertToSimpleChanges();
|
|
} else if (this.oClass.ConvertToSimpleChangesSpreadsheet) {
|
|
return this.oClass.ConvertToSimpleChangesSpreadsheet(this);
|
|
}
|
|
}
|
|
return [];
|
|
};
|
|
UndoRedoItemSerializable.prototype.ConvertFromSimpleActions = function(arrActions)
|
|
{
|
|
if (this.oClass) {
|
|
if (this.oClass.ConvertFromSimpleActions) {
|
|
return this.oClass.ConvertFromSimpleActions(arrActions);
|
|
} else if (this.oClass.ConvertFromSimpleActionsSpreadsheet) {
|
|
return this.oClass.ConvertFromSimpleActionsSpreadsheet(arrActions, this.oData);
|
|
}
|
|
}
|
|
};
|
|
UndoRedoItemSerializable.prototype.CreateReverseChange = function () {
|
|
if (this.oClass && this.oClass.CreateReverseChange) {
|
|
let change = this.oClass.CreateReverseChange();
|
|
if (change) {
|
|
return new UndoRedoItemSerializable(change, this.nActionType, this.nSheetId, this.oRange, this.oData, this.LocalChange);
|
|
} else {
|
|
return null;
|
|
}
|
|
} else if (this.oClass && this.oClass.CreateReverseChangeSpreadsheet) {
|
|
return this.oClass.CreateReverseChangeSpreadsheet(this.oClass, this.nActionType, this.nSheetId, this.oRange, this.oData, this.LocalChange);
|
|
}
|
|
return undefined;
|
|
};
|
|
UndoRedoItemSerializable.prototype.IsRelated = function(oChanges)
|
|
{
|
|
if (this.oClass && oChanges.oClass) {
|
|
if (this.oClass.IsRelated) {
|
|
return this.oClass.IsRelated(oChanges.oClass);
|
|
} else if(this.oClass.IsRelatedSpreadsheet){
|
|
return this.oClass.IsRelatedSpreadsheet(oChanges.oClass, oChanges.nActionType);
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
UndoRedoItemSerializable.prototype.IsContentChange = function () {
|
|
if (this.oClass) {
|
|
if (this.oClass.IsContentChange) {
|
|
return this.oClass.IsContentChange();
|
|
} else if (this.oClass.IsContentChangeSpreadsheet) {
|
|
return this.oClass.IsContentChangeSpreadsheet(this.nActionType);
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
UndoRedoItemSerializable.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
if (oActionToUndo.oClass && oActionToUndo.oClass.CommuteRelated) {
|
|
//ничего не делаем если есть изменения на удаленном листе
|
|
if (!AscCommonExcel.g_oUndoRedoWorkbook.CommuteRelatedRemoveSheet(oActionToUndo.nSheetId, oActionOther)) {
|
|
return false;
|
|
}
|
|
|
|
//todo don't use global api
|
|
let api = window["Asc"]["editor"];
|
|
if (api && api.wbModel && api.collaborativeEditing.oRedoObjectParam && api.collaborativeEditing.oRedoObjectParam.snapshot) {
|
|
let snapshot = api.collaborativeEditing.oRedoObjectParam.snapshot;
|
|
//todo batch transform
|
|
api.wbModel._forwardTransformation(snapshot, [oActionToUndo], [oActionOther], true);
|
|
}
|
|
return oActionToUndo.oClass.CommuteRelated(oActionToUndo, oActionOther);
|
|
} else if (oActionToUndo.oClass.WriteToBinary) {
|
|
//todo просмотреть измнения автофигур которые зависят от сдвигов
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
UndoRedoItemSerializable.prototype.ToHistoryItem = function () {
|
|
return {
|
|
Class : this.oClass || this.Class,
|
|
Type : this.nActionType,
|
|
SheetId : this.nSheetId,
|
|
Range : this.oRange,
|
|
Data : this.oData,
|
|
LocalChange: this.LocalChange,
|
|
Binary : {
|
|
Pos : 0,
|
|
Len : 0
|
|
}
|
|
};
|
|
};
|
|
UndoRedoItemSerializable.prototype.Load = function () {
|
|
AscFormat.ExecuteNoHistory(function () {
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb) {
|
|
return;
|
|
}
|
|
AscCommon.History.RedoExecuteItem(this.ToHistoryItem(), api.collaborativeEditing.oRedoObjectParam, true);
|
|
}, this);
|
|
};
|
|
UndoRedoItemSerializable.prototype.Redo = function () {
|
|
this.oClass.Redo(this.nActionType, this.oData, this.nSheetId);
|
|
};
|
|
UndoRedoItemSerializable.prototype.Undo = function () {
|
|
this.oClass.Undo(this.nActionType, this.oData, this.nSheetId);
|
|
};
|
|
UndoRedoItemSerializable.prototype.IsSpreadsheetChange = function () {
|
|
return true;
|
|
};
|
|
|
|
function CChangesPointChange(Class, Point, snapshot)
|
|
{
|
|
//todo наследование от CChangesTableIdDescription
|
|
AscDFH.CChangesBase.call(this, Class);
|
|
this.Point = Point;
|
|
this.snapshot = snapshot;
|
|
}
|
|
CChangesPointChange.prototype = Object.create(AscDFH.CChangesBase.prototype);
|
|
CChangesPointChange.prototype.constructor = CChangesPointChange;
|
|
CChangesPointChange.prototype.Properties = {};
|
|
CChangesPointChange.prototype.getType = function () {
|
|
return UndoRedoDataTypes.Unknown;
|
|
};
|
|
CChangesPointChange.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
CChangesPointChange.prototype.getProperty = function (nType) {
|
|
return null;
|
|
};
|
|
CChangesPointChange.prototype.setProperty = function (nType, value) {
|
|
}
|
|
CChangesPointChange.prototype.CreateReverseChangeSpreadsheet = function()
|
|
{
|
|
let Point = Object.assign({}, this.Point);
|
|
let tmp = Point.SelectRangeRedo;
|
|
Point.SelectRangeRedo = Point.SelectRange;
|
|
Point.SelectRange = tmp;
|
|
tmp = Point.RedoSheetId;
|
|
Point.RedoSheetId = Point.UndoSheetId;
|
|
Point.UndoSheetId = tmp;
|
|
return new CChangesPointChange(this.Class, Point, this.snapshot);
|
|
};
|
|
CChangesPointChange.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
if(!this.Point || !this.Point.SelectRangeRedo) {
|
|
return true;
|
|
}
|
|
var oSelectRange = null;
|
|
if (this.Point.SelectRangeRedo)
|
|
oSelectRange = this.Point.SelectRangeRedo;
|
|
else if(this.Point.SelectRange)
|
|
oSelectRange = this.Point.SelectRange;
|
|
if (null != oSelectRange) {
|
|
AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRange(oSelectRange, oActionOther);
|
|
}
|
|
return true;
|
|
}
|
|
window['AscDFH'].CChangesPointChange = CChangesPointChange;
|
|
|
|
//для сохранения в историю и пересылки изменений
|
|
var UndoRedoDataTypes = new function () {
|
|
this.Unknown = -1;
|
|
this.CellSimpleData = 0;
|
|
this.CellValue = 1;
|
|
this.ValueMultiTextElem = 2;
|
|
this.CellValueData = 3;
|
|
this.CellData = 4;
|
|
this.FromTo = 5;
|
|
this.FromToRowCol = 6;
|
|
this.FromToHyperlink = 7;
|
|
this.IndexSimpleProp = 8;
|
|
this.ColProp = 9;
|
|
this.RowProp = 10;
|
|
this.BBox = 11;
|
|
this.StyleFont = 12;
|
|
this.StyleFill = 13;
|
|
this.StyleNum = 14;
|
|
this.StyleBorder = 15;
|
|
this.StyleBorderProp = 16;
|
|
this.StyleXfs = 17;
|
|
this.StyleAlign = 18;
|
|
this.Hyperlink = 19;
|
|
this.SortData = 20;
|
|
this.CommentData = 21;
|
|
this.CommentCoords = 22;
|
|
this.ChartSeriesData = 24;
|
|
this.SheetAdd = 25;
|
|
this.SheetRemove = 26;
|
|
this.ClrScheme = 28;
|
|
this.AutoFilter = 29;
|
|
this.AutoFiltersOptions = 30;
|
|
this.AutoFilterObj = 31;
|
|
|
|
this.AutoFiltersOptionsElements = 32;
|
|
this.SingleProperty = 33;
|
|
this.RgbColor = 34;
|
|
this.ThemeColor = 35;
|
|
|
|
this.CustomFilters = 36;
|
|
this.CustomFilter = 37;
|
|
this.ColorFilter = 38;
|
|
|
|
this.DefinedName = 39;
|
|
|
|
this.AdvancedTableInfoSettings = 40;
|
|
|
|
this.AddFormatTableOptions = 63;
|
|
this.SheetPr = 69;
|
|
|
|
this.DynamicFilter = 75;
|
|
this.Top10 = 76;
|
|
|
|
this.DataField = 79;
|
|
this.PivotTable = 80;
|
|
this.PivotField = 81;
|
|
this.PivotRowItems = 82;
|
|
this.PivotColItems = 83;
|
|
this.PivotLocation = 84;
|
|
this.PivotCacheDefinition = 85;
|
|
this.PivotCacheRecords = 86;
|
|
this.BinaryWrapper = 87;
|
|
this.BinaryWrapper2 = 88;
|
|
this.PivotFieldElem = 89;
|
|
this.PivotFilter = 90;
|
|
|
|
this.Layout = 91;
|
|
|
|
this.ArrayFormula = 95;
|
|
|
|
this.StylePatternFill = 100;
|
|
this.StyleGradientFill = 101;
|
|
this.StyleGradientFillStop = 102;
|
|
|
|
this.SortState = 115;
|
|
this.SortStateData = 116;
|
|
|
|
this.Slicer = 117;
|
|
this.SlicerData = 118;
|
|
|
|
this.NamedSheetView = 130;
|
|
this.NamedSheetViewChange = 131;
|
|
|
|
this.DataValidation = 140;
|
|
this.DataValidationInner = 141;
|
|
|
|
this.CFData = 150;
|
|
this.CFDataInner = 151;
|
|
this.ColorScale = 152;
|
|
this.CFormulaCF = 153;
|
|
this.DataBar = 154;
|
|
this.IconSet = 155;
|
|
|
|
this.ProtectedRangeData = 160;
|
|
this.ProtectedRangeDataInner = 161;
|
|
|
|
this.UserProtectedRange = 165;
|
|
this.UserProtectedRangeChange = 166;
|
|
this.UserProtectedRangeUserInfo = 167;
|
|
|
|
this.externalReference = 170;
|
|
|
|
this.RowColBreaks = 175;
|
|
|
|
this.LegacyDrawingHFDrawing = 180;
|
|
this.PivotFieldItem = 181;
|
|
this.PivotCache = 182;
|
|
this.CacheFields = 183;
|
|
this.CacheFieldElem = 184;
|
|
this.CalculatedItems = 185;
|
|
|
|
this.Create = function (nType) {
|
|
switch (nType) {
|
|
case this.ValueMultiTextElem:
|
|
return new AscCommonExcel.CMultiTextElem();
|
|
case this.CellValue:
|
|
return new AscCommonExcel.CCellValue();
|
|
case this.CellValueData:
|
|
return new UndoRedoData_CellValueData();
|
|
case this.CellData:
|
|
return new UndoRedoData_CellData();
|
|
case this.CellSimpleData:
|
|
return new UndoRedoData_CellSimpleData();
|
|
case this.FromTo:
|
|
return new UndoRedoData_FromTo();
|
|
case this.FromToRowCol:
|
|
return new UndoRedoData_FromToRowCol();
|
|
case this.FromToHyperlink:
|
|
return new UndoRedoData_FromToHyperlink();
|
|
case this.IndexSimpleProp:
|
|
return new UndoRedoData_IndexSimpleProp();
|
|
case this.ColProp:
|
|
return new UndoRedoData_ColProp();
|
|
case this.RowProp:
|
|
return new UndoRedoData_RowProp();
|
|
case this.BBox:
|
|
return new UndoRedoData_BBox();
|
|
case this.Hyperlink:
|
|
return new AscCommonExcel.Hyperlink();
|
|
case this.SortData:
|
|
return new UndoRedoData_SortData();
|
|
case this.StyleFont:
|
|
return new AscCommonExcel.Font();
|
|
case this.StyleFill:
|
|
return new AscCommonExcel.Fill();
|
|
case this.StylePatternFill:
|
|
return new AscCommonExcel.PatternFill();
|
|
case this.StyleGradientFill:
|
|
return new AscCommonExcel.GradientFill();
|
|
case this.StyleGradientFillStop:
|
|
return new AscCommonExcel.GradientStop();
|
|
case this.StyleNum:
|
|
return new AscCommonExcel.Num();
|
|
case this.StyleBorder:
|
|
return new AscCommonExcel.Border();
|
|
case this.StyleBorderProp:
|
|
return new AscCommonExcel.BorderProp();
|
|
case this.StyleXfs:
|
|
return new AscCommonExcel.CellXfs();
|
|
case this.StyleAlign:
|
|
return new AscCommonExcel.Align();
|
|
case this.CommentData:
|
|
return new Asc.asc_CCommentData();
|
|
case this.CommentCoords:
|
|
return new AscCommonExcel.asc_CCommentCoords();
|
|
case this.ChartSeriesData:
|
|
return new AscFormat.asc_CChartSeria();
|
|
case this.SheetAdd:
|
|
return new UndoRedoData_SheetAdd();
|
|
case this.SheetRemove:
|
|
return new UndoRedoData_SheetRemove();
|
|
case this.ClrScheme:
|
|
return new UndoRedoData_ClrScheme();
|
|
case this.AutoFilter:
|
|
return new UndoRedoData_AutoFilter();
|
|
case this.AutoFiltersOptions:
|
|
return new Asc.AutoFiltersOptions();
|
|
case this.AutoFilterObj:
|
|
return new Asc.AutoFilterObj();
|
|
case this.AdvancedTableInfoSettings:
|
|
return new Asc.AdvancedTableInfoSettings();
|
|
case this.CustomFilters:
|
|
return new Asc.CustomFilters();
|
|
case this.CustomFilter:
|
|
return new Asc.CustomFilter();
|
|
case this.ColorFilter:
|
|
return new Asc.ColorFilter();
|
|
case this.DynamicFilter:
|
|
return new Asc.DynamicFilter();
|
|
case this.Top10:
|
|
return new Asc.Top10();
|
|
case this.AutoFiltersOptionsElements:
|
|
return new AscCommonExcel.AutoFiltersOptionsElements();
|
|
case this.AddFormatTableOptions:
|
|
return new AscCommonExcel.AddFormatTableOptions();
|
|
case this.SingleProperty:
|
|
return new UndoRedoData_SingleProperty();
|
|
case this.RgbColor:
|
|
return new AscCommonExcel.RgbColor();
|
|
case this.ThemeColor:
|
|
return new AscCommonExcel.ThemeColor();
|
|
case this.DefinedName:
|
|
return new UndoRedoData_DefinedNames();
|
|
case this.PivotTable:
|
|
return new UndoRedoData_PivotTable();
|
|
case this.PivotCache:
|
|
return new UndoRedoData_PivotCache();
|
|
case this.CacheFields:
|
|
return new UndoRedoData_CacheFields();
|
|
case this.DataField:
|
|
return new UndoRedoData_DataField();
|
|
case this.PivotField:
|
|
return new UndoRedoData_PivotField();
|
|
case this.PivotRowItems:
|
|
return new CT_rowItems();
|
|
case this.PivotColItems:
|
|
return new CT_colItems();
|
|
case this.PivotLocation:
|
|
return new CT_Location();
|
|
case this.PivotCacheDefinition:
|
|
return new CT_PivotCacheDefinition();
|
|
case this.PivotCacheRecords:
|
|
return new CT_PivotCacheRecords();
|
|
case this.PivotFieldElem:
|
|
return new CT_PivotField(true);
|
|
case this.CacheFieldElem:
|
|
return new CT_CacheField();
|
|
case this.CalculatedItems:
|
|
return new CT_CalculatedItems();
|
|
case this.PivotFilter:
|
|
return new CT_PivotFilter();
|
|
case this.BinaryWrapper:
|
|
return new UndoRedoData_BinaryWrapper();
|
|
case this.BinaryWrapper2:
|
|
return new UndoRedoData_BinaryWrapper2();
|
|
case this.Layout:
|
|
return new UndoRedoData_Layout();
|
|
case this.ArrayFormula:
|
|
return new UndoRedoData_ArrayFormula();
|
|
case this.SortState:
|
|
return new AscCommonExcel.SortState();
|
|
case this.SortStateData:
|
|
return new AscCommonExcel.UndoRedoData_SortState();
|
|
case this.SlicerData:
|
|
return new AscCommonExcel.UndoRedoData_Slicer();
|
|
case this.Slicer:
|
|
return new window['Asc'].CT_slicer();
|
|
case this.NamedSheetView:
|
|
return new window['Asc'].CT_NamedSheetView();
|
|
case this.NamedSheetViewChange:
|
|
if (window['AscCommonExcel'].UndoRedoData_NamedSheetView) {
|
|
return new window['AscCommonExcel'].UndoRedoData_NamedSheetView();
|
|
}
|
|
break;
|
|
case this.DataValidationInner:
|
|
return new window['AscCommonExcel'].CDataValidation();
|
|
case this.DataValidation:
|
|
return new window['AscCommonExcel'].UndoRedoData_DataValidation();
|
|
case this.CFData:
|
|
return new AscCommonExcel.UndoRedoData_CF();
|
|
case this.CFDataInner:
|
|
return new AscCommonExcel.CConditionalFormattingRule();
|
|
case this.ColorScale:
|
|
return new AscCommonExcel.CColorScale();
|
|
case this.CFormulaCF:
|
|
return new AscCommonExcel.CFormulaCF();
|
|
case this.DataBar:
|
|
return new AscCommonExcel.CDataBar();
|
|
case this.IconSet:
|
|
return new AscCommonExcel.CIconSet();
|
|
case this.ProtectedRangeData:
|
|
return new AscCommonExcel.UndoRedoData_ProtectedRange();
|
|
case this.ProtectedRangeDataInner:
|
|
return new Asc.CProtectedRange();
|
|
case this.externalReference:
|
|
return new AscCommonExcel.ExternalReference();
|
|
case this.UserProtectedRange:
|
|
return new Asc.CUserProtectedRange();
|
|
case this.UserProtectedRangeChange:
|
|
return new AscCommonExcel.UndoRedoData_UserProtectedRange();
|
|
case this.UserProtectedRangeUserInfo:
|
|
return new Asc.CUserProtectedRangeUserInfo();
|
|
case this.RowColBreaks:
|
|
return new AscCommonExcel.UndoRedoData_RowColBreaks();
|
|
case this.LegacyDrawingHFDrawing:
|
|
return new AscCommonExcel.UndoRedoData_LegacyDrawingHFDrawing();
|
|
case this.PivotFieldItem:
|
|
return new AscCommonExcel.UndoRedoData_PivotFieldItem();
|
|
}
|
|
return null;
|
|
};
|
|
};
|
|
|
|
function UndoRedoData_CellSimpleData(nRow, nCol, oOldVal, oNewVal, sFormula) {
|
|
this.nRow = nRow;
|
|
this.nCol = nCol;
|
|
this.oOldVal = oOldVal;
|
|
this.oNewVal = oNewVal;
|
|
this.sFormula = sFormula;//todo unused
|
|
}
|
|
UndoRedoData_CellSimpleData.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_CellSimpleData(this.nRow, this.nCol, this.oNewVal, this.oOldVal, this.sFormula);
|
|
}
|
|
UndoRedoData_CellSimpleData.prototype.Properties = {
|
|
Row: 0, Col: 1, NewVal: 2
|
|
};
|
|
UndoRedoData_CellSimpleData.prototype.getType = function () {
|
|
return UndoRedoDataTypes.CellSimpleData;
|
|
};
|
|
UndoRedoData_CellSimpleData.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_CellSimpleData.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.Row:
|
|
return this.nRow;
|
|
break;
|
|
case this.Properties.Col:
|
|
return this.nCol;
|
|
break;
|
|
case this.Properties.NewVal:
|
|
return this.oNewVal;
|
|
break;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_CellSimpleData.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.Row:
|
|
this.nRow = value;
|
|
break;
|
|
case this.Properties.Col:
|
|
this.nCol = value;
|
|
break;
|
|
case this.Properties.NewVal:
|
|
this.oNewVal = value;
|
|
break;
|
|
}
|
|
};
|
|
UndoRedoData_CellSimpleData.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
let nRowOld = this.nRow;
|
|
let nColOld = this.nCol;
|
|
this.nRow = collaborativeEditing.getLockMeRow2(nSheetId, this.nRow);
|
|
this.nCol = collaborativeEditing.getLockMeColumn2(nSheetId, this.nCol);
|
|
return this.nRow !== nRowOld || this.nCol !== nColOld;
|
|
};
|
|
|
|
function UndoRedoData_CellData(value, style) {
|
|
this.value = value;
|
|
this.style = style;
|
|
}
|
|
|
|
UndoRedoData_CellData.prototype.Properties = {
|
|
value: 0, style: 1
|
|
};
|
|
UndoRedoData_CellData.prototype.getType = function () {
|
|
return UndoRedoDataTypes.CellData;
|
|
};
|
|
UndoRedoData_CellData.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_CellData.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.value:
|
|
return this.value;
|
|
break;
|
|
case this.Properties.style:
|
|
return this.style;
|
|
break;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_CellData.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.value:
|
|
this.value = value;
|
|
break;
|
|
case this.Properties.style:
|
|
this.style = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_CellValueData(sFormula, oValue, formulaRef, bCa) {
|
|
this.formula = sFormula;
|
|
this.formulaRef = formulaRef;
|
|
this.value = oValue;
|
|
this.ca = bCa;
|
|
}
|
|
|
|
UndoRedoData_CellValueData.prototype.Properties = {
|
|
formula: 0, value: 1, formulaRef: 2, ca: 3
|
|
};
|
|
UndoRedoData_CellValueData.prototype.isEqual = function (val) {
|
|
if (null == val) {
|
|
return false;
|
|
}
|
|
if (this.formula != val.formula) {
|
|
return false;
|
|
}
|
|
if ((this.formulaRef && val.formulaRef &&
|
|
!(this.formulaRef.r1 === val.formulaRef.r1 && this.formulaRef.c1 === val.formulaRef.c1 && this.formulaRef.r2 === val.formulaRef.r2 &&
|
|
this.formulaRef.c2 === val.formulaRef.c2)) || (this.formulaRef !== val.formulaRef)) {
|
|
return false;
|
|
}
|
|
if (this.value.isEqual(val.value)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
UndoRedoData_CellValueData.prototype.getType = function () {
|
|
return UndoRedoDataTypes.CellValueData;
|
|
};
|
|
UndoRedoData_CellValueData.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_CellValueData.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.formula:
|
|
return this.formula;
|
|
case this.Properties.value:
|
|
return this.value;
|
|
case this.Properties.formulaRef:
|
|
return this.formulaRef ? new UndoRedoData_BBox(this.formulaRef) : null;
|
|
case this.Properties.ca:
|
|
return this.ca;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_CellValueData.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.formula:
|
|
this.formula = value;
|
|
break;
|
|
case this.Properties.value:
|
|
this.value = value;
|
|
break;
|
|
case this.Properties.formulaRef:
|
|
this.formulaRef = value ? new Asc.Range(value.c1, value.r1, value.c2, value.r2) : null;
|
|
break;
|
|
case this.Properties.ca:
|
|
this.ca = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_FromToRowCol(bRow, from, to) {
|
|
this.bRow = bRow;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_FromToRowCol.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_FromToRowCol(!this.bRow, this.from, this.to);
|
|
}
|
|
UndoRedoData_FromToRowCol.prototype.Properties = {
|
|
from: 0, to: 1, bRow: 2
|
|
};
|
|
UndoRedoData_FromToRowCol.prototype.getType = function () {
|
|
return UndoRedoDataTypes.FromToRowCol;
|
|
};
|
|
UndoRedoData_FromToRowCol.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_FromToRowCol.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
return this.from;
|
|
break;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
break;
|
|
case this.Properties.bRow:
|
|
return this.bRow;
|
|
break;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_FromToRowCol.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
case this.Properties.bRow:
|
|
this.bRow = value;
|
|
break;
|
|
}
|
|
};
|
|
UndoRedoData_FromToRowCol.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
let fromOld = this.from;
|
|
let toOld = this.to;
|
|
if (this.bRow) {
|
|
this.from = collaborativeEditing.getLockMeRow2(nSheetId, this.from);
|
|
this.to = collaborativeEditing.getLockMeRow2(nSheetId, this.to);
|
|
} else {
|
|
this.from = collaborativeEditing.getLockMeColumn2(nSheetId, this.from);
|
|
this.to = collaborativeEditing.getLockMeColumn2(nSheetId, this.to);
|
|
}
|
|
return this.from !== fromOld || this.to !== toOld;
|
|
};
|
|
|
|
function UndoRedoData_FromTo(from, to, copyRange, sheetIdTo) {
|
|
this.from = from;
|
|
this.to = to;
|
|
this.copyRange = copyRange;
|
|
this.sheetIdTo = sheetIdTo;
|
|
}
|
|
UndoRedoData_FromTo.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_FromTo(this.to, this.from, this.copyRange, this.sheetIdTo);
|
|
}
|
|
UndoRedoData_FromTo.prototype.Properties = {
|
|
from: 0, to: 1, copyRange: 2, sheetIdTo: 3
|
|
};
|
|
UndoRedoData_FromTo.prototype.getType = function () {
|
|
return UndoRedoDataTypes.FromTo;
|
|
};
|
|
UndoRedoData_FromTo.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_FromTo.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
case this.Properties.copyRange:
|
|
return this.copyRange;
|
|
case this.Properties.sheetIdTo:
|
|
return this.sheetIdTo;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_FromTo.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
case this.Properties.copyRange:
|
|
this.copyRange = value;
|
|
break;
|
|
case this.Properties.sheetIdTo:
|
|
this.sheetIdTo = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_FromToHyperlink(oBBoxFrom, oBBoxTo, hyperlink) {
|
|
this.from = new UndoRedoData_BBox(oBBoxFrom);
|
|
this.to = new UndoRedoData_BBox(oBBoxTo);
|
|
this.hyperlink = hyperlink;
|
|
}
|
|
UndoRedoData_FromToHyperlink.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_FromToHyperlink(this.to, this.from, this.hyperlink);
|
|
}
|
|
UndoRedoData_FromToHyperlink.prototype.Properties = {
|
|
from: 0, to: 1, hyperlink: 2
|
|
};
|
|
UndoRedoData_FromToHyperlink.prototype.getType = function () {
|
|
return UndoRedoDataTypes.FromToHyperlink;
|
|
};
|
|
UndoRedoData_FromToHyperlink.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_FromToHyperlink.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
case this.Properties.hyperlink:
|
|
return this.hyperlink;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_FromToHyperlink.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
case this.Properties.hyperlink:
|
|
this.hyperlink = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_IndexSimpleProp(index, bRow, oOldVal, oNewVal) {
|
|
this.index = index;
|
|
this.bRow = bRow;
|
|
this.oOldVal = oOldVal;
|
|
this.oNewVal = oNewVal;
|
|
}
|
|
|
|
UndoRedoData_IndexSimpleProp.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_IndexSimpleProp(this.index, this.bRow, this.oNewVal, this.oOldVal);
|
|
}
|
|
UndoRedoData_IndexSimpleProp.prototype.Properties = {
|
|
index: 0, oNewVal: 1
|
|
};
|
|
UndoRedoData_IndexSimpleProp.prototype.getType = function () {
|
|
return UndoRedoDataTypes.IndexSimpleProp;
|
|
};
|
|
UndoRedoData_IndexSimpleProp.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_IndexSimpleProp.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.index:
|
|
return this.index;
|
|
case this.Properties.oNewVal:
|
|
return this.oNewVal;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_IndexSimpleProp.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.index:
|
|
this.index = value;
|
|
break;
|
|
case this.Properties.oNewVal:
|
|
this.oNewVal = value;
|
|
break;
|
|
}
|
|
};
|
|
UndoRedoData_IndexSimpleProp.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
let indexOld = this.index;
|
|
if (this.bRow) {
|
|
this.index = collaborativeEditing.getLockMeRow2(nSheetId, this.index);
|
|
} else {
|
|
this.index = collaborativeEditing.getLockMeColumn2(nSheetId, this.index);
|
|
}
|
|
return this.index !== indexOld;
|
|
};
|
|
|
|
function UndoRedoData_ColProp(col) {
|
|
if (null != col) {
|
|
this.width = col.width;
|
|
this.hd = col.hd;
|
|
this.CustomWidth = col.CustomWidth;
|
|
this.BestFit = col.BestFit;
|
|
this.OutlineLevel = col.outlineLevel;
|
|
this.Collapsed = col.collapsed;
|
|
} else {
|
|
this.width = null;
|
|
this.hd = null;
|
|
this.CustomWidth = null;
|
|
this.BestFit = null;
|
|
this.OutlineLevel = null;
|
|
this.Collapsed = null;
|
|
}
|
|
}
|
|
|
|
UndoRedoData_ColProp.prototype.Properties = {
|
|
width: 0, hd: 1, CustomWidth: 2, BestFit: 3, OutlineLevel: 4, Collapsed: 5
|
|
};
|
|
UndoRedoData_ColProp.prototype.isEqual = function (val) {
|
|
var defaultColWidth = AscCommonExcel.oDefaultMetrics.ColWidthChars;
|
|
return this.hd == val.hd && this.CustomWidth == val.CustomWidth &&
|
|
((this.BestFit == val.BestFit && this.width == val.width) ||
|
|
((null == this.width || defaultColWidth == this.width) &&
|
|
(null == this.BestFit || true == this.BestFit) &&
|
|
(null == val.width || defaultColWidth == val.width) &&
|
|
(null == val.BestFit || true == val.BestFit))) && this.OutlineLevel == val.OutlineLevel && this.Collapsed == val.Collapsed;
|
|
};
|
|
UndoRedoData_ColProp.prototype.getType = function () {
|
|
return UndoRedoDataTypes.ColProp;
|
|
};
|
|
UndoRedoData_ColProp.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_ColProp.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.width:
|
|
return this.width;
|
|
case this.Properties.hd:
|
|
return this.hd;
|
|
case this.Properties.CustomWidth:
|
|
return this.CustomWidth;
|
|
case this.Properties.BestFit:
|
|
return this.BestFit;
|
|
case this.Properties.OutlineLevel:
|
|
return this.OutlineLevel;
|
|
case this.Properties.Collapsed:
|
|
return this.Collapsed;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_ColProp.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.width:
|
|
this.width = value;
|
|
break;
|
|
case this.Properties.hd:
|
|
this.hd = value;
|
|
break;
|
|
case this.Properties.CustomWidth:
|
|
this.CustomWidth = value;
|
|
break;
|
|
case this.Properties.BestFit:
|
|
this.BestFit = value;
|
|
break;
|
|
case this.Properties.OutlineLevel:
|
|
this.OutlineLevel = value;
|
|
break;
|
|
case this.Properties.Collapsed:
|
|
this.Collapsed = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_RowProp(row) {
|
|
if (null != row) {
|
|
this.h = row.getHeight();
|
|
this.hd = row.getHidden();
|
|
this.CustomHeight = row.getCustomHeight();
|
|
this.OutlineLevel = row.getOutlineLevel();
|
|
this.Collapsed = row.getCollapsed();
|
|
} else {
|
|
this.h = null;
|
|
this.hd = null;
|
|
this.CustomHeight = null;
|
|
this.OutlineLevel = null;
|
|
this.Collapsed = null;
|
|
}
|
|
}
|
|
|
|
UndoRedoData_RowProp.prototype.Properties = {
|
|
h: 0, hd: 1, CustomHeight: 2, OutlineLevel: 3, Collapsed: 4
|
|
};
|
|
UndoRedoData_RowProp.prototype.isEqual = function (val) {
|
|
var defaultRowHeight = AscCommonExcel.oDefaultMetrics.RowHeight;
|
|
return this.hd == val.hd && ((this.CustomHeight == val.CustomHeight && this.h == val.h) ||
|
|
((null == this.h || defaultRowHeight == this.h) &&
|
|
(null == this.CustomHeight || false == this.CustomHeight) &&
|
|
(null == val.h || defaultRowHeight == val.h) &&
|
|
(null == val.CustomHeight || false == val.CustomHeight))) && this.OutlineLevel == val.OutlineLevel && this.Collapsed == val.Collapsed;
|
|
};
|
|
UndoRedoData_RowProp.prototype.getType = function () {
|
|
return UndoRedoDataTypes.RowProp;
|
|
};
|
|
UndoRedoData_RowProp.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_RowProp.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.h:
|
|
return this.h;
|
|
case this.Properties.hd:
|
|
return this.hd;
|
|
case this.Properties.CustomHeight:
|
|
return this.CustomHeight;
|
|
case this.Properties.OutlineLevel:
|
|
return this.OutlineLevel;
|
|
case this.Properties.Collapsed:
|
|
return this.Collapsed;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_RowProp.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.h:
|
|
this.h = value;
|
|
break;
|
|
case this.Properties.hd:
|
|
this.hd = value;
|
|
break;
|
|
case this.Properties.CustomHeight:
|
|
this.CustomHeight = value;
|
|
break;
|
|
case this.Properties.OutlineLevel:
|
|
this.OutlineLevel = value;
|
|
break;
|
|
case this.Properties.Collapsed:
|
|
this.Collapsed = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_BBox(oBBox) {
|
|
if (null != oBBox) {
|
|
this.c1 = oBBox.c1;
|
|
this.r1 = oBBox.r1;
|
|
this.c2 = oBBox.c2;
|
|
this.r2 = oBBox.r2;
|
|
} else {
|
|
this.c1 = null;
|
|
this.r1 = null;
|
|
this.c2 = null;
|
|
this.r2 = null;
|
|
}
|
|
}
|
|
|
|
UndoRedoData_BBox.prototype.Properties = {
|
|
c1: 0, r1: 1, c2: 2, r2: 3
|
|
};
|
|
UndoRedoData_BBox.prototype.getType = function () {
|
|
return UndoRedoDataTypes.BBox;
|
|
};
|
|
UndoRedoData_BBox.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_BBox.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.c1:
|
|
return this.c1;
|
|
case this.Properties.r1:
|
|
return this.r1;
|
|
case this.Properties.c2:
|
|
return this.c2;
|
|
case this.Properties.r2:
|
|
return this.r2;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_BBox.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.c1:
|
|
this.c1 = value;
|
|
break;
|
|
case this.Properties.r1:
|
|
this.r1 = value;
|
|
break;
|
|
case this.Properties.c2:
|
|
this.c2 = value;
|
|
break;
|
|
case this.Properties.r2:
|
|
this.r2 = value;
|
|
break;
|
|
}
|
|
};
|
|
UndoRedoData_BBox.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
let r1old = this.r1;
|
|
let r2old = this.r2;
|
|
let c1old = this.c1;
|
|
let c2old = this.c2;
|
|
this.r1 = collaborativeEditing.getLockMeRow2(nSheetId, this.r1);
|
|
this.r2 = collaborativeEditing.getLockMeRow2(nSheetId, this.r2);
|
|
this.c1 = collaborativeEditing.getLockMeColumn2(nSheetId, this.c1);
|
|
this.c2 = collaborativeEditing.getLockMeColumn2(nSheetId, this.c2);
|
|
return this.r1 !== r1old || this.r2 !== r2old || this.c1 !== c1old || this.c2 !== c2old;
|
|
};
|
|
|
|
|
|
function UndoRedoData_FrozenBBox(oBBox) {
|
|
if (null != oBBox) {
|
|
this.c1 = oBBox.c1;
|
|
this.r1 = oBBox.r1;
|
|
this.c2 = oBBox.c2;
|
|
this.r2 = oBBox.r2;
|
|
} else {
|
|
this.c1 = null;
|
|
this.r1 = null;
|
|
this.c2 = null;
|
|
this.r2 = null;
|
|
}
|
|
}
|
|
|
|
UndoRedoData_FrozenBBox.prototype = Object.create(UndoRedoData_BBox.prototype);
|
|
UndoRedoData_FrozenBBox.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
let r1old = this.r1;
|
|
let r2old = this.r2;
|
|
let c1old = this.c1;
|
|
let c2old = this.c2;
|
|
var _r1 = this.r1 > 0 ? collaborativeEditing.getLockMeRow2(nSheetId, this.r1 - 1) : null;
|
|
var _r2 = this.r2 > 0 ? collaborativeEditing.getLockMeRow2(nSheetId, this.r2 - 1) : null;
|
|
var _c1 = this.c1 > 0 ? collaborativeEditing.getLockMeRow2(nSheetId, this.c1 - 1) : null;
|
|
var _c2 = this.c2 > 0 ? collaborativeEditing.getLockMeRow2(nSheetId, this.c2 - 1) : null;
|
|
|
|
if (_r1 !== null && _r1 !== this.r1 - 1) {
|
|
this.r1 = _r1 + 1;
|
|
}
|
|
if (_r2 !== null && _r2 !== this.r2 - 1) {
|
|
this.r2 = _r2 + 1;
|
|
}
|
|
if (_c1 !== null && _c1 !== this.c1 - 1) {
|
|
this.c1 = _c1 + 1;
|
|
}
|
|
if (_c2 !== null && _c2 !== this.c2 - 1) {
|
|
this.c2 = _c2 + 1;
|
|
}
|
|
return this.r1 !== r1old || this.r2 !== r2old || this.c1 !== c1old || this.c2 !== c2old;
|
|
};
|
|
|
|
|
|
function UndoRedoData_SortData(bbox, places, sortByRow) {
|
|
this.bbox = bbox;
|
|
this.places = places;
|
|
this.sortByRow = sortByRow;
|
|
}
|
|
|
|
UndoRedoData_SortData.prototype.Properties = {
|
|
bbox: 0, places: 1, sortByRow: 2
|
|
};
|
|
UndoRedoData_SortData.prototype.getType = function () {
|
|
return UndoRedoDataTypes.SortData;
|
|
};
|
|
UndoRedoData_SortData.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_SortData.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.bbox:
|
|
return this.bbox;
|
|
case this.Properties.places:
|
|
return this.places;
|
|
case this.Properties.sortByRow:
|
|
return this.sortByRow;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_SortData.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.bbox:
|
|
this.bbox = value;
|
|
break;
|
|
case this.Properties.places:
|
|
this.places = value;
|
|
break;
|
|
case this.Properties.sortByRow:
|
|
this.sortByRow = value;
|
|
break;
|
|
}
|
|
};
|
|
UndoRedoData_SortData.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
let res = false;
|
|
let r1old = this.bbox.r1;
|
|
let r2old = this.bbox.r2;
|
|
let c1old = this.bbox.c1;
|
|
let c2old = this.bbox.c2;
|
|
this.bbox.r1 = collaborativeEditing.getLockMeRow2(nSheetId, this.bbox.r1);
|
|
this.bbox.r2 = collaborativeEditing.getLockMeRow2(nSheetId, this.bbox.r2);
|
|
this.bbox.c1 = collaborativeEditing.getLockMeColumn2(nSheetId, this.bbox.c1);
|
|
this.bbox.c2 = collaborativeEditing.getLockMeColumn2(nSheetId, this.bbox.c2);
|
|
res = this.bbox.r1 !== r1old || this.bbox.r2 !== r2old || this.bbox.c1 !== c1old || this.bbox.c2 !== c2old;
|
|
for (var i = 0, length = this.places.length; i < length; ++i) {
|
|
var place = this.places[i];
|
|
let fromOld = place.from;
|
|
let toOld = place.to;
|
|
if (this.sortByRow) {
|
|
place.from = collaborativeEditing.getLockMeColumn2(nSheetId, place.from);
|
|
place.to = collaborativeEditing.getLockMeColumn2(nSheetId, place.to);
|
|
} else {
|
|
place.from = collaborativeEditing.getLockMeRow2(nSheetId, place.from);
|
|
place.to = collaborativeEditing.getLockMeRow2(nSheetId, place.to);
|
|
}
|
|
res = res || place.from !== fromOld || place.to !== toOld;
|
|
}
|
|
return res;
|
|
};
|
|
|
|
function UndoRedoData_PivotTable(pivot, from, to) {
|
|
this.pivot = pivot;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
|
|
UndoRedoData_PivotTable.prototype.Properties = {
|
|
pivot: 0, from: 1, to: 2
|
|
};
|
|
UndoRedoData_PivotTable.prototype.getType = function () {
|
|
return UndoRedoDataTypes.PivotTable;
|
|
};
|
|
UndoRedoData_PivotTable.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_PivotTable.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
return this.pivot;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_PivotTable.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
this.pivot = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
function UndoRedoData_PivotCache(pivot, from, to) {
|
|
this.pivot = pivot;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
|
|
UndoRedoData_PivotCache.prototype.Properties = {
|
|
pivot: 0, from: 1, to: 2
|
|
};
|
|
UndoRedoData_PivotCache.prototype.getType = function () {
|
|
return UndoRedoDataTypes.PivotCache;
|
|
};
|
|
UndoRedoData_PivotCache.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_PivotCache.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
return this.pivot;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_PivotCache.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
this.pivot = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
function UndoRedoData_CacheFields(pivot, index, from, to) {
|
|
this.pivot = pivot;
|
|
this.index = index;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_CacheFields.prototype.Properties = {
|
|
pivot: 0, index: 1, from: 2, to: 3
|
|
};
|
|
UndoRedoData_CacheFields.prototype.getType = function () {
|
|
return UndoRedoDataTypes.CacheFields;
|
|
};
|
|
UndoRedoData_CacheFields.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_CacheFields.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
return this.pivot;
|
|
case this.Properties.index:
|
|
return this.index;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_CacheFields.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
this.pivot = value;
|
|
break;
|
|
case this.Properties.index:
|
|
this.index = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_PivotTableRedo(pivot, from, to) {
|
|
this.pivot = pivot;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
|
|
UndoRedoData_PivotTableRedo.prototype = Object.create(UndoRedoData_PivotTable.prototype);
|
|
UndoRedoData_PivotTableRedo.prototype.Properties = {
|
|
pivot: 0, to: 2
|
|
};
|
|
|
|
function UndoRedoData_DataField(pivot, from, to, name) {
|
|
this.pivot = pivot;
|
|
this.from = from;
|
|
this.to = to;
|
|
this.name = name;
|
|
}
|
|
|
|
UndoRedoData_DataField.prototype.Properties = {
|
|
pivot: 0, from: 1, to: 2, name: 3
|
|
};
|
|
UndoRedoData_DataField.prototype.getType = function () {
|
|
return UndoRedoDataTypes.DataField;
|
|
};
|
|
UndoRedoData_DataField.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_DataField.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
return this.pivot;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
case this.Properties.name:
|
|
return this.name;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_DataField.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
this.pivot = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
case this.Properties.name:
|
|
this.name = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_PivotField(pivot, index, from, to) {
|
|
this.pivot = pivot;
|
|
this.index = index;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
|
|
UndoRedoData_PivotField.prototype.Properties = {
|
|
pivot: 0, index: 1, from: 2, to: 3
|
|
};
|
|
UndoRedoData_PivotField.prototype.getType = function () {
|
|
return UndoRedoDataTypes.PivotField;
|
|
};
|
|
UndoRedoData_PivotField.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_PivotField.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
return this.pivot;
|
|
case this.Properties.index:
|
|
return this.index;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_PivotField.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
this.pivot = value;
|
|
break;
|
|
case this.Properties.index:
|
|
this.index = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_PivotFieldItem(pivot, pivotIndex, itemIndex, from, to) {
|
|
this.pivot = pivot;
|
|
this.pivotIndex = pivotIndex;
|
|
this.itemIndex = itemIndex;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
|
|
UndoRedoData_PivotFieldItem.prototype.Properties = {
|
|
pivot: 0, pivotIndex: 1, itemIndex: 2, from: 3, to: 4
|
|
};
|
|
UndoRedoData_PivotFieldItem.prototype.getType = function () {
|
|
return UndoRedoDataTypes.PivotFieldItem;
|
|
};
|
|
UndoRedoData_PivotFieldItem.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_PivotFieldItem.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
return this.pivot;
|
|
case this.Properties.pivotIndex:
|
|
return this.pivotIndex;
|
|
case this.Properties.itemIndex:
|
|
return this.itemIndex;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_PivotFieldItem.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.pivot:
|
|
this.pivot = value;
|
|
break;
|
|
case this.Properties.pivotIndex:
|
|
this.pivotIndex = value;
|
|
break;
|
|
case this.Properties.itemIndex:
|
|
this.itemIndex = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_BinaryWrapper(data) {
|
|
this.binary = null;
|
|
this.len = 0;
|
|
this.Id = null;
|
|
if (data) {
|
|
var memory = new AscCommon.CMemory(true);
|
|
memory.CheckSize(1000);
|
|
data.Write_ToBinary2(memory);
|
|
this.Id = data.Get_Id();
|
|
this.len = memory.GetCurPosition();
|
|
this.binary = memory.GetData();
|
|
}
|
|
}
|
|
|
|
UndoRedoData_BinaryWrapper.prototype.getType = function () {
|
|
return UndoRedoDataTypes.BinaryWrapper;
|
|
};
|
|
UndoRedoData_BinaryWrapper.prototype.Write_ToBinary2 = function (writer) {
|
|
writer.WriteString2(this.Id);
|
|
writer.WriteLong(this.len);
|
|
writer.WriteBuffer(this.binary, 0, this.len);
|
|
};
|
|
UndoRedoData_BinaryWrapper.prototype.Read_FromBinary2 = function (reader) {
|
|
this.Id = reader.GetString2();
|
|
this.len = reader.GetLong();
|
|
this.binary = reader.GetBufferUint8(this.len);
|
|
};
|
|
UndoRedoData_BinaryWrapper.prototype.getData = function () {
|
|
var reader = new AscCommon.FT_Stream2(this.binary, this.len);
|
|
var data = AscCommon.g_oTableId.GetClassFromFactory(reader.GetLong());
|
|
data.Id = this.Id;
|
|
data.Read_FromBinary2(reader);
|
|
return data;
|
|
};
|
|
UndoRedoData_BinaryWrapper.prototype.readData = function (data) {
|
|
var reader = new AscCommon.FT_Stream2(this.binary, this.len);
|
|
data.Read_FromBinary2(reader);
|
|
};
|
|
|
|
function UndoRedoData_BinaryWrapper2(data) {
|
|
this.binary = null;
|
|
this.len = 0;
|
|
if (data) {
|
|
var memory = new AscCommon.CMemory(true);
|
|
memory.CheckSize(1000);
|
|
data.Write_ToBinary2(memory);
|
|
this.len = memory.GetCurPosition();
|
|
this.binary = memory.GetData();
|
|
}
|
|
}
|
|
|
|
UndoRedoData_BinaryWrapper2.prototype.getType = function () {
|
|
return UndoRedoDataTypes.BinaryWrapper2;
|
|
};
|
|
UndoRedoData_BinaryWrapper2.prototype.Write_ToBinary2 = function (writer) {
|
|
writer.WriteLong(this.len);
|
|
writer.WriteBuffer(this.binary, 0, this.len);
|
|
};
|
|
UndoRedoData_BinaryWrapper2.prototype.Read_FromBinary2 = function (reader) {
|
|
this.len = reader.GetLong();
|
|
this.binary = reader.GetBufferUint8(this.len);
|
|
};
|
|
UndoRedoData_BinaryWrapper2.prototype.initObject = function (data) {
|
|
var reader = new AscCommon.FT_Stream2(this.binary, this.len);
|
|
data.Read_FromBinary2(reader);
|
|
};
|
|
|
|
function UndoRedoData_Layout(from, to) {
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_Layout.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_Layout(this.to, this.from);
|
|
}
|
|
UndoRedoData_Layout.prototype.Properties = {
|
|
from: 0, to: 1
|
|
};
|
|
UndoRedoData_Layout.prototype.getType = function () {
|
|
return UndoRedoDataTypes.Layout;
|
|
};
|
|
UndoRedoData_Layout.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_Layout.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_Layout.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_SheetAdd(insertBefore, name, sheetidfrom, sheetid, tableNames, opt_sheet, opt_sheetidToAdd) {
|
|
this.insertBefore = insertBefore;
|
|
this.name = name;
|
|
this.sheetidfrom = sheetidfrom;
|
|
this.sheetid = sheetid;
|
|
this.opt_sheet = opt_sheet;
|
|
this.opt_sheetidToAdd = opt_sheetidToAdd;
|
|
|
|
//Эти поля заполняются после Undo/Redo
|
|
this.sheet = null;
|
|
|
|
this.tableNames = tableNames;
|
|
}
|
|
|
|
UndoRedoData_SheetAdd.prototype.Properties = {
|
|
name: 0, sheetidfrom: 1, sheetid: 2, tableNames: 3, insertBefore: 4, opt_sheet: 5, opt_sheetidToAdd: 6
|
|
};
|
|
UndoRedoData_SheetAdd.prototype.getType = function () {
|
|
return UndoRedoDataTypes.SheetAdd;
|
|
};
|
|
UndoRedoData_SheetAdd.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_SheetAdd.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.name:
|
|
return this.name;
|
|
break;
|
|
case this.Properties.sheetidfrom:
|
|
return this.sheetidfrom;
|
|
break;
|
|
case this.Properties.sheetid:
|
|
return this.sheetid;
|
|
break;
|
|
case this.Properties.tableNames:
|
|
return this.tableNames;
|
|
break;
|
|
case this.Properties.insertBefore:
|
|
return this.insertBefore;
|
|
break;
|
|
case this.Properties.opt_sheet:
|
|
return this.opt_sheet;
|
|
break;
|
|
case this.Properties.opt_sheetidToAdd:
|
|
return this.opt_sheetidToAdd;
|
|
break;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_SheetAdd.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.name:
|
|
this.name = value;
|
|
break;
|
|
case this.Properties.sheetidfrom:
|
|
this.sheetidfrom = value;
|
|
break;
|
|
case this.Properties.sheetid:
|
|
this.sheetid = value;
|
|
break;
|
|
case this.Properties.tableNames:
|
|
this.tableNames = value;
|
|
break;
|
|
case this.Properties.insertBefore:
|
|
this.insertBefore = value;
|
|
break;
|
|
case this.Properties.opt_sheet:
|
|
this.opt_sheet = value;
|
|
break;
|
|
case this.Properties.opt_sheetidToAdd:
|
|
this.opt_sheetidToAdd = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_SheetRemove(index, sheetId, sheet) {
|
|
this.index = index;
|
|
this.sheetId = sheetId;
|
|
this.sheet = sheet;
|
|
}
|
|
|
|
UndoRedoData_SheetRemove.prototype.Properties = {
|
|
index: 0, sheetId: 1, sheet: 2
|
|
};
|
|
UndoRedoData_SheetRemove.prototype.getType = function () {
|
|
return UndoRedoDataTypes.SheetRemove;
|
|
};
|
|
UndoRedoData_SheetRemove.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_SheetRemove.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.index:
|
|
return this.index;
|
|
case this.Properties.sheetId:
|
|
return this.sheetId;
|
|
case this.Properties.sheet:
|
|
return this.sheet;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_SheetRemove.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.index:
|
|
this.index = value;
|
|
break;
|
|
case this.Properties.sheetId:
|
|
this.sheetId = value;
|
|
break;
|
|
case this.Properties.sheet:
|
|
this.sheet = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_DefinedNames(name, ref, sheetId, type, isXLNM, hidden) {
|
|
this.name = name;
|
|
this.ref = ref;
|
|
this.sheetId = sheetId;
|
|
this.type = type;
|
|
this.isXLNM = isXLNM;
|
|
this.hidden = hidden === undefined ? false : hidden;
|
|
}
|
|
|
|
UndoRedoData_DefinedNames.prototype.Properties = {
|
|
name: 0, ref: 1, sheetId: 2, type: 4, isXLNM: 5, hidden: 6
|
|
};
|
|
UndoRedoData_DefinedNames.prototype.getType = function () {
|
|
return UndoRedoDataTypes.DefinedName;
|
|
};
|
|
UndoRedoData_DefinedNames.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_DefinedNames.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.name:
|
|
return this.name;
|
|
case this.Properties.ref:
|
|
return this.ref;
|
|
case this.Properties.sheetId:
|
|
return this.sheetId;
|
|
case this.Properties.type:
|
|
return this.type;
|
|
case this.Properties.isXLNM:
|
|
return this.isXLNM;
|
|
case this.Properties.hidden:
|
|
return this.hidden;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_DefinedNames.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.name:
|
|
this.name = value;
|
|
break;
|
|
case this.Properties.ref:
|
|
this.ref = value;
|
|
break;
|
|
case this.Properties.sheetId:
|
|
this.sheetId = value;
|
|
break;
|
|
case this.Properties.type:
|
|
this.type = value;
|
|
break;
|
|
case this.Properties.isXLNM:
|
|
this.isXLNM = value;
|
|
break;
|
|
case this.Properties.hidden:
|
|
this.hidden = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_ClrScheme(oldVal, newVal) {
|
|
this.oldVal = oldVal;
|
|
this.newVal = newVal;
|
|
}
|
|
|
|
UndoRedoData_ClrScheme.prototype.getType = function () {
|
|
return UndoRedoDataTypes.ClrScheme;
|
|
};
|
|
UndoRedoData_ClrScheme.prototype.Write_ToBinary2 = function (writer) {
|
|
};
|
|
UndoRedoData_ClrScheme.prototype.Read_FromBinary2 = function (reader) {
|
|
};
|
|
|
|
function UndoRedoData_AutoFilter() {
|
|
|
|
this.undo = null;
|
|
|
|
this.activeCells = null;
|
|
this.styleName = null;
|
|
this.type = null;
|
|
this.cellId = null;
|
|
this.autoFiltersObject = null;
|
|
this.addFormatTableOptionsObj = null;
|
|
this.moveFrom = null;
|
|
this.moveTo = null;
|
|
this.bWithoutFilter = null;
|
|
this.displayName = null;
|
|
this.val = null;
|
|
|
|
this.ShowColumnStripes = null;
|
|
this.ShowFirstColumn = null;
|
|
this.ShowLastColumn = null;
|
|
this.ShowRowStripes = null;
|
|
|
|
this.HeaderRowCount = null;
|
|
this.TotalsRowCount = null;
|
|
this.color = null;
|
|
this.tablePart = null;
|
|
this.nCol = null;
|
|
this.nRow = null;
|
|
this.formula = null;
|
|
this.totalFunction = null;
|
|
this.viewId = null;
|
|
|
|
this.redoColumnName = null;
|
|
}
|
|
|
|
UndoRedoData_AutoFilter.prototype.Properties = {
|
|
activeCells: 0,
|
|
styleName: 1,
|
|
type: 2,
|
|
cellId: 3,
|
|
autoFiltersObject: 4,
|
|
addFormatTableOptionsObj: 5,
|
|
moveFrom: 6,
|
|
moveTo: 7,
|
|
bWithoutFilter: 8,
|
|
displayName: 9,
|
|
val: 10,
|
|
ShowColumnStripes: 11,
|
|
ShowFirstColumn: 12,
|
|
ShowLastColumn: 13,
|
|
ShowRowStripes: 14,
|
|
HeaderRowCount: 15,
|
|
TotalsRowCount: 16,
|
|
color: 17,
|
|
tablePart: 18,
|
|
nCol: 19,
|
|
nRow: 20,
|
|
formula: 21,
|
|
totalFunction: 22,
|
|
viewId: 23,
|
|
redoColumnName: 24
|
|
};
|
|
UndoRedoData_AutoFilter.prototype.getType = function () {
|
|
return UndoRedoDataTypes.AutoFilter;
|
|
};
|
|
UndoRedoData_AutoFilter.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_AutoFilter.prototype.getProperty = function (nType, nSheetId) {
|
|
switch (nType) {
|
|
case this.Properties.activeCells:
|
|
return new UndoRedoData_BBox(this.activeCells);
|
|
case this.Properties.styleName:
|
|
return this.styleName;
|
|
case this.Properties.type:
|
|
return this.type;
|
|
case this.Properties.cellId:
|
|
return this.cellId;
|
|
case this.Properties.autoFiltersObject:
|
|
return this.autoFiltersObject;
|
|
case this.Properties.addFormatTableOptionsObj:
|
|
return this.addFormatTableOptionsObj;
|
|
case this.Properties.moveFrom:
|
|
return new UndoRedoData_BBox(this.moveFrom);
|
|
case this.Properties.moveTo:
|
|
return new UndoRedoData_BBox(this.moveTo);
|
|
case this.Properties.bWithoutFilter:
|
|
return this.bWithoutFilter;
|
|
case this.Properties.displayName:
|
|
return this.displayName;
|
|
case this.Properties.val:
|
|
return this.val;
|
|
case this.Properties.ShowColumnStripes:
|
|
return this.ShowColumnStripes;
|
|
case this.Properties.ShowFirstColumn:
|
|
return this.ShowFirstColumn;
|
|
case this.Properties.ShowLastColumn:
|
|
return this.ShowLastColumn;
|
|
case this.Properties.ShowRowStripes:
|
|
return this.ShowRowStripes;
|
|
case this.Properties.HeaderRowCount:
|
|
return this.HeaderRowCount;
|
|
case this.Properties.TotalsRowCount:
|
|
return this.TotalsRowCount;
|
|
case this.Properties.color:
|
|
return this.color;
|
|
case this.Properties.tablePart: {
|
|
var tablePart = this.tablePart;
|
|
if (tablePart) {
|
|
var memory = new AscCommon.CMemory();
|
|
var wb = window["Asc"]["editor"].wb;
|
|
var initSaveManager = new AscCommonExcel.InitSaveManager(wb && wb.model);
|
|
var oBinaryTableWriter = new AscCommonExcel.BinaryTableWriter(memory, initSaveManager, false, {});
|
|
var ws = wb ? wb.getWorksheetById(nSheetId) : null;
|
|
oBinaryTableWriter.WriteTable(tablePart, ws ? ws.model : null);
|
|
tablePart = memory.GetBase64Memory();
|
|
}
|
|
|
|
return tablePart;
|
|
}
|
|
case this.Properties.nCol:
|
|
return this.nCol;
|
|
case this.Properties.nRow:
|
|
return this.nRow;
|
|
case this.Properties.formula:
|
|
return this.formula;
|
|
case this.Properties.totalFunction:
|
|
return this.totalFunction;
|
|
case this.Properties.viewId:
|
|
return this.viewId;
|
|
case this.Properties.redoColumnName:
|
|
return this.redoColumnName;
|
|
}
|
|
|
|
return null;
|
|
};
|
|
UndoRedoData_AutoFilter.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.activeCells:
|
|
this.activeCells = new Asc.Range(value.c1, value.r1, value.c2, value.r2);
|
|
break;
|
|
case this.Properties.styleName:
|
|
this.styleName = value;
|
|
break;
|
|
case this.Properties.type:
|
|
this.type = value;
|
|
break;
|
|
case this.Properties.cellId:
|
|
this.cellId = value;
|
|
break;
|
|
case this.Properties.autoFiltersObject:
|
|
this.autoFiltersObject = value;
|
|
break;
|
|
case this.Properties.addFormatTableOptionsObj:
|
|
return this.addFormatTableOptionsObj = value;
|
|
case this.Properties.moveFrom:
|
|
this.moveFrom = value;
|
|
break;
|
|
case this.Properties.moveTo:
|
|
this.moveTo = value;
|
|
break;
|
|
case this.Properties.bWithoutFilter:
|
|
this.bWithoutFilter = value;
|
|
break;
|
|
case this.Properties.displayName:
|
|
this.displayName = value;
|
|
break;
|
|
case this.Properties.val:
|
|
this.val = value;
|
|
break;
|
|
case this.Properties.ShowColumnStripes:
|
|
this.ShowColumnStripes = value;
|
|
break;
|
|
case this.Properties.ShowFirstColumn:
|
|
this.ShowFirstColumn = value;
|
|
break;
|
|
case this.Properties.ShowLastColumn:
|
|
this.ShowLastColumn = value;
|
|
break;
|
|
case this.Properties.ShowRowStripes:
|
|
this.ShowRowStripes = value;
|
|
break;
|
|
case this.Properties.HeaderRowCount:
|
|
this.HeaderRowCount = value;
|
|
break;
|
|
case this.Properties.TotalsRowCount:
|
|
this.TotalsRowCount = value;
|
|
break;
|
|
case this.Properties.color:
|
|
this.color = value;
|
|
break;
|
|
case this.Properties.tablePart: {
|
|
var table;
|
|
if (value) {
|
|
//TODO длину скорее всего нужно записывать
|
|
var dstLen = 0;
|
|
dstLen += value.length;
|
|
|
|
var pointer = g_memory.Alloc(dstLen);
|
|
var stream = new AscCommon.FT_Stream2(pointer.data, dstLen);
|
|
stream.obj = pointer.obj;
|
|
|
|
var nCurOffset = 0;
|
|
var oBinaryFileReader = new AscCommonExcel.BinaryFileReader();
|
|
nCurOffset = oBinaryFileReader.getbase64DecodedData2(value, 0, stream, nCurOffset);
|
|
|
|
var initOpenManager = new AscCommonExcel.InitOpenManager();
|
|
var oBinaryTableReader = new AscCommonExcel.Binary_TableReader(stream, initOpenManager);
|
|
oBinaryTableReader.stream = stream;
|
|
oBinaryTableReader.oReadResult = {
|
|
tableCustomFunc: []
|
|
};
|
|
|
|
table = new AscCommonExcel.TablePart();
|
|
var res = oBinaryTableReader.bcr.Read1(dstLen, function (t, l) {
|
|
return oBinaryTableReader.ReadTable(t, l, table);
|
|
});
|
|
}
|
|
|
|
if (table) {
|
|
this.tablePart = table;
|
|
}
|
|
break;
|
|
}
|
|
case this.Properties.nCol:
|
|
this.nCol = value;
|
|
break;
|
|
case this.Properties.nRow:
|
|
this.nRow = value;
|
|
break;
|
|
case this.Properties.formula:
|
|
this.formula = value;
|
|
break;
|
|
case this.Properties.totalFunction:
|
|
this.totalFunction = value;
|
|
break;
|
|
case this.Properties.viewId:
|
|
this.viewId = value;
|
|
break;
|
|
case this.Properties.redoColumnName:
|
|
this.redoColumnName = value;
|
|
break;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_AutoFilter.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
let res = false;
|
|
let r1old = this.activeCells.r1;
|
|
let r2old = this.activeCells.r2;
|
|
let c1old = this.activeCells.c1;
|
|
let c2old = this.activeCells.c2;
|
|
this.activeCells.c1 = collaborativeEditing.getLockMeColumn2(nSheetId, this.activeCells.c1);
|
|
this.activeCells.c2 = collaborativeEditing.getLockMeColumn2(nSheetId, this.activeCells.c2);
|
|
this.activeCells.r1 = collaborativeEditing.getLockMeRow2(nSheetId, this.activeCells.r1);
|
|
this.activeCells.r2 = collaborativeEditing.getLockMeRow2(nSheetId, this.activeCells.r2);
|
|
res = this.activeCells.r1 !== r1old || this.activeCells.r2 !== r2old || this.activeCells.c1 !== c1old || this.activeCells.c2 !== c2old;
|
|
|
|
if (this.autoFiltersObject && this.autoFiltersObject.cellId !== undefined) {
|
|
var curCellId = this.autoFiltersObject.cellId.split('af')[0];
|
|
var range;
|
|
AscCommonExcel.executeInR1C1Mode(false, function () {
|
|
range = AscCommonExcel.g_oRangeCache.getAscRange(curCellId).clone();
|
|
});
|
|
let nRowOld = range.r1;
|
|
let nColOld = range.c1;
|
|
var nRow = collaborativeEditing.getLockMeRow2(nSheetId, range.r1);
|
|
var nCol = collaborativeEditing.getLockMeColumn2(nSheetId, range.c1);
|
|
res = res || range.r1 !== nRowOld || range.c1 !== nColOld;
|
|
|
|
this.autoFiltersObject.cellId = new AscCommon.CellBase(nRow, nCol).getName();
|
|
}
|
|
return res;
|
|
};
|
|
|
|
//***array-formula***
|
|
function UndoRedoData_ArrayFormula(range, formula) {
|
|
this.range = range;
|
|
this.formula = formula;
|
|
}
|
|
|
|
UndoRedoData_ArrayFormula.prototype.Properties = {
|
|
range: 0,
|
|
formula: 1
|
|
};
|
|
UndoRedoData_ArrayFormula.prototype.getType = function () {
|
|
return UndoRedoDataTypes.ArrayFormula;
|
|
};
|
|
UndoRedoData_ArrayFormula.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_ArrayFormula.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.range:
|
|
return new UndoRedoData_BBox(this.range);
|
|
case this.Properties.formula:
|
|
return this.formula;
|
|
}
|
|
|
|
return null;
|
|
};
|
|
UndoRedoData_ArrayFormula.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.range:
|
|
this.range = new Asc.Range(value.c1, value.r1, value.c2, value.r2);
|
|
break;
|
|
case this.Properties.formula:
|
|
this.formula = value;
|
|
break;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
|
|
function UndoRedoData_SingleProperty(elem) {
|
|
this.elem = elem;
|
|
}
|
|
|
|
UndoRedoData_SingleProperty.prototype.Properties = {
|
|
elem: 0
|
|
};
|
|
UndoRedoData_SingleProperty.prototype.getType = function () {
|
|
return UndoRedoDataTypes.SingleProperty;
|
|
};
|
|
UndoRedoData_SingleProperty.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_SingleProperty.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.elem:
|
|
return this.elem;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_SingleProperty.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.elem:
|
|
this.elem = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_SortState(from, to, bFilter, tableName) {
|
|
this.from = from;
|
|
this.to = to;
|
|
this.bFilter = bFilter;
|
|
this.tableName = tableName;
|
|
}
|
|
UndoRedoData_SortState.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_SortState(this.to, this.from, this.bFilter, this.tableName);
|
|
}
|
|
UndoRedoData_SortState.prototype.Properties = {
|
|
from: 0, to: 1, bFilter: 2, tableName: 3
|
|
};
|
|
UndoRedoData_SortState.prototype.getType = function () {
|
|
return UndoRedoDataTypes.SortStateData;
|
|
};
|
|
UndoRedoData_SortState.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_SortState.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
case this.Properties.bFilter:
|
|
return this.bFilter;
|
|
case this.Properties.tableName:
|
|
return this.tableName;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_SortState.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
case this.Properties.bFilter:
|
|
this.bFilter = value;
|
|
break;
|
|
case this.Properties.tableName:
|
|
this.tableName = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_Slicer(name, from, to) {
|
|
this.name = name;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_Slicer.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_Slicer(this.to, this.from);
|
|
}
|
|
UndoRedoData_Slicer.prototype.Properties = {
|
|
name: 0, from: 1, to: 2
|
|
};
|
|
UndoRedoData_Slicer.prototype.getType = function () {
|
|
return UndoRedoDataTypes.SlicerData;
|
|
};
|
|
UndoRedoData_Slicer.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_Slicer.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.name:
|
|
return this.name;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_Slicer.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.name:
|
|
this.name = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_DataValidation(id, from, to) {
|
|
this.id = id;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_DataValidation.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_DataValidation(this.id, this.to, this.from);
|
|
}
|
|
UndoRedoData_DataValidation.prototype.Properties = {
|
|
id: 0, to: 2
|
|
};
|
|
UndoRedoData_DataValidation.prototype.getType = function () {
|
|
return UndoRedoDataTypes.DataValidation;
|
|
};
|
|
UndoRedoData_DataValidation.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_DataValidation.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
return this.id;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_DataValidation.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
case this.Properties.id:
|
|
this.id = value;
|
|
break;
|
|
}
|
|
};
|
|
UndoRedoData_DataValidation.prototype.applyCollaborative = function (nSheetId, collaborativeEditing) {
|
|
if (this.to) {
|
|
for (var i = 0; i < this.to.ranges.length; i++) {
|
|
var range = this.to.ranges[i];
|
|
range.r1 = collaborativeEditing.getLockMeRow2(nSheetId, range.r1);
|
|
range.r2 = collaborativeEditing.getLockMeRow2(nSheetId, range.r2);
|
|
range.c1 = collaborativeEditing.getLockMeColumn2(nSheetId, range.c1);
|
|
range.c2 = collaborativeEditing.getLockMeColumn2(nSheetId, range.c2);
|
|
}
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_CF(id, from, to) {
|
|
this.id = id;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_CF.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_CF(this.id, this.to, this.from);
|
|
}
|
|
UndoRedoData_CF.prototype.Properties = {
|
|
id: 0, to: 2
|
|
};
|
|
UndoRedoData_CF.prototype.getType = function () {
|
|
return UndoRedoDataTypes.CFData;
|
|
};
|
|
UndoRedoData_CF.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_CF.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
return this.id;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_CF.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
this.id = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_ProtectedRange(id, from, to) {
|
|
this.id = id;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_ProtectedRange.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_ProtectedRange(this.id, this.to, this.from);
|
|
}
|
|
UndoRedoData_ProtectedRange.prototype.Properties = {
|
|
id: 0, to: 2
|
|
};
|
|
UndoRedoData_ProtectedRange.prototype.getType = function () {
|
|
return UndoRedoDataTypes.ProtectedRangeData;
|
|
};
|
|
UndoRedoData_ProtectedRange.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_ProtectedRange.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
return this.id;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_ProtectedRange.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
this.id = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_NamedSheetView(sheetView, from, to) {
|
|
this.sheetView = sheetView;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_NamedSheetView.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_NamedSheetView(this.sheetView, this.to, this.from);
|
|
}
|
|
UndoRedoData_NamedSheetView.prototype.Properties = {
|
|
sheetView: 0, from: 1, to: 2
|
|
};
|
|
UndoRedoData_NamedSheetView.prototype.getType = function () {
|
|
return window['AscCommonExcel'].UndoRedoDataTypes.NamedSheetViewChange;
|
|
};
|
|
UndoRedoData_NamedSheetView.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_NamedSheetView.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.sheetView:
|
|
return this.sheetView;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_NamedSheetView.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.sheetView:
|
|
this.sheetView = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_NamedSheetViewRedo(sheetView, from, to) {
|
|
this.sheetView = sheetView;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
|
|
UndoRedoData_NamedSheetViewRedo.prototype = Object.create(UndoRedoData_NamedSheetView.prototype);
|
|
UndoRedoData_NamedSheetViewRedo.prototype.Properties = {
|
|
sheetView: 0, to: 2
|
|
};
|
|
|
|
function UndoRedoData_UserProtectedRange(id, from, to) {
|
|
this.id = id;
|
|
this.from = from;
|
|
this.to = to;
|
|
}
|
|
UndoRedoData_UserProtectedRange.prototype.CreateReverseChangeSpreadsheet = function () {
|
|
return new UndoRedoData_UserProtectedRange(this.id, this.to, this.from);
|
|
}
|
|
UndoRedoData_UserProtectedRange.prototype.Properties = {
|
|
id: 0, from: 1, to: 2
|
|
};
|
|
UndoRedoData_UserProtectedRange.prototype.getType = function () {
|
|
return UndoRedoDataTypes.UserProtectedRangeChange;
|
|
};
|
|
UndoRedoData_UserProtectedRange.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_UserProtectedRange.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
return this.id;
|
|
case this.Properties.from:
|
|
return this.from;
|
|
case this.Properties.to:
|
|
return this.to;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_UserProtectedRange.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
this.id = value;
|
|
break;
|
|
case this.Properties.from:
|
|
this.from = value;
|
|
break;
|
|
case this.Properties.to:
|
|
this.to = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_RowColBreaks(id, min, max, man, pt, byCol) {
|
|
this.id = id;
|
|
this.min = min;
|
|
this.max = max;
|
|
this.man = man;
|
|
this.pt = pt;
|
|
this.byCol = byCol;
|
|
}
|
|
|
|
UndoRedoData_RowColBreaks.prototype.Properties = {
|
|
id: 0, min: 1, max: 2, man: 3, pt: 4, byCol: 5
|
|
};
|
|
UndoRedoData_RowColBreaks.prototype.getType = function () {
|
|
return UndoRedoDataTypes.RowColBreaks;
|
|
};
|
|
UndoRedoData_RowColBreaks.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_RowColBreaks.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
return this.id;
|
|
case this.Properties.min:
|
|
return this.min;
|
|
case this.Properties.max:
|
|
return this.max;
|
|
case this.Properties.man:
|
|
return this.man;
|
|
case this.Properties.pt:
|
|
return this.pt;
|
|
case this.Properties.byCol:
|
|
return this.byCol;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_RowColBreaks.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
this.id = value;
|
|
break;
|
|
case this.Properties.min:
|
|
this.min = value;
|
|
break;
|
|
case this.Properties.max:
|
|
this.max = value;
|
|
break;
|
|
case this.Properties.man:
|
|
this.man = value;
|
|
break;
|
|
case this.Properties.pt:
|
|
this.pt = value;
|
|
break;
|
|
case this.Properties.byCol:
|
|
this.byCol = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoData_LegacyDrawingHFDrawing(id, graphicId) {
|
|
this.id = id;
|
|
this.graphicId = graphicId;
|
|
}
|
|
|
|
UndoRedoData_LegacyDrawingHFDrawing.prototype.Properties = {
|
|
id: 0, graphicId: 1
|
|
};
|
|
UndoRedoData_LegacyDrawingHFDrawing.prototype.getType = function () {
|
|
return UndoRedoDataTypes.LegacyDrawingHFDrawing;
|
|
};
|
|
UndoRedoData_LegacyDrawingHFDrawing.prototype.getProperties = function () {
|
|
return this.Properties;
|
|
};
|
|
UndoRedoData_LegacyDrawingHFDrawing.prototype.getProperty = function (nType) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
return this.id;
|
|
case this.Properties.graphicId:
|
|
return this.graphicId;
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoData_LegacyDrawingHFDrawing.prototype.setProperty = function (nType, value) {
|
|
switch (nType) {
|
|
case this.Properties.id:
|
|
this.id = value;
|
|
break;
|
|
case this.Properties.graphicId:
|
|
this.graphicId = value;
|
|
break;
|
|
}
|
|
};
|
|
|
|
//для применения изменений
|
|
var UndoRedoClassTypes = new function () {
|
|
this.aTypes = [];
|
|
this.offset = 0;
|
|
this.Add = function (fCreate) {
|
|
var nRes = this.aTypes.length;
|
|
this.aTypes.push(fCreate);
|
|
return nRes + this.offset;
|
|
};
|
|
this.Create = function (nType) {
|
|
const nTypeIndex = nType - this.offset;
|
|
if (0 <= nTypeIndex && nTypeIndex < this.aTypes.length) {
|
|
return this.aTypes[nTypeIndex]();
|
|
}
|
|
return null;
|
|
};
|
|
this.SetOffset = function (offset) {
|
|
this.offset = offset || 0;
|
|
};
|
|
this.Clean = function () {
|
|
this.aTypes = [];
|
|
};
|
|
};
|
|
|
|
function UndoRedoClassBase() {
|
|
}
|
|
UndoRedoClassBase.prototype.Get_Id = function () {
|
|
//for CCollaborativeHistory.prototype.UndoOwnPoint
|
|
};
|
|
UndoRedoClassBase.prototype.IsNeedRecalculate = function () {
|
|
//for CHistory.prototype.Add
|
|
return false;
|
|
};
|
|
UndoRedoClassBase.prototype.IsNeedRecalculateLineNumbers = function () {
|
|
//for CHistory.prototype.Add
|
|
return false;
|
|
};
|
|
UndoRedoClassBase.prototype.GetClass = function () {
|
|
//for CChangesBaseContentChange.prototype.IsRelated
|
|
return undefined;
|
|
};
|
|
|
|
function UndoRedoWorkbook(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoWorkbook;
|
|
});
|
|
}
|
|
UndoRedoWorkbook.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoWorkbook.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoWorkbook.prototype.IsContentChangeSpreadsheet = function (Type) {
|
|
return AscCH.historyitem_Workbook_SheetAdd === Type || AscCH.historyitem_Workbook_SheetRemove === Type;
|
|
};
|
|
UndoRedoWorkbook.prototype.IsRelatedSpreadsheet = function (oChanges, Type) {
|
|
return this === oChanges && oChanges.IsContentChangeSpreadsheet(Type);
|
|
};
|
|
UndoRedoWorkbook.prototype.ConvertToSimpleActionsSpreadsheet = function(Type, Data)
|
|
{
|
|
let isAdd = AscCH.historyitem_Workbook_SheetAdd === Type;
|
|
let index = isAdd ? Data.insertBefore : Data.index;
|
|
return [{
|
|
Item : this,
|
|
Pos : index,
|
|
Add : isAdd
|
|
}];
|
|
};
|
|
UndoRedoWorkbook.prototype.ConvertToSimpleChangesSpreadsheet = function(SerializableItem)
|
|
{
|
|
const oItem = new UndoRedoItemSerializable(SerializableItem.oClass, SerializableItem.nActionType, SerializableItem.nSheetId, SerializableItem.oRange, SerializableItem.oData, SerializableItem.LocalChange);
|
|
return [oItem];
|
|
};
|
|
UndoRedoWorkbook.prototype.ConvertFromSimpleActionsSpreadsheet = function(arrActions, Data)
|
|
{
|
|
let action = arrActions[0];
|
|
if (action) {
|
|
if (action.Add) {
|
|
Data.insertBefore = action.Pos;
|
|
} else {
|
|
Data.index = action.Pos;
|
|
}
|
|
}
|
|
};
|
|
UndoRedoWorkbook.prototype.CreateReverseChangeSpreadsheet = function (ToClass, Type, nSheetId, oRange, Data, LocalChange) {
|
|
if (AscCH.historyitem_Workbook_SheetAdd === Type) {
|
|
Type = AscCH.historyitem_Workbook_SheetRemove;
|
|
Data = new AscCommonExcel.UndoRedoData_SheetRemove(Data.insertBefore, Data.sheetid, Data.opt_sheet);
|
|
} else if (AscCH.historyitem_Workbook_SheetRemove === Type) {
|
|
Type = AscCH.historyitem_Workbook_SheetAdd;
|
|
let ws = AscCommon.g_oTableId.Get_ById(Data.sheetId);
|
|
if (ws) {
|
|
Data = new UndoRedoData_SheetAdd(Data.index, ws.getName(), null, Data.sheetId, null, null, Data.sheetId);
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
return new UndoRedoItemSerializable(ToClass, Type, nSheetId, oRange, Data, LocalChange);
|
|
};
|
|
UndoRedoWorkbook.prototype.CommuteRelatedRemoveSheet = function (sheetId, oActionOther) {
|
|
return !(AscCH.historyitem_Workbook_SheetRemove === oActionOther.nActionType && oActionOther.oData && sheetId === oActionOther.oData.sheetId);
|
|
}
|
|
UndoRedoWorkbook.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
return true;
|
|
}
|
|
UndoRedoWorkbook.prototype.Undo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, true, opt_wb);
|
|
};
|
|
UndoRedoWorkbook.prototype.Redo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, false, opt_wb);
|
|
};
|
|
UndoRedoWorkbook.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo, opt_wb) {
|
|
var wb = opt_wb ? opt_wb : this.wb;
|
|
var bNeedTrigger = true;
|
|
if (AscCH.historyitem_Workbook_SheetAdd == Type) {
|
|
if (null == Data.insertBefore) {
|
|
Data.insertBefore = 0;
|
|
}
|
|
if (bUndo) {
|
|
var outputParams = {sheet: null};
|
|
wb.removeWorksheet(Data.insertBefore, outputParams);
|
|
//сохраняем тот sheet который удалили, иначе может возникнуть ошибка, если какой-то обьект запоминал ссылку на sheet(например):
|
|
//Добавляем лист -> Добавляем ссылку -> undo -> undo -> redo -> redo
|
|
Data.sheet = outputParams.sheet;
|
|
} else {
|
|
if (Data.opt_sheet) {
|
|
|
|
/*var api = window["Asc"]["editor"];
|
|
api.wb.pasteSheet(Data.opt_sheet, 0, Data.name);
|
|
api.asc_EndMoveSheet2(Data.opt_sheet, 0, Data.name);*/
|
|
|
|
var tempWorkbook = new AscCommonExcel.Workbook(undefined, undefined, false);
|
|
tempWorkbook.DrawingDocument = Asc.editor.wbModel.DrawingDocument;
|
|
tempWorkbook.setCommonIndexObjectsFrom(wb);
|
|
AscCommonExcel.g_clipboardExcel.pasteProcessor._readExcelBinary(Data.opt_sheet.split('xslData;')[1], tempWorkbook, true);
|
|
|
|
/*var api = window["Asc"]["editor"];
|
|
//api.wb.pasteSheet(Data.opt_sheet, 0, Data.name);
|
|
api.asc_EndMoveSheet(Data.insertBefore, [Data.name], [Data.opt_sheet]);*/
|
|
|
|
wb.copyWorksheet(0, Data.insertBefore, Data.name, Data.sheetid, true, Data.tableNames, tempWorkbook.aWorksheets[0]);
|
|
|
|
//var renameParams = t.model.copyWorksheet(0, insertBefore, name, undefined, undefined, undefined, pastedWs);
|
|
|
|
//wb.copyWorksheet(0, Data.insertBefore, Data.name, Data.sheetid, true, Data.tableNames, tempWorkbook.aWorksheets[0]);
|
|
} else if (null != Data.sheet) {
|
|
//сюда заходим только если до этого было сделано Undo
|
|
wb.insertWorksheet(Data.insertBefore, Data.sheet);
|
|
} else if (null != Data.opt_sheetidToAdd) {
|
|
let ws = AscCommon.g_oTableId.Get_ById(Data.opt_sheetidToAdd);
|
|
if (ws) {
|
|
wb.insertWorksheet(Data.insertBefore, ws);
|
|
}
|
|
} else {
|
|
if (null == Data.sheetidfrom) {
|
|
wb.createWorksheet(Data.insertBefore, Data.name, Data.sheetid);
|
|
} else {
|
|
var oCurWorksheet = wb.getWorksheetById(Data.sheetidfrom);
|
|
var nIndex = oCurWorksheet.getIndex();
|
|
wb.copyWorksheet(nIndex, Data.insertBefore, Data.name, Data.sheetid, true, Data.tableNames);
|
|
}
|
|
}
|
|
}
|
|
wb.handlers.trigger("updateWorksheetByModel");
|
|
wb.handlers.trigger("changeCellWatches");
|
|
} else if (AscCH.historyitem_Workbook_SheetRemove == Type) {
|
|
if (bUndo) {
|
|
wb.insertWorksheet(Data.index, Data.sheet);
|
|
} else {
|
|
var nIndex = Data.index;
|
|
if (null == nIndex) {
|
|
var oCurWorksheet = wb.getWorksheetById(Data.sheetId);
|
|
if (oCurWorksheet) {
|
|
nIndex = oCurWorksheet.getIndex();
|
|
}
|
|
}
|
|
if (null != nIndex) {
|
|
wb.removeWorksheet(nIndex);
|
|
}
|
|
}
|
|
wb.handlers.trigger("updateWorksheetByModel");
|
|
wb.handlers.trigger("changeCellWatches");
|
|
} else if (AscCH.historyitem_Workbook_DefinedNamesChange === Type ||
|
|
AscCH.historyitem_Workbook_DefinedNamesChangeUndo === Type) {
|
|
var oldName, newName;
|
|
if (bUndo) {
|
|
oldName = Data.to;
|
|
newName = Data.from;
|
|
} else {
|
|
if (wb.bCollaborativeChanges) {
|
|
wb.handlers.trigger("asc_onLockDefNameManager", Asc.c_oAscDefinedNameReason.OK);
|
|
}
|
|
oldName = Data.from;
|
|
newName = Data.to;
|
|
}
|
|
if (bUndo || AscCH.historyitem_Workbook_DefinedNamesChangeUndo !== Type) {
|
|
if (null == newName) {
|
|
wb.delDefinesNamesUndoRedo(oldName);
|
|
wb.handlers.trigger("asc_onDelDefName")
|
|
} else {
|
|
wb.editDefinesNamesUndoRedo(oldName, newName, true);
|
|
wb.handlers.trigger("asc_onEditDefName", oldName, newName);
|
|
}
|
|
// clear traces
|
|
wb.oApi.asc_RemoveTraceArrows(Asc.c_oAscRemoveArrowsType.all);
|
|
}
|
|
} else if (AscCH.historyitem_Workbook_Calculate === Type) {
|
|
if (!bUndo && wb.bCollaborativeChanges) {
|
|
wb.calculate(Data.elem, nSheetId);
|
|
}
|
|
} else if (bUndo && AscCH.historyitem_Workbook_PivotWorksheetSource === Type) {
|
|
var wrapper = bUndo ? Data.from : Data.to;
|
|
var worksheetSource = AscCommon.g_oTableId.Get_ById(wrapper.Id);
|
|
if (worksheetSource) {
|
|
wrapper.readData(worksheetSource);
|
|
worksheetSource.fromWorksheetSource(worksheetSource, true);
|
|
}
|
|
} else if (AscCH.historyitem_Workbook_Date1904 === Type) {
|
|
wb.setDate1904(bUndo ? Data.from : Data.to);
|
|
AscCommon.oNumFormatCache.cleanCache();
|
|
} else if (AscCH.historyitem_Workbook_ChangeExternalReference === Type) {
|
|
var from = bUndo ? Data.from : Data.to;
|
|
var to = bUndo ? Data.to : Data.from;
|
|
var externalReferenceIndex;
|
|
|
|
if (from && !to) {//удаление
|
|
from.initExternalReference();
|
|
/* the first call is a search by referenceData, if we get null, we make a second call to search by Id below and then add or re-assign the link */
|
|
externalReferenceIndex = wb.getExternalReferenceByReferenceData(from.referenceData, true);
|
|
if (!externalReferenceIndex) {
|
|
externalReferenceIndex = wb.getExternalLinkIndexById(from._id);
|
|
}
|
|
|
|
if (externalReferenceIndex !== null) {
|
|
wb.externalReferences[externalReferenceIndex - 1] = from;
|
|
} else {
|
|
wb.externalReferences.push(from);
|
|
}
|
|
} else if (!from && to) { //добавление
|
|
/* the first call is a search by referenceData, if we get null, we make a second call to search by Id below and then delete the link */
|
|
externalReferenceIndex = wb.getExternalReferenceByReferenceData(to.referenceData, true);
|
|
if (!externalReferenceIndex) {
|
|
externalReferenceIndex = wb.getExternalLinkIndexById(to._id);
|
|
}
|
|
|
|
if (externalReferenceIndex !== null) {
|
|
wb._removeExternalReference(externalReferenceIndex - 1);
|
|
}
|
|
} else if (from && to) { //изменение
|
|
//TODO нужно сохранить ссылки на текущий лист
|
|
/* the first call is a search by referenceData, if we get null, we make a second call to search by Id below and then change the link */
|
|
externalReferenceIndex = wb.getExternalReferenceByReferenceData(to.referenceData, true);
|
|
if (!externalReferenceIndex) {
|
|
externalReferenceIndex = wb.getExternalLinkIndexById(to._id);
|
|
}
|
|
|
|
if (externalReferenceIndex !== null) {
|
|
for (let ws in to.worksheets) {
|
|
let externalSheet = to.worksheets[ws];
|
|
if (externalSheet) {
|
|
let externalSheetId = externalSheet.getId();
|
|
wb.dependencyFormulas.forEachSheetListeners(externalSheetId, function (parsed) {
|
|
let cell = parsed && parsed.parent;
|
|
if (cell && cell && cell.nCol != null && cell.nRow != null) {
|
|
// endListeningRange for previous external source
|
|
let bbox = new Asc.Range(cell.nCol, cell.nRow, cell.nCol, cell.nRow);
|
|
parsed._buildDependenciesRef(externalSheetId, bbox, null, null);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
from.worksheets = wb.externalReferences[externalReferenceIndex - 1].worksheets;
|
|
from.initExternalReference();
|
|
from.putToChangedCells();
|
|
wb.externalReferences[externalReferenceIndex - 1] = from;
|
|
}
|
|
}
|
|
wb.handlers.trigger("asc_onUpdateExternalReferenceList");
|
|
} else if (AscCH.historyitem_Workbook_TimelineCacheDelete === Type) {
|
|
if (bUndo) {
|
|
wb.timelineCaches.push(Data.from);
|
|
} else {
|
|
wb.onTimelineCacheDelete(Data.from.name);
|
|
}
|
|
} else if (AscCH.historyitem_Workbook_CalcPr_iterate === Type) {
|
|
wb.calcPr.setIterate(bUndo ? Data.from : Data.to);
|
|
AscCommonExcel.g_cCalcRecursion.initCalcProperties(wb.calcPr);
|
|
} else if (AscCH.historyitem_Workbook_CalcPr_iterateCount === Type) {
|
|
wb.calcPr.setIterateCount(bUndo ? Data.from : Data.to);
|
|
AscCommonExcel.g_cCalcRecursion.initCalcProperties(wb.calcPr);
|
|
} else if (AscCH.historyitem_Workbook_CalcPr_iterateDelta === Type) {
|
|
wb.calcPr.setIterateDelta(bUndo ? Data.from : Data.to);
|
|
AscCommonExcel.g_cCalcRecursion.initCalcProperties(wb.calcPr);
|
|
|
|
} else if(AscCH.historyitem_Workbook_UpdateLinks === Type) {
|
|
wb.setUpdateLinks(bUndo ? Data.from : Data.to, null, null, !wb.oApi.isDocumentLoadComplete && wb.bCollaborativeChanges);
|
|
} else if (AscCH.historyitem_Workbook_ShowVerticalScroll === Type) {
|
|
wb.setShowVerticalScroll(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Workbook_ShowHorizontalScroll === Type) {
|
|
wb.setShowHorizontalScroll(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Workbook_SetCustomFunctions === Type) {
|
|
wb.oApi["pluginMethod_SetCustomFunctions"] && wb.oApi["pluginMethod_SetCustomFunctions"](bUndo ? Data.from : Data.to);
|
|
}
|
|
};
|
|
UndoRedoWorkbook.prototype.forwardTransformationIsAffect = function (Type) {
|
|
//todo parserFormula.prototype.processNotify
|
|
return AscCH.historyitem_Workbook_SheetAdd === Type || AscCH.historyitem_Workbook_SheetRemove === Type ||
|
|
AscCH.historyitem_Workbook_DefinedNamesChange === Type;
|
|
};
|
|
UndoRedoWorkbook.prototype.forwardTransformationGet = function (Type, Data, nSheetId) {
|
|
if (AscCH.historyitem_Workbook_DefinedNamesChange === Type) {
|
|
if (Data.newName && Data.newName.Ref) {
|
|
return {formula: Data.newName.Ref};
|
|
} else if (Data.to && Data.to.ref) {
|
|
return {formula: Data.to.ref};
|
|
}
|
|
} else if (AscCH.historyitem_Workbook_SheetAdd === Type) {
|
|
return {name: Data.name};
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoWorkbook.prototype.forwardTransformationSet = function (Type, Data, nSheetId, getRes) {
|
|
if (AscCH.historyitem_Workbook_SheetAdd === Type) {
|
|
Data.name = getRes.name;
|
|
} else if (AscCH.historyitem_Cell_ChangeValue === Type) {
|
|
if (Data && Data.newName) {
|
|
Data.newName.Ref = getRes.formula;
|
|
}
|
|
} else if (AscCH.historyitem_Workbook_DefinedNamesChange === Type) {
|
|
if (Data.to && Data.to.ref) {
|
|
Data.to.ref = getRes.formula;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
function UndoRedoCell(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoCell;
|
|
});
|
|
}
|
|
UndoRedoCell.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoCell.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoCell.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoCell.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoCell.prototype.CreateReverseChangeSpreadsheet = function (ToClass, nActionType, nSheetId, oRange, oData, LocalChange) {
|
|
oData = oData.CreateReverseChangeSpreadsheet();
|
|
return new UndoRedoItemSerializable(ToClass, nActionType, nSheetId, oRange, oData, LocalChange, null)
|
|
};
|
|
UndoRedoCell.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
if (AscCH.historyitem_Unknown === oActionToUndo.nActionType) {
|
|
//CChangesPointChange
|
|
oActionToUndo.oData.CommuteRelated(oActionToUndo, oActionOther);
|
|
return true;
|
|
}
|
|
return AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedCell(oActionToUndo.oData, oActionOther);
|
|
};
|
|
UndoRedoCell.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
let ws = this.wb.getWorksheetById(nSheetId), t = this;
|
|
if (null == ws) {
|
|
return;
|
|
}
|
|
var nRow = Data.nRow;
|
|
var nCol = Data.nCol;
|
|
if (this.wb.bCollaborativeChanges) {
|
|
var collaborativeEditing = this.wb.oApi.collaborativeEditing;
|
|
nRow = collaborativeEditing.getLockOtherRow2(nSheetId, nRow);
|
|
nCol = collaborativeEditing.getLockOtherColumn2(nSheetId, nCol);
|
|
var oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(nCol, nRow, nCol, nRow);
|
|
this.wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
ws._getCell(nRow, nCol, function (cell) {
|
|
var Val = bUndo ? Data.oOldVal : Data.oNewVal;
|
|
if (AscCH.historyitem_Cell_Fontname == Type) {
|
|
cell.setFontname(Val);
|
|
} else if (AscCH.historyitem_Cell_Fontsize == Type) {
|
|
cell.setFontsize(Val);
|
|
} else if (AscCH.historyitem_Cell_Fontcolor == Type) {
|
|
cell.setFontcolor(Val);
|
|
} else if (AscCH.historyitem_Cell_Bold == Type) {
|
|
cell.setBold(Val);
|
|
} else if (AscCH.historyitem_Cell_Italic == Type) {
|
|
cell.setItalic(Val);
|
|
} else if (AscCH.historyitem_Cell_Underline == Type) {
|
|
cell.setUnderline(Val);
|
|
} else if (AscCH.historyitem_Cell_Strikeout == Type) {
|
|
cell.setStrikeout(Val);
|
|
} else if (AscCH.historyitem_Cell_FontAlign == Type) {
|
|
cell.setFontAlign(Val);
|
|
} else if (AscCH.historyitem_Cell_AlignVertical == Type) {
|
|
cell.setAlignVertical(Val);
|
|
} else if (AscCH.historyitem_Cell_AlignHorizontal == Type) {
|
|
cell.setAlignHorizontal(Val);
|
|
} else if (AscCH.historyitem_Cell_ReadingOrder == Type) {
|
|
cell.setReadingOrder(Val);
|
|
} else if (AscCH.historyitem_Cell_Fill == Type) {
|
|
cell.setFill(Val);
|
|
} else if (AscCH.historyitem_Cell_Border == Type) {
|
|
if (null != Val) {
|
|
cell.setBorder(Val.clone());
|
|
} else {
|
|
cell.setBorder(null);
|
|
}
|
|
} else if (AscCH.historyitem_Cell_ShrinkToFit == Type) {
|
|
cell.setShrinkToFit(Val);
|
|
} else if (AscCH.historyitem_Cell_Wrap == Type) {
|
|
cell.setWrap(Val);
|
|
} else if (AscCH.historyitem_Cell_Num == Type) {
|
|
cell.setNum(Val);
|
|
} else if (AscCH.historyitem_Cell_Angle == Type) {
|
|
cell.setAngle(Val);
|
|
} else if (AscCH.historyitem_Cell_Indent == Type) {
|
|
cell.setIndent(Val);
|
|
} else if (AscCH.historyitem_Cell_ChangeArrayValueFormat == Type) {
|
|
var multiText = [];
|
|
for (var i = 0, length = Val.length; i < length; ++i) {
|
|
multiText.push(Val[i].clone());
|
|
}
|
|
cell.setValueMultiTextInternal(multiText);
|
|
} else if (AscCH.historyitem_Cell_ChangeValue === Type || AscCH.historyitem_Cell_ChangeValueUndo === Type) {
|
|
if (bUndo || AscCH.historyitem_Cell_ChangeValueUndo !== Type) {
|
|
cell.setValueData(Val);
|
|
}
|
|
} else if (AscCH.historyitem_Cell_SetStyle == Type) {
|
|
if (null != Val) {
|
|
cell.setStyle(Val);
|
|
} else {
|
|
cell.setStyle(null);
|
|
}
|
|
} else if (AscCH.historyitem_Cell_SetFont == Type) {
|
|
cell.setFont(Val);
|
|
} else if (AscCH.historyitem_Cell_SetQuotePrefix == Type) {
|
|
cell.setQuotePrefix(Val);
|
|
} else if (AscCH.historyitem_Cell_SetPivotButton == Type) {
|
|
cell.setPivotButton(Val);
|
|
} else if (AscCH.historyitem_Cell_Style == Type) {
|
|
cell.setCellStyle(Val);
|
|
} else if (AscCH.historyitem_Cell_RemoveSharedFormula == Type) {
|
|
if (null !== Val && bUndo) {
|
|
var parsed = ws.workbook.workbookFormulas.get(Val);
|
|
if (parsed) {
|
|
cell.setFormulaParsed(parsed);
|
|
}
|
|
}
|
|
} else if (AscCH.historyitem_Cell_SetApplyProtection == Type) {
|
|
cell.setApplyProtection(Val);
|
|
} else if (AscCH.historyitem_Cell_SetLocked == Type) {
|
|
cell.setLocked(Val);
|
|
} else if (AscCH.historyitem_Cell_SetHidden == Type) {
|
|
cell.setHiddenFormulas(Val);
|
|
}
|
|
});
|
|
};
|
|
UndoRedoCell.prototype.forwardTransformationGet = function (Type, Data, nSheetId) {
|
|
if (AscCH.historyitem_Cell_ChangeValue === Type && Data.oNewVal && Data.oNewVal.formula) {
|
|
return {formula: Data.oNewVal.formula};
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoCell.prototype.forwardTransformationSet = function (Type, Data, nSheetId, getRes) {
|
|
if (AscCH.historyitem_Cell_ChangeValue === Type) {
|
|
if (Data && Data.oNewVal) {
|
|
Data.oNewVal.formula = getRes.formula;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
function UndoRedoWoorksheet(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoWorksheet;
|
|
});
|
|
|
|
this.tmpCell = new AscCommon.CellBase(0, 0);
|
|
this.tmpRange = new Asc.Range(0,0,0,0);
|
|
}
|
|
UndoRedoWoorksheet.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoWoorksheet.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoWoorksheet.prototype.CreateReverseChangeSpreadsheet = function (ToClass, Type, nSheetId, oRange, Data, LocalChange) {
|
|
if (AscCH.historyitem_Worksheet_RemoveCell === Type || AscCH.historyitem_Worksheet_ColProp === Type ||
|
|
AscCH.historyitem_Worksheet_RowProp === Type) {
|
|
Data = Data.CreateReverseChangeSpreadsheet();
|
|
} else if (AscCH.historyitem_Worksheet_RowHide === Type) {
|
|
Data = Data.CreateReverseChangeSpreadsheet();
|
|
} else if (AscCH.historyitem_Worksheet_AddRows === Type) {
|
|
Type = AscCH.historyitem_Worksheet_RemoveRows;
|
|
} else if (AscCH.historyitem_Worksheet_RemoveRows === Type) {
|
|
Type = AscCH.historyitem_Worksheet_AddRows;
|
|
} else if (AscCH.historyitem_Worksheet_AddCols === Type) {
|
|
Type = AscCH.historyitem_Worksheet_RemoveCols;
|
|
} else if (AscCH.historyitem_Worksheet_RemoveCols === Type) {
|
|
Type = AscCH.historyitem_Worksheet_AddCols;
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsLeft === Type) {
|
|
Type = AscCH.historyitem_Worksheet_ShiftCellsRight;
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsRight === Type) {
|
|
Type = AscCH.historyitem_Worksheet_ShiftCellsLeft;
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsTop === Type) {
|
|
Type = AscCH.historyitem_Worksheet_ShiftCellsBottom;
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsBottom === Type) {
|
|
Type = AscCH.historyitem_Worksheet_ShiftCellsTop;
|
|
} else if (AscCH.historyitem_Worksheet_Sort === Type) {
|
|
;
|
|
} else if (AscCH.historyitem_Worksheet_MoveRange === Type || AscCH.historyitem_Worksheet_Rename === Type ||
|
|
AscCH.historyitem_Worksheet_Hide === Type || AscCH.historyitem_Worksheet_SetDisplayGridlines === Type ||
|
|
AscCH.historyitem_Worksheet_SetDisplayHeadings === Type || AscCH.historyitem_Worksheet_ChangeMerge === Type ||
|
|
AscCH.historyitem_Worksheet_ChangeHyperlink === Type || AscCH.historyitem_Worksheet_ChangeFrozenCell === Type ||
|
|
AscCH.historyitem_Worksheet_SetTabColor === Type || AscCH.historyitem_Worksheet_SetSummaryRight === Type ||
|
|
AscCH.historyitem_Worksheet_SetSummaryBelow === Type || AscCH.historyitem_Worksheet_GroupRow === Type ||
|
|
AscCH.historyitem_Worksheet_GroupCol === Type || AscCH.historyitem_Worksheet_CollapsedRow === Type ||
|
|
AscCH.historyitem_Worksheet_CollapsedCol === Type || AscCH.historyitem_Worksheet_SetFitToPage === Type ||
|
|
AscCH.historyitem_Worksheet_SetTopLeftCell === Type) {
|
|
Data = Data.CreateReverseChangeSpreadsheet();
|
|
} else {
|
|
return;
|
|
}
|
|
return new UndoRedoItemSerializable(ToClass, Type, nSheetId, oRange, Data, LocalChange);
|
|
};
|
|
UndoRedoWoorksheet.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
let isAddRowUndo = AscCH.historyitem_Worksheet_AddRows === oActionToUndo.nActionType;
|
|
let isAddColUndo = AscCH.historyitem_Worksheet_AddCols === oActionToUndo.nActionType;
|
|
let isRemoveRowUndo = AscCH.historyitem_Worksheet_RemoveRows === oActionToUndo.nActionType;
|
|
let isRemoveColUndo = AscCH.historyitem_Worksheet_RemoveCols === oActionToUndo.nActionType;
|
|
let isAddRowOther = AscCommonExcel.g_oUndoRedoWorksheet === oActionOther.oClass && AscCH.historyitem_Worksheet_AddRows === oActionOther.nActionType;
|
|
let isAddColOther = AscCommonExcel.g_oUndoRedoWorksheet === oActionOther.oClass && AscCH.historyitem_Worksheet_AddCols === oActionOther.nActionType;
|
|
let isRemoveRowOther = AscCommonExcel.g_oUndoRedoWorksheet === oActionOther.oClass && AscCH.historyitem_Worksheet_RemoveRows === oActionOther.nActionType;
|
|
let isRemoveColOther = AscCommonExcel.g_oUndoRedoWorksheet === oActionOther.oClass && AscCH.historyitem_Worksheet_RemoveCols === oActionOther.nActionType;
|
|
let isAddUndo = isAddRowUndo || isAddColUndo;
|
|
let isAddOther = isAddRowOther || isAddColOther;
|
|
let isRemoveUndo = isRemoveRowUndo || isRemoveColUndo;
|
|
let isRemoveOther = isRemoveRowOther || isRemoveColOther;
|
|
|
|
let res = true;
|
|
if ((isAddRowUndo || isRemoveRowUndo) && (isAddRowOther || isRemoveRowOther) ||
|
|
(isAddColUndo || isRemoveColUndo) && (isAddColOther || isRemoveColOther)) {
|
|
if(isAddUndo) {
|
|
if(isAddOther) {
|
|
let heightUndo = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
let heightOther = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
if (oActionToUndo.oData.from >= oActionOther.oData.from) {
|
|
oActionToUndo.oData.from += heightOther;
|
|
oActionToUndo.oData.to += heightOther;
|
|
} else if (oActionToUndo.oData.from < oActionOther.oData.from && oActionOther.oData.from <= oActionToUndo.oData.to) {
|
|
oActionToUndo.oData.to += heightOther;
|
|
} else {
|
|
oActionOther.oData.from -= heightUndo;
|
|
oActionOther.oData.to -= heightUndo;
|
|
}
|
|
} else if(isRemoveOther){
|
|
//todo
|
|
|
|
let heightUndo = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
let heightOther = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
if (oActionToUndo.oData.from > oActionOther.oData.to) {
|
|
oActionToUndo.oData.from -= heightOther;
|
|
oActionToUndo.oData.to -= heightOther;
|
|
} else if (oActionToUndo.oData.to < oActionOther.oData.from) {
|
|
oActionOther.oData.from += heightUndo;
|
|
oActionOther.oData.to += heightUndo;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
} else if(isRemoveUndo){
|
|
if(isAddOther) {
|
|
//todo
|
|
|
|
let heightUndo = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
let heightOther = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
if (oActionToUndo.oData.from >= oActionOther.oData.from) {
|
|
oActionToUndo.oData.from += heightOther;
|
|
oActionToUndo.oData.to += heightOther;
|
|
} else if (oActionToUndo.oData.from < oActionOther.oData.from && oActionOther.oData.from <= oActionToUndo.oData.to) {
|
|
oActionToUndo.oData.to += heightOther;
|
|
} else {
|
|
oActionOther.oData.from -= heightUndo;
|
|
oActionOther.oData.to -= heightUndo;
|
|
}
|
|
} else if(isRemoveOther){
|
|
let heightUndo = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
let heightOther = oActionOther.oData.to - oActionOther.oData.from + 1;
|
|
if (oActionToUndo.oData.from > oActionOther.oData.to) {
|
|
oActionToUndo.oData.from -= heightOther;
|
|
oActionToUndo.oData.to -= heightOther;
|
|
} else if (oActionToUndo.oData.to < oActionOther.oData.from) {
|
|
oActionOther.oData.from += heightUndo;
|
|
oActionOther.oData.to += heightUndo;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (AscCH.historyitem_Worksheet_RemoveCell === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedCell(oActionToUndo.oData, oActionOther);
|
|
} else if (AscCH.historyitem_Worksheet_ColProp === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_GroupCol === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_CollapsedCol === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRowCol(oActionToUndo.oData, false, oActionOther);
|
|
} else if (AscCH.historyitem_Worksheet_RowProp === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_GroupRow === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_CollapsedRow === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRowCol(oActionToUndo.oData, true, oActionOther);
|
|
} else if (AscCH.historyitem_Worksheet_RowHide === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRowColFromTo(oActionToUndo.oData, true, oActionOther);
|
|
} else if (AscCH.historyitem_Worksheet_Sort === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRange(oActionToUndo.oData.bbox, oActionOther);
|
|
} else if (AscCH.historyitem_Worksheet_MoveRange === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_ChangeMerge === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_ChangeHyperlink === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_ChangeFrozenCell === oActionToUndo.nActionType ||
|
|
AscCH.historyitem_Worksheet_SetTopLeftCell === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRange(oActionToUndo.oData.from, oActionOther);
|
|
res = res && AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRange(oActionToUndo.oData.to, oActionOther);
|
|
}
|
|
return res;
|
|
};
|
|
UndoRedoWoorksheet.prototype.Undo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, true, opt_wb);
|
|
};
|
|
UndoRedoWoorksheet.prototype.Redo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, false, opt_wb);
|
|
};
|
|
UndoRedoWoorksheet.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo, opt_wb) {
|
|
var wb = opt_wb ? opt_wb : this.wb;
|
|
var worksheetView, nRow, nCol, oLockInfo, index, from, to, range, r1, c1, r2, c2, temp, i, length, data;
|
|
var bInsert, operType; // ToDo избавиться от этого
|
|
var ws = wb.getWorksheetById(nSheetId);
|
|
if (null == ws) {
|
|
return;
|
|
}
|
|
var collaborativeEditing = wb.oApi.collaborativeEditing;
|
|
var changeFreezePane;
|
|
if (AscCH.historyitem_Worksheet_RemoveCell === Type) {
|
|
nRow = Data.nRow;
|
|
nCol = Data.nCol;
|
|
if (wb.bCollaborativeChanges) {
|
|
nRow = collaborativeEditing.getLockOtherRow2(nSheetId, nRow);
|
|
nCol = collaborativeEditing.getLockOtherColumn2(nSheetId, nCol);
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(nCol, nRow, nCol, nRow);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
|
|
let oValue, oStyle;
|
|
if (bUndo) {
|
|
oValue = Data.oOldVal.value;
|
|
oStyle = Data.oOldVal.style;
|
|
ws._getCell(nRow, nCol, function (cell) {
|
|
cell.setValueData(oValue);
|
|
if (null != oStyle) {
|
|
cell.setStyle(oStyle);
|
|
} else {
|
|
cell.setStyle(null);
|
|
}
|
|
});
|
|
|
|
} else {
|
|
if (Data.oNewVal) {
|
|
oValue = Data.oNewVal.value;
|
|
oStyle = Data.oNewVal.style;
|
|
ws._getCell(nRow, nCol, function (cell) {
|
|
cell.setValueData(oValue);
|
|
if (null != oStyle) {
|
|
cell.setStyle(oStyle);
|
|
} else {
|
|
cell.setStyle(null);
|
|
}
|
|
});
|
|
} else {
|
|
ws._removeCell(nRow, nCol);
|
|
}
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ColProp === Type) {
|
|
index = Data.index;
|
|
if (wb.bCollaborativeChanges) {
|
|
if (AscCommonExcel.g_nAllColIndex === index) {
|
|
range = new Asc.Range(0, 0, gc_nMaxCol0, gc_nMaxRow0);
|
|
} else {
|
|
index = collaborativeEditing.getLockOtherColumn2(nSheetId, index);
|
|
range = new Asc.Range(index, 0, index, gc_nMaxRow0);
|
|
}
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = range;
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
var col = ws._getCol(index);
|
|
col.setWidthProp(bUndo ? Data.oOldVal : Data.oNewVal);
|
|
ws.initColumn(col);
|
|
} else if (AscCH.historyitem_Worksheet_RowProp === Type) {
|
|
index = Data.index;
|
|
if (wb.bCollaborativeChanges) {
|
|
index = collaborativeEditing.getLockOtherRow2(nSheetId, index);
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, index, gc_nMaxCol0, index);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
ws._getRow(index, function (row) {
|
|
if (bUndo) {
|
|
row.setHeightProp(Data.oOldVal);
|
|
} else {
|
|
row.setHeightProp(Data.oNewVal);
|
|
}
|
|
});
|
|
|
|
//нужно для того, чтобы грамотно выставлялись цвета в ф/т при ручном скрытии строк, затрагивающих ф/т(undo/redo)
|
|
//TODO для случая скрытия строк фильтром(undo), может два раза вызываться функция setColorStyleTable - пересмотреть
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView.model.autoFilters.reDrawFilter(null, index);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_RowHide === Type) {
|
|
from = Data.from;
|
|
to = Data.to;
|
|
nRow = Data.bRow;
|
|
|
|
if (wb.bCollaborativeChanges) {
|
|
from = collaborativeEditing.getLockOtherRow2(nSheetId, from);
|
|
to = collaborativeEditing.getLockOtherRow2(nSheetId, to);
|
|
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, from, gc_nMaxCol0, to);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
|
|
if (bUndo) {
|
|
nRow = !nRow;
|
|
}
|
|
|
|
ws.setRowHidden(nRow, from, to);
|
|
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView.model.autoFilters.reDrawFilter(new Asc.Range(0, from, ws.nColsCount - 1, to));
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_AddRows === Type || AscCH.historyitem_Worksheet_RemoveRows === Type) {
|
|
from = Data.from;
|
|
to = Data.to;
|
|
if (wb.bCollaborativeChanges) {
|
|
from = collaborativeEditing.getLockOtherRow2(nSheetId, from);
|
|
to = collaborativeEditing.getLockOtherRow2(nSheetId, to);
|
|
if (false == ((true == bUndo && AscCH.historyitem_Worksheet_AddRows === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_RemoveRows === Type))) {
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, from, gc_nMaxCol0, to);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
}
|
|
range = new Asc.Range(0, from, gc_nMaxCol0, to);
|
|
if ((true == bUndo && AscCH.historyitem_Worksheet_AddRows === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_RemoveRows === Type)) {
|
|
ws.removeRows(from, to);
|
|
bInsert = false;
|
|
operType = c_oAscDeleteOptions.DeleteRows;
|
|
} else {
|
|
ws.insertRowsBefore(from, to - from + 1);
|
|
bInsert = true;
|
|
operType = c_oAscInsertOptions.InsertRows;
|
|
}
|
|
|
|
// Нужно поменять пересчетные индексы для совместного редактирования (lock-элементы), но только если это не изменения от другого пользователя
|
|
if (!wb.bCollaborativeChanges) {
|
|
ws.workbook.handlers.trigger("undoRedoAddRemoveRowCols", nSheetId, Type, range, bUndo);
|
|
}
|
|
|
|
// ToDo Так делать неправильно, нужно поправить (перенести логику в model, а отрисовку отделить)
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView.cellCommentator.updateCommentsDependencies(bInsert, operType, range);
|
|
worksheetView.shiftCellWatches(bInsert, operType, range);
|
|
|
|
if (wb.bCollaborativeChanges) {
|
|
changeFreezePane = worksheetView._getFreezePaneOffset(operType, range, bInsert);
|
|
if (changeFreezePane) {
|
|
worksheetView._updateFreezePane(changeFreezePane.col, changeFreezePane.row, true);
|
|
}
|
|
}
|
|
}
|
|
//ws.shiftDataValidation(bInsert, operType, range);
|
|
} else if (AscCH.historyitem_Worksheet_AddCols === Type || AscCH.historyitem_Worksheet_RemoveCols === Type) {
|
|
from = Data.from;
|
|
to = Data.to;
|
|
if (wb.bCollaborativeChanges) {
|
|
from = collaborativeEditing.getLockOtherColumn2(nSheetId, from);
|
|
to = collaborativeEditing.getLockOtherColumn2(nSheetId, to);
|
|
if (false == ((true == bUndo && AscCH.historyitem_Worksheet_AddCols === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_RemoveCols === Type))) {
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(from, 0, to, gc_nMaxRow0);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
}
|
|
|
|
range = new Asc.Range(from, 0, to, gc_nMaxRow0);
|
|
if ((true == bUndo && AscCH.historyitem_Worksheet_AddCols === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_RemoveCols === Type)) {
|
|
ws.removeCols(from, to);
|
|
bInsert = false;
|
|
operType = c_oAscDeleteOptions.DeleteColumns;
|
|
} else {
|
|
ws.insertColsBefore(from, to - from + 1);
|
|
bInsert = true;
|
|
operType = c_oAscInsertOptions.InsertColumns;
|
|
}
|
|
|
|
// Нужно поменять пересчетные индексы для совместного редактирования (lock-элементы), но только если это не изменения от другого пользователя
|
|
if (!wb.bCollaborativeChanges) {
|
|
ws.workbook.handlers.trigger("undoRedoAddRemoveRowCols", nSheetId, Type, range, bUndo);
|
|
}
|
|
|
|
// ToDo Так делать неправильно, нужно поправить (перенести логику в model, а отрисовку отделить)
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView.cellCommentator.updateCommentsDependencies(bInsert, operType, range);
|
|
worksheetView.shiftCellWatches(bInsert, operType, range);
|
|
|
|
if (wb.bCollaborativeChanges) {
|
|
changeFreezePane = worksheetView._getFreezePaneOffset(operType, range, bInsert);
|
|
if (changeFreezePane) {
|
|
worksheetView._updateFreezePane(changeFreezePane.col, changeFreezePane.row, true);
|
|
}
|
|
}
|
|
}
|
|
//ws.shiftDataValidation(bInsert, operType, range)
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsLeft === Type ||
|
|
AscCH.historyitem_Worksheet_ShiftCellsRight === Type) {
|
|
r1 = Data.r1;
|
|
c1 = Data.c1;
|
|
r2 = Data.r2;
|
|
c2 = Data.c2;
|
|
if (wb.bCollaborativeChanges) {
|
|
r1 = collaborativeEditing.getLockOtherRow2(nSheetId, r1);
|
|
c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, c1);
|
|
r2 = collaborativeEditing.getLockOtherRow2(nSheetId, r2);
|
|
c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, c2);
|
|
if (false == ((true == bUndo && AscCH.historyitem_Worksheet_ShiftCellsLeft === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_ShiftCellsRight === Type))) {
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(c1, r1, c2, r2);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
}
|
|
|
|
range = ws.getRange3(r1, c1, r2, c2);
|
|
if ((true == bUndo && AscCH.historyitem_Worksheet_ShiftCellsLeft === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_ShiftCellsRight === Type)) {
|
|
range.addCellsShiftRight();
|
|
bInsert = true;
|
|
operType = c_oAscInsertOptions.InsertCellsAndShiftRight;
|
|
} else {
|
|
range.deleteCellsShiftLeft();
|
|
bInsert = false;
|
|
operType = c_oAscDeleteOptions.DeleteCellsAndShiftLeft;
|
|
}
|
|
|
|
// ToDo Так делать неправильно, нужно поправить (перенести логику в model, а отрисовку отделить)
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView.cellCommentator.updateCommentsDependencies(bInsert, operType, range.bbox);
|
|
worksheetView.shiftCellWatches(bInsert, operType, range.bbox);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsTop === Type ||
|
|
AscCH.historyitem_Worksheet_ShiftCellsBottom === Type) {
|
|
r1 = Data.r1;
|
|
c1 = Data.c1;
|
|
r2 = Data.r2;
|
|
c2 = Data.c2;
|
|
if (wb.bCollaborativeChanges) {
|
|
r1 = collaborativeEditing.getLockOtherRow2(nSheetId, r1);
|
|
c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, c1);
|
|
r2 = collaborativeEditing.getLockOtherRow2(nSheetId, r2);
|
|
c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, c2);
|
|
if (false == ((true == bUndo && AscCH.historyitem_Worksheet_ShiftCellsTop === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_ShiftCellsBottom === Type))) {
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(c1, r1, c2, r2);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
}
|
|
|
|
range = ws.getRange3(r1, c1, r2, c2);
|
|
if ((true == bUndo && AscCH.historyitem_Worksheet_ShiftCellsTop === Type) ||
|
|
(false == bUndo && AscCH.historyitem_Worksheet_ShiftCellsBottom === Type)) {
|
|
range.addCellsShiftBottom();
|
|
bInsert = true;
|
|
operType = c_oAscInsertOptions.InsertCellsAndShiftDown;
|
|
} else {
|
|
range.deleteCellsShiftUp();
|
|
bInsert = false;
|
|
operType = c_oAscDeleteOptions.DeleteCellsAndShiftTop;
|
|
}
|
|
|
|
// ToDo Так делать неправильно, нужно поправить (перенести логику в model, а отрисовку отделить)
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView.cellCommentator.updateCommentsDependencies(bInsert, operType, range.bbox);
|
|
worksheetView.shiftCellWatches(bInsert, operType, range.bbox);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_Sort == Type) {
|
|
var bbox = Data.bbox;
|
|
var places = Data.places;
|
|
var sortByRow = Data.sortByRow;
|
|
if (wb.bCollaborativeChanges) {
|
|
bbox.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, bbox.r1);
|
|
bbox.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, bbox.c1);
|
|
bbox.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, bbox.r2);
|
|
bbox.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, bbox.c2);
|
|
for (i = 0, length = Data.places.length; i < length; ++i) {
|
|
var place = Data.places[i];
|
|
place.from = sortByRow ? collaborativeEditing.getLockOtherColumn2(nSheetId, place.from) : collaborativeEditing.getLockOtherRow2(nSheetId, place.from);
|
|
place.to = sortByRow ? collaborativeEditing.getLockOtherColumn2(nSheetId, place.to) : collaborativeEditing.getLockOtherRow2(nSheetId, place.to);
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(bbox.c1, place.from, bbox.c2, place.from);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
}
|
|
range = ws.getRange3(bbox.r1, bbox.c1, bbox.r2, bbox.c2);
|
|
range._sortByArray(bbox, places, null, sortByRow);
|
|
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView.model.autoFilters.resetTableStyles(bbox);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_MoveRange == Type) {
|
|
//todo worksheetView.autoFilters._moveAutoFilters(worksheetView ,null, null, g_oUndoRedoAutoFiltersMoveData);
|
|
from = new Asc.Range(Data.from.c1, Data.from.r1, Data.from.c2, Data.from.r2);
|
|
to = new Asc.Range(Data.to.c1, Data.to.r1, Data.to.c2, Data.to.r2);
|
|
var copyRange = Data.copyRange;
|
|
|
|
var wsTo = wb.getWorksheetById(Data.sheetIdTo);
|
|
if (wsTo) {
|
|
if (bUndo) {
|
|
temp = from;
|
|
from = to;
|
|
to = temp;
|
|
if (wsTo) {
|
|
temp = wsTo;
|
|
wsTo = ws;
|
|
ws = temp;
|
|
}
|
|
}
|
|
if (wb.bCollaborativeChanges) {
|
|
var coBBoxTo = new Asc.Range(0, 0, 0, 0), coBBoxFrom = new Asc.Range(0, 0, 0, 0);
|
|
|
|
coBBoxTo.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r1);
|
|
coBBoxTo.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c1);
|
|
coBBoxTo.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r2);
|
|
coBBoxTo.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c2);
|
|
|
|
coBBoxFrom.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r1);
|
|
coBBoxFrom.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c1);
|
|
coBBoxFrom.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r2);
|
|
coBBoxFrom.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c2);
|
|
|
|
ws._moveRange(coBBoxFrom, coBBoxTo, copyRange, wsTo);
|
|
} else {
|
|
ws._moveRange(from, to, copyRange, wsTo);
|
|
}
|
|
}
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
if (bUndo)//если на Undo перемещается диапазон из форматированной таблицы - стиль форматированной таблицы не должен цепляться
|
|
{
|
|
worksheetView.model.autoFilters._cleanStyleTable(to);
|
|
}
|
|
|
|
worksheetView.model.autoFilters.reDrawFilter(to);
|
|
worksheetView.model.autoFilters.reDrawFilter(from);
|
|
|
|
// clear traces
|
|
if (worksheetView.traceDependentsManager) {
|
|
worksheetView.traceDependentsManager.clearAll();
|
|
}
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_Rename == Type) {
|
|
if (bUndo) {
|
|
ws.setName(Data.from);
|
|
} else {
|
|
ws.setName(Data.to);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_Hide == Type) {
|
|
if (bUndo) {
|
|
ws.setHidden(Data.from);
|
|
} else {
|
|
ws.setHidden(Data.to);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetDisplayGridlines === Type) {
|
|
ws.setDisplayGridlines(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Worksheet_SetDisplayHeadings === Type) {
|
|
ws.setDisplayHeadings(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Worksheet_ChangeMerge === Type) {
|
|
from = null;
|
|
if (null != Data.from && null != Data.from.r1 && null != Data.from.c1 && null != Data.from.r2 &&
|
|
null != Data.from.c2) {
|
|
from = new Asc.Range(Data.from.c1, Data.from.r1, Data.from.c2, Data.from.r2);
|
|
if (wb.bCollaborativeChanges) {
|
|
from.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r1);
|
|
from.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c1);
|
|
from.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r2);
|
|
from.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c2);
|
|
}
|
|
}
|
|
to = null;
|
|
if (null != Data.to && null != Data.to.r1 && null != Data.to.c1 && null != Data.to.r2 &&
|
|
null != Data.to.c2) {
|
|
to = new Asc.Range(Data.to.c1, Data.to.r1, Data.to.c2, Data.to.r2);
|
|
if (wb.bCollaborativeChanges) {
|
|
to.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r1);
|
|
to.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c1);
|
|
to.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r2);
|
|
to.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c2);
|
|
}
|
|
}
|
|
if (bUndo) {
|
|
temp = from;
|
|
from = to;
|
|
to = temp;
|
|
}
|
|
if (null != from) {
|
|
var aMerged = ws.mergeManager.get(from);
|
|
for (i in aMerged.inner) {
|
|
var merged = aMerged.inner[i];
|
|
if (merged.bbox.isEqual(from)) {
|
|
ws.mergeManager.removeElement(merged);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
data = 1;
|
|
if (null != to) {
|
|
ws.mergeManager.add(to, data);
|
|
ws.workbook.handlers.trigger("changeDocument", AscCommonExcel.docChangedType.mergeRange, null, to, ws.getId());
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ChangeHyperlink === Type) {
|
|
from = null;
|
|
if (null != Data.from && null != Data.from.r1 && null != Data.from.c1 && null != Data.from.r2 &&
|
|
null != Data.from.c2) {
|
|
from = new Asc.Range(Data.from.c1, Data.from.r1, Data.from.c2, Data.from.r2);
|
|
if (wb.bCollaborativeChanges) {
|
|
from.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r1);
|
|
from.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c1);
|
|
from.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r2);
|
|
from.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c2);
|
|
}
|
|
}
|
|
to = null;
|
|
if (null != Data.to && null != Data.to.r1 && null != Data.to.c1 && null != Data.to.r2 &&
|
|
null != Data.to.c2) {
|
|
to = new Asc.Range(Data.to.c1, Data.to.r1, Data.to.c2, Data.to.r2);
|
|
if (wb.bCollaborativeChanges) {
|
|
to.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r1);
|
|
to.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c1);
|
|
to.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r2);
|
|
to.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c2);
|
|
}
|
|
}
|
|
if (bUndo) {
|
|
temp = from;
|
|
from = to;
|
|
to = temp;
|
|
}
|
|
//не делаем clone потому что предполагаем, что здесь могут быть только операции изменения рзмеров, перемещение или удаления одной ссылки
|
|
data = null;
|
|
if (null != from) {
|
|
var aHyperlinks = ws.hyperlinkManager.get(from);
|
|
for (i in aHyperlinks.inner) {
|
|
var hyp = aHyperlinks.inner[i];
|
|
if (hyp.bbox.isEqual(from)) {
|
|
data = hyp.data;
|
|
ws.hyperlinkManager.removeElement(hyp);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (null == data) {
|
|
data = Data.hyperlink;
|
|
}
|
|
if (null != data && null != to) {
|
|
data.Ref = ws.getRange3(to.r1, to.c1, to.r2, to.c2);
|
|
ws.hyperlinkManager.add(to, data);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ChangeFrozenCell === Type) {
|
|
var updateData = bUndo ? Data.from : Data.to;
|
|
|
|
var _r1 = updateData.r1 > 0 ? collaborativeEditing.getLockOtherRow2(nSheetId, updateData.r1 - 1) : null;
|
|
var _c1 = updateData.c1 > 0 ? collaborativeEditing.getLockOtherColumn2(nSheetId, updateData.c1 - 1) : null;
|
|
|
|
if (_r1 !== null && _r1 !== updateData.r1 - 1) {
|
|
_r1++;
|
|
} else {
|
|
_r1 = updateData.r1;
|
|
}
|
|
if (_c1 !== null && _c1 !== updateData.c1 - 1) {
|
|
_c1++;
|
|
} else {
|
|
_c1 = updateData.c1;
|
|
}
|
|
worksheetView = wb.oApi.wb.getWorksheetById(nSheetId);
|
|
if (worksheetView) {
|
|
worksheetView._updateFreezePane(_c1, _r1, /*lockDraw*/true);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetTabColor === Type) {
|
|
ws.setTabColor(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Worksheet_SetSummaryRight === Type) {
|
|
ws.setSummaryRight(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Worksheet_SetSummaryBelow === Type) {
|
|
ws.setSummaryBelow(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Worksheet_GroupRow == Type) {
|
|
index = Data.index;
|
|
if (wb.bCollaborativeChanges) {
|
|
index = collaborativeEditing.getLockOtherRow2(nSheetId, index);
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, index, gc_nMaxCol0, index);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
ws._getRow(index, function (row) {
|
|
if (bUndo) {
|
|
row.setOutlineLevel(Data.oOldVal);
|
|
} else {
|
|
row.setOutlineLevel(Data.oNewVal);
|
|
}
|
|
});
|
|
} else if (AscCH.historyitem_Worksheet_GroupCol == Type) {
|
|
index = Data.index;
|
|
if (wb.bCollaborativeChanges) {
|
|
index = collaborativeEditing.getLockOtherRow2(nSheetId, index);
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, index, gc_nMaxCol0, index);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
col = ws._getCol(index);
|
|
if (col) {
|
|
if (bUndo) {
|
|
col.setOutlineLevel(Data.oOldVal);
|
|
} else {
|
|
col.setOutlineLevel(Data.oNewVal);
|
|
}
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_CollapsedRow == Type) {
|
|
index = Data.index;
|
|
if (wb.bCollaborativeChanges) {
|
|
index = collaborativeEditing.getLockOtherRow2(nSheetId, index);
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, index, gc_nMaxCol0, index);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
|
|
if (bUndo) {
|
|
ws.setCollapsedRow(Data.oOldVal, index);
|
|
} else {
|
|
ws.setCollapsedRow(Data.oNewVal, index);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_CollapsedCol == Type) {
|
|
index = Data.index;
|
|
if (wb.bCollaborativeChanges) {
|
|
index = collaborativeEditing.getLockOtherRow2(nSheetId, index);
|
|
oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, index, gc_nMaxCol0, index);
|
|
wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
|
|
if (bUndo) {
|
|
ws.setCollapsedCol(Data.oOldVal, index);
|
|
} else {
|
|
ws.setCollapsedCol(Data.oNewVal, index);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetFitToPage === Type) {
|
|
ws.setFitToPage(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Worksheet_PivotAdd === Type) {
|
|
if (bUndo) {
|
|
ws.deletePivotTable(Data.Id);
|
|
} else {
|
|
var pivot = Data.getData();
|
|
pivot.init();
|
|
ws.insertPivotTable(pivot, false, true);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_PivotDelete === Type) {
|
|
if (bUndo) {
|
|
ws.insertPivotTable(Data.from, false, true);
|
|
} else {
|
|
ws.deletePivotTable(Data.pivot);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_PivotReplace === Type) {
|
|
var data = bUndo ? Data.from : Data.to;
|
|
var pivot = data.getData();
|
|
pivot.init();
|
|
var oldPivot = ws.getPivotTableById(Data.pivot);
|
|
if (oldPivot) {
|
|
pivot.replaceSlicersPivotCacheDefinition(oldPivot.cacheDefinition, pivot.cacheDefinition);
|
|
}
|
|
ws.deletePivotTable(Data.pivot);
|
|
ws.insertPivotTable(pivot, false, false);
|
|
} else if (AscCH.historyitem_Worksheet_PivotReplaceKeepRecords === Type) {
|
|
var data = bUndo ? Data.from : Data.to;
|
|
var pivot = data.getData();
|
|
pivot.init();
|
|
var oldPivot = ws.getPivotTableById(Data.pivot);
|
|
if (oldPivot) {
|
|
pivot.cacheDefinition.cacheRecords = oldPivot.cacheDefinition.cacheRecords;
|
|
pivot.replaceSlicersPivotCacheDefinition(oldPivot.cacheDefinition, pivot.cacheDefinition);
|
|
ws.deletePivotTable(Data.pivot);
|
|
ws.insertPivotTable(pivot, false, false);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SlicerAdd === Type) {
|
|
if (bUndo) {
|
|
ws.deleteSlicer(Data.to.name);
|
|
} else {
|
|
ws.aSlicers.push(Data.to);
|
|
Data.to.init(null, null, null, ws);
|
|
wb.onSlicerUpdate(Data.to.name);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SlicerDelete === Type) {
|
|
if (bUndo) {
|
|
ws.aSlicers.push(Data.from);
|
|
Data.from.init(null, null, null, ws);
|
|
wb.onSlicerUpdate(Data.from.name);
|
|
} else {
|
|
ws.deleteSlicer(Data.from.name);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetActiveNamedSheetView === Type) {
|
|
if (ws.aNamedSheetViews) {
|
|
var activeId = bUndo ? Data.from : Data.to;
|
|
var namedSheetView = ws.getNamedSheetViewById(activeId);
|
|
|
|
for (i = 0; i < ws.aNamedSheetViews.length; i++) {
|
|
ws.aNamedSheetViews[i]._isActive = false;
|
|
}
|
|
|
|
ws.setActiveNamedSheetView(activeId);
|
|
if (namedSheetView) {
|
|
namedSheetView._isActive = true;
|
|
}
|
|
|
|
ws.autoFilters.reapplyAllFilters(true, ws.getActiveNamedSheetViewId() !== null, true);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SheetViewAdd === Type) {
|
|
if (bUndo) {
|
|
ws.deleteNamedSheetViews([ws.getNamedSheetViewById(Data.Id)], true);
|
|
} else {
|
|
ws.addNamedSheetView(Data.getData(), true);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SheetViewDelete === Type) {
|
|
if (bUndo) {
|
|
ws.addNamedSheetView(Data.from);
|
|
} else {
|
|
ws.deleteNamedSheetViews([ws.getNamedSheetViewById(Data.sheetView)], true);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_DataValidationAdd === Type) {
|
|
if (bUndo) {
|
|
ws.deleteDataValidationById(Data.id);
|
|
} else {
|
|
var _dataValidation = Data.to;
|
|
_dataValidation.Id = Data.id;
|
|
if (wb.bCollaborativeChanges) {
|
|
if (_dataValidation.ranges) {
|
|
for (i = 0; i < _dataValidation.ranges.length; i++) {
|
|
_dataValidation.ranges[i].r1 = collaborativeEditing.getLockOtherRow2(nSheetId, _dataValidation.ranges[i].r1);
|
|
_dataValidation.ranges[i].c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, _dataValidation.ranges[i].c1);
|
|
_dataValidation.ranges[i].r2 = collaborativeEditing.getLockOtherRow2(nSheetId, _dataValidation.ranges[i].r2);
|
|
_dataValidation.ranges[i].c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, _dataValidation.ranges[i].c2);
|
|
}
|
|
}
|
|
}
|
|
|
|
ws.addDataValidation(_dataValidation);
|
|
_dataValidation._init(ws);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_DataValidationChange === Type) {
|
|
var dataValidationTo = bUndo ? Data.from : Data.to;
|
|
var dataValidationFrom = ws.getDataValidationById(Data.id);
|
|
if (dataValidationFrom) {
|
|
dataValidationTo.Id = Data.id;
|
|
if (wb.bCollaborativeChanges) {
|
|
if (dataValidationTo.ranges) {
|
|
for (i = 0; i < dataValidationTo.ranges.length; i++) {
|
|
dataValidationTo.ranges[i].r1 = collaborativeEditing.getLockOtherRow2(nSheetId, dataValidationTo.ranges[i].r1);
|
|
dataValidationTo.ranges[i].c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, dataValidationTo.ranges[i].c1);
|
|
dataValidationTo.ranges[i].r2 = collaborativeEditing.getLockOtherRow2(nSheetId, dataValidationTo.ranges[i].r2);
|
|
dataValidationTo.ranges[i].c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, dataValidationTo.ranges[i].c2);
|
|
}
|
|
}
|
|
}
|
|
ws.dataValidations.elems[dataValidationFrom.index] = dataValidationTo;
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_DataValidationDelete === Type) {
|
|
if (bUndo) {
|
|
ws.addDataValidation(Data.from);
|
|
} else {
|
|
ws.deleteDataValidationById(Data.id);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_CFRuleAdd === Type) {
|
|
if (bUndo) {
|
|
ws.deleteCFRule(Data.id);
|
|
} else {
|
|
Data.to.id = Data.id;
|
|
ws.addCFRule(Data.to);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_CFRuleDelete === Type) {
|
|
if (bUndo) {
|
|
ws.addCFRule(Data.from);
|
|
} else {
|
|
ws.deleteCFRule(Data.id);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetShowZeros === Type) {
|
|
ws.setShowZeros(bUndo ? Data.from : Data.to);
|
|
} else if (AscCH.historyitem_Worksheet_SetShowFormulas === Type) {
|
|
//except - apply changes in other user
|
|
if (window["NATIVE_EDITOR_ENJINE"] || !wb.oApi.isDocumentLoadComplete || !wb.bCollaborativeChanges) {
|
|
ws.setShowFormulas(bUndo ? Data.from : Data.to);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetTopLeftCell === Type) {
|
|
ws.setTopLeftCell(Data.to ? new Asc.Range(Data.to.c1, Data.to.r1, Data.to.c2, Data.to.r2) : null);
|
|
} else if (AscCH.historyitem_Worksheet_AddProtectedRange === Type) {
|
|
if (bUndo) {
|
|
ws.deleteProtectedRange(Data.id);
|
|
} else {
|
|
Data.to.Id = Data.id;
|
|
ws.addProtectedRange(Data.to);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_DelProtectedRange === Type) {
|
|
if (bUndo) {
|
|
ws.addProtectedRange(Data.from);
|
|
} else {
|
|
ws.deleteProtectedRange(Data.id);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_AddCellWatch === Type) {
|
|
if (Data.to) {
|
|
range = new Asc.Range(Data.to.c1, Data.to.r1, Data.to.c2, Data.to.r2);
|
|
if (bUndo) {
|
|
ws.deleteCellWatch(range);
|
|
} else {
|
|
ws.addCellWatch(range);
|
|
}
|
|
wb.handlers.trigger("changeCellWatches");
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_DelCellWatch === Type) {
|
|
if (Data.from) {
|
|
range = new Asc.Range(Data.from.c1, Data.from.r1, Data.from.c2, Data.from.r2);
|
|
if (bUndo) {
|
|
ws.addCellWatch(range);
|
|
} else {
|
|
ws.deleteCellWatch(range);
|
|
}
|
|
wb.handlers.trigger("changeCellWatches");
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ChangeUserProtectedRange === Type) {
|
|
//TODO lock ?
|
|
//var _r1 = updateData.r1 > 0 ? collaborativeEditing.getLockOtherRow2(nSheetId, updateData.r1 - 1) : null;
|
|
//var _c1 = updateData.c1 > 0 ? collaborativeEditing.getLockOtherColumn2(nSheetId, updateData.c1 - 1) : null;
|
|
|
|
if (bUndo) {
|
|
ws.editUserProtectedRanges(Data.to, Data.from);
|
|
} else {
|
|
ws.editUserProtectedRanges(Data.from, Data.to);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetSheetViewType === Type) {
|
|
//накатываем только при открытии
|
|
/*if (this.wb.bCollaborativeChanges) {
|
|
ws.setTopLeftCell(Data.to ? new Asc.Range(Data.to.c1, Data.to.r1, Data.to.c2, Data.to.r2) : null);
|
|
}*/
|
|
//except - apply changes in other user
|
|
if (window["NATIVE_EDITOR_ENJINE"] || !wb.oApi.isDocumentLoadComplete || !wb.bCollaborativeChanges) {
|
|
ws.setSheetViewType(bUndo ? Data.from : Data.to);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ChangeRowColBreaks === Type) {
|
|
let from, to, min, max, man, pt, byCol;
|
|
if (bUndo) {
|
|
from = Data.to && Data.to.id;
|
|
to = Data.from && Data.from.id;
|
|
min = Data.from && Data.from.min;
|
|
max = Data.from && Data.from.max;
|
|
man = Data.from && Data.from.man;
|
|
pt = Data.from && Data.from.pt;
|
|
byCol = (Data.from && Data.from.byCol) || (Data.to && Data.to.byCol);
|
|
} else {
|
|
from = Data.from && Data.from.id;
|
|
to = Data.to && Data.to.id;
|
|
min = Data.to && Data.to.min;
|
|
max = Data.to && Data.to.max;
|
|
man = Data.to && Data.to.man;
|
|
pt = Data.to && Data.to.pt;
|
|
byCol = (Data.from && Data.from.byCol) || (Data.to && Data.to.byCol);
|
|
}
|
|
ws._changeRowColBreaks(from, to, min, max, man, pt, byCol);
|
|
} else if (AscCH.historyitem_Worksheet_ChangeLegacyDrawingHFDrawing === Type) {
|
|
let from, to;
|
|
if (bUndo) {
|
|
let fromId = Data.to && Data.to.id;
|
|
if (fromId) {
|
|
from = new AscCommonExcel.CLegacyDrawingHFDrawing();
|
|
from.id = fromId;
|
|
from.graphicObject = AscCommon.g_oTableId.Get_ById(Data.to.graphicId);
|
|
}
|
|
let toId = Data.from && Data.from.id;
|
|
if (toId) {
|
|
to = new AscCommonExcel.CLegacyDrawingHFDrawing();
|
|
to.id = toId;
|
|
to.graphicObject = AscCommon.g_oTableId.Get_ById(Data.from.graphicId);
|
|
}
|
|
} else {
|
|
let fromId = Data.from && Data.from.id;
|
|
if (fromId) {
|
|
from = new AscCommonExcel.CLegacyDrawingHFDrawing();
|
|
from.id = fromId;
|
|
from.graphicObject = AscCommon.g_oTableId.Get_ById(Data.from.graphicId);
|
|
}
|
|
let toId = Data.to && Data.to.id;
|
|
if (toId) {
|
|
to = new AscCommonExcel.CLegacyDrawingHFDrawing();
|
|
to.id = toId;
|
|
to.graphicObject = AscCommon.g_oTableId.Get_ById(Data.to.graphicId);
|
|
}
|
|
}
|
|
|
|
if (!ws.legacyDrawingHF) {
|
|
ws.legacyDrawingHF = new AscCommonExcel.CLegacyDrawingHF(ws);
|
|
}
|
|
ws.legacyDrawingHF.changePicture(from, to);
|
|
} else if (AscCH.historyitem_Worksheet_TimelineDelete === Type) {
|
|
if (bUndo) {
|
|
ws.timelines.push(Data.from);
|
|
} else {
|
|
wb.onTimelinesDelete(Data.from.name);
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_SetRightToLeft === Type) {
|
|
//накатываем только при открытии
|
|
if (!bUndo && this.wb.bCollaborativeChanges) {
|
|
ws.setRightToLeft(bUndo ? Data.from : Data.to);
|
|
}
|
|
}
|
|
};
|
|
UndoRedoWoorksheet.prototype.forwardTransformationIsAffect = function (Type) {
|
|
return AscCH.historyitem_Worksheet_AddRows === Type || AscCH.historyitem_Worksheet_RemoveRows === Type ||
|
|
AscCH.historyitem_Worksheet_AddCols === Type || AscCH.historyitem_Worksheet_RemoveCols === Type ||
|
|
AscCH.historyitem_Worksheet_ShiftCellsLeft === Type || AscCH.historyitem_Worksheet_ShiftCellsRight ===
|
|
Type || AscCH.historyitem_Worksheet_ShiftCellsTop === Type ||
|
|
AscCH.historyitem_Worksheet_ShiftCellsBottom === Type || AscCH.historyitem_Worksheet_MoveRange === Type ||
|
|
AscCH.historyitem_Worksheet_Rename === Type || AscCH.historyitem_Worksheet_RemoveCell === Type;
|
|
};
|
|
UndoRedoWoorksheet.prototype.forwardTransformationGet = function (Type, Data, nSheetId) {
|
|
if (AscCH.historyitem_Worksheet_Rename === Type) {
|
|
return {from: Data.from, name: Data.to};
|
|
} else if (AscCH.historyitem_Worksheet_RemoveCell === Type && Data.oNewVal && Data.oNewVal.value && Data.oNewVal.value.formula) {
|
|
return {formula: Data.oNewVal.value.formula};
|
|
}
|
|
return null;
|
|
};
|
|
UndoRedoWoorksheet.prototype.forwardTransformationSet = function (Type, Data, nSheetId, getRes) {
|
|
if (AscCH.historyitem_Worksheet_Rename === Type) {
|
|
Data.from = getRes.from;
|
|
Data.to = getRes.name;
|
|
} else if (AscCH.historyitem_Worksheet_RemoveCell === Type) {
|
|
if (Data && Data.oNewVal && Data.oNewVal.value) {
|
|
Data.oNewVal.value.formula = getRes.formula;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
UndoRedoWoorksheet.prototype.CommuteRelatedCell = function (oData, oActionOther) {
|
|
if (!oData) {
|
|
return true;
|
|
}
|
|
let res = this.CommuteRelatedCell2(oData.nRow, oData.nCol, oActionOther);
|
|
if (res) {
|
|
oData.nRow = this.tmpCell.nRow;
|
|
oData.nCol = this.tmpCell.nCol;
|
|
}
|
|
return res;
|
|
}
|
|
UndoRedoWoorksheet.prototype.CommuteRelatedCell2 = function (nRow, nCol, oActionOther) {
|
|
if (AscCommonExcel.g_oUndoRedoWorksheet !== oActionOther.oClass) {
|
|
this.tmpCell.nRow = nRow;
|
|
this.tmpCell.nCol = nCol;
|
|
return true;
|
|
}
|
|
let isAddRow = AscCH.historyitem_Worksheet_AddRows === oActionOther.nActionType;
|
|
let isAddCol = AscCH.historyitem_Worksheet_AddCols === oActionOther.nActionType;
|
|
let isRemoveRow = AscCH.historyitem_Worksheet_RemoveRows === oActionOther.nActionType;
|
|
let isRemoveCol = AscCH.historyitem_Worksheet_RemoveCols === oActionOther.nActionType;
|
|
let isAdd = isAddRow || isAddCol;
|
|
let isRemove = isRemoveRow || isRemoveCol;
|
|
let isShiftLeft = AscCH.historyitem_Worksheet_ShiftCellsLeft === oActionOther.nActionType;
|
|
let isShiftRight = AscCH.historyitem_Worksheet_ShiftCellsRight === oActionOther.nActionType;
|
|
let isShiftTop = AscCH.historyitem_Worksheet_ShiftCellsTop === oActionOther.nActionType;
|
|
let isShiftBottom = AscCH.historyitem_Worksheet_ShiftCellsBottom === oActionOther.nActionType;
|
|
let isShiftMove = AscCH.historyitem_Worksheet_MoveRange === oActionOther.nActionType;
|
|
let isShift = isShiftRight || isShiftBottom;
|
|
let isUnShift = isShiftLeft || isShiftTop;
|
|
if (isAdd || isRemove) {
|
|
let from = oActionOther.oData.from;
|
|
let to = oActionOther.oData.to;
|
|
let len = to - from + 1;
|
|
let index = (isAddRow || isRemoveRow) ? nRow : nCol;
|
|
if (isAdd) {
|
|
if (index >= from) {
|
|
index += len;
|
|
}
|
|
} else if (isRemove) {
|
|
if (index > from){
|
|
index -= len;
|
|
} else if (from <= index && index <= to) {
|
|
//не восстанавливаем действия внутри диапазона который уже удален. как google drive
|
|
return false;
|
|
}
|
|
|
|
}
|
|
(isAddRow || isRemoveRow) ? nRow = index : nCol = index;
|
|
} else if (isShift || isUnShift) {
|
|
let r1 = oActionOther.oData.r1;
|
|
let c1 = oActionOther.oData.c1;
|
|
let r2 = oActionOther.oData.r2;
|
|
let c2 = oActionOther.oData.c2;
|
|
let width = c2 - c1 + 1;
|
|
let height = r2 - r1 + 1;
|
|
if (isShiftLeft) {
|
|
if (r1 <= nRow && nRow <= r2) {
|
|
if (c2 < nCol) {
|
|
nCol -= width;
|
|
} else if (c1 <= nCol) {
|
|
return false;
|
|
}
|
|
}
|
|
} else if (isShiftRight) {
|
|
if (r1 <= nRow && nRow <= r2) {
|
|
if (c1 <= nCol) {
|
|
nCol += width;
|
|
}
|
|
}
|
|
} else if (isShiftTop) {
|
|
if (c1 <= nCol && nCol <= c2) {
|
|
if (r2 < nRow) {
|
|
nRow -= height;
|
|
} else if (r1 <= nRow) {
|
|
return false;
|
|
}
|
|
}
|
|
} else if (isShiftBottom) {
|
|
if (c1 <= nCol && nCol <= c2) {
|
|
if (r1 <= nRow) {
|
|
nRow += height;
|
|
}
|
|
}
|
|
}
|
|
} else if (isShiftMove) {
|
|
if (oActionOther.oData.from.r1 <= nRow && nRow <= oActionOther.oData.from.r2 && oActionOther.oData.from.c1 <= nCol && nCol <= oActionOther.oData.from.c2) {
|
|
nRow += oActionOther.oData.to.r1 - oActionOther.oData.from.r1;
|
|
nCol += oActionOther.oData.to.c1 - oActionOther.oData.from.c1;
|
|
}
|
|
}
|
|
this.tmpCell.nRow = nRow;
|
|
this.tmpCell.nCol = nCol;
|
|
return true;
|
|
}
|
|
UndoRedoWoorksheet.prototype.CommuteRelatedRange = function (oData, oActionOther) {
|
|
if (!oData) {
|
|
return true;
|
|
}
|
|
let res = this.CommuteRelatedRange2(oData.r1, oData.c1, oData.r2, oData.c2, oActionOther);
|
|
if (res) {
|
|
oData.r1 = this.tmpRange.r1;
|
|
oData.c1 = this.tmpRange.c1;
|
|
oData.r2 = this.tmpRange.r2;
|
|
oData.c2 = this.tmpRange.c2;
|
|
}
|
|
return res;
|
|
}
|
|
UndoRedoWoorksheet.prototype.CommuteRelatedRange2 = function (r1, c1, r2, c2, oActionOther) {
|
|
if (AscCommonExcel.g_oUndoRedoWorksheet !== oActionOther.oClass) {
|
|
this.tmpRange.r1 = r1;
|
|
this.tmpRange.c1 = c1;
|
|
this.tmpRange.r2 = r2;
|
|
this.tmpRange.c2 = c2;
|
|
return true;
|
|
}
|
|
let nActionType = oActionOther.nActionType;
|
|
let oData = oActionOther.oData;
|
|
if (AscCH.historyitem_Worksheet_AddRows === nActionType || AscCH.historyitem_Worksheet_AddCols === nActionType ||
|
|
AscCH.historyitem_Worksheet_RemoveRows === nActionType || AscCH.historyitem_Worksheet_RemoveCols === nActionType) {
|
|
let from = oData.from;
|
|
let to = oData.to;
|
|
let len = to - from + 1;
|
|
if (AscCH.historyitem_Worksheet_AddRows === nActionType) {
|
|
if (from <= r1) {
|
|
r1 += len;
|
|
r2 += len;
|
|
} else if (from <= r2) {
|
|
r2 += len;
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_AddCols === nActionType) {
|
|
if (from <= c1) {
|
|
c1 += len;
|
|
c2 += len;
|
|
} else if (from <= c2) {
|
|
c2 += len;
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_RemoveRows === nActionType) {
|
|
if (to < r1) {
|
|
r1 -= len;
|
|
r2 -= len;
|
|
} else if (from <= r1 && to < r2) {
|
|
r1 = to + 1;
|
|
} else if (r1 < from && to < r2) {
|
|
r2 -= len;
|
|
} else if (from <= r1 && r2 <= to) {
|
|
return false;
|
|
} else if (r1 < from && from <= r2) {
|
|
r2 = from - 1;
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_RemoveCols === nActionType) {
|
|
if (to < c1) {
|
|
c1 -= len;
|
|
c2 -= len;
|
|
} else if (from <= c1 && to < c2) {
|
|
c1 = to + 1;
|
|
} else if (c1 < from && to < c2) {
|
|
c2 -= len;
|
|
} else if (from <= c1 && c2 <= to) {
|
|
return false;
|
|
} else if (c1 < from && from <= c2) {
|
|
c2 = from - 1;
|
|
}
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsLeft === nActionType ||
|
|
AscCH.historyitem_Worksheet_ShiftCellsRight === nActionType ||
|
|
AscCH.historyitem_Worksheet_ShiftCellsTop === nActionType ||
|
|
AscCH.historyitem_Worksheet_ShiftCellsBottom === nActionType) {
|
|
let r1Shift = oData.r1;
|
|
let c1Shift = oData.c1;
|
|
let r2Shift = oData.r2;
|
|
let c2Shift = oData.c2;
|
|
let width = c2Shift - c1Shift + 1;
|
|
let height = r2Shift - r1Shift + 1;
|
|
if (AscCH.historyitem_Worksheet_ShiftCellsLeft === nActionType) {
|
|
if (r1Shift <= r1 && r2 <= r2Shift) {
|
|
if (c2Shift < c1) {
|
|
c1 -= width;
|
|
c2 -= width;
|
|
} else if (c1Shift <= c1 && c2Shift < c2) {
|
|
c1 = c2Shift + 1;
|
|
} else if (c1 < c1Shift && c2Shift < c2) {
|
|
c2 -= width;
|
|
} else if (c1Shift <= c1 && c2 <= c2Shift) {
|
|
return false;
|
|
} else if (c1 < c1Shift && c1Shift <= c2) {
|
|
c2 = c1Shift - 1;
|
|
}
|
|
} else if ((r1 <= r1Shift && r1Shift <= r2) || (r1 <= r2Shift && r2Shift <= r2)) {
|
|
return false;
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsRight === nActionType) {
|
|
if (r1Shift <= r1 && r2 <= r2Shift) {
|
|
if (c1Shift <= c1) {
|
|
c1 += width;
|
|
c2 += width;
|
|
} else if (c1Shift <= c2) {
|
|
c2 += width;
|
|
}
|
|
} else if ((r1 <= r1Shift && r1Shift <= r2) || (r1 <= r2Shift && r2Shift <= r2)) {
|
|
return false;
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsTop === nActionType) {
|
|
if (c1Shift <= c1 && c2 <= c2Shift) {
|
|
if (r2Shift < r1) {
|
|
r1 -= height;
|
|
r2 -= height;
|
|
} else if (r1Shift <= r1 && r2Shift < r2) {
|
|
r1 = r2Shift + 1;
|
|
} else if (r1 < r1Shift && r2Shift < r2) {
|
|
r2 -= height;
|
|
} else if (r1Shift <= r1 && r2 <= r2Shift) {
|
|
return false;
|
|
} else if (r1 < r1Shift && r1Shift <= r2) {
|
|
r2 = r1Shift - 1;
|
|
}
|
|
} else if ((c1 <= c1Shift && c1Shift <= c2) || (c1 <= c2Shift && c2Shift <= c2)) {
|
|
return false;
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_ShiftCellsBottom === nActionType) {
|
|
if (c1Shift <= c1 && c2 <= c2Shift) {
|
|
if (r1Shift <= r1) {
|
|
r1 += height;
|
|
r2 += height;
|
|
} else if (r1Shift <= r2) {
|
|
r2 += height;
|
|
}
|
|
} else if ((c1 <= c1Shift && c1Shift <= c2) || (c1 <= c2Shift && c2Shift <= c2)) {
|
|
return false;
|
|
}
|
|
}
|
|
} else if (AscCH.historyitem_Worksheet_MoveRange === nActionType) {
|
|
if (oData.from.r1 <= r1 && r2 <= oData.from.r2 &&
|
|
oData.from.c1 <= c1 && c2 <= oData.from.c2) {
|
|
r1 += oData.to.r1 - oData.from.r1;
|
|
r2 += oData.to.r1 - oData.from.r1;
|
|
c1 += oData.to.c1 - oData.from.c1;
|
|
c2 += oData.to.c1 - oData.from.c1;
|
|
} else if(oData.to.r1 <= r1 && r2 <= oData.to.r2 &&
|
|
oData.to.c1 <= c1 && c2 <= oData.to.c2) {
|
|
return false;
|
|
}
|
|
}
|
|
this.tmpRange.r1 = r1;
|
|
this.tmpRange.c1 = c1;
|
|
this.tmpRange.r2 = r2;
|
|
this.tmpRange.c2 = c2;
|
|
return true;
|
|
}
|
|
UndoRedoWoorksheet.prototype.CommuteRelatedRowCol = function (oData, isRow, oActionOther) {
|
|
let res = this.CommuteRelatedRowCol2(oData.index, oData.index, isRow, oActionOther);
|
|
if (res) {
|
|
oData.index = isRow ? this.tmpRange.r1 : this.tmpRange.c1;
|
|
}
|
|
return res;
|
|
}
|
|
UndoRedoWoorksheet.prototype.CommuteRelatedRowColFromTo = function (oData, isRow, oActionOther) {
|
|
let res = this.CommuteRelatedRowCol2(oData.from, oData.to, isRow, oActionOther);
|
|
if (res) {
|
|
if (isRow) {
|
|
oData.from = this.tmpRange.r1;
|
|
oData.to = this.tmpRange.r2;
|
|
} else {
|
|
oData.from = this.tmpRange.c1;
|
|
oData.to = this.tmpRange.c2;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
UndoRedoWoorksheet.prototype.CommuteRelatedRowCol2 = function (from, to, isRow, oActionOther) {
|
|
let r1 = 0;
|
|
let c1 = 0;
|
|
let r2 = gc_nMaxRow0;
|
|
let c2 = gc_nMaxCol0;
|
|
if (isRow) {
|
|
r1 = from;
|
|
r2 = to;
|
|
} else {
|
|
c1 = from;
|
|
c2 = to;
|
|
}
|
|
return this.CommuteRelatedRange2(r1, c1, r2, c2, oActionOther);
|
|
}
|
|
function UndoRedoRowCol(wb, bRow) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.bRow = bRow;
|
|
this.nTypeRow = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoRow;
|
|
});
|
|
this.nTypeCol = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoCol;
|
|
});
|
|
}
|
|
UndoRedoRowCol.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoRowCol.prototype.getClassType = function () {
|
|
if (this.bRow) {
|
|
return this.nTypeRow;
|
|
} else {
|
|
return this.nTypeCol;
|
|
}
|
|
};
|
|
UndoRedoRowCol.prototype.CreateReverseChangeSpreadsheet = function (ToClass, Type, nSheetId, oRange, Data, LocalChange) {
|
|
Data = Data.CreateReverseChangeSpreadsheet();
|
|
return new UndoRedoItemSerializable(ToClass, Type, nSheetId, oRange, Data, LocalChange);
|
|
};
|
|
UndoRedoRowCol.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
return AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRowCol(oActionToUndo.oData, this.bRow, oActionOther);
|
|
}
|
|
UndoRedoRowCol.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoRowCol.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoRowCol.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (null == ws) {
|
|
return;
|
|
}
|
|
var nIndex = Data.index;
|
|
if (this.wb.bCollaborativeChanges) {
|
|
var collaborativeEditing = this.wb.oApi.collaborativeEditing;
|
|
var oLockInfo = new AscCommonExcel.asc_CLockInfo();
|
|
oLockInfo["sheetId"] = nSheetId;
|
|
oLockInfo["type"] = c_oAscLockTypeElem.Range;
|
|
if (this.bRow) {
|
|
nIndex = collaborativeEditing.getLockOtherRow2(nSheetId, nIndex);
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, nIndex, gc_nMaxCol0, nIndex);
|
|
} else {
|
|
if (AscCommonExcel.g_nAllColIndex == nIndex) {
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(0, 0, gc_nMaxCol0, gc_nMaxRow0);
|
|
} else {
|
|
nIndex = collaborativeEditing.getLockOtherColumn2(nSheetId, nIndex);
|
|
oLockInfo["rangeOrObjectId"] = new Asc.Range(nIndex, 0, nIndex, gc_nMaxRow0);
|
|
}
|
|
}
|
|
this.wb.aCollaborativeChangeElements.push(oLockInfo);
|
|
}
|
|
var Val;
|
|
if (bUndo) {
|
|
Val = Data.oOldVal;
|
|
} else {
|
|
Val = Data.oNewVal;
|
|
}
|
|
|
|
function fAction(row) {
|
|
if (AscCH.historyitem_RowCol_SetFont == Type) {
|
|
row.setFont(Val);
|
|
} else if (AscCH.historyitem_RowCol_Fontname == Type) {
|
|
row.setFontname(Val);
|
|
} else if (AscCH.historyitem_RowCol_Fontsize == Type) {
|
|
row.setFontsize(Val);
|
|
} else if (AscCH.historyitem_RowCol_Fontcolor == Type) {
|
|
row.setFontcolor(Val);
|
|
} else if (AscCH.historyitem_RowCol_Bold == Type) {
|
|
row.setBold(Val);
|
|
} else if (AscCH.historyitem_RowCol_Italic == Type) {
|
|
row.setItalic(Val);
|
|
} else if (AscCH.historyitem_RowCol_Underline == Type) {
|
|
row.setUnderline(Val);
|
|
} else if (AscCH.historyitem_RowCol_Strikeout == Type) {
|
|
row.setStrikeout(Val);
|
|
} else if (AscCH.historyitem_RowCol_FontAlign == Type) {
|
|
row.setFontAlign(Val);
|
|
} else if (AscCH.historyitem_RowCol_AlignVertical == Type) {
|
|
row.setAlignVertical(Val);
|
|
} else if (AscCH.historyitem_RowCol_AlignHorizontal == Type) {
|
|
row.setAlignHorizontal(Val);
|
|
} else if (AscCH.historyitem_RowCol_ReadingOrder == Type) {
|
|
row.setReadingOrder(Val);
|
|
} else if (AscCH.historyitem_RowCol_Fill == Type) {
|
|
row.setFill(Val);
|
|
} else if (AscCH.historyitem_RowCol_Border == Type) {
|
|
if (null != Val) {
|
|
row.setBorder(Val.clone());
|
|
} else {
|
|
row.setBorder(null);
|
|
}
|
|
} else if (AscCH.historyitem_RowCol_ShrinkToFit == Type) {
|
|
row.setShrinkToFit(Val);
|
|
} else if (AscCH.historyitem_RowCol_Wrap == Type) {
|
|
row.setWrap(Val);
|
|
} else if (AscCH.historyitem_RowCol_Num == Type) {
|
|
row.setNum(Val);
|
|
} else if (AscCH.historyitem_RowCol_Angle == Type) {
|
|
row.setAngle(Val);
|
|
} else if (AscCH.historyitem_RowCol_SetStyle == Type) {
|
|
row.setStyle(Val);
|
|
} else if (AscCH.historyitem_RowCol_SetCellStyle == Type) {
|
|
row.setCellStyle(Val);
|
|
} else if (AscCH.historyitem_RowCol_Indent == Type) {
|
|
row.setIndent(Val);
|
|
} else if (AscCH.historyitem_RowCol_ApplyProtection == Type) {
|
|
row.setApplyProtection(Val);
|
|
} else if (AscCH.historyitem_RowCol_Locked == Type) {
|
|
row.setLocked(Val);
|
|
} else if (AscCH.historyitem_RowCol_HiddenFormulas == Type) {
|
|
row.setHiddenFormulas(Val);
|
|
}
|
|
}
|
|
|
|
if (this.bRow) {
|
|
ws._getRow(nIndex, fAction);
|
|
} else {
|
|
var row = ws._getCol(nIndex);
|
|
fAction(row);
|
|
}
|
|
};
|
|
|
|
function UndoRedoComment(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoComment;
|
|
});
|
|
}
|
|
UndoRedoComment.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoComment.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoComment.prototype.CreateReverseChangeSpreadsheet = function (ToClass, Type, nSheetId, oRange, Data, LocalChange) {
|
|
if (Type === AscCH.historyitem_Comment_Add) {
|
|
Type = AscCH.historyitem_Comment_Remove;
|
|
} else if (Type === AscCH.historyitem_Comment_Remove) {
|
|
Type = AscCH.historyitem_Comment_Add;
|
|
} else if (Type === AscCH.historyitem_Comment_Change || Type === AscCH.historyitem_Comment_Coords) {
|
|
Data = Data.CreateReverseChangeSpreadsheet();
|
|
}
|
|
return new AscCommonExcel.UndoRedoItemSerializable(ToClass, Type, nSheetId, oRange, Data, LocalChange);
|
|
};
|
|
UndoRedoComment.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
let res = true;
|
|
if (AscCH.historyitem_Comment_Add === oActionToUndo.nActionType || AscCH.historyitem_Comment_Add === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedCell(oActionToUndo.oData, oActionOther);
|
|
if(oActionToUndo.oData.coords) {
|
|
res = res && AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedCell(oActionToUndo.oData.coords, oActionOther);
|
|
}
|
|
} else if (AscCH.historyitem_Comment_Change === oActionToUndo.nActionType || AscCH.historyitem_Comment_Coords === oActionToUndo.nActionType) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedCell(oActionToUndo.oData.from, oActionOther);
|
|
res = res && AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedCell(oActionToUndo.oData.to, oActionOther);
|
|
}
|
|
return res;
|
|
}
|
|
UndoRedoComment.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoComment.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoComment.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var collaborativeEditing, to;
|
|
var oModel = (null == nSheetId) ? this.wb : this.wb.getWorksheetById(nSheetId);
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb || !oModel) {
|
|
return;
|
|
}
|
|
|
|
var ws = (null == nSheetId) ? api.wb : api.wb.getWorksheetById(nSheetId);
|
|
Data.worksheet = ws;
|
|
|
|
var cellCommentator = ws.cellCommentator;
|
|
if (bUndo) {
|
|
cellCommentator.Undo(Type, Data);
|
|
} else {
|
|
to = (Data.from || Data.to) ? Data.to : Data;
|
|
if (to && !to.bDocument && this.wb.bCollaborativeChanges) {
|
|
collaborativeEditing = this.wb.oApi.collaborativeEditing;
|
|
to.nRow = collaborativeEditing.getLockOtherRow2(nSheetId, to.nRow);
|
|
to.nCol = collaborativeEditing.getLockOtherColumn2(nSheetId, to.nCol);
|
|
}
|
|
|
|
cellCommentator.Redo(Type, Data);
|
|
}
|
|
};
|
|
|
|
function UndoRedoSortState(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoSortState;
|
|
});
|
|
}
|
|
UndoRedoSortState.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoSortState.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoSortState.prototype.CreateReverseChangeSpreadsheet = function (ToClass, Type, nSheetId, oRange, Data, LocalChange) {
|
|
if (AscCH.historyitem_SortState_Add === Type) {
|
|
Data = Data.CreateReverseChangeSpreadsheet();
|
|
} else {
|
|
return;
|
|
}
|
|
return new UndoRedoItemSerializable(ToClass, Type, nSheetId, oRange, Data, LocalChange);
|
|
};
|
|
UndoRedoSortState.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
return true;
|
|
}
|
|
UndoRedoSortState.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoSortState.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoSortState.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var collaborativeEditing, to;
|
|
var oModel = (null == nSheetId) ? this.wb : this.wb.getWorksheetById(nSheetId);
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb || !oModel) {
|
|
return;
|
|
}
|
|
|
|
var ws = (null == nSheetId) ? api.wb : api.wb.getWorksheetById(nSheetId);
|
|
Data.worksheet = ws;
|
|
|
|
if (Data.bFilter) {
|
|
if (Data.tableName) {
|
|
var table = ws.model.autoFilters._getFilterByDisplayName(Data.tableName);
|
|
table.SortState = bUndo ? Data.from : Data.to;
|
|
} else {
|
|
ws.model.AutoFilter.SortState = bUndo ? Data.from : Data.to;
|
|
}
|
|
} else {
|
|
ws.model.sortState = bUndo ? Data.from : Data.to;
|
|
}
|
|
};
|
|
|
|
function UndoRedoAutoFilters(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoAutoFilters;
|
|
});
|
|
}
|
|
UndoRedoAutoFilters.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoAutoFilters.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoAutoFilters.prototype.Undo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, true, opt_wb);
|
|
};
|
|
UndoRedoAutoFilters.prototype.Redo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, false, opt_wb);
|
|
};
|
|
UndoRedoAutoFilters.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo, opt_wb) {
|
|
var wb = opt_wb ? opt_wb : this.wb;
|
|
var ws = wb.getWorksheetById(nSheetId);
|
|
if (ws) {
|
|
var autoFilters = ws.autoFilters;
|
|
if (bUndo === true) {
|
|
autoFilters.Undo(Type, Data);
|
|
} else {
|
|
var collaborativeEditing = this.wb.oApi.collaborativeEditing;
|
|
if (AscCH.historyitem_AutoFilter_ChangeColumnName === Type ||
|
|
AscCH.historyitem_AutoFilter_ChangeTotalRow === Type) {
|
|
if (this.wb.bCollaborativeChanges) {
|
|
Data.nRow = collaborativeEditing.getLockOtherRow2(nSheetId, Data.nRow);
|
|
Data.nCol = collaborativeEditing.getLockOtherColumn2(nSheetId, Data.nCol);
|
|
}
|
|
} else if (AscCH.historyitem_AutoFilter_Apply === Type ||
|
|
AscCH.historyitem_AutoFilter_ClearFilterColumn === Type) {
|
|
var _obj = Data.autoFiltersObject ? Data.autoFiltersObject : Data;
|
|
if (_obj.cellId !== undefined) {
|
|
var curCellId = _obj.cellId.split('af')[0];
|
|
var range;
|
|
AscCommonExcel.executeInR1C1Mode(false, function () {
|
|
range = AscCommonExcel.g_oRangeCache.getAscRange(curCellId).clone();
|
|
});
|
|
var nRow = collaborativeEditing.getLockOtherRow2(nSheetId, range.r1);
|
|
var nCol = collaborativeEditing.getLockOtherColumn2(nSheetId, range.c1);
|
|
if (nCol !== range.c1 || nRow !== range.r1) {
|
|
_obj.cellId = new AscCommon.CellBase(nRow, nCol).getName();
|
|
}
|
|
}
|
|
}
|
|
autoFilters.Redo(Type, Data);
|
|
}
|
|
}
|
|
};
|
|
UndoRedoAutoFilters.prototype.forwardTransformationIsAffect = function (Type) {
|
|
return AscCH.historyitem_AutoFilter_Add === Type || AscCH.historyitem_AutoFilter_ChangeTableName === Type ||
|
|
AscCH.historyitem_AutoFilter_Empty === Type || AscCH.historyitem_AutoFilter_ChangeColumnName === Type;
|
|
};
|
|
UndoRedoAutoFilters.prototype.CreateReverseChangeSpreadsheet = function (ToClass, nActionType, nSheetId, oRange, oData, LocalChange) {
|
|
let type, data;
|
|
if (AscCH.historyitem_AutoFilter_Add === nActionType) {
|
|
type = AscCH.historyitem_AutoFilter_Empty;
|
|
data = new AscCommonExcel.UndoRedoData_AutoFilter();
|
|
data.activeCells = oData.activeCells;
|
|
} else {
|
|
return;
|
|
}
|
|
return new UndoRedoItemSerializable(ToClass, type, nSheetId, oRange, data, LocalChange);
|
|
};
|
|
UndoRedoAutoFilters.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
if (AscCommonExcel.g_oUndoRedoAutoFilters === oActionOther.oClass) {
|
|
//изменения в форматированной таблице. например добавление total
|
|
return false;
|
|
}
|
|
let res = true;
|
|
if (AscCH.historyitem_AutoFilter_Empty === oActionToUndo.nActionType) {
|
|
if(oActionToUndo.oData.activeCells) {
|
|
res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRange(oActionToUndo.oData.activeCells, oActionOther);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
function UndoRedoSparklines(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoSparklines;
|
|
});
|
|
}
|
|
UndoRedoSparklines.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoSparklines.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoSparklines.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoSparklines.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoSparklines.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
};
|
|
|
|
|
|
function UndoRedoSharedFormula(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoSharedFormula;
|
|
});
|
|
}
|
|
UndoRedoSharedFormula.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoSharedFormula.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoSharedFormula.prototype.Undo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, true, opt_wb);
|
|
};
|
|
UndoRedoSharedFormula.prototype.Redo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, false, opt_wb);
|
|
};
|
|
UndoRedoSharedFormula.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo, opt_wb) {
|
|
var wb = opt_wb ? opt_wb : this.wb;
|
|
var parsed = wb.workbookFormulas.get(Data.index);
|
|
if (parsed && bUndo) {
|
|
var val = bUndo ? Data.oOldVal : Data.oNewVal;
|
|
if (AscCH.historyitem_SharedFormula_ChangeFormula == Type) {
|
|
parsed.removeDependencies();
|
|
parsed.setFormula(val);
|
|
wb.dependencyFormulas.addToBuildDependencyShared(parsed);
|
|
} else if (AscCH.historyitem_SharedFormula_ChangeShared == Type) {
|
|
parsed.setSharedRef(val, Data.bRow);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
function UndoRedoRedoLayout(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoLayout;
|
|
});
|
|
}
|
|
UndoRedoRedoLayout.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoRedoLayout.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoRedoLayout.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoRedoLayout.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoRedoLayout.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (!ws) {
|
|
return;
|
|
}
|
|
|
|
var pageOptions = ws.PagePrintOptions;
|
|
var pageSetup = pageOptions.asc_getPageSetup();
|
|
var pageMargins = pageOptions.asc_getPageMargins();
|
|
var value = bUndo ? Data.from : Data.to;
|
|
switch (Type) {
|
|
case AscCH.historyitem_Layout_Left:
|
|
pageMargins.asc_setLeft(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Right:
|
|
pageMargins.asc_setRight(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Top:
|
|
pageMargins.asc_setTop(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Bottom:
|
|
pageMargins.asc_setBottom(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Width:
|
|
pageSetup.asc_setWidth(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Height:
|
|
pageSetup.asc_setHeight(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_FitToWidth:
|
|
pageSetup.asc_setFitToWidth(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_FitToHeight:
|
|
pageSetup.asc_setFitToHeight(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_GridLines:
|
|
pageOptions.asc_setGridLines(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Headings:
|
|
pageOptions.asc_setHeadings(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Orientation:
|
|
pageSetup.asc_setOrientation(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_Scale:
|
|
pageSetup.asc_setScale(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_FirstPageNumber:
|
|
pageSetup.asc_setFirstPageNumber(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_HorizontalCentered:
|
|
pageOptions.asc_setHorizontalCentered(value);
|
|
break;
|
|
case AscCH.historyitem_Layout_VerticalCentered:
|
|
pageOptions.asc_setVerticalCentered(value);
|
|
break;
|
|
}
|
|
|
|
this.wb.oApi._onUpdateLayoutMenu(nSheetId);
|
|
};
|
|
|
|
//***array-formula***
|
|
function UndoRedoArrayFormula(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoArrayFormula;
|
|
});
|
|
}
|
|
UndoRedoArrayFormula.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoArrayFormula.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoArrayFormula.prototype.Undo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, true, opt_wb);
|
|
};
|
|
UndoRedoArrayFormula.prototype.Redo = function (Type, Data, nSheetId, opt_wb) {
|
|
this.UndoRedo(Type, Data, nSheetId, false, opt_wb);
|
|
};
|
|
UndoRedoArrayFormula.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo, opt_wb) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (null == ws) {
|
|
return;
|
|
}
|
|
|
|
var bbox = Data.range;
|
|
var formula = Data.formula;
|
|
var range = ws.getRange3(bbox.r1, bbox.c1, bbox.r2, bbox.c2);
|
|
switch (Type) {
|
|
case AscCH.historyitem_ArrayFromula_AddFormula:
|
|
if (!bUndo) {
|
|
AscCommonExcel.executeInR1C1Mode(false, function () {
|
|
range.setValue(formula, null, null, bbox);
|
|
});
|
|
}
|
|
break;
|
|
case AscCH.historyitem_ArrayFromula_DeleteFormula:
|
|
if (bUndo) {
|
|
range.setValue(formula, null, null, bbox);
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoHeaderFooter(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoHeaderFooter;
|
|
});
|
|
}
|
|
UndoRedoHeaderFooter.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoHeaderFooter.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoHeaderFooter.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoHeaderFooter.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoHeaderFooter.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (!ws) {
|
|
return;
|
|
}
|
|
|
|
var headerFooter = ws.headerFooter;
|
|
var value = bUndo ? Data.from : Data.to;
|
|
switch (Type) {
|
|
case AscCH.historyitem_Header_First:
|
|
headerFooter.setFirstHeader(value);
|
|
break;
|
|
case AscCH.historyitem_Header_Even:
|
|
headerFooter.setEvenHeader(value);
|
|
break;
|
|
case AscCH.historyitem_Header_Odd:
|
|
headerFooter.setOddHeader(value);
|
|
break;
|
|
case AscCH.historyitem_Footer_First:
|
|
headerFooter.setFirstFooter(value);
|
|
break;
|
|
case AscCH.historyitem_Footer_Even:
|
|
headerFooter.setEvenFooter(value);
|
|
break;
|
|
case AscCH.historyitem_Footer_Odd:
|
|
headerFooter.setOddFooter(value);
|
|
break;
|
|
case AscCH.historyitem_Align_With_Margins:
|
|
headerFooter.setAlignWithMargins(value);
|
|
break;
|
|
case AscCH.historyitem_Scale_With_Doc:
|
|
headerFooter.setScaleWithDoc(value);
|
|
break;
|
|
case AscCH.historyitem_Different_First:
|
|
headerFooter.setDifferentFirst(value);
|
|
break;
|
|
case AscCH.historyitem_Different_Odd_Even:
|
|
headerFooter.setDifferentOddEven(value);
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoPivotTables(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoPivotTables;
|
|
});
|
|
}
|
|
UndoRedoPivotTables.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoPivotTables.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoPivotTables.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoPivotTables.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoPivotTables.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (!ws) {
|
|
return;
|
|
}
|
|
var pivotTable = ws.getPivotTableById(Data.pivot);
|
|
if (!pivotTable) {
|
|
return;
|
|
}
|
|
pivotTable.stashCurReportRange();
|
|
|
|
var value = bUndo ? Data.from : Data.to;
|
|
var valueFrom = bUndo ? Data.to : Data.from;
|
|
switch (Type) {
|
|
case AscCH.historyitem_PivotTable_StyleName:
|
|
pivotTable.asc_getStyleInfo()._setName(value, pivotTable, ws);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_StyleShowRowHeaders:
|
|
pivotTable.asc_getStyleInfo()._setShowRowHeaders(value, pivotTable, ws);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_StyleShowColHeaders:
|
|
pivotTable.asc_getStyleInfo()._setShowColHeaders(value, pivotTable, ws);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_StyleShowRowStripes:
|
|
pivotTable.asc_getStyleInfo()._setShowRowStripes(value, pivotTable, ws);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_StyleShowColStripes:
|
|
pivotTable.asc_getStyleInfo()._setShowColStripes(value, pivotTable, ws);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetName:
|
|
pivotTable.asc_setName(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetRowHeaderCaption:
|
|
pivotTable.asc_setRowHeaderCaption(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetColHeaderCaption:
|
|
pivotTable.asc_setColHeaderCaption(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetDataCaption:
|
|
pivotTable.asc_setDataCaption(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetRowGrandTotals:
|
|
pivotTable.asc_setRowGrandTotals(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetColGrandTotals:
|
|
pivotTable.asc_setColGrandTotals(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetPageOverThenDown:
|
|
pivotTable.asc_setPageOverThenDown(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetPageWrap:
|
|
pivotTable.asc_setPageWrap(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetShowHeaders:
|
|
pivotTable.asc_setShowHeaders(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetGrandTotalCaption:
|
|
pivotTable.asc_setGrandTotalCaption(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetCompact:
|
|
pivotTable.asc_setCompact(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetOutline:
|
|
pivotTable.asc_setOutline(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetGridDropZones:
|
|
pivotTable.asc_setGridDropZones(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_UseAutoFormatting:
|
|
pivotTable.asc_setUseAutoFormatting(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetFillDownLabelsDefault:
|
|
pivotTable.setFillDownLabelsDefault(value, false);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetDataOnRows:
|
|
pivotTable.setDataOnRows(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetDataPosition:
|
|
pivotTable.setDataPosition(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetAltText:
|
|
pivotTable.setTitle(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_SetAltTextSummary:
|
|
pivotTable.setDescription(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_HideValuesRow:
|
|
pivotTable.setHideValuesRow(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_AddPageField:
|
|
if (bUndo) {
|
|
pivotTable.removeNoDataField(Data.from);
|
|
} else {
|
|
pivotTable.addPageField(Data.from, Data.to);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_AddRowField:
|
|
if (bUndo) {
|
|
pivotTable.removeNoDataField(Data.from);
|
|
} else {
|
|
pivotTable.addRowField(Data.from, Data.to);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_AddColField:
|
|
if (bUndo) {
|
|
pivotTable.removeNoDataField(Data.from);
|
|
} else {
|
|
pivotTable.addColField(Data.from, Data.to);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_AddDataField:
|
|
if (bUndo) {
|
|
pivotTable.removeDataField(Data.from, Data.to);
|
|
} else {
|
|
pivotTable.addDataField({
|
|
pivotIndex: Data.from,
|
|
insertIndex: Data.to,
|
|
name: Data.name
|
|
});
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_RemovePageField:
|
|
if (bUndo) {
|
|
pivotTable.addPageField(Data.from, Data.to);
|
|
} else {
|
|
pivotTable.removeNoDataField(Data.from);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_RemoveRowField:
|
|
if (bUndo) {
|
|
pivotTable.addRowField(Data.from, Data.to);
|
|
} else {
|
|
pivotTable.removeNoDataField(Data.from);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_RemoveColField:
|
|
if (bUndo) {
|
|
pivotTable.addColField(Data.from, Data.to);
|
|
} else {
|
|
pivotTable.removeNoDataField(Data.from);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_RemoveDataField:
|
|
if (bUndo) {
|
|
for (var i = Data.to.length - 1; i >= 0; --i) {
|
|
pivotTable.addDataField({
|
|
pivotIndex: Data.from,
|
|
insertIndex: Data.to[i],
|
|
name: Data.name[i]
|
|
});
|
|
}
|
|
} else {
|
|
for (var i = 0; i < Data.to.length; ++i) {
|
|
pivotTable.removeDataField(Data.from, Data.to[i]);
|
|
}
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_MovePageField:
|
|
pivotTable.moveField(pivotTable.asc_getPageFields(), valueFrom, value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_MoveRowField:
|
|
pivotTable.moveField(pivotTable.asc_getRowFields(), valueFrom, value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_MoveColField:
|
|
pivotTable.moveField(pivotTable.asc_getColumnFields(), valueFrom, value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_MoveDataField:
|
|
pivotTable.moveField(pivotTable.asc_getDataFields(), valueFrom, value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_RowItems:
|
|
pivotTable.setRowItems(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_ColItems:
|
|
pivotTable.setColItems(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_Location:
|
|
pivotTable.setLocation(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_CacheField:
|
|
var cacheFields = pivotTable.asc_getCacheFields();
|
|
if (cacheFields && cacheFields[Data.index]) {
|
|
cacheFields[Data.index].checkSharedItems(pivotTable, Data.index, pivotTable.getRecords());
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotField:
|
|
var pivotFields = pivotTable.asc_getPivotFields();
|
|
if (pivotFields[Data.index]) {
|
|
pivotFields[Data.index] = value;
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFilter:
|
|
if (value) {
|
|
if (!pivotTable.filters) {
|
|
pivotTable.filters = new CT_PivotFilters();
|
|
}
|
|
pivotTable.filters.filter.splice(Data.index, 0, value);
|
|
} else if (pivotTable.filters) {
|
|
pivotTable.filters.filter.splice(Data.index, 1);
|
|
if (pivotTable.filters.filter.length == 0) {
|
|
pivotTable.filters = null;
|
|
}
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFilterDataField:
|
|
var pivotFilters = pivotTable.asc_getPivotFilters();
|
|
if (pivotFilters && Data.index < pivotFilters.length) {
|
|
pivotFilters[Data.index].dataField = value;
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFilterMeasureFld:
|
|
var pivotFilters = pivotTable.asc_getPivotFilters();
|
|
if (pivotFilters && Data.index < pivotFilters.length) {
|
|
pivotFilters[Data.index].setMeasureFld(value);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PageFilter:
|
|
var pageField = pivotTable.getPageFieldByFieldIndex(Data.index);
|
|
if (pageField) {
|
|
pageField.item = value;
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotCacheId:
|
|
pivotTable.setPivotCacheId(value);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_FormatsReindex:
|
|
if (bUndo) {
|
|
pivotTable.formats = value;
|
|
} else {
|
|
pivotTable.formatsManager.reIndexDataFields(value, false);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_FormatsRemoveField:
|
|
if (bUndo) {
|
|
pivotTable.formats = value;
|
|
} else {
|
|
pivotTable.formatsManager.removeField(value, false);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_FormatsAddRowField:
|
|
if (bUndo) {
|
|
pivotTable.formats = value;
|
|
} else {
|
|
pivotTable.formatsManager.addRowField(value, false);
|
|
}
|
|
break;
|
|
case AscCH.historyitem_PivotTable_FormatsAddColField:
|
|
if (bUndo) {
|
|
pivotTable.formats = value;
|
|
} else {
|
|
pivotTable.formatsManager.addColField(value, false);
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
function UndoRedoPivotCache(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoPivotCache;
|
|
});
|
|
}
|
|
UndoRedoPivotCache.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoPivotCache.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoPivotCache.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoPivotCache.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoPivotCache.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
const cacheDefinition = this.wb.getPivotTableById(Data.pivot).cacheDefinition;
|
|
switch (Type) {
|
|
case AscCH.historyitem_PivotCache_SetCalculatedItems:
|
|
bUndo ? cacheDefinition.setCalculatedItems(Data.from) : cacheDefinition.setCalculatedItems(Data.to);
|
|
break;
|
|
}
|
|
};
|
|
function UndoRedoCacheFields(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoCacheFields;
|
|
});
|
|
}
|
|
UndoRedoCacheFields.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoCacheFields.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoCacheFields.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoCacheFields.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoCacheFields.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
const cacheDefinition = this.wb.getPivotTableById(Data.pivot).cacheDefinition;
|
|
switch (Type) {
|
|
case AscCH.historyitem_PivotCacheFields_SetCacheField:
|
|
bUndo ? cacheDefinition.setCacheField(Data.index, Data.from) : cacheDefinition.setCacheField(Data.index, Data.to);
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoPivotFields(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoPivotFields;
|
|
});
|
|
}
|
|
UndoRedoPivotFields.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoPivotFields.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoPivotFields.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoPivotFields.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoPivotFields.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (!ws) {
|
|
return;
|
|
}
|
|
var pivotTable = ws.getPivotTableById(Data.pivot);
|
|
if (!pivotTable) {
|
|
return;
|
|
}
|
|
var fields;
|
|
if (Type === AscCH.historyitem_PivotTable_DataFieldSetName ||
|
|
Type === AscCH.historyitem_PivotTable_DataFieldSetSubtotal ||
|
|
Type === AscCH.historyitem_PivotTable_DataFieldSetShowDataAs ||
|
|
Type === AscCH.historyitem_PivotTable_DataFieldSetBaseField ||
|
|
Type === AscCH.historyitem_PivotTable_DataFieldSetBaseItem ||
|
|
Type === AscCH.historyitem_PivotTable_DataFieldSetNumFormat) {
|
|
fields = pivotTable.asc_getDataFields();
|
|
} else {
|
|
fields = pivotTable.asc_getPivotFields();
|
|
}
|
|
var index = AscCH.historyitem_PivotTable_PivotFieldVisible === Type ? Data.index.from : Data.index;
|
|
if (!fields || !fields[index]) {
|
|
return;
|
|
}
|
|
var field = fields[index];
|
|
pivotTable.stashCurReportRange();
|
|
|
|
var value = bUndo ? Data.from : Data.to;
|
|
var valueFrom = bUndo ? Data.to : Data.from;
|
|
switch (Type) {
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetName:
|
|
field.asc_setName(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetOutline:
|
|
field.asc_setOutline(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetCompact:
|
|
field.asc_setCompact(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldFillDownLabelsDefault:
|
|
field.setFillDownLabelsDefault(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetInsertBlankRow:
|
|
field.asc_setInsertBlankRow(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetDefaultSubtotal:
|
|
field.asc_setDefaultSubtotal(value, pivotTable, index);
|
|
field.checkSubtotal();
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetSubtotalTop:
|
|
field.asc_setSubtotalTop(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetSubtotalCaption:
|
|
field.asc_setSubtotalCaption(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetShowAll:
|
|
field.asc_setShowAll(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldVisible:
|
|
field.asc_setVisible(value, pivotTable, index, Data.index.to);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetSubtotals:
|
|
field.setSubtotals(value, pivotTable, index);
|
|
field.checkSubtotal();
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldSetNumFormat:
|
|
field.setNumFormat(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_DataFieldSetName:
|
|
field.asc_setName(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_DataFieldSetSubtotal:
|
|
field.asc_setSubtotal(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_DataFieldSetShowDataAs:
|
|
field.asc_setShowDataAs(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_DataFieldSetBaseField:
|
|
field.asc_setBaseField(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_DataFieldSetBaseItem:
|
|
field.asc_setBaseItem(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_DataFieldSetNumFormat:
|
|
field.setNumFormat(value, pivotTable, index);
|
|
break;
|
|
case AscCH.historyitem_PivotTable_PivotFieldMoveItem:
|
|
field.moveItem(pivotTable, index, valueFrom, value);
|
|
break;
|
|
}
|
|
};
|
|
function UndoRedoPivotFieldItems(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoPivotFieldItems;
|
|
});
|
|
}
|
|
UndoRedoPivotFieldItems.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoPivotFieldItems.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoPivotFieldItems.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoPivotFieldItems.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoPivotFieldItems.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (!ws) {
|
|
return;
|
|
}
|
|
var pivotTable = ws.getPivotTableById(Data.pivot);
|
|
if (!pivotTable) {
|
|
return;
|
|
}
|
|
var field = pivotTable.asc_getPivotFields()[Data.pivotIndex];
|
|
var pivotFieldItem = field.getItem(Data.itemIndex)
|
|
pivotTable.stashCurReportRange();
|
|
|
|
var value = bUndo ? Data.from : Data.to;
|
|
switch (Type) {
|
|
case AscCH.historyitem_PivotTable_PivotFieldItemSetName:
|
|
pivotFieldItem.asc_setName(value, pivotTable, Data.pivotIndex, Data.itemIndex);
|
|
break;
|
|
}
|
|
};
|
|
|
|
function UndoRedoSlicer(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoSlicer;
|
|
});
|
|
}
|
|
UndoRedoSlicer.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoSlicer.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoSlicer.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoSlicer.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoSlicer.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var oModel = (null == nSheetId) ? this.wb : this.wb.getWorksheetById(nSheetId);
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb || !oModel) {
|
|
return;
|
|
}
|
|
|
|
var slicer, slicerCache;
|
|
switch (Type) {
|
|
case AscCH.historyitem_Slicer_SetCaption: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.setCaption(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheSourceName: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.setSourceName(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetTableColName: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.setTableCacheColName(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetTableName: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.setTableName(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheName: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.setCacheName(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetName: {
|
|
slicer = oModel.getSlicerByName(bUndo ? Data.to : Data.from);
|
|
if (slicer) {
|
|
slicer.setName(bUndo ? Data.from : Data.to);
|
|
this.wb.onSlicerUpdate(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetStartItem: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.startItem = bUndo ? Data.from : Data.to;
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetColumnCount: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.columnCount = bUndo ? Data.from : Data.to;
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetShowCaption: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.showCaption = bUndo ? Data.from : Data.to;
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetLevel: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.level = bUndo ? Data.from : Data.to;
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetStyle: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.style = bUndo ? Data.from : Data.to;
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetLockedPosition: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.lockedPosition = bUndo ? Data.from : Data.to;
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetRowHeight: {
|
|
slicer = oModel.getSlicerByName(Data.name);
|
|
if (slicer) {
|
|
slicer.rowHeight = bUndo ? Data.from : Data.to;
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheSortOrder: {
|
|
slicerCache = oModel.getSlicerCacheByName(Data.name);
|
|
if (slicerCache) {
|
|
slicerCache.setSortOrder(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheCustomListSort: {
|
|
slicerCache = oModel.getSlicerCacheByName(Data.name);
|
|
if (slicerCache) {
|
|
slicerCache.setCustomListSort(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheCrossFilter: {
|
|
slicerCache = oModel.getSlicerCacheByName(Data.name);
|
|
if (slicerCache) {
|
|
slicerCache.setCrossFilter(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheHideItemsWithNoData: {
|
|
slicerCache = oModel.getSlicerCacheByName(Data.name);
|
|
if (slicerCache) {
|
|
slicerCache.setHideItemsWithNoData(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheData: {
|
|
slicerCache = oModel.getSlicerCacheByName(Data.name);
|
|
if (slicerCache) {
|
|
var wrapper = bUndo ? Data.from : Data.to;
|
|
var cache = new Asc.CT_slicerCacheDefinition();
|
|
wrapper.initObject(cache);
|
|
cache.initAfterSerialize(this.wb);
|
|
slicerCache.copyFrom(cache);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheMovePivot: {
|
|
slicerCache = oModel.getSlicerCacheByName(Data.name);
|
|
if (slicerCache) {
|
|
var from = bUndo ? Data.to : Data.from;
|
|
var to = bUndo ? Data.from : Data.to;
|
|
slicerCache.movePivotTable(from.value, from.style, to.value, to.style);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Slicer_SetCacheCopySheet: {
|
|
slicerCache = oModel.getSlicerCacheByName(Data.name);
|
|
if (slicerCache) {
|
|
var from = bUndo ? Data.to : Data.from;
|
|
var to = bUndo ? Data.from : Data.to;
|
|
slicerCache.forCopySheet(from, to);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
function UndoRedoCF(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoCF;
|
|
});
|
|
}
|
|
UndoRedoCF.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoCF.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoCF.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoCF.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoCF.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var t = this;
|
|
var oModel = (null == nSheetId) ? this.wb : this.wb.getWorksheetById(nSheetId);
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb || !oModel) {
|
|
return;
|
|
}
|
|
|
|
var collaborativeEditing = this.wb.oApi.collaborativeEditing;
|
|
let cfRule = oModel.getCFRuleById(Data.id, true)
|
|
if (cfRule) {
|
|
var value = bUndo ? Data.from : Data.to;
|
|
|
|
switch (Type) {
|
|
case AscCH.historyitem_CFRule_SetAboveAverage: {
|
|
cfRule.asc_setAboveAverage(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetActivePresent: {
|
|
cfRule.activePresent = value;
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetBottom: {
|
|
cfRule.asc_setBottom(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetEqualAverage: {
|
|
cfRule.asc_setEqualAverage(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetOperator: {
|
|
cfRule.asc_setOperator(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetPercent: {
|
|
cfRule.asc_setPercent(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetPriority: {
|
|
cfRule.asc_setPriority(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetRank: {
|
|
cfRule.asc_setRank(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetStdDev: {
|
|
cfRule.asc_setStdDev(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetStopIfTrue: {
|
|
cfRule.asc_setStopIfTrue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetText: {
|
|
cfRule.asc_setText(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetTimePeriod: {
|
|
cfRule.asc_setTimePeriod(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetType: {
|
|
cfRule.asc_setType(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetPivot: {
|
|
cfRule.pivot = value;
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetDxf: {
|
|
cfRule.asc_setDxf(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetRanges: {
|
|
var toAscRanges = function (_ranges) {
|
|
var ascRanges = [];
|
|
|
|
for (var i = 0; i < _ranges.length; i++) {
|
|
var r1 = t.wb.bCollaborativeChanges ? collaborativeEditing.getLockOtherRow2(nSheetId, _ranges[i].r1) : _ranges[i].r1;
|
|
var c1 = t.wb.bCollaborativeChanges ? collaborativeEditing.getLockOtherColumn2(nSheetId, _ranges[i].c1) : _ranges[i].c1;
|
|
var r2 = t.wb.bCollaborativeChanges ? collaborativeEditing.getLockOtherRow2(nSheetId, _ranges[i].r2) : _ranges[i].r2;
|
|
var c2 = t.wb.bCollaborativeChanges ? collaborativeEditing.getLockOtherColumn2(nSheetId, _ranges[i].c2) : _ranges[i].c2;
|
|
|
|
ascRanges.push(new Asc.Range(c1, r1, c2, r2));
|
|
}
|
|
|
|
return ascRanges;
|
|
};
|
|
|
|
cfRule.ranges = toAscRanges(value);
|
|
if (oModel) {
|
|
oModel.cleanConditionalFormattingRangeIterator();
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_CFRule_SetRuleElements: {
|
|
cfRule.aRuleElements = value;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
function UndoRedoProtectedRange(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoProtectedRange;
|
|
});
|
|
}
|
|
UndoRedoProtectedRange.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoProtectedRange.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoProtectedRange.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoProtectedRange.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
|
|
UndoRedoProtectedRange.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var oModel = (null == nSheetId) ? this.wb : this.wb.getWorksheetById(nSheetId);
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb || !oModel) {
|
|
return;
|
|
}
|
|
|
|
var collaborativeEditing = this.wb.oApi.collaborativeEditing;
|
|
var protectedRange = oModel.getProtectedRangeById(Data.id);
|
|
if (protectedRange && protectedRange.val) {
|
|
var value = bUndo ? Data.from : Data.to;
|
|
protectedRange = protectedRange.val;
|
|
|
|
switch (Type) {
|
|
case AscCH.historyitem_Protected_SetName: {
|
|
protectedRange.asc_setName(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetAlgorithmName: {
|
|
protectedRange.asc_setAlgorithmName(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetHashValue: {
|
|
protectedRange.asc_setHashValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSaltValue: {
|
|
protectedRange.asc_setSaltValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSpinCount: {
|
|
protectedRange.asc_setSpinCount(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSqref: {
|
|
var toAscRanges = function (_ranges) {
|
|
var ascRanges = [];
|
|
|
|
for (var i = 0; i < _ranges.length; i++) {
|
|
var r1 = collaborativeEditing.getLockOtherRow2(nSheetId, _ranges[i].r1);
|
|
var c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, _ranges[i].c1);
|
|
var r2 = collaborativeEditing.getLockOtherRow2(nSheetId, _ranges[i].r2);
|
|
var c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, _ranges[i].c2);
|
|
|
|
ascRanges.push(new Asc.Range(c1, r1, c2, r2));
|
|
}
|
|
|
|
return ascRanges;
|
|
};
|
|
|
|
protectedRange.sqref = toAscRanges(value);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
function UndoRedoProtectedSheet(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoProtectedSheet;
|
|
});
|
|
}
|
|
UndoRedoProtectedSheet.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoProtectedSheet.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoProtectedSheet.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoProtectedSheet.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
|
|
UndoRedoProtectedSheet.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var oModel = (null == nSheetId) ? this.wb : this.wb.getWorksheetById(nSheetId);
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb || !oModel) {
|
|
return;
|
|
}
|
|
|
|
var protectedSheet = oModel.sheetProtection;
|
|
if (!protectedSheet) {
|
|
oModel.sheetProtection = protectedSheet = new window["Asc"].CSheetProtection();
|
|
oModel.sheetProtection.setDefaultInterface();
|
|
}
|
|
|
|
if (protectedSheet) {
|
|
var value = bUndo ? Data.from : Data.to;
|
|
|
|
switch (Type) {
|
|
case AscCH.historyitem_Protected_SetAlgorithmName: {
|
|
protectedSheet.setAlgorithmName(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetHashValue: {
|
|
protectedSheet.setHashValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSaltValue: {
|
|
protectedSheet.setSaltValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSpinCount: {
|
|
protectedSheet.setSpinCount(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetPassword: {
|
|
protectedSheet.setPasswordXL(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSheet: {
|
|
protectedSheet.setSheet(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetObjects: {
|
|
protectedSheet.setObjects(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetScenarios: {
|
|
protectedSheet.setScenarios(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetFormatCells: {
|
|
protectedSheet.setFormatCells(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetFormatColumns: {
|
|
protectedSheet.setFormatColumns(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetInsertColumns: {
|
|
protectedSheet.setInsertColumns(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetInsertRows: {
|
|
protectedSheet.setInsertRows(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetFormatRows: {
|
|
protectedSheet.setFormatRows(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetInsertHyperlinks: {
|
|
protectedSheet.setInsertHyperlinks(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetDeleteRows: {
|
|
protectedSheet.setDeleteRows(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetDeleteColumns: {
|
|
protectedSheet.setDeleteColumns(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSelectLockedCells: {
|
|
protectedSheet.setSelectLockedCells(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSort: {
|
|
protectedSheet.setSort(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetAutoFilter: {
|
|
protectedSheet.setAutoFilter(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetPivotTables: {
|
|
protectedSheet.setPivotTables(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetSelectUnlockedCells: {
|
|
protectedSheet.setSelectUnlockedCells(value);
|
|
break;
|
|
}
|
|
}
|
|
if (bUndo) {
|
|
if (oModel.sheetProtection && oModel.sheetProtection.isDefault()) {
|
|
oModel.sheetProtection = null;
|
|
}
|
|
}
|
|
this.wb.handlers.trigger("asc_onChangeProtectWorksheet", oModel.index);
|
|
}
|
|
};
|
|
|
|
function UndoRedoProtectedWorkbook(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoProtectedWorkbook;
|
|
});
|
|
}
|
|
UndoRedoProtectedWorkbook.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoProtectedWorkbook.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoProtectedWorkbook.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoProtectedWorkbook.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
|
|
UndoRedoProtectedWorkbook.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var oModel = (null == nSheetId) ? this.wb : this.wb.getWorksheetById(nSheetId);
|
|
var api = window["Asc"]["editor"];
|
|
if (!api.wb || !oModel) {
|
|
return;
|
|
}
|
|
|
|
var protectedWorkbook = oModel.workbookProtection;
|
|
if (!protectedWorkbook) {
|
|
oModel.workbookProtection = protectedWorkbook = new window["Asc"].CWorkbookProtection();
|
|
}
|
|
|
|
if (protectedWorkbook) {
|
|
var value = bUndo ? Data.from : Data.to;
|
|
|
|
switch (Type) {
|
|
case AscCH.historyitem_Protected_SetLockStructure: {
|
|
protectedWorkbook.setLockStructure(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetLockWindows: {
|
|
protectedWorkbook.asc_setLockWindows(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetLockRevision: {
|
|
protectedWorkbook.asc_setLockRevision(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetRevisionsAlgorithmName: {
|
|
protectedWorkbook.asc_setRevisionsAlgorithmName(value);
|
|
break;
|
|
}
|
|
|
|
case AscCH.historyitem_Protected_SetRevisionsHashValue: {
|
|
protectedWorkbook.asc_setRevisionsHashValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetRevisionsSaltValue: {
|
|
protectedWorkbook.asc_setRevisionsSaltValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetRevisionsSpinCount: {
|
|
protectedWorkbook.asc_setRevisionsSpinCount(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetWorkbookAlgorithmName: {
|
|
protectedWorkbook.asc_setWorkbookAlgorithmName(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetWorkbookHashValue: {
|
|
protectedWorkbook.asc_setWorkbookHashValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetWorkbookSaltValue: {
|
|
protectedWorkbook.asc_setWorkbookSaltValue(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetWorkbookSpinCount: {
|
|
protectedWorkbook.asc_setWorkbookSpinCount(value);
|
|
break;
|
|
}
|
|
case AscCH.historyitem_Protected_SetPassword: {
|
|
protectedWorkbook.setPasswordXL(value);
|
|
break;
|
|
}
|
|
}
|
|
oModel.handlers.trigger("asc_onChangeProtectWorkbook");
|
|
}
|
|
};
|
|
|
|
function UndoRedoNamedSheetViews(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoNamedSheetViews;
|
|
});
|
|
}
|
|
UndoRedoNamedSheetViews.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoNamedSheetViews.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoNamedSheetViews.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoNamedSheetViews.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoNamedSheetViews.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (!ws) {
|
|
return;
|
|
}
|
|
var api = window["Asc"]["editor"];
|
|
var sheetView;
|
|
switch (Type) {
|
|
case AscCH.historyitem_NamedSheetView_SetName: {
|
|
sheetView = ws.getNamedSheetViewById(Data.sheetView);
|
|
if (sheetView) {
|
|
sheetView.setName(bUndo ? Data.from : Data.to);
|
|
}
|
|
break;
|
|
}
|
|
case AscCH.historyitem_NamedSheetView_DeleteFilter: {
|
|
sheetView = ws.getNamedSheetViewById(Data.sheetView);
|
|
if (sheetView && bUndo) {
|
|
sheetView.nsvFilters.push(Data.from);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
function UndoRedoUserProtectedRange(wb) {
|
|
UndoRedoClassBase.call(this);
|
|
this.wb = wb;
|
|
this.nType = UndoRedoClassTypes.Add(function () {
|
|
return AscCommonExcel.g_oUndoRedoUserProtectedRange;
|
|
});
|
|
}
|
|
UndoRedoUserProtectedRange.prototype = Object.create(UndoRedoClassBase.prototype);
|
|
UndoRedoUserProtectedRange.prototype.getClassType = function () {
|
|
return this.nType;
|
|
};
|
|
UndoRedoUserProtectedRange.prototype.Undo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, true);
|
|
};
|
|
UndoRedoUserProtectedRange.prototype.Redo = function (Type, Data, nSheetId) {
|
|
this.UndoRedo(Type, Data, nSheetId, false);
|
|
};
|
|
UndoRedoUserProtectedRange.prototype.UndoRedo = function (Type, Data, nSheetId, bUndo) {
|
|
var wb = this.wb;
|
|
var ws = this.wb.getWorksheetById(nSheetId);
|
|
if (!ws) {
|
|
return;
|
|
}
|
|
var userProtectedRange = ws.getUserProtectedRangeById(Data.id);
|
|
if (!userProtectedRange) {
|
|
return;
|
|
}
|
|
|
|
var value = bUndo ? Data.from : Data.to;
|
|
switch (Type) {
|
|
case AscCH.historyitem_UserProtectedRange_Ref:
|
|
var from = null, to = null, temp;
|
|
var collaborativeEditing = this.wb.oApi.collaborativeEditing;
|
|
if (null != Data.from && null != Data.from.r1 && null != Data.from.c1 && null != Data.from.r2 &&
|
|
null != Data.from.c2) {
|
|
from = new Asc.Range(Data.from.c1, Data.from.r1, Data.from.c2, Data.from.r2);
|
|
if (wb.bCollaborativeChanges) {
|
|
from.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r1);
|
|
from.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c1);
|
|
from.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, from.r2);
|
|
from.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, from.c2);
|
|
}
|
|
}
|
|
to = null;
|
|
if (null != Data.to && null != Data.to.r1 && null != Data.to.c1 && null != Data.to.r2 &&
|
|
null != Data.to.c2) {
|
|
to = new Asc.Range(Data.to.c1, Data.to.r1, Data.to.c2, Data.to.r2);
|
|
if (wb.bCollaborativeChanges) {
|
|
to.r1 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r1);
|
|
to.c1 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c1);
|
|
to.r2 = collaborativeEditing.getLockOtherRow2(nSheetId, to.r2);
|
|
to.c2 = collaborativeEditing.getLockOtherColumn2(nSheetId, to.c2);
|
|
}
|
|
}
|
|
if (bUndo) {
|
|
temp = from;
|
|
from = to;
|
|
to = temp;
|
|
}
|
|
|
|
userProtectedRange.obj.setLocation(to);
|
|
break;
|
|
}
|
|
};
|
|
|
|
//----------------------------------------------------------export----------------------------------------------------
|
|
window['AscCommonExcel'] = window['AscCommonExcel'] || {};
|
|
window['AscCommonExcel'].UndoRedoItemSerializable = UndoRedoItemSerializable;
|
|
window['AscCommonExcel'].UndoRedoClassTypes = UndoRedoClassTypes;
|
|
window['AscCommonExcel'].UndoRedoDataTypes = UndoRedoDataTypes;
|
|
window['AscCommonExcel'].UndoRedoData_CellSimpleData = UndoRedoData_CellSimpleData;
|
|
window['AscCommonExcel'].UndoRedoData_CellData = UndoRedoData_CellData;
|
|
window['AscCommonExcel'].UndoRedoData_CellValueData = UndoRedoData_CellValueData;
|
|
window['AscCommonExcel'].UndoRedoData_FromToRowCol = UndoRedoData_FromToRowCol;
|
|
window['AscCommonExcel'].UndoRedoData_FromTo = UndoRedoData_FromTo;
|
|
window['AscCommonExcel'].UndoRedoData_FromToHyperlink = UndoRedoData_FromToHyperlink;
|
|
window['AscCommonExcel'].UndoRedoData_IndexSimpleProp = UndoRedoData_IndexSimpleProp;
|
|
window['AscCommonExcel'].UndoRedoData_ColProp = UndoRedoData_ColProp;
|
|
window['AscCommonExcel'].UndoRedoData_RowProp = UndoRedoData_RowProp;
|
|
window['AscCommonExcel'].UndoRedoData_BBox = UndoRedoData_BBox;
|
|
window['AscCommonExcel'].UndoRedoData_FrozenBBox = UndoRedoData_FrozenBBox;
|
|
window['AscCommonExcel'].UndoRedoData_SortData = UndoRedoData_SortData;
|
|
window['AscCommonExcel'].UndoRedoData_PivotTable = UndoRedoData_PivotTable;
|
|
window['AscCommonExcel'].UndoRedoData_PivotCache = UndoRedoData_PivotCache;
|
|
window['AscCommonExcel'].UndoRedoData_CacheFields = UndoRedoData_CacheFields;
|
|
window['AscCommonExcel'].UndoRedoData_DataField = UndoRedoData_DataField;
|
|
window['AscCommonExcel'].UndoRedoData_PivotTableRedo = UndoRedoData_PivotTableRedo;
|
|
window['AscCommonExcel'].UndoRedoData_PivotField = UndoRedoData_PivotField;
|
|
window['AscCommonExcel'].UndoRedoData_PivotFieldItem = UndoRedoData_PivotFieldItem;
|
|
window['AscCommonExcel'].UndoRedoData_Layout = UndoRedoData_Layout;
|
|
window['AscCommonExcel'].UndoRedoData_SheetAdd = UndoRedoData_SheetAdd;
|
|
window['AscCommonExcel'].UndoRedoData_SheetRemove = UndoRedoData_SheetRemove;
|
|
window['AscCommonExcel'].UndoRedoData_DefinedNames = UndoRedoData_DefinedNames;
|
|
window['AscCommonExcel'].UndoRedoData_ClrScheme = UndoRedoData_ClrScheme;
|
|
window['AscCommonExcel'].UndoRedoData_AutoFilter = UndoRedoData_AutoFilter;
|
|
window['AscCommonExcel'].UndoRedoData_SingleProperty = UndoRedoData_SingleProperty;
|
|
window['AscCommonExcel'].UndoRedoData_ArrayFormula = UndoRedoData_ArrayFormula;
|
|
window['AscCommonExcel'].UndoRedoData_SortState = UndoRedoData_SortState;
|
|
window['AscCommonExcel'].UndoRedoData_Slicer = UndoRedoData_Slicer;
|
|
window['AscCommonExcel'].UndoRedoData_DataValidation = UndoRedoData_DataValidation;
|
|
window['AscCommonExcel'].UndoRedoData_CF = UndoRedoData_CF;
|
|
window['AscCommonExcel'].UndoRedoData_ProtectedRange = UndoRedoData_ProtectedRange;
|
|
window['AscCommonExcel'].UndoRedoData_UserProtectedRange = UndoRedoData_UserProtectedRange;
|
|
window['AscCommonExcel'].UndoRedoData_RowColBreaks = UndoRedoData_RowColBreaks;
|
|
window['AscCommonExcel'].UndoRedoData_LegacyDrawingHFDrawing = UndoRedoData_LegacyDrawingHFDrawing;
|
|
window['AscCommonExcel'].UndoRedoWorkbook = UndoRedoWorkbook;
|
|
window['AscCommonExcel'].UndoRedoCell = UndoRedoCell;
|
|
window['AscCommonExcel'].UndoRedoWoorksheet = UndoRedoWoorksheet;
|
|
window['AscCommonExcel'].UndoRedoRowCol = UndoRedoRowCol;
|
|
window['AscCommonExcel'].UndoRedoComment = UndoRedoComment;
|
|
window['AscCommonExcel'].UndoRedoAutoFilters = UndoRedoAutoFilters;
|
|
window['AscCommonExcel'].UndoRedoSparklines = UndoRedoSparklines;
|
|
window['AscCommonExcel'].UndoRedoSharedFormula = UndoRedoSharedFormula;
|
|
window['AscCommonExcel'].UndoRedoRedoLayout = UndoRedoRedoLayout;
|
|
window['AscCommonExcel'].UndoRedoArrayFormula = UndoRedoArrayFormula;
|
|
window['AscCommonExcel'].UndoRedoHeaderFooter = UndoRedoHeaderFooter;
|
|
window['AscCommonExcel'].UndoRedoSortState = UndoRedoSortState;
|
|
window['AscCommonExcel'].UndoRedoData_BinaryWrapper = UndoRedoData_BinaryWrapper;
|
|
window['AscCommonExcel'].UndoRedoData_BinaryWrapper2 = UndoRedoData_BinaryWrapper2;
|
|
window['AscCommonExcel'].UndoRedoPivotTables = UndoRedoPivotTables;
|
|
window['AscCommonExcel'].UndoRedoPivotFields = UndoRedoPivotFields;
|
|
window['AscCommonExcel'].UndoRedoPivotCache = UndoRedoPivotCache;
|
|
window['AscCommonExcel'].UndoRedoCacheFields = UndoRedoCacheFields;
|
|
window['AscCommonExcel'].UndoRedoPivotFieldItems = UndoRedoPivotFieldItems;
|
|
window['AscCommonExcel'].UndoRedoSlicer = UndoRedoSlicer;
|
|
window['AscCommonExcel'].UndoRedoCF = UndoRedoCF;
|
|
window['AscCommonExcel'].UndoRedoProtectedRange = UndoRedoProtectedRange;
|
|
window['AscCommonExcel'].UndoRedoProtectedSheet = UndoRedoProtectedSheet;
|
|
window['AscCommonExcel'].UndoRedoProtectedWorkbook = UndoRedoProtectedWorkbook;
|
|
window['AscCommonExcel'].UndoRedoUserProtectedRange = UndoRedoUserProtectedRange;
|
|
|
|
window['AscCommonExcel'].g_oUndoRedoWorkbook = null;
|
|
window['AscCommonExcel'].g_oUndoRedoCell = null;
|
|
window['AscCommonExcel'].g_oUndoRedoWorksheet = null;
|
|
window['AscCommonExcel'].g_oUndoRedoRow = null;
|
|
window['AscCommonExcel'].g_oUndoRedoCol = null;
|
|
window['AscCommonExcel'].g_oUndoRedoComment = null;
|
|
window['AscCommonExcel'].g_oUndoRedoAutoFilters = null;
|
|
window['AscCommonExcel'].g_oUndoRedoSparklines = null;
|
|
window['AscCommonExcel'].g_oUndoRedoPivotTables = null;
|
|
window['AscCommonExcel'].g_oUndoRedoPivotFields = null;
|
|
window['AscCommonExcel'].g_oUndoRedoPivotCache = null;
|
|
window['AscCommonExcel'].g_oUndoRedoCacheFields = null;
|
|
window['AscCommonExcel'].g_oUndoRedoPivotFieldItems = null;
|
|
window['AscCommonExcel'].g_oUndoRedoSharedFormula = null;
|
|
window['AscCommonExcel'].g_oUndoRedoLayout = null;
|
|
window['AscCommonExcel'].g_UndoRedoArrayFormula = null;
|
|
window['AscCommonExcel'].g_oUndoRedoHeaderFooter = null;
|
|
window['AscCommonExcel'].g_oUndoRedoSlicer = null;
|
|
window['AscCommonExcel'].g_oUndoRedoNamedSheetViews = null;
|
|
window['AscCommonExcel'].g_oUndoRedoCF = null;
|
|
window['AscCommonExcel'].g_UndoRedoProtectedRange = null;
|
|
window['AscCommonExcel'].g_UndoRedoProtectedSheet = null;
|
|
window['AscCommonExcel'].g_UndoRedoProtectedWorkbook = null;
|
|
|
|
window['AscCommonExcel'].UndoRedoNamedSheetViews = UndoRedoNamedSheetViews;
|
|
window['AscCommonExcel'].UndoRedoData_NamedSheetView = UndoRedoData_NamedSheetView;
|
|
window['AscCommonExcel'].UndoRedoData_NamedSheetViewRedo = UndoRedoData_NamedSheetViewRedo;
|
|
|
|
})(window);
|