4276 lines
134 KiB
JavaScript
4276 lines
134 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
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* @param {Window} window
|
|
* @param {undefined} undefined
|
|
*/
|
|
(function (window, undefined) {
|
|
|
|
|
|
var CBaseObject = AscFormat.CBaseObject;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetLocks] = AscDFH.CChangesDrawingsLong;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetDrawingBaseType] = AscDFH.CChangesDrawingsLong;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetDrawingBaseEditAs] = AscDFH.CChangesDrawingsLong;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetWorksheet] = AscDFH.CChangesDrawingsString;
|
|
AscDFH.changesFactory[AscDFH.historyitem_ShapeSetBDeleted] = AscDFH.CChangesDrawingsBool;
|
|
|
|
AscDFH.changesFactory[AscDFH.historyitem_ShapeSetMacro] = AscDFH.CChangesDrawingsString;
|
|
AscDFH.changesFactory[AscDFH.historyitem_ShapeSetTextLink] = AscDFH.CChangesDrawingsString;
|
|
AscDFH.changesFactory[AscDFH.historyitem_ShapeSetModelId] = AscDFH.CChangesDrawingsString;
|
|
|
|
AscDFH.changesFactory[AscDFH.historyitem_ShapeSetFLocksText] = AscDFH.CChangesDrawingsBool;
|
|
|
|
|
|
AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetDrawingBasePos] = AscDFH.CChangesDrawingsObjectNoId;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetDrawingBaseExt] = AscDFH.CChangesDrawingsObjectNoId;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AutoShapes_SetDrawingBaseCoors] = AscDFH.CChangesDrawingsObjectNoId;
|
|
AscDFH.changesFactory[AscDFH.historyitem_ShapeSetClientData] = AscDFH.CChangesDrawingsObjectNoId;
|
|
AscDFH.changesFactory[AscDFH.historyitem_ShapeSetUseBgFill] = AscDFH.CChangesDrawingsBool;
|
|
|
|
|
|
var drawingsChangesMap = window['AscDFH'].drawingsChangesMap;
|
|
|
|
drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetLocks] = function (oClass, value) {
|
|
oClass.locks = value;
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_ShapeSetBDeleted] = function (oClass, value) {
|
|
oClass.bDeleted = value;
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetDrawingBaseType] = function (oClass, value) {
|
|
if (oClass.drawingBase) {
|
|
oClass.drawingBase.Type = value;
|
|
oClass.handleUpdateExtents();
|
|
}
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetDrawingBaseEditAs] = function (oClass, value) {
|
|
if (oClass.drawingBase) {
|
|
oClass.drawingBase.editAs = value;
|
|
oClass.handleUpdateExtents();
|
|
}
|
|
};
|
|
|
|
drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetWorksheet] = function (oClass, value) {
|
|
if (typeof value === "string") {
|
|
var oApi = window['Asc'] && window['Asc']['editor'];
|
|
if (oApi && oApi.wbModel) {
|
|
oClass.worksheet = oApi.wbModel.getWorksheetById(value);
|
|
} else {
|
|
oClass.worksheet = null;
|
|
}
|
|
} else {
|
|
oClass.worksheet = null;
|
|
}
|
|
};
|
|
|
|
|
|
drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetDrawingBasePos] = function (oClass, value) {
|
|
if (value) {
|
|
if (oClass.drawingBase && oClass.drawingBase.Pos) {
|
|
oClass.drawingBase.Pos.X = value.a;
|
|
oClass.drawingBase.Pos.Y = value.b;
|
|
oClass.handleUpdatePosition();
|
|
}
|
|
}
|
|
};
|
|
|
|
drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetDrawingBaseExt] = function (oClass, value) {
|
|
if (value) {
|
|
if (oClass.drawingBase && oClass.drawingBase.ext) {
|
|
oClass.drawingBase.ext.cx = value.a;
|
|
oClass.drawingBase.ext.cy = value.b;
|
|
oClass.handleUpdateExtents();
|
|
}
|
|
}
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_AutoShapes_SetDrawingBaseCoors] = function (oClass, value) {
|
|
if (value) {
|
|
if (oClass.drawingBase) {
|
|
oClass.drawingBase.from.col = value.fromCol;
|
|
oClass.drawingBase.from.colOff = value.fromColOff;
|
|
oClass.drawingBase.from.row = value.fromRow;
|
|
oClass.drawingBase.from.rowOff = value.fromRowOff;
|
|
oClass.drawingBase.to.col = value.toCol;
|
|
oClass.drawingBase.to.colOff = value.toColOff;
|
|
oClass.drawingBase.to.row = value.toRow;
|
|
oClass.drawingBase.to.rowOff = value.toRowOff;
|
|
oClass.drawingBase.Pos.X = value.posX;
|
|
oClass.drawingBase.Pos.Y = value.posY;
|
|
oClass.drawingBase.ext.cx = value.cx;
|
|
oClass.drawingBase.ext.cy = value.cy;
|
|
oClass.handleUpdateExtents();
|
|
}
|
|
}
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_ShapeSetClientData] = function (oClass, value) {
|
|
oClass.clientData = value;
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_ShapeSetUseBgFill] = function (oClass, value) {
|
|
oClass.useBgFill = value;
|
|
};
|
|
|
|
|
|
drawingsChangesMap[AscDFH.historyitem_ShapeSetMacro] = function (oClass, value) {
|
|
oClass.macro = value;
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_ShapeSetTextLink] = function (oClass, value) {
|
|
oClass.textLink = value;
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_ShapeSetModelId] = function (oClass, value) {
|
|
oClass.modelId = value;
|
|
};
|
|
drawingsChangesMap[AscDFH.historyitem_ShapeSetFLocksText] = function (oClass, value) {
|
|
oClass.fLocksText = value;
|
|
};
|
|
|
|
AscDFH.drawingsConstructorsMap[AscDFH.historyitem_AutoShapes_SetDrawingBasePos] = CDrawingBaseCoordsWritable;
|
|
AscDFH.drawingsConstructorsMap[AscDFH.historyitem_AutoShapes_SetDrawingBaseExt] = CDrawingBaseCoordsWritable;
|
|
AscDFH.drawingsConstructorsMap[AscDFH.historyitem_AutoShapes_SetDrawingBaseCoors] = CDrawingBasePosWritable;
|
|
AscDFH.drawingsConstructorsMap[AscDFH.historyitem_ShapeSetClientData] = CClientData;
|
|
|
|
var LOCKS_MASKS =
|
|
{
|
|
noGrp: 1,
|
|
noUngrp: 4,
|
|
noSelect: 16,
|
|
noRot: 64,
|
|
noChangeAspect: 256,
|
|
noMove: 1024,
|
|
noResize: 4096,
|
|
noEditPoints: 16384,
|
|
noAdjustHandles: 65536,
|
|
noChangeArrowheads: 262144,
|
|
noChangeShapeType: 1048576,
|
|
noDrilldown: 4194304,
|
|
noTextEdit: 8388608,
|
|
noCrop: 16777216,
|
|
txBox: 33554432
|
|
};
|
|
|
|
function checkNormalRotate(rot) {
|
|
var _rot = normalizeRotate(rot);
|
|
return (_rot >= 0 && _rot < Math.PI * 0.25) || (_rot >= 3 * Math.PI * 0.25 && _rot < 5 * Math.PI * 0.25) || (_rot >= 7 * Math.PI * 0.25 && _rot < 2 * Math.PI);
|
|
}
|
|
|
|
function normalizeRotate(rot) {
|
|
var new_rot = rot;
|
|
if (AscFormat.isRealNumber(new_rot)) {
|
|
while (new_rot >= 2 * Math.PI)
|
|
new_rot -= 2 * Math.PI;
|
|
while (new_rot < 0)
|
|
new_rot += 2 * Math.PI;
|
|
if (AscFormat.fApproxEqual(new_rot, 2 * Math.PI, 0.001)) {
|
|
new_rot = 0.0;
|
|
}
|
|
return new_rot;
|
|
}
|
|
return new_rot;
|
|
}
|
|
|
|
|
|
function CDrawingBaseCoordsWritable(a, b) {
|
|
this.a = a;
|
|
this.b = b;
|
|
}
|
|
|
|
CDrawingBaseCoordsWritable.prototype.Write_ToBinary = function (Writer) {
|
|
Writer.WriteDouble(this.a);
|
|
Writer.WriteDouble(this.b);
|
|
};
|
|
|
|
CDrawingBaseCoordsWritable.prototype.Read_FromBinary = function (Reader) {
|
|
this.a = Reader.GetDouble();
|
|
this.b = Reader.GetDouble();
|
|
};
|
|
|
|
window['AscFormat'].CDrawingBaseCoordsWritable = CDrawingBaseCoordsWritable;
|
|
|
|
function CDrawingBasePosWritable(oObject) {
|
|
|
|
this.fromCol = null;
|
|
this.fromColOff = null;
|
|
this.fromRow = null;
|
|
this.fromRowOff = null;
|
|
this.toCol = null;
|
|
this.toColOff = null;
|
|
this.toRow = null;
|
|
this.toRowOff = null;
|
|
this.posX = null;
|
|
this.posY = null;
|
|
this.cx = null;
|
|
this.cy = null;
|
|
if (oObject) {
|
|
this.fromCol = oObject.fromCol;
|
|
this.fromColOff = oObject.fromColOff;
|
|
this.fromRow = oObject.fromRow;
|
|
this.fromRowOff = oObject.fromRowOff;
|
|
this.toCol = oObject.toCol;
|
|
this.toColOff = oObject.toColOff;
|
|
this.toRow = oObject.toRow;
|
|
this.toRowOff = oObject.toRowOff;
|
|
this.posX = oObject.posX;
|
|
this.posY = oObject.posY;
|
|
this.cx = oObject.cx;
|
|
this.cy = oObject.cy;
|
|
}
|
|
}
|
|
|
|
CDrawingBasePosWritable.prototype.Write_ToBinary = function (Writer) {
|
|
AscFormat.writeLong(Writer, this.fromCol);
|
|
AscFormat.writeDouble(Writer, this.fromColOff);
|
|
AscFormat.writeLong(Writer, this.fromRow);
|
|
AscFormat.writeDouble(Writer, this.fromRowOff);
|
|
AscFormat.writeLong(Writer, this.toCol);
|
|
AscFormat.writeDouble(Writer, this.toColOff);
|
|
AscFormat.writeLong(Writer, this.toRow);
|
|
AscFormat.writeDouble(Writer, this.toRowOff);
|
|
AscFormat.writeDouble(Writer, this.posX);
|
|
AscFormat.writeDouble(Writer, this.posY);
|
|
AscFormat.writeDouble(Writer, this.cx);
|
|
AscFormat.writeDouble(Writer, this.cy);
|
|
};
|
|
CDrawingBasePosWritable.prototype.Read_FromBinary = function (Reader) {
|
|
this.fromCol = AscFormat.readLong(Reader);
|
|
this.fromColOff = AscFormat.readDouble(Reader);
|
|
this.fromRow = AscFormat.readLong(Reader);
|
|
this.fromRowOff = AscFormat.readDouble(Reader);
|
|
this.toCol = AscFormat.readLong(Reader);
|
|
this.toColOff = AscFormat.readDouble(Reader);
|
|
this.toRow = AscFormat.readLong(Reader);
|
|
this.toRowOff = AscFormat.readDouble(Reader);
|
|
this.posX = AscFormat.readDouble(Reader);
|
|
this.posY = AscFormat.readDouble(Reader);
|
|
this.cx = AscFormat.readDouble(Reader);
|
|
this.cy = AscFormat.readDouble(Reader);
|
|
};
|
|
CDrawingBasePosWritable.prototype.CommuteRelated = function (oActionToUndo, oActionOther) {
|
|
let res = AscCommonExcel.g_oUndoRedoWorksheet.CommuteRelatedRange2(this.fromRow, this.fromCol, this.toRow, this.toCol, oActionOther);
|
|
if (res) {
|
|
this.fromRow = AscCommonExcel.g_oUndoRedoWorksheet.tmpRange.r1;
|
|
this.fromCol = AscCommonExcel.g_oUndoRedoWorksheet.tmpRange.c1;
|
|
this.toRow = AscCommonExcel.g_oUndoRedoWorksheet.tmpRange.r2;
|
|
this.toCol = AscCommonExcel.g_oUndoRedoWorksheet.tmpRange.c2;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
function CClientData(fLocksWithSheet, fPrintsWithSheet) {
|
|
this.fLocksWithSheet = fLocksWithSheet !== undefined ? fLocksWithSheet : null;
|
|
this.fPrintsWithSheet = fPrintsWithSheet !== undefined ? fPrintsWithSheet : null;
|
|
}
|
|
|
|
CClientData.prototype.Write_ToBinary = function (Writer) {
|
|
AscFormat.writeBool(Writer, this.fLocksWithSheet);
|
|
AscFormat.writeBool(Writer, this.fPrintsWithSheet);
|
|
};
|
|
CClientData.prototype.Read_FromBinary = function (Reader) {
|
|
this.fLocksWithSheet = AscFormat.readBool(Reader);
|
|
this.fPrintsWithSheet = AscFormat.readBool(Reader);
|
|
};
|
|
CClientData.prototype.createDuplicate = function () {
|
|
return new CClientData(this.fLocksWithSheet, this.fPrintsWithSheet);
|
|
};
|
|
|
|
/**
|
|
* Class represent bounds graphical object
|
|
* @param {number} l
|
|
* @param {number} t
|
|
* @param {number} r
|
|
* @param {number} b
|
|
* @constructor
|
|
*/
|
|
function CGraphicBounds(l, t, r, b) {
|
|
this.l = l;
|
|
this.t = t;
|
|
this.r = r;
|
|
this.b = b;
|
|
this.checkWH();
|
|
}
|
|
|
|
CGraphicBounds.prototype.fromOther = function (oBounds) {
|
|
this.l = oBounds.l;
|
|
this.t = oBounds.t;
|
|
this.r = oBounds.r;
|
|
this.b = oBounds.b;
|
|
this.checkWH();
|
|
};
|
|
CGraphicBounds.prototype.copy = function () {
|
|
return new CGraphicBounds(this.l, this.t, this.r, this.b);
|
|
};
|
|
CGraphicBounds.prototype.transform = function (oTransform) {
|
|
if(!oTransform) {
|
|
return;
|
|
}
|
|
var xlt = oTransform.TransformPointX(this.l, this.t);
|
|
var ylt = oTransform.TransformPointY(this.l, this.t);
|
|
|
|
var xrt = oTransform.TransformPointX(this.r, this.t);
|
|
var yrt = oTransform.TransformPointY(this.r, this.t);
|
|
var xlb = oTransform.TransformPointX(this.l, this.b);
|
|
var ylb = oTransform.TransformPointY(this.l, this.b);
|
|
|
|
var xrb = oTransform.TransformPointX(this.r, this.b);
|
|
var yrb = oTransform.TransformPointY(this.r, this.b);
|
|
|
|
this.l = Math.min(xlb, xlt, xrb, xrt);
|
|
this.t = Math.min(ylb, ylt, yrb, yrt);
|
|
|
|
this.r = Math.max(xlb, xlt, xrb, xrt);
|
|
this.b = Math.max(ylb, ylt, yrb, yrt);
|
|
|
|
this.checkWH();
|
|
};
|
|
CGraphicBounds.prototype.shift = function(dx, dy) {
|
|
this.l -= dx;
|
|
this.t -= dy;
|
|
this.r -= dx;
|
|
this.b -= dy;
|
|
this.checkWH();
|
|
};
|
|
CGraphicBounds.prototype.transformRect = function (oTransform) {
|
|
this.shift(this.l, this.t);
|
|
this.transform(oTransform);
|
|
};
|
|
|
|
|
|
CGraphicBounds.prototype.checkByOther = function (oBounds) {
|
|
if (oBounds) {
|
|
if (oBounds.l < this.l) {
|
|
this.l = oBounds.l;
|
|
}
|
|
if (oBounds.t < this.t) {
|
|
this.t = oBounds.t;
|
|
}
|
|
if (oBounds.r > this.r) {
|
|
this.r = oBounds.r;
|
|
}
|
|
if (oBounds.b > this.b) {
|
|
this.b = oBounds.b;
|
|
}
|
|
this.checkWH();
|
|
}
|
|
};
|
|
CGraphicBounds.prototype.checkPoint = function (dX, dY) {
|
|
if (dX < this.l) {
|
|
this.l = dX;
|
|
}
|
|
if (dX > this.r) {
|
|
this.r = dX;
|
|
}
|
|
if (dY < this.t) {
|
|
this.t = dY;
|
|
}
|
|
if (dY > this.b) {
|
|
this.b = dY;
|
|
}
|
|
this.checkWH();
|
|
};
|
|
CGraphicBounds.prototype.checkWH = function () {
|
|
|
|
this.x = this.l;
|
|
this.y = this.t;
|
|
this.w = this.r - this.l;
|
|
this.h = this.b - this.t;
|
|
};
|
|
CGraphicBounds.prototype.reset = function (l, t, r, b) {
|
|
|
|
this.l = l;
|
|
this.t = t;
|
|
this.r = r;
|
|
this.b = b;
|
|
this.checkWH();
|
|
};
|
|
|
|
|
|
CGraphicBounds.prototype.isIntersect = function (l, t, r, b) {
|
|
|
|
if (l > this.r) {
|
|
return false;
|
|
}
|
|
if (r < this.l) {
|
|
return false;
|
|
}
|
|
if (t > this.b) {
|
|
return false;
|
|
}
|
|
if (b < this.t) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
CGraphicBounds.prototype.isIntersectOther = function (o) {
|
|
return this.isIntersect(o.l, o.t, o.r, o.b)
|
|
};
|
|
|
|
CGraphicBounds.prototype.intersection = function (o) {
|
|
var oRes = null;
|
|
var l = Math.max(this.l, o.l);
|
|
var t = Math.max(this.t, o.t);
|
|
var r = Math.min(this.r, o.r);
|
|
var b = Math.min(this.b, o.b);
|
|
if (l <= r && t <= b) {
|
|
return new CGraphicBounds(l, t, r, b);
|
|
}
|
|
return oRes;
|
|
};
|
|
CGraphicBounds.prototype.hit = function (x, y) {
|
|
return x >= this.l && x <= this.r && y >= this.t && y <= this.b;
|
|
};
|
|
CGraphicBounds.prototype.isEqual = function (oBounds) {
|
|
if (!oBounds) {
|
|
return false;
|
|
}
|
|
return AscFormat.fApproxEqual(this.l, oBounds.l) &&
|
|
AscFormat.fApproxEqual(this.t, oBounds.t) &&
|
|
AscFormat.fApproxEqual(this.r, oBounds.r) &&
|
|
AscFormat.fApproxEqual(this.b, oBounds.b);
|
|
};
|
|
CGraphicBounds.prototype.getPixSize = function(dScale) {
|
|
return {w: this.w * dScale + 0.5 >> 0, h: this.h * dScale + 0.5 >> 0};
|
|
};
|
|
CGraphicBounds.prototype.getCenter = function() {
|
|
return {x: (this.l + this.r) / 2.0, y: (this.t + this.b) / 2.0};
|
|
};
|
|
CGraphicBounds.prototype.createCanvas = function (dScale) {
|
|
const oPixSize = this.getPixSize(dScale);
|
|
const nWidth = oPixSize.w;
|
|
const nHeight = oPixSize.h;
|
|
if (nWidth === 0 || nHeight === 0) {
|
|
return null;
|
|
}
|
|
const oCanvas = document.createElement('canvas');
|
|
if(!oCanvas) {
|
|
return null;
|
|
}
|
|
oCanvas.width = nWidth;
|
|
oCanvas.height = nHeight;
|
|
return oCanvas;
|
|
};
|
|
CGraphicBounds.prototype.createGraphicsFromCanvas = function (oCanvas, dScale) {
|
|
const oCtx = oCanvas.getContext('2d');
|
|
if(!oCtx) {
|
|
return null;
|
|
}
|
|
const nWidth = oCanvas.width;
|
|
const nHeight = oCanvas.height;
|
|
const oGraphics = new AscCommon.CGraphics();
|
|
oGraphics.init(oCtx, nWidth, nHeight, nWidth / dScale, nHeight / dScale);
|
|
oGraphics.m_oFontManager = AscCommon.g_fontManager;
|
|
return oGraphics;
|
|
};
|
|
|
|
CGraphicBounds.prototype.createGraphics = function (dScale) {
|
|
return this.createGraphicsFromCanvas(this.createCanvas(dScale));
|
|
};
|
|
|
|
CGraphicBounds.prototype.drawFillTexture = function (oGraphics, oUnifill) {
|
|
AscFormat.ExecuteNoHistory(function () {
|
|
const oGeometry = new AscFormat.CreateGeometry("rect");
|
|
oGeometry.Recalculate(this.w, this.h, true);
|
|
oGraphics.save();
|
|
const oMatrix = new AscCommon.CMatrix();
|
|
oGraphics.transform3(oMatrix);
|
|
const oShapeDrawer = new AscCommon.CShapeDrawer();
|
|
oShapeDrawer.Graphics = oGraphics;
|
|
oShapeDrawer.fromShape2(new AscFormat.CColorObj(null, oUnifill, oGeometry), oGraphics, oGeometry);
|
|
oShapeDrawer.draw(oGeometry);
|
|
oGraphics.restore();
|
|
}, this, []);
|
|
};
|
|
|
|
|
|
CGraphicBounds.prototype.toObject = function () {
|
|
return {
|
|
"X": this.x,
|
|
"Y": this.y,
|
|
"W": this.w,
|
|
"H": this.h
|
|
};
|
|
};
|
|
|
|
function CCopyObjectProperties() {
|
|
this.drawingDocument = null;
|
|
this.idMap = null;
|
|
this.bSaveSourceFormatting = null;
|
|
this.contentCopyPr = null;
|
|
this.cacheImage = true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Base class for all graphic objects
|
|
* @constructor
|
|
*/
|
|
function CGraphicObjectBase() {
|
|
|
|
CBaseObject.call(this);
|
|
/*Format fields*/
|
|
this.spPr = null;
|
|
this.group = null;
|
|
this.parent = null;
|
|
this.bDeleted = true;
|
|
this.locks = 0;
|
|
this.macro = null;
|
|
this.textLink = null;
|
|
this.modelId = null;
|
|
this.fLocksText = null;
|
|
this.clientData = null;
|
|
|
|
/*Calculated fields*/
|
|
this.posX = null;
|
|
this.posY = null;
|
|
this.x = 0;
|
|
this.y = 0;
|
|
this.extX = 0;
|
|
this.extY = 0;
|
|
this.rot = 0;
|
|
this.flipH = false;
|
|
this.flipV = false;
|
|
this.bounds = new CGraphicBounds(0, 0, 0, 0);
|
|
this.localTransform = new AscCommon.CMatrix();
|
|
this.transform = new AscCommon.CMatrix();
|
|
this.invertTransform = null;
|
|
this.pen = null;
|
|
this.brush = null;
|
|
this.snapArrayX = [];
|
|
this.snapArrayY = [];
|
|
|
|
this.selected = false;
|
|
|
|
this.cropObject = null;
|
|
this.Lock = new AscCommon.CLock();
|
|
this.setRecalculateInfo();
|
|
}
|
|
|
|
CGraphicObjectBase.prototype = Object.create(CBaseObject.prototype);
|
|
CGraphicObjectBase.prototype.constructor = CGraphicObjectBase;
|
|
|
|
CGraphicObjectBase.prototype.isDrawing = true;
|
|
CGraphicObjectBase.prototype.notAllowedWithoutId = function () {
|
|
return true;
|
|
};
|
|
/**
|
|
* Create a scheme color
|
|
* @memberof CGraphicObjectBase
|
|
* @returns {CGraphicBounds}
|
|
*/
|
|
CGraphicObjectBase.prototype.checkBoundsRect = function () {
|
|
var aCheckX = [], aCheckY = [];
|
|
this.calculateSnapArrays(aCheckX, aCheckY, this.localTransform);
|
|
return new CGraphicBounds(Math.min.apply(Math, aCheckX), Math.min.apply(Math, aCheckY), Math.max.apply(Math, aCheckX), Math.max.apply(Math, aCheckY));
|
|
};
|
|
/**
|
|
* Set default recalculate info
|
|
* @memberof CGraphicObjectBase
|
|
*/
|
|
CGraphicObjectBase.prototype.setRecalculateInfo = function () {
|
|
};
|
|
/**
|
|
* Get object bounds for defining group size
|
|
* @memberof CGraphicObjectBase
|
|
* @returns {CGraphicBounds}
|
|
*/
|
|
CGraphicObjectBase.prototype.getBoundsInGroup = function () {
|
|
var r = this.rot;
|
|
if (!AscFormat.isRealNumber(r) || AscFormat.checkNormalRotate(r)) {
|
|
return new CGraphicBounds(this.x, this.y, this.x + this.extX, this.y + this.extY);
|
|
} else {
|
|
var hc = this.extX * 0.5;
|
|
var vc = this.extY * 0.5;
|
|
var xc = this.x + hc;
|
|
var yc = this.y + vc;
|
|
return new CGraphicBounds(xc - vc, yc - hc, xc + vc, yc + hc);
|
|
}
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.hasSmartArt = function (bReturnSmartArt) {
|
|
return bReturnSmartArt ? null : false;
|
|
}
|
|
/**
|
|
* Normalize a size object in group
|
|
* @memberof CGraphicObjectBase
|
|
*/
|
|
CGraphicObjectBase.prototype.normalize = function () {
|
|
var new_off_x, new_off_y, new_ext_x, new_ext_y;
|
|
var xfrm = this.spPr.xfrm;
|
|
if (!AscCommon.isRealObject(this.group)) {
|
|
new_off_x = xfrm.offX;
|
|
new_off_y = xfrm.offY;
|
|
new_ext_x = xfrm.extX;
|
|
new_ext_y = xfrm.extY;
|
|
} else {
|
|
var scale_scale_coefficients = this.group.getResultScaleCoefficients();
|
|
new_off_x = scale_scale_coefficients.cx * (xfrm.offX - this.group.spPr.xfrm.chOffX);
|
|
new_off_y = scale_scale_coefficients.cy * (xfrm.offY - this.group.spPr.xfrm.chOffY);
|
|
new_ext_x = scale_scale_coefficients.cx * xfrm.extX;
|
|
new_ext_y = scale_scale_coefficients.cy * xfrm.extY;
|
|
var txXfrm = this.txXfrm;
|
|
if (txXfrm) {
|
|
|
|
var new_tx_off_x = scale_scale_coefficients.cx * txXfrm.offX;
|
|
var new_tx_off_y = scale_scale_coefficients.cy * txXfrm.offY;
|
|
var new_tx_ext_x = scale_scale_coefficients.cx * txXfrm.extX;
|
|
var new_tx_ext_y = scale_scale_coefficients.cy * txXfrm.extY;
|
|
|
|
Math.abs(new_tx_off_x - txXfrm.offX) > AscFormat.MOVE_DELTA && txXfrm.setOffX(new_tx_off_x);
|
|
Math.abs(new_tx_off_y - txXfrm.offY) > AscFormat.MOVE_DELTA && txXfrm.setOffY(new_tx_off_y);
|
|
Math.abs(new_tx_ext_x - txXfrm.extX) > AscFormat.MOVE_DELTA && txXfrm.setExtX(new_tx_ext_x);
|
|
Math.abs(new_tx_ext_y - txXfrm.extY) > AscFormat.MOVE_DELTA && txXfrm.setExtY(new_tx_ext_y);
|
|
}
|
|
}
|
|
Math.abs(new_off_x - xfrm.offX) > AscFormat.MOVE_DELTA && xfrm.setOffX(new_off_x);
|
|
Math.abs(new_off_y - xfrm.offY) > AscFormat.MOVE_DELTA && xfrm.setOffY(new_off_y);
|
|
Math.abs(new_ext_x - xfrm.extX) > AscFormat.MOVE_DELTA && xfrm.setExtX(new_ext_x);
|
|
Math.abs(new_ext_y - xfrm.extY) > AscFormat.MOVE_DELTA && xfrm.setExtY(new_ext_y);
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.checkHiddenInAnimation = function () {
|
|
if (AscCommonSlide.Slide && (this.parent instanceof AscCommonSlide.Slide)) {
|
|
var oGrObjects = this.parent.graphicObjects;
|
|
if (oGrObjects) {
|
|
if (oGrObjects.isSlideShow()) {
|
|
var oAnimPlayer = oGrObjects.getAnimationPlayer();
|
|
if (oAnimPlayer) {
|
|
if (oAnimPlayer.isDrawingHidden(this.Get_Id())) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
/**
|
|
* Check point hit to bounds object
|
|
* @memberof CGraphicObjectBase
|
|
*/
|
|
CGraphicObjectBase.prototype.checkHitToBounds = function (x, y) {
|
|
if (this.parent && (this.parent.Get_ParentTextTransform && this.parent.Get_ParentTextTransform())) {
|
|
return true;
|
|
}
|
|
if (this.checkHiddenInAnimation && this.checkHiddenInAnimation()) {
|
|
return false;
|
|
}
|
|
|
|
if (!AscFormat.canSelectDrawing(this)) {
|
|
return false;
|
|
}
|
|
var _x, _y;
|
|
if (AscFormat.isRealNumber(this.posX) && AscFormat.isRealNumber(this.posY)) {
|
|
_x = x - this.posX - this.bounds.x;
|
|
_y = y - this.posY - this.bounds.y;
|
|
} else {
|
|
_x = x - this.bounds.x;
|
|
_y = y - this.bounds.y;
|
|
}
|
|
var delta = 3 + (this.pen && AscFormat.isRealNumber(this.pen.w) ? this.pen.w / 36000 : 0);
|
|
if (_x >= -delta && _x <= this.bounds.w + delta && _y >= -delta && _y <= this.bounds.h + delta) {
|
|
var oClipRect;
|
|
if (this.getClipRect) {
|
|
oClipRect = this.getClipRect();
|
|
}
|
|
if (oClipRect) {
|
|
if (x < oClipRect.x || x > oClipRect.x + oClipRect.w
|
|
|| y < oClipRect.y || y > oClipRect.y + oClipRect.h) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
|
|
CGraphicObjectBase.prototype.getRectBounds = function () {
|
|
let aSnapX = [];
|
|
let aSnapY = [];
|
|
this.calculateSnapArrays(aSnapX, aSnapY, this.getTransformMatrix());
|
|
return new CGraphicBounds(Math.min.apply(Math, aSnapX), Math.min.apply(Math, aSnapY), Math.max.apply(Math, aSnapX), Math.max.apply(Math, aSnapY));
|
|
};
|
|
/**
|
|
* Internal method for calculating snap arrays
|
|
* @param {Array} snapArrayX
|
|
* @param {Array} snapArrayY
|
|
* @param {CMatrix} transform
|
|
* @memberof CGraphicObjectBase
|
|
*/
|
|
CGraphicObjectBase.prototype.calculateSnapArrays = function (snapArrayX, snapArrayY, transform) {
|
|
var t = transform ? transform : this.transform;
|
|
snapArrayX.push(t.TransformPointX(0, 0));
|
|
snapArrayY.push(t.TransformPointY(0, 0));
|
|
snapArrayX.push(t.TransformPointX(this.extX, 0));
|
|
snapArrayY.push(t.TransformPointY(this.extX, 0));
|
|
|
|
snapArrayX.push(t.TransformPointX(this.extX * 0.5, this.extY * 0.5));
|
|
snapArrayY.push(t.TransformPointY(this.extX * 0.5, this.extY * 0.5));
|
|
snapArrayX.push(t.TransformPointX(this.extX, this.extY));
|
|
snapArrayY.push(t.TransformPointY(this.extX, this.extY));
|
|
snapArrayX.push(t.TransformPointX(0, this.extY));
|
|
snapArrayY.push(t.TransformPointY(0, this.extY));
|
|
};
|
|
/**
|
|
* Public method for calculating snap arrays
|
|
* @memberof CGraphicObjectBase
|
|
*/
|
|
CGraphicObjectBase.prototype.recalculateSnapArrays = function () {
|
|
this.snapArrayX.length = 0;
|
|
this.snapArrayY.length = 0;
|
|
this.calculateSnapArrays(this.snapArrayX, this.snapArrayY, null);
|
|
};
|
|
CGraphicObjectBase.prototype.setLocks = function (nLocks) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsLong(this, AscDFH.historyitem_AutoShapes_SetLocks, this.locks, nLocks));
|
|
this.locks = nLocks;
|
|
};
|
|
CGraphicObjectBase.prototype.readMacro = function (oStream) {
|
|
var nLength = oStream.GetULong();//length
|
|
var nType = oStream.GetUChar();//attr type - 0
|
|
this.setMacro(oStream.GetString2());
|
|
};
|
|
CGraphicObjectBase.prototype.writeMacro = function (oWriter) {
|
|
if (typeof this.macro === "string" && this.macro.length > 0) {
|
|
oWriter.StartRecord(0xA1);
|
|
oWriter._WriteString1(0, this.macro);
|
|
oWriter.EndRecord();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.ReadRedactIds = function (oReader) {
|
|
oReader.GetULong();//length
|
|
|
|
let nRedacts = oReader.GetULong();
|
|
for (let i = 0; i < nRedacts; i++) {
|
|
let sId = oReader.GetString2();
|
|
|
|
if (Asc.editor.isPdfEditor()) {
|
|
this.AddRedactId(sId);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.WriteRedactIds = function(oWriter) {
|
|
oWriter.StartRecord(0xFF);
|
|
oWriter.WriteULong(0);
|
|
oWriter.EndRecord();
|
|
};
|
|
CGraphicObjectBase.prototype.setMacro = function (sMacroName) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsString(this, AscDFH.historyitem_ShapeSetMacro, this.macro, sMacroName));
|
|
this.macro = sMacroName;
|
|
};
|
|
CGraphicObjectBase.prototype.setModelId = function (sModelId) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsString(this, AscDFH.historyitem_ShapeSetModelId, this.modelId, sModelId));
|
|
this.modelId = sModelId;
|
|
};
|
|
CGraphicObjectBase.prototype.setFLocksText = function (bLock) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsBool(this, AscDFH.historyitem_ShapeSetFLocksText, this.fLocksText, bLock));
|
|
this.fLocksText = bLock;
|
|
};
|
|
CGraphicObjectBase.prototype.setClientData = function (oClientData) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObjectNoId(this, AscDFH.historyitem_ShapeSetClientData, this.clientData, oClientData));
|
|
this.clientData = oClientData;
|
|
};
|
|
CGraphicObjectBase.prototype.checkClientData = function () {
|
|
if (!this.clientData) {
|
|
this.setClientData(new CClientData());
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getProtectionLockText = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getProtectionLocked = function () {
|
|
if (this.group) {
|
|
return this.group.getProtectionLocked();
|
|
}
|
|
if (!this.clientData) {
|
|
return true;
|
|
}
|
|
return this.clientData.fLocksWithSheet !== false;
|
|
};
|
|
CGraphicObjectBase.prototype.getProtectionPrint = function () {
|
|
if (this.group) {
|
|
return this.group.getProtectionPrint();
|
|
}
|
|
if (!this.clientData) {
|
|
return false;
|
|
}
|
|
return this.clientData.fPrintsWithSheet !== false;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.setProtectionLockText = function (bVal) {
|
|
if (this.getObjectType() === AscDFH.historyitem_type_Shape) {
|
|
if (bVal === true || bVal === false) {
|
|
var bValToSet = bVal ? null : false;
|
|
if (this.fLocksText !== bValToSet) {
|
|
this.setFLocksText(bValToSet);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setProtectionLocked = function (bVal) {
|
|
if (bVal === true || bVal === false) {
|
|
if (this.group) {
|
|
this.group.setProtectionLocked(bVal);
|
|
return
|
|
}
|
|
this.checkClientData();
|
|
var bValToSet = bVal ? undefined : false;
|
|
if (this.clientData.fLocksWithSheet !== bValToSet) {
|
|
var oData = this.clientData.createDuplicate();
|
|
oData.fLocksWithSheet = bValToSet;
|
|
this.setClientData(oData);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setProtectionPrint = function (bVal) {
|
|
if (bVal === true || bVal === false) {
|
|
if (this.group) {
|
|
this.group.setProtectionPrint(bVal);
|
|
return
|
|
}
|
|
this.checkClientData();
|
|
var bValToSet = bVal ? undefined : false;
|
|
if (this.clientData.fPrintsWithSheet !== bValToSet) {
|
|
var oData = this.clientData.createDuplicate();
|
|
oData.fPrintsWithSheet = bValToSet;
|
|
this.setClientData(oData);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.assignMacro = function (sGuid) {
|
|
if (Array.isArray(this.spTree)) {
|
|
for (var nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].assignMacro(sGuid);
|
|
}
|
|
return;
|
|
}
|
|
if (typeof sGuid === "string" && sGuid.length > 0) {
|
|
this.setMacro(AscFormat.MACRO_PREFIX + sGuid);
|
|
} else {
|
|
this.setMacro(null);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setTextLink = function (sLink) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsString(this, AscDFH.historyitem_ShapeSetTextLink, this.textLink, sLink));
|
|
this.textLink = sLink;
|
|
};
|
|
CGraphicObjectBase.prototype.hasMacro = function () {
|
|
var sMacro = this.getMacroOwnOrGroup();
|
|
if (sMacro !== null) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.getMacroOwnOrGroup = function () {
|
|
if (Array.isArray(this.spTree)) {
|
|
if (this.spTree.length > 0) {
|
|
var oSp = this.spTree[0];
|
|
var sMacro = oSp.getMacroOwnOrGroup();
|
|
if (!sMacro) {
|
|
return null;
|
|
}
|
|
for (let nSp = 1; nSp < this.spTree.length; ++nSp) {
|
|
if (sMacro !== this.spTree[nSp].getMacroOwnOrGroup()) {
|
|
return null;
|
|
}
|
|
}
|
|
return sMacro;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
if (typeof this.macro === "string" && this.macro.length > 0) {
|
|
return this.macro;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.hasJSAMacro = function () {
|
|
var sMacro = this.getMacroOwnOrGroup();
|
|
if (typeof sMacro === "string" && sMacro.indexOf(AscFormat.MACRO_PREFIX) === 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.getJSAMacroId = function () {
|
|
var sMacro = this.getMacroOwnOrGroup();
|
|
if (typeof sMacro === "string" && sMacro.indexOf(AscFormat.MACRO_PREFIX) === 0) {
|
|
return sMacro.slice(AscFormat.MACRO_PREFIX.length);
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getLockValue = function (nMask) {
|
|
return !!((this.locks & nMask) && (this.locks & (nMask << 1)));
|
|
};
|
|
CGraphicObjectBase.prototype.setLockValue = function (nMask, bValue) {
|
|
if (!AscFormat.isRealBool(bValue)) {
|
|
this.setLocks((~nMask) & this.locks);
|
|
} else {
|
|
this.setLocks(AscFormat.fUpdateLocksValue(this.locks, nMask, bValue));
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getNoGrp = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noGrp);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoUngrp = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noUngrp);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoSelect = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noSelect);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoRot = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noRot);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoChangeAspect = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noChangeAspect);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoMove = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noMove);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoResize = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noResize);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoEditPoints = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noEditPoints);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoAdjustHandles = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noAdjustHandles);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoChangeArrowheads = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noChangeArrowheads);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoChangeShapeType = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noChangeShapeType);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoDrilldown = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noDrilldown);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoTextEdit = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noTextEdit);
|
|
};
|
|
CGraphicObjectBase.prototype.getNoCrop = function () {
|
|
return this.getLockValue(LOCKS_MASKS.noCrop);
|
|
};
|
|
CGraphicObjectBase.prototype.getTxBox = function () {
|
|
return this.getLockValue(LOCKS_MASKS.txBox);
|
|
};
|
|
CGraphicObjectBase.prototype.setTxBox = function (bValue) {
|
|
return this.setLockValue(LOCKS_MASKS.txBox, bValue);
|
|
};
|
|
CGraphicObjectBase.prototype.setNoChangeAspect = function (bValue) {
|
|
return this.setLockValue(LOCKS_MASKS.noChangeAspect, bValue);
|
|
};
|
|
CGraphicObjectBase.prototype.canEditGeometry = function () {
|
|
return this.getObjectType() === AscDFH.historyitem_type_Shape &&
|
|
!this.isPlaceholder() &&
|
|
this.getNoEditPoints() !== true &&
|
|
!!(this.spPr && this.spPr.geometry) && !(this.isObjectInSmartArt()); // todo: functionality not available in microsoft for smartart shapes, but the OOX format supports it, currently blocked due to resizing blocking
|
|
};
|
|
CGraphicObjectBase.prototype.canEditTableOleObject = function (bReturnOle) {
|
|
return bReturnOle ? null : false;
|
|
};
|
|
CGraphicObjectBase.prototype.canRotate = function () {
|
|
if (!this.canEdit()) {
|
|
return false;
|
|
}
|
|
return this.getNoRot() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.canResize = function () {
|
|
if (!this.canEdit()) {
|
|
return false;
|
|
}
|
|
return this.getNoResize() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.canSelect = function () {
|
|
return this.getNoSelect() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.canResize = function () {
|
|
if (!this.canEdit()) {
|
|
return false;
|
|
}
|
|
return this.getNoResize() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.canMove = function () {
|
|
var oApi = Asc.editor || editor;
|
|
var isDrawHandles = oApi ? oApi.isShowShapeAdjustments() : true;
|
|
if (isDrawHandles === false) {
|
|
return false;
|
|
}
|
|
if (!this.canEdit()) {
|
|
return false;
|
|
}
|
|
return this.getNoMove() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.canGroup = function () {
|
|
if (!this.canEdit()) {
|
|
return false;
|
|
}
|
|
return this.getNoGrp() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.canUnGroup = function () {
|
|
if (!this.canEdit()) {
|
|
return false;
|
|
}
|
|
return (this.getObjectType() === AscDFH.historyitem_type_GroupShape || this.getObjectType() === AscDFH.historyitem_type_SmartArt && this.drawing) && this.getNoUngrp() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.canChangeAdjustments = function () {
|
|
if (!this.canEdit()) {
|
|
return false;
|
|
}
|
|
return !this.isObjectInSmartArt() && this.getNoAdjustHandles() === false;
|
|
};
|
|
CGraphicObjectBase.prototype.Reassign_ImageUrls = function (mapUrl) {
|
|
var blip_fill;
|
|
if (this.blipFill) {
|
|
if (mapUrl[this.blipFill.RasterImageId]) {
|
|
if (this.setBlipFill) {
|
|
blip_fill = this.blipFill.createDuplicate();
|
|
blip_fill.setRasterImageId(mapUrl[this.blipFill.RasterImageId]);
|
|
this.setBlipFill(blip_fill);
|
|
}
|
|
}
|
|
}
|
|
if (this.spPr && this.spPr.Fill && this.spPr.Fill.fill && this.spPr.Fill.fill.RasterImageId) {
|
|
if (mapUrl[this.spPr.Fill.fill.RasterImageId] && mapUrl[this.spPr.Fill.fill.RasterImageId] !== this.spPr.Fill.fill.RasterImageId) {
|
|
blip_fill = this.spPr.Fill.fill.createDuplicate();
|
|
blip_fill.setRasterImageId(mapUrl[this.spPr.Fill.fill.RasterImageId]);
|
|
var oUniFill = this.spPr.Fill.createDuplicate();
|
|
oUniFill.setFill(blip_fill);
|
|
this.spPr.setFill(oUniFill);
|
|
}
|
|
}
|
|
if (Array.isArray(this.spTree)) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].Reassign_ImageUrls) {
|
|
this.spTree[i].Reassign_ImageUrls(mapUrl);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getAllFonts = function (mapUrl) {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcText = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.collectEquations3 = function (aEquations) {
|
|
if (Array.isArray(this.spTree)) {
|
|
for (var nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].collectEquations3(aEquations);
|
|
}
|
|
}
|
|
if (this.m_oMathObject) {
|
|
aEquations.push(this);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getOuterShdw = function () {
|
|
if (this.isShadowSp) {
|
|
return null;
|
|
}
|
|
let outerShdw = null;
|
|
if (this.spPr) {
|
|
outerShdw = this.spPr.getOuterShdw();
|
|
}
|
|
if (!outerShdw) {
|
|
let parents = this.getParentObjects();
|
|
let compiled_style = this.getCompiledStyle && this.getCompiledStyle();
|
|
if (isRealObject(parents.theme) && isRealObject(compiled_style) && isRealObject(compiled_style.effectRef)) {
|
|
outerShdw = parents.theme.getOuterShdw(compiled_style.effectRef.idx);
|
|
}
|
|
}
|
|
if(!outerShdw) {
|
|
if(this.getHierarchy) {
|
|
let aHierarchy = this.getHierarchy();
|
|
for(let nIdx = 0; nIdx < aHierarchy.length; ++nIdx) {
|
|
let oDrawing = aHierarchy[nIdx];
|
|
if(oDrawing) {
|
|
outerShdw = oDrawing.getOuterShdw();
|
|
if(outerShdw) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return outerShdw;
|
|
};
|
|
CGraphicObjectBase.prototype.getOuterShdwAsc = function () {
|
|
const oShdw = this.getOuterShdw();
|
|
if(!oShdw) {
|
|
return null;
|
|
}
|
|
let oAscShdw = oShdw.getAscShdw();
|
|
if(oAscShdw) {
|
|
oAscShdw.checkColor(this.Get_Theme(), this.Get_ColorMap());
|
|
}
|
|
return oAscShdw;
|
|
};
|
|
CGraphicObjectBase.prototype.getShadowFill = function (oShadowColor, oShapeUniFill) {
|
|
let oShadowFill;
|
|
if (oShadowColor) {
|
|
const oMainFill = oShapeUniFill && oShapeUniFill.fill;
|
|
if (oMainFill && oMainFill.type === Asc.c_oAscFill.FILL_TYPE_GRAD) {
|
|
oShadowFill = new AscFormat.CUniFill();
|
|
oShadowFill.fill = new AscFormat.CGradFill();
|
|
oShadowFill.fill.setLin(oMainFill.lin ? oMainFill.lin.createDuplicate() : null);
|
|
oShadowFill.fill.setPath(oMainFill.path ? oMainFill.path.createDuplicate() : null);
|
|
oShadowFill.fill.rotateWithShape = oMainFill.rotateWithShape;
|
|
for (let i = 0; i < oMainFill.colors.length; i += 1) {
|
|
const oMainGs = oMainFill.colors[i];
|
|
const oMainUniColor = oMainGs.color;
|
|
const nMainColorAlphaValue = oMainUniColor && oMainUniColor.getModValue('alpha');
|
|
|
|
const oGs = new AscFormat.CGs();
|
|
const oNewColor = oShadowColor.createDuplicate();
|
|
if (AscFormat.isRealNumber(nMainColorAlphaValue)) {
|
|
let oAlphaMod = oNewColor.getMod('alpha');
|
|
if (!oAlphaMod) {
|
|
oAlphaMod = new AscFormat.CColorMod('alpha', 100000);
|
|
oNewColor.addColorMod(oAlphaMod);
|
|
}
|
|
oAlphaMod.val = oAlphaMod.val * nMainColorAlphaValue / 100000;
|
|
}
|
|
oGs.setColor(oNewColor);
|
|
oGs.setPos(oMainGs.pos);
|
|
oShadowFill.fill.addColor(oGs);
|
|
}
|
|
} else {
|
|
const nTransparency = oShadowColor.getTransparency();
|
|
const nAlpha = 255 - 255 * nTransparency / 100;
|
|
const nMainAlpha = oShapeUniFill && AscFormat.isRealNumber(oShapeUniFill.transparent) ? oShapeUniFill.transparent : 255;
|
|
oShadowFill = AscFormat.CreateUniFillByUniColorCopy(oShadowColor);
|
|
oShadowFill.transparent = nAlpha * nMainAlpha / 255;
|
|
}
|
|
} else {
|
|
oShadowFill = AscFormat.CreateUniFillByUniColor(AscFormat.CreateUniColorRGB(0, 0, 0));
|
|
}
|
|
return oShadowFill;
|
|
};
|
|
CGraphicObjectBase.prototype.recalculateShdw = function () {
|
|
|
|
this.shdwSp = null;
|
|
var outerShdw = this.getOuterShdw && this.getOuterShdw();
|
|
if (outerShdw) {
|
|
AscFormat.ExecuteNoHistory(function () {
|
|
let geometry = this.calcGeometry || this.spPr && this.spPr.geometry;
|
|
|
|
let oParentObjects = this.getParentObjects();
|
|
let track_object = new AscFormat.NewShapeTrack("rect", 0, 0, oParentObjects.theme, oParentObjects.master, oParentObjects.layout, oParentObjects.slide, 0);
|
|
track_object.track({}, 0, 0);
|
|
let shape = track_object.getShape(false, null, null);
|
|
shape.isShadowSp = true;
|
|
shape.setStyle(null);
|
|
let oSpPr = shape.spPr;
|
|
if (geometry) {
|
|
oSpPr.setGeometry(geometry.createDuplicate());
|
|
}
|
|
if ((this.getObjectType() === AscDFH.historyitem_type_Shape || this.getObjectType() === AscDFH.historyitem_type_Control)
|
|
&& (!this.brush || !this.brush.isVisible())) {
|
|
if (this.pen && this.pen.isVisible()) {
|
|
oSpPr.Fill = AscFormat.CreateNoFillUniFill();
|
|
oSpPr.ln = this.pen.createDuplicate();
|
|
oSpPr.ln.Fill = this.getShadowFill(outerShdw.color, this.pen.Fill);
|
|
} else {
|
|
oSpPr.Fill = AscFormat.CreateNoFillUniFill();
|
|
oSpPr.ln = AscFormat.CreateNoFillLine();
|
|
}
|
|
} else {
|
|
oSpPr.Fill = this.getShadowFill(outerShdw.color, this.brush);
|
|
oSpPr.ln = AscFormat.CreateNoFillLine();
|
|
}
|
|
let penW = 0;
|
|
if (this.pen && this.pen.isVisible() && this.brush && this.brush.isVisible()) {
|
|
penW = this.pen.w ? this.pen.w / 36000.0 : 12700.0 / 36000.0;
|
|
}
|
|
let W = this.extX + penW;
|
|
let H = this.extY + penW;
|
|
let W0 = W;
|
|
let H0 = H;
|
|
let bFlipH = false;
|
|
let bFlipV = false;
|
|
if (outerShdw.sx) {
|
|
W *= Math.abs(outerShdw.sx / 100000);
|
|
bFlipH = outerShdw.sx < 0;
|
|
}
|
|
if (outerShdw.sy) {
|
|
H *= Math.abs(outerShdw.sy / 100000);
|
|
bFlipV = outerShdw.sy < 0;
|
|
}
|
|
|
|
let dist = outerShdw.dist ? outerShdw.dist / 36000 : 0;
|
|
if(AscFormat.fApproxEqual(W, W0) && AscFormat.fApproxEqual(H, H0) && AscFormat.fApproxEqual(dist, 0)) {
|
|
const nAppendValue = 1;
|
|
W += nAppendValue;
|
|
H += nAppendValue;
|
|
penW += nAppendValue;
|
|
}
|
|
let oXfrm = oSpPr.xfrm;
|
|
oXfrm.setExtX(W);
|
|
oXfrm.setExtY(H);
|
|
oXfrm.setOffX(0);
|
|
oXfrm.setOffY(0);
|
|
oXfrm.setFlipH(bFlipH);
|
|
oXfrm.setFlipV(bFlipV);
|
|
if (!(this.parent && this.parent.Extent)) {
|
|
shape.setParent(this.parent);
|
|
}
|
|
shape.recalculate();
|
|
shape.shdwPenW = penW;
|
|
this.shdwSp = shape;
|
|
}, this, []);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.handleObject = function (fCallback) {
|
|
fCallback(this);
|
|
};
|
|
CGraphicObjectBase.prototype.clearLang = function () {
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.editTxStyleLst = function (ParaPr, bSelect) {
|
|
};
|
|
CGraphicObjectBase.prototype.checkEditTextStyle = function (fDocContentMethod, params) {
|
|
return false;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.isObjectInSmartArt = function () {
|
|
if (this.group && this.group.isSmartArtObject()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.isGroupObject = function () {
|
|
var nType = this.getObjectType();
|
|
return nType === AscDFH.historyitem_type_GroupShape || nType === AscDFH.historyitem_type_LockedCanvas || this.isSmartArtObject() || nType === AscDFH.historyitem_type_Pdf_Annot_FreeText;
|
|
};
|
|
CGraphicObjectBase.prototype.isSmartArtObject = function () {
|
|
var nType = this.getObjectType();
|
|
return nType === AscDFH.historyitem_type_SmartArt ||
|
|
nType === AscDFH.historyitem_type_SmartArtDrawing;
|
|
};
|
|
CGraphicObjectBase.prototype.isOleObject = function () {
|
|
return this.getObjectType() === AscDFH.historyitem_type_OleObject;
|
|
};
|
|
CGraphicObjectBase.prototype.isSignatureLine = function () {
|
|
return this.getObjectType() === AscDFH.historyitem_type_Shape && this.signatureLine;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.isShape = function () {
|
|
return this.getObjectType() === AscDFH.historyitem_type_Shape;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.isGroup = function () {
|
|
return false;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.isChart = function () {
|
|
return this.getObjectType() === AscDFH.historyitem_type_ChartSpace;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.isTable = function () {
|
|
return this.graphicObject && (this.graphicObject instanceof AscCommonWord.CTable);
|
|
};
|
|
CGraphicObjectBase.prototype.isImage = function () {
|
|
return this.getObjectType() === AscDFH.historyitem_type_ImageShape;
|
|
};
|
|
CGraphicObjectBase.prototype.isInk = function () {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.isHaveOnlyInks = function () {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.isPlaceholder = function () {
|
|
let oUniPr = this.getUniNvProps();
|
|
if (oUniPr) {
|
|
return isRealObject(oUniPr.nvPr) && isRealObject(oUniPr.nvPr.ph);
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.getHierarchy = function () {
|
|
return [];
|
|
};
|
|
CGraphicObjectBase.prototype.recalculate = function () {
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.drawShdw = function (graphics) {
|
|
var outerShdw = this.getOuterShdw && this.getOuterShdw();
|
|
const needToDrawShadow = AscCommon.IsShapeToImageConverter || !graphics.isBoundsChecker();
|
|
if (this.shdwSp && outerShdw && needToDrawShadow) {
|
|
this.shdwSp.transform = this.shdwSp.getShdwTransform(outerShdw, this);
|
|
this.shdwSp.recalculateBounds();
|
|
this.shdwSp.draw(graphics);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getShdwTransform = function(outerShdw, mainShape) {
|
|
const oTransform = new AscCommon.CMatrix();
|
|
if(this.flipH) {
|
|
AscCommon.global_MatrixTransformer.ScaleAppend(oTransform , -1, 1);
|
|
}
|
|
if(this.flipV) {
|
|
AscCommon.global_MatrixTransformer.ScaleAppend(oTransform , 1, -1);
|
|
}
|
|
global_MatrixTransformer.MultiplyAppend(oTransform, mainShape.transform);
|
|
const oShdwBounds = this.getGeometryBounds(oTransform);
|
|
const oMainBounds = mainShape.getGeometryBounds(mainShape.transform);
|
|
|
|
const nMainW = oMainBounds.w;
|
|
const nMainH = oMainBounds.h;
|
|
const dMainX = oMainBounds.x;
|
|
const dMainY = oMainBounds.y;
|
|
|
|
const nShwdPenW = this.shdwPenW || 0;
|
|
const nShdwW = oShdwBounds.w - nShwdPenW;
|
|
const nShdwH = oShdwBounds.h - nShwdPenW;
|
|
const dShdwX = oShdwBounds.x + nShwdPenW / 2;
|
|
const dShdwY = oShdwBounds.y + nShwdPenW / 2;
|
|
|
|
let dX;
|
|
let dY;
|
|
switch (outerShdw.algn) {
|
|
case AscFormat.RECT_ALIGN_BL: {
|
|
dX = dMainX - dShdwX;
|
|
dY = dMainY + nMainH - (dShdwY + nShdwH);
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_BR: {
|
|
dX = (dMainX + nMainW) - (dShdwX + nShdwW);
|
|
dY = dMainY + nMainH - (dShdwY + nShdwH);
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_CTR: {
|
|
dX = (dMainX + nMainW / 2) - (dShdwX + nShdwW / 2);
|
|
dY = (dMainY + nMainH / 2) - (dShdwY + nShdwH / 2);
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_L: {
|
|
dX = dMainX - dShdwX;
|
|
dY = (dMainY + nMainH / 2) - (dShdwY + nShdwH / 2);
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_R: {
|
|
dX = (dMainX + nMainW) - (dShdwX + nShdwW);
|
|
dY = (dMainY + nMainH / 2) - (dShdwY + nShdwH / 2);
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_T: {
|
|
dX = (dMainX + nMainW / 2) - (dShdwX + nShdwW / 2);
|
|
dY = dMainY - dShdwY;
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_TL: {
|
|
dX = dMainX - dShdwX;
|
|
dY = dMainY - dShdwY;
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_TR: {
|
|
dX = (dMainX + nMainW) - (dShdwX + nShdwW);
|
|
dY = dMainY - dShdwY;
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_B:
|
|
default: {
|
|
dX = (dMainX + nMainW / 2) - (dShdwX + nShdwW / 2);
|
|
dY = dMainY + nMainH - (dShdwY + nShdwH);
|
|
break;
|
|
}
|
|
}
|
|
if(this.flipH) {
|
|
switch (outerShdw.algn) {
|
|
case AscFormat.RECT_ALIGN_L:
|
|
case AscFormat.RECT_ALIGN_TL:
|
|
case AscFormat.RECT_ALIGN_BL: {
|
|
dX -= nShdwW;
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_R:
|
|
case AscFormat.RECT_ALIGN_TR:
|
|
case AscFormat.RECT_ALIGN_BR: {
|
|
dX += nShdwW;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if(this.flipV) {
|
|
switch (outerShdw.algn) {
|
|
case AscFormat.RECT_ALIGN_CTR:
|
|
case AscFormat.RECT_ALIGN_L:
|
|
case AscFormat.RECT_ALIGN_R: {
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_T:
|
|
case AscFormat.RECT_ALIGN_TL:
|
|
case AscFormat.RECT_ALIGN_TR: {
|
|
dY -= nShdwH;
|
|
break;
|
|
}
|
|
case AscFormat.RECT_ALIGN_B:
|
|
case AscFormat.RECT_ALIGN_BL:
|
|
case AscFormat.RECT_ALIGN_BR:
|
|
default: {
|
|
dY += nShdwH;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
var dist = outerShdw.dist ? outerShdw.dist / 36000 : 0;
|
|
var dir = outerShdw.dir ? outerShdw.dir : 0;
|
|
dX += dist * Math.cos(AscFormat.cToRad * dir);
|
|
dY += dist * Math.sin(AscFormat.cToRad * dir);
|
|
oTransform.tx += dX;
|
|
oTransform.ty += dY;
|
|
return oTransform;
|
|
};
|
|
CGraphicObjectBase.prototype.drawAdjustments = function (drawingDocument) {
|
|
};
|
|
CGraphicObjectBase.prototype.getAllRasterImages = function (mapUrl) {
|
|
};
|
|
CGraphicObjectBase.prototype.getImageFromBulletsMap = function (oImages) {
|
|
};
|
|
CGraphicObjectBase.prototype.getDocContentsWithImageBullets = function (arrContents) {
|
|
};
|
|
CGraphicObjectBase.prototype.getAllSlicerViews = function (aSlicerView) {
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.checkCorrect = function () {
|
|
if (this.bDeleted === true) {
|
|
return false;
|
|
}
|
|
return this.checkTypeCorrect();
|
|
};
|
|
CGraphicObjectBase.prototype.Clear_ContentChanges = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.Add_ContentChanges = function (Changes) {
|
|
};
|
|
CGraphicObjectBase.prototype.Refresh_ContentChanges = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.getWatermarkProps = function () {
|
|
var oProps = new Asc.CAscWatermarkProperties();
|
|
oProps.put_Type(Asc.c_oAscWatermarkType.None);
|
|
return oProps;
|
|
};
|
|
CGraphicObjectBase.prototype.CheckCorrect = function () {
|
|
return this.checkCorrect();
|
|
};
|
|
CGraphicObjectBase.prototype.checkTypeCorrect = function () {
|
|
return true;
|
|
};
|
|
CGraphicObjectBase.prototype.isSupported = function () {
|
|
return true;
|
|
};
|
|
CGraphicObjectBase.prototype.handleUpdateExtents = function (bExtX) {
|
|
};
|
|
CGraphicObjectBase.prototype.handleUpdatePosition = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.setDrawingObjects = function (drawingObjects) {
|
|
this.drawingObjects = drawingObjects;
|
|
if (Array.isArray(this.spTree)) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].setDrawingObjects(drawingObjects);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setDrawingBase = function (drawingBase) {
|
|
this.drawingBase = drawingBase;
|
|
};
|
|
CGraphicObjectBase.prototype.setDrawingBaseType = function (nType) {
|
|
if (this.drawingBase) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsLong(this, AscDFH.historyitem_AutoShapes_SetDrawingBaseType, this.drawingBase.Type, nType));
|
|
this.drawingBase.Type = nType;
|
|
this.handleUpdateExtents();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setDrawingBaseEditAs = function (nType) {
|
|
if (this.drawingBase) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsLong(this, AscDFH.historyitem_AutoShapes_SetDrawingBaseEditAs, this.drawingBase.editAs, nType));
|
|
this.drawingBase.editAs = nType;
|
|
this.handleUpdateExtents();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setDrawingBasePos = function (fPosX, fPosY) {
|
|
if (this.drawingBase && this.drawingBase.Pos) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObjectNoId(this, AscDFH.historyitem_AutoShapes_SetDrawingBasePos, new CDrawingBaseCoordsWritable(this.drawingBase.Pos.X, this.drawingBase.Pos.Y), new CDrawingBaseCoordsWritable(fPosX, fPosY)));
|
|
this.drawingBase.Pos.X = fPosX;
|
|
this.drawingBase.Pos.Y = fPosY;
|
|
this.handleUpdatePosition();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setDrawingBaseExt = function (fExtX, fExtY) {
|
|
if (this.drawingBase && this.drawingBase.ext) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObjectNoId(this, AscDFH.historyitem_AutoShapes_SetDrawingBaseExt, new CDrawingBaseCoordsWritable(this.drawingBase.ext.cx, this.drawingBase.ext.cy), new CDrawingBaseCoordsWritable(fExtX, fExtY)));
|
|
this.drawingBase.ext.cx = fExtX;
|
|
this.drawingBase.ext.cy = fExtY;
|
|
this.handleUpdateExtents();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setTransformParams = function (x, y, extX, extY, rot, flipH, flipV) {
|
|
if (!this.spPr) {
|
|
this.setSpPr(new AscFormat.CSpPr());
|
|
this.spPr.setParent(this);
|
|
}
|
|
if (!this.spPr.xfrm) {
|
|
this.spPr.setXfrm(new AscFormat.CXfrm());
|
|
this.spPr.xfrm.setParent(this.spPr);
|
|
}
|
|
this.spPr.xfrm.setOffX(x);
|
|
this.spPr.xfrm.setOffY(y);
|
|
this.spPr.xfrm.setExtX(extX);
|
|
this.spPr.xfrm.setExtY(extY);
|
|
this.spPr.xfrm.setRot(rot);
|
|
this.spPr.xfrm.setFlipH(flipH);
|
|
this.spPr.xfrm.setFlipV(flipV);
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.updateTransformMatrix = function()
|
|
{
|
|
var oParentTransform = null;
|
|
let oParent = (this.parent || this.group);
|
|
if(oParent && oParent.Get_ParentParagraph)
|
|
{
|
|
var oParagraph = oParent.Get_ParentParagraph();
|
|
if(oParagraph)
|
|
{
|
|
oParentTransform = oParagraph.Get_ParentTextTransform();
|
|
}
|
|
}
|
|
this.transform = this.localTransform.CreateDublicate();
|
|
global_MatrixTransformer.TranslateAppend(this.transform, this.posX, this.posY);
|
|
if(oParentTransform)
|
|
{
|
|
global_MatrixTransformer.MultiplyAppend(this.transform, oParentTransform);
|
|
}
|
|
this.invertTransform = global_MatrixTransformer.Invert(this.transform);
|
|
|
|
if(this.localTransformText)
|
|
{
|
|
this.transformText = this.localTransformText.CreateDublicate();
|
|
global_MatrixTransformer.TranslateAppend(this.transformText, this.posX, this.posY);
|
|
if(oParentTransform)
|
|
{
|
|
global_MatrixTransformer.MultiplyAppend(this.transformText, oParentTransform);
|
|
}
|
|
this.invertTransformText = global_MatrixTransformer.Invert(this.transformText);
|
|
}
|
|
if(this.localTransformTextWordArt)
|
|
{
|
|
this.transformTextWordArt = this.localTransformTextWordArt.CreateDublicate();
|
|
global_MatrixTransformer.TranslateAppend(this.transformTextWordArt, this.posX, this.posY);
|
|
if(oParentTransform)
|
|
{
|
|
global_MatrixTransformer.MultiplyAppend(this.transformTextWordArt, oParentTransform);
|
|
}
|
|
this.invertTransformTextWordArt = global_MatrixTransformer.Invert(this.transformTextWordArt);
|
|
}
|
|
if(this.localTransformText2)
|
|
{
|
|
|
|
this.transformText2 = this.localTransformText2.CreateDublicate();
|
|
global_MatrixTransformer.TranslateAppend(this.transformText2, this.posX, this.posY);
|
|
if(oParentTransform)
|
|
{
|
|
global_MatrixTransformer.MultiplyAppend(this.transformText2, oParentTransform);
|
|
}
|
|
this.invertTransformText2 = global_MatrixTransformer.Invert(this.transformText2);
|
|
}
|
|
this.checkShapeChildTransform && this.checkShapeChildTransform();
|
|
this.checkContentDrawings && this.checkContentDrawings();
|
|
};
|
|
CGraphicObjectBase.prototype.getPlaceholderType = function () {
|
|
if(!this.isPlaceholder()) {
|
|
return null;
|
|
}
|
|
let oNvPr = this.getNvProps();
|
|
if (oNvPr && oNvPr.ph) {
|
|
return oNvPr.ph.type;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getPlaceholderIndex = function () {
|
|
if(!this.isPlaceholder()) {
|
|
return null;
|
|
}
|
|
let oNvPr = this.getNvProps();
|
|
if (oNvPr && oNvPr.ph) {
|
|
return oNvPr.ph.idx;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getDrawingBaseType = function () {
|
|
if (this.drawingBase) {
|
|
if (this.drawingBase.Type === AscCommon.c_oAscCellAnchorType.cellanchorTwoCell) {
|
|
if (this.drawingBase.editAs !== null) {
|
|
return this.drawingBase.editAs;
|
|
}
|
|
}
|
|
return this.drawingBase.Type;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.recalcBrush = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcPen = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcTransform = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcTransformText = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcBounds = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcSmartArtCoords = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcGeometry = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcStyle = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcFill = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcLine = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcTransparent = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcTextStyles = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcTxBoxContent = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcWrapPolygon = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcContent = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.recalcContent2 = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.applySpecialPasteProps = function () {};
|
|
CGraphicObjectBase.prototype.getSpecialPasteProps = function () {};
|
|
|
|
CGraphicObjectBase.prototype.checkDrawingBaseCoords = function () {
|
|
if (this.drawingBase && this.spPr && this.spPr.xfrm && !this.group) {
|
|
var oldX = this.x, oldY = this.y, oldExtX = this.extX, oldExtY = this.extY;
|
|
var oldRot = this.rot;
|
|
this.x = this.spPr.xfrm.offX;
|
|
this.y = this.spPr.xfrm.offY;
|
|
this.extX = this.spPr.xfrm.extX;
|
|
this.extY = this.spPr.xfrm.extY;
|
|
this.rot = AscFormat.isRealNumber(this.spPr.xfrm.rot) ? AscFormat.normalizeRotate(this.spPr.xfrm.rot) : 0;
|
|
|
|
var oldFromCol = this.drawingBase.from.col,
|
|
oldFromColOff = this.drawingBase.from.colOff,
|
|
oldFromRow = this.drawingBase.from.row,
|
|
oldFromRowOff = this.drawingBase.from.rowOff,
|
|
oldToCol = this.drawingBase.to.col,
|
|
oldToColOff = this.drawingBase.to.colOff,
|
|
oldToRow = this.drawingBase.to.row,
|
|
oldToRowOff = this.drawingBase.to.rowOff,
|
|
oldPosX = this.drawingBase.Pos.X,
|
|
oldPosY = this.drawingBase.Pos.Y,
|
|
oldCx = this.drawingBase.ext.cx,
|
|
oldCy = this.drawingBase.ext.cy;
|
|
|
|
|
|
this.drawingBase.setGraphicObjectCoords();
|
|
this.x = oldX;
|
|
this.y = oldY;
|
|
this.extX = oldExtX;
|
|
this.extY = oldExtY;
|
|
this.rot = oldRot;
|
|
var from = this.drawingBase.from, to = this.drawingBase.to;
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObjectNoId(this, AscDFH.historyitem_AutoShapes_SetDrawingBaseCoors,
|
|
new CDrawingBasePosWritable({
|
|
fromCol: oldFromCol,
|
|
fromColOff: oldFromColOff,
|
|
fromRow: oldFromRow,
|
|
fromRowOff: oldFromRowOff,
|
|
toCol: oldToCol,
|
|
toColOff: oldToColOff,
|
|
toRow: oldToRow,
|
|
toRowOff: oldToRowOff,
|
|
posX: oldPosX,
|
|
posY: oldPosY,
|
|
cx: oldCx,
|
|
cy: oldCy
|
|
}),
|
|
new CDrawingBasePosWritable({
|
|
fromCol: from.col,
|
|
fromColOff: from.colOff,
|
|
fromRow: from.row,
|
|
fromRowOff: from.rowOff,
|
|
toCol: to.col,
|
|
toColOff: to.colOff,
|
|
toRow: to.row,
|
|
toRowOff: to.rowOff,
|
|
posX: this.drawingBase.Pos.X,
|
|
posY: this.drawingBase.Pos.Y,
|
|
cx: this.drawingBase.ext.cx,
|
|
cy: this.drawingBase.ext.cy
|
|
})));
|
|
this.handleUpdateExtents();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setDrawingBaseCoords = function (fromCol, fromColOff, fromRow, fromRowOff, toCol, toColOff, toRow, toRowOff, posX, posY, extX, extY) {
|
|
if (this.drawingBase) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObjectNoId(this, AscDFH.historyitem_AutoShapes_SetDrawingBaseCoors, new CDrawingBasePosWritable({
|
|
fromCol: this.drawingBase.from.col,
|
|
fromColOff: this.drawingBase.from.colOff,
|
|
fromRow: this.drawingBase.from.row,
|
|
fromRowOff: this.drawingBase.from.rowOff,
|
|
toCol: this.drawingBase.to.col,
|
|
toColOff: this.drawingBase.to.colOff,
|
|
toRow: this.drawingBase.to.row,
|
|
toRowOff: this.drawingBase.to.rowOff,
|
|
posX: this.drawingBase.Pos.X,
|
|
posY: this.drawingBase.Pos.Y,
|
|
cx: this.drawingBase.ext.cx,
|
|
cy: this.drawingBase.ext.cy
|
|
}),
|
|
new CDrawingBasePosWritable({
|
|
fromCol: fromCol,
|
|
fromColOff: fromColOff,
|
|
fromRow: fromRow,
|
|
fromRowOff: fromRowOff,
|
|
toCol: toCol,
|
|
toColOff: toColOff,
|
|
toRow: toRow,
|
|
toRowOff: toRowOff,
|
|
posX: posX,
|
|
posY: posY,
|
|
cx: extX,
|
|
cy: extY
|
|
})));
|
|
|
|
|
|
this.drawingBase.from.col = fromCol;
|
|
this.drawingBase.from.colOff = fromColOff;
|
|
this.drawingBase.from.row = fromRow;
|
|
this.drawingBase.from.rowOff = fromRowOff;
|
|
|
|
this.drawingBase.to.col = toCol;
|
|
this.drawingBase.to.colOff = toColOff;
|
|
this.drawingBase.to.row = toRow;
|
|
this.drawingBase.to.rowOff = toRowOff;
|
|
|
|
this.drawingBase.Pos.X = posX;
|
|
this.drawingBase.Pos.Y = posY;
|
|
this.drawingBase.ext.cx = extX;
|
|
this.drawingBase.ext.cy = extY;
|
|
|
|
this.handleUpdateExtents();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setWorksheet = function (worksheet) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsString(this, AscDFH.historyitem_AutoShapes_SetWorksheet, this.worksheet ? this.worksheet.getId() : null, worksheet ? worksheet.getId() : null));
|
|
this.worksheet = worksheet;
|
|
if (Array.isArray(this.spTree)) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].setWorksheet(worksheet);
|
|
}
|
|
}
|
|
if (Array.isArray(this.userShapes)) {
|
|
for (var nSp = 0; nSp < this.userShapes.length; ++nSp) {
|
|
var oAnchor = this.userShapes[nSp];
|
|
if (oAnchor) {
|
|
var oSp = oAnchor.object;
|
|
if (oSp && oSp.setWorksheet) {
|
|
oSp.setWorksheet(worksheet);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getWorksheet = function () {
|
|
return this.worksheet;
|
|
};
|
|
CGraphicObjectBase.prototype.getWorksheetView = function () {
|
|
let oWS = this.getWorksheet();
|
|
if(!oWS) return null;
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.getWorkbook = function () {
|
|
var oWorksheet = this.getWorksheet();
|
|
if (!oWorksheet) {
|
|
return null;
|
|
}
|
|
if (oWorksheet.workbook) {
|
|
return oWorksheet.workbook;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getUniNvProps = function () {
|
|
return this.nvSpPr || this.nvPicPr || this.nvGrpSpPr || this.nvGraphicFramePr || null;
|
|
};
|
|
CGraphicObjectBase.prototype.getCNvProps = function () {
|
|
var oUniNvPr = this.getUniNvProps();
|
|
if (oUniNvPr) {
|
|
return oUniNvPr.cNvPr;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getFormatId = function () {
|
|
var oCNvPr = this.getCNvProps();
|
|
if (oCNvPr) {
|
|
return oCNvPr.id;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getFormatIdString = function () {
|
|
let nId = this.getFormatId();
|
|
if (nId !== null) {
|
|
return nId + "";
|
|
}
|
|
return "";
|
|
};
|
|
CGraphicObjectBase.prototype.getNvProps = function () {
|
|
var oUniNvPr = this.getUniNvProps();
|
|
if (oUniNvPr) {
|
|
return oUniNvPr.nvPr;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.hasCustomPrompt = function () {
|
|
let oNvPr = this.getNvProps();
|
|
if (oNvPr && oNvPr.ph) {
|
|
return oNvPr.ph.hasCustomPrompt === true;
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.setTitle = function (sTitle) {
|
|
if (undefined === sTitle || null === sTitle) {
|
|
return;
|
|
}
|
|
var oNvPr = this.getCNvProps();
|
|
if (oNvPr) {
|
|
oNvPr.setTitle(sTitle ? sTitle : null);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setDescription = function (sDescription) {
|
|
if (undefined === sDescription || null === sDescription) {
|
|
return;
|
|
}
|
|
var oNvPr = this.getCNvProps();
|
|
if (oNvPr) {
|
|
oNvPr.setDescr(sDescription ? sDescription : null);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setName = function (sName) {
|
|
if (undefined === sName || null === sName) {
|
|
return;
|
|
}
|
|
var oNvPr = this.getCNvProps();
|
|
if (oNvPr) {
|
|
oNvPr.setName(sName ? sName : null);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getTitle = function () {
|
|
var oNvPr = this.getCNvProps();
|
|
if (oNvPr) {
|
|
return oNvPr.title ? oNvPr.title : undefined;
|
|
}
|
|
return undefined;
|
|
};
|
|
CGraphicObjectBase.prototype.getDescription = function () {
|
|
var oNvPr = this.getCNvProps();
|
|
if (oNvPr) {
|
|
return oNvPr.descr ? oNvPr.descr : undefined;
|
|
}
|
|
return undefined;
|
|
};
|
|
CGraphicObjectBase.prototype.setBDeleted = function (pr) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsBool(this, AscDFH.historyitem_ShapeSetBDeleted, this.bDeleted, pr));
|
|
this.bDeleted = pr;
|
|
};
|
|
CGraphicObjectBase.prototype.getEditorType = function () {
|
|
return 1;
|
|
};
|
|
CGraphicObjectBase.prototype.isEmptyPlaceholder = function () {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.RestartSpellCheck = function () {
|
|
};
|
|
CGraphicObjectBase.prototype.GetAllFields = function (isUseSelection, arrFields) {
|
|
return arrFields ? arrFields : [];
|
|
};
|
|
CGraphicObjectBase.prototype.GetAllSeqFieldsByType = function (sType, aFields) {
|
|
};
|
|
CGraphicObjectBase.prototype.convertToConnectionParams = function (rot, flipH, flipV, oTransform, oBounds, oConnectorInfo) {
|
|
var _ret = new AscFormat.ConnectionParams();
|
|
var _rot = oConnectorInfo.ang * AscFormat.cToRad + rot;
|
|
var _normalized_rot = AscFormat.normalizeRotate(_rot);
|
|
_ret.dir = AscFormat.CARD_DIRECTION_E;
|
|
if (_normalized_rot >= 0 && _normalized_rot < Math.PI * 0.25 || _normalized_rot >= 7 * Math.PI * 0.25 && _normalized_rot < 2 * Math.PI) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_E;
|
|
if (flipH) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_W;
|
|
}
|
|
} else if (_normalized_rot >= Math.PI * 0.25 && _normalized_rot < 3 * Math.PI * 0.25) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_S;
|
|
if (flipV) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_N;
|
|
}
|
|
} else if (_normalized_rot >= 3 * Math.PI * 0.25 && _normalized_rot < 5 * Math.PI * 0.25) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_W;
|
|
if (flipH) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_E;
|
|
}
|
|
} else if (_normalized_rot >= 5 * Math.PI * 0.25 && _normalized_rot < 7 * Math.PI * 0.25) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_N;
|
|
if (flipV) {
|
|
_ret.dir = AscFormat.CARD_DIRECTION_S;
|
|
}
|
|
}
|
|
_ret.x = oTransform.TransformPointX(oConnectorInfo.x, oConnectorInfo.y);
|
|
_ret.y = oTransform.TransformPointY(oConnectorInfo.x, oConnectorInfo.y);
|
|
_ret.bounds.fromOther(oBounds);
|
|
_ret.idx = oConnectorInfo.idx;
|
|
return _ret;
|
|
};
|
|
CGraphicObjectBase.prototype.convertToWord = function() {
|
|
return this;
|
|
};
|
|
CGraphicObjectBase.prototype.removePlaceholder = function () {
|
|
let oUniPr = this.getUniNvProps();
|
|
if (oUniPr) {
|
|
if(isRealObject(oUniPr.nvPr) && isRealObject(oUniPr.nvPr.ph)) {
|
|
oUniPr.nvPr.setPh(null);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getGeometry = function() {
|
|
if(this.calcGeometry) {
|
|
return this.calcGeometry;
|
|
}
|
|
if(this.spPr && this.spPr.geometry) {
|
|
return this.spPr.geometry;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getMorphGeometry = function() {
|
|
let oGeometry = this.getGeometry();
|
|
if(!oGeometry) {
|
|
oGeometry = AscFormat.ExecuteNoHistory(function () {
|
|
oGeometry = AscFormat.CreateGeometry("rect");
|
|
oGeometry.Recalculate(this.extX, this.extY);
|
|
}, this, []);
|
|
}
|
|
return oGeometry;
|
|
};
|
|
CGraphicObjectBase.prototype.getTrackGeometry = function () {
|
|
|
|
const oOwnGeometry = this.getGeometry();
|
|
if(oOwnGeometry) {
|
|
return oOwnGeometry;
|
|
}
|
|
if(this.rectGeometry) {
|
|
return this.rectGeometry;
|
|
}
|
|
return AscFormat.ExecuteNoHistory(
|
|
function () {
|
|
var _ret = AscFormat.CreateGeometry("rect");
|
|
_ret.Recalculate(this.extX, this.extY);
|
|
return _ret;
|
|
}, this, []
|
|
);
|
|
};
|
|
CGraphicObjectBase.prototype.findGeomConnector = function (x, y) {
|
|
var _geom = this.getTrackGeometry();
|
|
var oInvertTransform = this.invertTransform;
|
|
var _x = oInvertTransform.TransformPointX(x, y);
|
|
var _y = oInvertTransform.TransformPointY(x, y);
|
|
return _geom.findConnector(_x, _y, this.convertPixToMM(AscCommon.global_mouseEvent.KoefPixToMM * AscCommon.TRACK_CIRCLE_RADIUS));
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.canConnectTo = function () {
|
|
let sPreset = this.getPresetGeom();
|
|
if (sPreset && AscFormat.LINE_PRESETS_MAP[sPreset]) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
CGraphicObjectBase.prototype.findConnector = function (x, y) {
|
|
if (!this.canConnectTo()) {
|
|
return null;
|
|
}
|
|
var oConnGeom = this.findGeomConnector(x, y);
|
|
if (oConnGeom) {
|
|
var _rot = this.rot;
|
|
var _flipH = this.flipH;
|
|
var _flipV = this.flipV;
|
|
if (this.group) {
|
|
_rot = AscFormat.normalizeRotate(this.group.getFullRotate() + _rot);
|
|
if (this.group.getFullFlipH()) {
|
|
_flipH = !_flipH;
|
|
}
|
|
if (this.group.getFullFlipV()) {
|
|
_flipV = !_flipV;
|
|
}
|
|
}
|
|
return this.convertToConnectionParams(_rot, _flipH, _flipV, this.transform, this.bounds, oConnGeom);
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.findConnectionShape = function (x, y) {
|
|
if (!this.canConnectTo()) {
|
|
return null;
|
|
}
|
|
if (this.hit(x, y)) {
|
|
return this;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getAllDocContents = function (aDrawings) {
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.GetParaDrawing = function () {
|
|
return AscFormat.getParaDrawing(this);
|
|
};
|
|
CGraphicObjectBase.prototype.checkRunContent = function (fCallback) {
|
|
let aDocContents = [];
|
|
this.getAllDocContents(aDocContents);
|
|
for (let nIdx = 0; nIdx < aDocContents.length; ++nIdx) {
|
|
aDocContents[nIdx].CheckRunContent(fCallback);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getScaleCoefficient = function () {
|
|
let oParaDrawing = AscFormat.getParaDrawing(this);
|
|
if (oParaDrawing) {
|
|
return oParaDrawing.GetScaleCoefficient();
|
|
}
|
|
return 1.0;
|
|
};
|
|
CGraphicObjectBase.prototype.getFullRotate = function () {
|
|
return !AscCommon.isRealObject(this.group) ? this.rot : this.rot + this.group.getFullRotate();
|
|
};
|
|
CGraphicObjectBase.prototype.getAspect = function (num) {
|
|
var _tmp_x = this.extX !== 0 ? this.extX : 0.1;
|
|
var _tmp_y = this.extY !== 0 ? this.extY : 0.1;
|
|
return num === 0 || num === 4 ? _tmp_x / _tmp_y : _tmp_y / _tmp_x;
|
|
};
|
|
CGraphicObjectBase.prototype.getFullFlipH = function () {
|
|
if (!AscCommon.isRealObject(this.group))
|
|
return this.flipH;
|
|
return this.group.getFullFlipH() ? !this.flipH : this.flipH;
|
|
};
|
|
CGraphicObjectBase.prototype.getFullFlipV = function () {
|
|
if (!AscCommon.isRealObject(this.group))
|
|
return this.flipV;
|
|
return this.group.getFullFlipV() ? !this.flipV : this.flipV;
|
|
};
|
|
CGraphicObjectBase.prototype.getMainGroup = function () {
|
|
if (!AscCommon.isRealObject(this.group)) {
|
|
if (this.isGroupObject()) {
|
|
return this;
|
|
}
|
|
return null;
|
|
}
|
|
return this.group.getMainGroup();
|
|
};
|
|
CGraphicObjectBase.prototype.drawConnectors = function (overlay) {
|
|
var _geom = this.getTrackGeometry();
|
|
_geom.drawConnectors(overlay, this.transform);
|
|
};
|
|
CGraphicObjectBase.prototype.getConnectionParams = function (cnxIdx, _group) {
|
|
AscFormat.ExecuteNoHistory(
|
|
function () {
|
|
if (this.recalculateSizes) {
|
|
this.recalculateSizes();
|
|
} else if (this.recalculateTransform) {
|
|
this.recalculateTransform();
|
|
}
|
|
}, this, []
|
|
);
|
|
if (cnxIdx !== null) {
|
|
var oConnectionObject = this.getTrackGeometry().cnxLst[cnxIdx];
|
|
if (oConnectionObject) {
|
|
var g_conn_info = {
|
|
idx: cnxIdx,
|
|
ang: oConnectionObject.ang,
|
|
x: oConnectionObject.x,
|
|
y: oConnectionObject.y
|
|
};
|
|
var _rot = AscFormat.normalizeRotate(this.getFullRotate());
|
|
var _flipH = this.getFullFlipH();
|
|
var _flipV = this.getFullFlipV();
|
|
var _bounds = this.bounds;
|
|
var _transform = this.transform;
|
|
|
|
if (_group) {
|
|
_rot = AscFormat.normalizeRotate((this.group ? this.group.getFullRotate() : 0) + _rot - _group.getFullRotate());
|
|
if (_group.getFullFlipH()) {
|
|
_flipH = !_flipH;
|
|
}
|
|
if (_group.getFullFlipV()) {
|
|
_flipV = !_flipV;
|
|
}
|
|
_bounds = _bounds.copy();
|
|
_bounds.transform(_group.invertTransform);
|
|
_transform = _transform.CreateDublicate();
|
|
AscCommon.global_MatrixTransformer.MultiplyAppend(_transform, _group.invertTransform);
|
|
}
|
|
return this.convertToConnectionParams(_rot, _flipH, _flipV, _transform, _bounds, g_conn_info);
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getCardDirectionByNum = function (num) {
|
|
var num_north = this.getNumByCardDirection(AscFormat.CARD_DIRECTION_N);
|
|
var full_flip_h = this.getFullFlipH();
|
|
var full_flip_v = this.getFullFlipV();
|
|
var same_flip = !full_flip_h && !full_flip_v || full_flip_h && full_flip_v;
|
|
if (same_flip)
|
|
return ((num - num_north) + AscFormat.CARD_DIRECTION_N + 8) % 8;
|
|
|
|
return (AscFormat.CARD_DIRECTION_N - (num - num_north) + 8) % 8;
|
|
};
|
|
CGraphicObjectBase.prototype.getTransformMatrix = function () {
|
|
return this.transform;
|
|
};
|
|
CGraphicObjectBase.prototype.getNumByCardDirection = function (cardDirection) {
|
|
var hc = this.extX * 0.5;
|
|
var vc = this.extY * 0.5;
|
|
var transform = this.getTransformMatrix();
|
|
var y1, y3, y5, y7;
|
|
y1 = transform.TransformPointY(hc, 0);
|
|
y3 = transform.TransformPointY(this.extX, vc);
|
|
y5 = transform.TransformPointY(hc, this.extY);
|
|
y7 = transform.TransformPointY(0, vc);
|
|
|
|
var north_number;
|
|
var full_flip_h = this.getFullFlipH();
|
|
var full_flip_v = this.getFullFlipV();
|
|
switch (Math.min(y1, y3, y5, y7)) {
|
|
case y1: {
|
|
north_number = 1;
|
|
break;
|
|
}
|
|
case y3: {
|
|
north_number = 3;
|
|
break;
|
|
}
|
|
case y5: {
|
|
north_number = 5;
|
|
break;
|
|
}
|
|
default: {
|
|
north_number = 7;
|
|
break;
|
|
}
|
|
}
|
|
var same_flip = !full_flip_h && !full_flip_v || full_flip_h && full_flip_v;
|
|
|
|
if (same_flip)
|
|
return (north_number + cardDirection) % 8;
|
|
return (north_number - cardDirection + 8) % 8;
|
|
};
|
|
CGraphicObjectBase.prototype.getInvertTransform = function () {
|
|
return this.invertTransform;
|
|
};
|
|
CGraphicObjectBase.prototype.getResizeCoefficients = function (numHandle, x, y, aDrawings, oController) {
|
|
var cx, cy;
|
|
cx = this.extX > 0 ? this.extX : 0.01;
|
|
cy = this.extY > 0 ? this.extY : 0.01;
|
|
|
|
var invert_transform = this.getInvertTransform();
|
|
if (!invert_transform) {
|
|
return {kd1: 1, kd2: 1};
|
|
}
|
|
var t_x = invert_transform.TransformPointX(x, y);
|
|
var t_y = invert_transform.TransformPointY(x, y);
|
|
|
|
var bSnapH = false;
|
|
var bSnapV = false;
|
|
|
|
var oSnapHorObject, oSnapVertObject;
|
|
var dSnapX = null;
|
|
var dSnapY = null;
|
|
var bOwnH = false;
|
|
var bOwnV = false;
|
|
if (numHandle === 0 || numHandle === 6 || numHandle === 7) {
|
|
if (Math.abs(t_x) < AscFormat.SNAP_DISTANCE) {
|
|
t_x = 0;
|
|
bSnapH = true;
|
|
bOwnH = true;
|
|
}
|
|
}
|
|
if (numHandle === 2 || numHandle === 3 || numHandle === 4) {
|
|
if (Math.abs(t_x - this.extX) < AscFormat.SNAP_DISTANCE) {
|
|
t_x = this.extX;
|
|
bSnapH = true;
|
|
bOwnH = true;
|
|
}
|
|
}
|
|
|
|
if (numHandle === 0 || numHandle === 1 || numHandle === 2) {
|
|
if (Math.abs(t_y) < AscFormat.SNAP_DISTANCE) {
|
|
t_y = 0;
|
|
bSnapV = true;
|
|
bOwnV = true;
|
|
}
|
|
}
|
|
|
|
if (numHandle === 4 || numHandle === 5 || numHandle === 6) {
|
|
if (Math.abs(t_y - this.extY) < AscFormat.SNAP_DISTANCE) {
|
|
t_y = this.extY;
|
|
bSnapV = true;
|
|
bOwnV = true;
|
|
}
|
|
}
|
|
|
|
|
|
if (!bSnapH) {
|
|
if (Array.isArray(aDrawings)) {
|
|
let aVertGuidesPos = [];
|
|
if (oController) {
|
|
aVertGuidesPos = oController.getVertGuidesPos();
|
|
}
|
|
oSnapHorObject = AscFormat.GetMinSnapDistanceXObject(x, aDrawings, this, aVertGuidesPos);
|
|
if (oSnapHorObject) {
|
|
if (Math.abs(oSnapHorObject.dist) < AscFormat.SNAP_DISTANCE) {
|
|
bSnapH = true;
|
|
} else {
|
|
oSnapHorObject = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!bSnapV) {
|
|
if (Array.isArray(aDrawings)) {
|
|
let aHorGuidesPos = [];
|
|
if (oController) {
|
|
aHorGuidesPos = oController.getHorGuidesPos();
|
|
}
|
|
oSnapVertObject = AscFormat.GetMinSnapDistanceYObject(y, aDrawings, this, aHorGuidesPos);
|
|
if (oSnapVertObject && Math.abs(oSnapVertObject.dist) < AscFormat.SNAP_DISTANCE) {
|
|
bSnapV = true;
|
|
} else {
|
|
oSnapVertObject = null;
|
|
}
|
|
}
|
|
}
|
|
if (oSnapHorObject || oSnapVertObject) {
|
|
var newX = oSnapHorObject ? x + oSnapHorObject.dist : x;
|
|
var newY = oSnapVertObject ? y + oSnapVertObject.dist : y;
|
|
if (oSnapHorObject || !bSnapH) {
|
|
t_x = invert_transform.TransformPointX(newX, newY);
|
|
}
|
|
if (oSnapVertObject || !bSnapV) {
|
|
t_y = invert_transform.TransformPointY(newX, newY);
|
|
}
|
|
}
|
|
if (bSnapH && !bOwnH) {
|
|
if (numHandle !== 1 && numHandle !== 5 &&
|
|
!((numHandle === 7 || numHandle === 3) && !this.transform.IsIdentity2())) {
|
|
dSnapX = this.transform.TransformPointX(t_x, t_y);
|
|
}
|
|
}
|
|
if (bSnapV && !bOwnV) {
|
|
if (numHandle !== 7 && numHandle !== 3 &&
|
|
!((numHandle === 1 || numHandle === 5) && !this.transform.IsIdentity2())) {
|
|
dSnapY = this.transform.TransformPointY(t_x, t_y);
|
|
}
|
|
}
|
|
let bHorGuideSnap = oSnapHorObject && oSnapHorObject.guide;
|
|
let bVertGuideSnap = oSnapVertObject && oSnapVertObject.guide;
|
|
|
|
switch (numHandle) {
|
|
case 0:
|
|
return {
|
|
kd1: (cx - t_x) / cx,
|
|
kd2: (cy - t_y) / cy,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
case 1:
|
|
return {
|
|
kd1: (cy - t_y) / cy,
|
|
kd2: 0,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
case 2:
|
|
return {
|
|
kd1: (cy - t_y) / cy,
|
|
kd2: t_x / cx,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
case 3:
|
|
return {
|
|
kd1: t_x / cx,
|
|
kd2: 0,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
case 4:
|
|
return {
|
|
kd1: t_x / cx,
|
|
kd2: t_y / cy,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
case 5:
|
|
return {
|
|
kd1: t_y / cy,
|
|
kd2: 0,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
case 6:
|
|
return {
|
|
kd1: t_y / cy,
|
|
kd2: (cx - t_x) / cx,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
case 7:
|
|
return {
|
|
kd1: (cx - t_x) / cx,
|
|
kd2: 0,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
}
|
|
return {
|
|
kd1: 1,
|
|
kd2: 1,
|
|
snapH: bSnapH,
|
|
snapV: bSnapV,
|
|
snapX: dSnapX,
|
|
snapY: dSnapY,
|
|
horGuideSnap: bHorGuideSnap,
|
|
vertGuideSnap: bVertGuideSnap
|
|
};
|
|
};
|
|
CGraphicObjectBase.prototype.GetAllContentControls = function (arrContentControls) {
|
|
};
|
|
CGraphicObjectBase.prototype.GetAllDrawingObjects = function (arrDrawingObjects) {
|
|
};
|
|
CGraphicObjectBase.prototype.GetAllOleObjects = function (sPluginId, arrObjects) {
|
|
};
|
|
CGraphicObjectBase.prototype.CheckContentControlEditingLock = function () {
|
|
if (this.group) {
|
|
this.group.CheckContentControlEditingLock();
|
|
return;
|
|
}
|
|
if (this.parent && this.parent.CheckContentControlEditingLock) {
|
|
this.parent.CheckContentControlEditingLock();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.hit = function (x, y) {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.hitToAdjustment = function () {
|
|
return {hit: false};
|
|
};
|
|
CGraphicObjectBase.prototype.hitToHandles = function (x, y) {
|
|
if (this.parent && this.parent.kind === AscFormat.TYPE_KIND.NOTES) {
|
|
return -1;
|
|
}
|
|
if (!AscFormat.canSelectDrawing(this)) {
|
|
return -1;
|
|
}
|
|
if (this.isProtected && this.isProtected()) {
|
|
return -1;
|
|
}
|
|
return AscFormat.hitToHandles(x, y, this);
|
|
};
|
|
CGraphicObjectBase.prototype.hitInBoundingRect = function (x, y) {
|
|
if (this.parent && this.parent.kind === AscFormat.TYPE_KIND.NOTES) {
|
|
return false;
|
|
}
|
|
if (!AscFormat.canSelectDrawing(this)) {
|
|
return false;
|
|
}
|
|
var invert_transform = this.getInvertTransform();
|
|
if (!invert_transform) {
|
|
return false;
|
|
}
|
|
var x_t = invert_transform.TransformPointX(x, y);
|
|
var y_t = invert_transform.TransformPointY(x, y);
|
|
|
|
var _hit_context = this.getCanvasContext();
|
|
|
|
return !(AscFormat.CheckObjectLine(this)) && (AscFormat.HitInLine(_hit_context, x_t, y_t, 0, 0, this.extX, 0) ||
|
|
AscFormat.HitInLine(_hit_context, x_t, y_t, this.extX, 0, this.extX, this.extY) ||
|
|
AscFormat.HitInLine(_hit_context, x_t, y_t, this.extX, this.extY, 0, this.extY) ||
|
|
AscFormat.HitInLine(_hit_context, x_t, y_t, 0, this.extY, 0, 0) ||
|
|
(this.canRotate && this.canRotate() && AscFormat.HitInLine(_hit_context, x_t, y_t, this.extX * 0.5, 0, this.extX * 0.5, -this.convertPixToMM(AscCommon.TRACK_DISTANCE_ROTATE))));
|
|
};
|
|
CGraphicObjectBase.prototype.hitInTextHyperlink = function(x, y) {
|
|
return null;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.onMouseMove = function (e, x, y) {
|
|
return this.hit(x, y);
|
|
};
|
|
CGraphicObjectBase.prototype.drawLocks = function (transform, graphics) {
|
|
if (AscCommon.IsShapeToImageConverter) {
|
|
return;
|
|
}
|
|
var bNotes = !!(this.parent && this.parent.kind === AscFormat.TYPE_KIND.NOTES);
|
|
if (!this.group && !bNotes) {
|
|
var oLock;
|
|
if (this.parent instanceof AscCommonWord.ParaDrawing) {
|
|
oLock = this.parent.Lock;
|
|
} else if (this.Lock) {
|
|
oLock = this.Lock;
|
|
}
|
|
if (oLock && AscCommon.c_oAscLockTypes.kLockTypeNone !== oLock.Get_Type()) {
|
|
var bCoMarksDraw = true;
|
|
var oApi = editor || Asc['editor'];
|
|
if (oApi) {
|
|
|
|
switch (oApi.getEditorId()) {
|
|
case AscCommon.c_oEditorId.Word: {
|
|
bCoMarksDraw = (true === oApi.isCoMarksDraw || AscCommon.c_oAscLockTypes.kLockTypeMine !== oLock.Get_Type());
|
|
break;
|
|
}
|
|
case AscCommon.c_oEditorId.Presentation: {
|
|
bCoMarksDraw = (!AscCommon.CollaborativeEditing.Is_Fast() || AscCommon.c_oAscLockTypes.kLockTypeMine !== oLock.Get_Type());
|
|
break;
|
|
}
|
|
case AscCommon.c_oEditorId.Spreadsheet: {
|
|
bCoMarksDraw = (!oApi.collaborativeEditing.getFast() || AscCommon.c_oAscLockTypes.kLockTypeMine !== oLock.Get_Type());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (bCoMarksDraw && graphics.DrawLockObjectRect) {
|
|
graphics.transform3(transform);
|
|
graphics.DrawLockObjectRect(oLock.Get_Type(), 0, 0, this.extX, this.extY);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.getSignatureLineGuid = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getMacrosName = function () {
|
|
var sGuid = this.getJSAMacroId();
|
|
if (sGuid) {
|
|
var oApi = Asc.editor || editor;
|
|
if (oApi) {
|
|
return oApi.asc_getMacrosByGuid(sGuid);
|
|
}
|
|
}
|
|
return this.macro;
|
|
};
|
|
CGraphicObjectBase.prototype.getCopyWithSourceFormatting = function (oIdMap) {
|
|
return this.copy(oIdMap);
|
|
};
|
|
CGraphicObjectBase.prototype.checkNeedRecalculate = function () {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.handleAllContents = function (fCallback) {
|
|
};
|
|
CGraphicObjectBase.prototype.canFill = function () {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.getPaddings = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getBodyPr = function () {
|
|
var oThis = this;
|
|
return AscFormat.ExecuteNoHistory(function () {
|
|
var ret = new AscFormat.CBodyPr();
|
|
ret.setDefault();
|
|
return ret;
|
|
}, oThis, []);
|
|
};
|
|
CGraphicObjectBase.prototype.getTextArtProperties = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getColumnNumber = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getColumnSpace = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getTextFitType = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getVertOverflowType = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.canChangeArrows = function () {
|
|
if (!this.spPr || this.spPr.geometry == null) {
|
|
return false;
|
|
}
|
|
var _path_list = this.spPr.geometry.pathLst;
|
|
var _path_index;
|
|
var _path_command_index;
|
|
var _path_command_arr;
|
|
for (_path_index = 0; _path_index < _path_list.length; ++_path_index) {
|
|
_path_command_arr = _path_list[_path_index].ArrPathCommandInfo;
|
|
for (_path_command_index = 0; _path_command_index < _path_command_arr.length; ++_path_command_index) {
|
|
if (_path_command_arr[_path_command_index].id == 5) {
|
|
break;
|
|
}
|
|
}
|
|
if (_path_command_index == _path_command_arr.length) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.getStroke = function () {
|
|
if (this.pen && this.pen.Fill) {
|
|
return this.pen;
|
|
}
|
|
var ret = AscFormat.CreateNoFillLine();
|
|
ret.w = 0;
|
|
return ret;
|
|
};
|
|
CGraphicObjectBase.prototype.getPresetGeom = function () {
|
|
const oGeometry = this.getGeometry();
|
|
if(!oGeometry) {
|
|
return null;
|
|
}
|
|
return oGeometry.preset;
|
|
};
|
|
CGraphicObjectBase.prototype.getDistanceL1 = function (oOther) {
|
|
return Math.abs(this.x - oOther.x) + Math.abs(this.y - oOther.y);
|
|
};
|
|
CGraphicObjectBase.prototype.getFill = function () {
|
|
if (this.brush && this.brush.fill) {
|
|
return this.brush;
|
|
}
|
|
return AscFormat.CreateNoFillUniFill();
|
|
};
|
|
CGraphicObjectBase.prototype.getClipRect = function () {
|
|
if (this.parent && this.parent.GetClipRect) {
|
|
return this.parent.GetClipRect();
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getBlipFill = function () {
|
|
if (this.getObjectType() === AscDFH.historyitem_type_ImageShape || this.getObjectType() === AscDFH.historyitem_type_Shape) {
|
|
if (this.blipFill) {
|
|
return this.blipFill;
|
|
}
|
|
if (this.brush && this.brush.fill && this.brush.fill.type === window['Asc'].c_oAscFill.FILL_TYPE_BLIP) {
|
|
return this.brush.fill;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.checkSrcRect = function () {
|
|
|
|
if (this.getObjectType() === AscDFH.historyitem_type_ImageShape) {
|
|
if (this.blipFill.tile || !this.blipFill.srcRect || this.blipFill.stretch) {
|
|
|
|
var blipFill = this.blipFill.createDuplicate();
|
|
if (blipFill.tile) {
|
|
blipFill.tile = null;
|
|
}
|
|
if (!blipFill.srcRect) {
|
|
blipFill.srcRect = new AscFormat.CSrcRect();
|
|
blipFill.srcRect.l = 0;
|
|
blipFill.srcRect.t = 0;
|
|
blipFill.srcRect.r = 100;
|
|
blipFill.srcRect.b = 100;
|
|
}
|
|
if (blipFill.stretch) {
|
|
blipFill.stretch = null;
|
|
}
|
|
this.setBlipFill(blipFill);
|
|
}
|
|
} else {
|
|
if (this.brush.fill.tile || !this.brush.fill.srcRect || this.brush.fill.stretch) {
|
|
var brush = this.brush.createDuplicate();
|
|
if (brush.fill.tile) {
|
|
brush.fill.tile = null;
|
|
}
|
|
if (!brush.fill.srcRect) {
|
|
brush.fill.srcRect = new AscFormat.CSrcRect();
|
|
brush.fill.srcRect.l = 0;
|
|
brush.fill.srcRect.t = 0;
|
|
brush.fill.srcRect.r = 100;
|
|
brush.fill.srcRect.b = 100;
|
|
}
|
|
if (brush.fill.stretch) {
|
|
brush.fill.stretch = null;
|
|
}
|
|
this.brush = brush;
|
|
this.spPr.setFill(brush);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getCropObject = function () {
|
|
if (!this.cropObject) {
|
|
this.createCropObject();
|
|
}
|
|
return this.cropObject;
|
|
};
|
|
CGraphicObjectBase.prototype.check_bounds = function (oShapeDrawer) {
|
|
};
|
|
CGraphicObjectBase.prototype.cropFit = function() {
|
|
var oBlipFill = this.getBlipFill();
|
|
if (oBlipFill) {
|
|
var oImgP = new Asc.asc_CImgProperty();
|
|
oImgP.ImageUrl = oBlipFill.RasterImageId;
|
|
var oSize = oImgP.asc_getOriginSize(Asc.editor || editor);
|
|
var oShapeDrawer = new AscCommon.CShapeDrawer();
|
|
oShapeDrawer.bIsCheckBounds = true;
|
|
oShapeDrawer.Graphics = new AscFormat.CSlideBoundsChecker();
|
|
this.check_bounds(oShapeDrawer);
|
|
var bounds_w = oShapeDrawer.max_x - oShapeDrawer.min_x;
|
|
var bounds_h = oShapeDrawer.max_y - oShapeDrawer.min_y;
|
|
var dScale = bounds_w / oSize.Width;
|
|
var dTestHeight = oSize.Height * dScale;
|
|
var srcRect = new AscFormat.CSrcRect();
|
|
if (dTestHeight <= bounds_h) {
|
|
srcRect.l = 0;
|
|
srcRect.r = 100;
|
|
srcRect.t = -100 * (bounds_h - dTestHeight) / 2.0 / dTestHeight;
|
|
srcRect.b = 100 - srcRect.t;
|
|
} else {
|
|
srcRect.t = 0;
|
|
srcRect.b = 100;
|
|
dScale = bounds_h / oSize.Height;
|
|
var dTestWidth = oSize.Width * dScale;
|
|
srcRect.l = -100 * (bounds_w - dTestWidth) / 2.0 / dTestWidth;
|
|
srcRect.r = 100 - srcRect.l;
|
|
}
|
|
this.setSrcRect(srcRect);
|
|
var oParent = this.parent;
|
|
if (oParent && oParent.Check_WrapPolygon) {
|
|
oParent.Check_WrapPolygon()
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.cropFill = function() {
|
|
var oImgP = new Asc.asc_CImgProperty();
|
|
let oBlipFill = this.getBlipFill();
|
|
if(!oBlipFill) {
|
|
return;
|
|
}
|
|
oImgP.ImageUrl = this.getBlipFill().RasterImageId;
|
|
var oSize = oImgP.asc_getOriginSize(Asc.editor || editor);
|
|
var oShapeDrawer = new AscCommon.CShapeDrawer();
|
|
oShapeDrawer.bIsCheckBounds = true;
|
|
oShapeDrawer.Graphics = new AscFormat.CSlideBoundsChecker();
|
|
this.check_bounds(oShapeDrawer);
|
|
var bounds_w = oShapeDrawer.max_x - oShapeDrawer.min_x;
|
|
var bounds_h = oShapeDrawer.max_y - oShapeDrawer.min_y;
|
|
var dScale = bounds_w / oSize.Width;
|
|
var dTestHeight = oSize.Height * dScale;
|
|
var srcRect = new AscFormat.CSrcRect();
|
|
if (dTestHeight >= bounds_h) {
|
|
srcRect.l = 0;
|
|
srcRect.r = 100;
|
|
srcRect.t = -100 * (bounds_h - dTestHeight) / 2.0 / dTestHeight;
|
|
srcRect.b = 100 - srcRect.t;
|
|
} else {
|
|
srcRect.t = 0;
|
|
srcRect.b = 100;
|
|
dScale = bounds_h / oSize.Height;
|
|
var dTestWidth = oSize.Width * dScale;
|
|
srcRect.l = -100 * (bounds_w - dTestWidth) / 2.0 / dTestWidth;
|
|
srcRect.r = 100 - srcRect.l;
|
|
}
|
|
this.setSrcRect(srcRect);
|
|
var oParent = this.parent;
|
|
if (oParent && oParent.Check_WrapPolygon) {
|
|
oParent.Check_WrapPolygon();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.createCropObject = function () {
|
|
return AscFormat.ExecuteNoHistory(function () {
|
|
var oBlipFill = this.getBlipFill();
|
|
if (!oBlipFill) {
|
|
return;
|
|
}
|
|
var srcRect = oBlipFill.srcRect;
|
|
var sRasterImageId = oBlipFill.RasterImageId;
|
|
var _l = srcRect && srcRect.l ? srcRect.l : 0;
|
|
var _t = srcRect && srcRect.t ? srcRect.t : 0;
|
|
var _r = srcRect && srcRect.r ? srcRect.r : 100;
|
|
var _b = srcRect && srcRect.b ? srcRect.b : 100;
|
|
var oShapeDrawer = new AscCommon.CShapeDrawer();
|
|
oShapeDrawer.bIsCheckBounds = true;
|
|
oShapeDrawer.Graphics = new AscFormat.CSlideBoundsChecker();
|
|
this.check_bounds(oShapeDrawer);
|
|
var boundsW = oShapeDrawer.max_x - oShapeDrawer.min_x;
|
|
var boundsH = oShapeDrawer.max_y - oShapeDrawer.min_y;
|
|
var wpct = (_r - _l) / 100.0;
|
|
var hpct = (_b - _t) / 100.0;
|
|
var extX = boundsW / wpct;
|
|
var extY = boundsH / hpct;
|
|
var DX = -extX * _l / 100.0 + oShapeDrawer.min_x;
|
|
var DY = -extY * _t / 100.0 + oShapeDrawer.min_y;
|
|
var XC = DX + extX / 2.0;
|
|
var YC = DY + extY / 2.0;
|
|
|
|
var oTransform = this.transform.CreateDublicate();
|
|
|
|
var XC_ = oTransform.TransformPointX(XC, YC);
|
|
var YC_ = oTransform.TransformPointY(XC, YC);
|
|
|
|
var X = XC_ - extX / 2.0;
|
|
var Y = YC_ - extY / 2.0;
|
|
|
|
var oImage = AscFormat.DrawingObjectsController.prototype.createImage(sRasterImageId, X, Y, extX, extY);
|
|
oImage.isCrop = true;
|
|
oImage.parentCrop = this;
|
|
oImage.worksheet = this.worksheet;
|
|
oImage.drawingBase = this.drawingBase;
|
|
oImage.spPr.xfrm.setRot(this.rot);
|
|
oImage.spPr.xfrm.setFlipH(this.flipH);
|
|
oImage.spPr.xfrm.setFlipV(this.flipV);
|
|
|
|
|
|
oImage.setParent(this.parent);
|
|
oImage.recalculate();
|
|
oImage.setParent(null);
|
|
oImage.recalculateTransform();
|
|
oImage.recalculateGeometry();
|
|
oImage.invertTransform = AscCommon.global_MatrixTransformer.Invert(oImage.transform);
|
|
oImage.recalculateBounds();
|
|
oImage.setParent(this.parent);
|
|
oImage.selectStartPage = this.selectStartPage;
|
|
oImage.cropBrush = AscFormat.CreateUnfilFromRGB(128, 128, 128);
|
|
oImage.cropBrush.transparent = 100;
|
|
oImage.pen = AscFormat.CreatePenBrushForChartTrack().pen;
|
|
oImage.parent = this.parent;
|
|
var oParentObjects = this.getParentObjects();
|
|
oImage.cropBrush.calculate(oParentObjects.theme, oParentObjects.slide, oParentObjects.layout, oParentObjects.master, {
|
|
R: 0,
|
|
G: 0,
|
|
B: 0,
|
|
A: 255,
|
|
needRecalc: true
|
|
}, AscFormat.GetDefaultColorMap());
|
|
this.cropObject = oImage;
|
|
return true;
|
|
}, this, []);
|
|
};
|
|
CGraphicObjectBase.prototype.clearCropObject = function () {
|
|
this.cropObject = null;
|
|
};
|
|
CGraphicObjectBase.prototype.drawCropTrack = function (graphics, srcRect, transform, cropObjectTransform) {
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.calculateSrcRect = function () {
|
|
|
|
var oldTransform = this.transform.CreateDublicate();
|
|
var oldExtX = this.extX;
|
|
var oldExtY = this.extY;
|
|
AscFormat.ExecuteNoHistory(function () {
|
|
// this.cropObject.recalculateTransform();
|
|
// this.recalculateTransform();
|
|
var oldVal = this.recalcInfo.recalculateTransform;
|
|
this.recalcInfo.recalculateTransform = false;
|
|
this.recalculateGeometry();
|
|
this.recalcInfo.recalculateTransform = oldVal;
|
|
}, this, []);
|
|
this.transform = oldTransform;
|
|
this.extX = oldExtX;
|
|
this.extY = oldExtY;
|
|
this.setSrcRect(this.calculateSrcRect2());
|
|
this.clearCropObject();
|
|
};
|
|
CGraphicObjectBase.prototype.setSrcRect = function (srcRect) {
|
|
|
|
if (this.getObjectType() === AscDFH.historyitem_type_ImageShape) {
|
|
if (this.blipFill.srcRect) {
|
|
if (this.blipFill.srcRect.isEqual(srcRect)) {
|
|
return;
|
|
}
|
|
} else if (srcRect.isFullRect()) {
|
|
return;
|
|
}
|
|
var blipFill = this.blipFill.createDuplicate();
|
|
blipFill.srcRect = srcRect;
|
|
this.setBlipFill(blipFill);
|
|
} else {
|
|
if (this.brush.fill.srcRect) {
|
|
if (this.brush.fill.srcRect.isEqual(srcRect)) {
|
|
return;
|
|
}
|
|
} else if (srcRect.isFullRect()) {
|
|
return;
|
|
}
|
|
var brush = this.brush.createDuplicate();
|
|
brush.fill.srcRect = srcRect;
|
|
this.spPr.setFill(brush);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.calculateSrcRect2 = function () {
|
|
|
|
var oShapeDrawer = new AscCommon.CShapeDrawer();
|
|
oShapeDrawer.bIsCheckBounds = true;
|
|
oShapeDrawer.Graphics = new AscFormat.CSlideBoundsChecker();
|
|
this.check_bounds(oShapeDrawer);
|
|
return CalculateSrcRect(this.transform, oShapeDrawer, this.cropObject.invertTransform, this.cropObject.extX, this.cropObject.extY);
|
|
};
|
|
CGraphicObjectBase.prototype.getMediaFileName = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getMediaData = function() {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getMediaStartTime = function() {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getMediaEndTime = function() {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.isVideo = function() {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.getUniMedia = function() {
|
|
let oUniPr = this.getUniNvProps();
|
|
if (oUniPr) {
|
|
let oNvPr = oUniPr.nvPr;
|
|
if (oNvPr && oNvPr.unimedia) {
|
|
return oNvPr.unimedia;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getLogicDocument = function () {
|
|
var oApi = editor || Asc['editor'];
|
|
if (oApi && oApi.WordControl) {
|
|
return oApi.WordControl.m_oLogicDocument;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.updatePosition = function (x, y) {
|
|
this.posX = x;
|
|
this.posY = y;
|
|
if (!this.group) {
|
|
this.x = this.localX + x;
|
|
this.y = this.localY + y;
|
|
} else {
|
|
this.x = this.localX;
|
|
this.y = this.localY;
|
|
}
|
|
if (this.updateTransformMatrix) {
|
|
this.updateTransformMatrix();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.copyComments = function (oLogicDocument) {
|
|
if (!oLogicDocument) {
|
|
return;
|
|
}
|
|
|
|
var aDocContents = [];
|
|
this.getAllDocContents(aDocContents);
|
|
for (var i = 0; i < aDocContents.length; ++i) {
|
|
aDocContents[i].CreateDuplicateComments();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.writeRecord1 = function (pWriter, nType, oChild) {
|
|
if (AscCommon.isRealObject(oChild)) {
|
|
pWriter.WriteRecord1(nType, oChild, function (oChild) {
|
|
oChild.toPPTY(pWriter);
|
|
});
|
|
} else {
|
|
//TODO: throw an error
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.writeRecord2 = function (pWriter, nType, oChild) {
|
|
if (AscCommon.isRealObject(oChild)) {
|
|
this.writeRecord1(pWriter, nType, oChild);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.ResetParametersWithResize = function (bNoResetRelSize) {
|
|
var oParaDrawing = AscFormat.getParaDrawing(this);
|
|
if (oParaDrawing && !(bNoResetRelSize === true)) {
|
|
if (oParaDrawing.SizeRelH) {
|
|
oParaDrawing.SetSizeRelH(undefined);
|
|
}
|
|
if (oParaDrawing.SizeRelV) {
|
|
oParaDrawing.SetSizeRelV(undefined);
|
|
}
|
|
}
|
|
if (this instanceof AscFormat.CShape) {
|
|
var oPropsToSet = null;
|
|
if (this.bWordShape) {
|
|
if (!this.textBoxContent)
|
|
return;
|
|
if (this.bodyPr) {
|
|
oPropsToSet = this.bodyPr.createDuplicate();
|
|
} else {
|
|
oPropsToSet = new AscFormat.CBodyPr();
|
|
}
|
|
} else {
|
|
if (!this.txBody)
|
|
return;
|
|
if (this.txBody.bodyPr) {
|
|
oPropsToSet = this.txBody.bodyPr.createDuplicate();
|
|
} else {
|
|
oPropsToSet = new AscFormat.CBodyPr();
|
|
}
|
|
}
|
|
var oBodyPr = this.getBodyPr();
|
|
if (this.bWordShape) {
|
|
if (oBodyPr.textFit && oBodyPr.textFit.type === AscFormat.text_fit_Auto) {
|
|
if (!oPropsToSet.textFit) {
|
|
oPropsToSet.textFit = new AscFormat.CTextFit();
|
|
}
|
|
oPropsToSet.textFit.type = AscFormat.text_fit_No;
|
|
}
|
|
}
|
|
if (oBodyPr.wrap === AscFormat.nTWTNone) {
|
|
oPropsToSet.wrap = AscFormat.nTWTSquare;
|
|
}
|
|
if (this.bWordShape) {
|
|
this.setBodyPr(oPropsToSet);
|
|
} else {
|
|
this.txBody.setBodyPr(oPropsToSet);
|
|
if (this.checkExtentsByDocContent) {
|
|
this.checkExtentsByDocContent(true, true);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.canAddButtonPlaceholder = function () {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.GetAbsolutePage = function (nCurPage) {
|
|
return nCurPage || 0;
|
|
};
|
|
CGraphicObjectBase.prototype.createPlaceholderControl = function (aControls) {
|
|
|
|
let nParentType = null;
|
|
if(this.parent && this.parent.getObjectType) {
|
|
nParentType = this.parent.getObjectType();
|
|
}
|
|
let bCanAdd = false;
|
|
let bMasterLtPh = (this.isPlaceholder() && (nParentType === AscDFH.historyitem_type_SlideMaster || nParentType === AscDFH.historyitem_type_SlideLayout))
|
|
if(bMasterLtPh) {
|
|
bCanAdd = true;
|
|
}
|
|
else {
|
|
if (this.isEmptyPlaceholder() && this.canAddButtonPlaceholder()) {
|
|
bCanAdd = true;
|
|
}
|
|
}
|
|
|
|
if (!bCanAdd) {
|
|
return;
|
|
}
|
|
let phType = this.getPlaceholderType();
|
|
let aButtons = [];
|
|
let isLocalDesktop = window["AscDesktopEditor"] && window["AscDesktopEditor"]["IsSupportMedia"] && window["AscDesktopEditor"]["IsSupportMedia"]();
|
|
const oRect = {x: 0, y: 0, w: this.extX, h: this.extY};
|
|
let isDisabled = bMasterLtPh;
|
|
switch (phType) {
|
|
case null: {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Table);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Chart);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Image);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.ImageUrl);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.SmartArt);
|
|
if (isLocalDesktop) {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Video);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Audio);
|
|
}
|
|
break;
|
|
}
|
|
case AscFormat.phType_body: {
|
|
break;
|
|
}
|
|
case AscFormat.phType_chart: {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Chart);
|
|
break;
|
|
}
|
|
case AscFormat.phType_clipArt: {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Image);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.ImageUrl);
|
|
break;
|
|
}
|
|
case AscFormat.phType_ctrTitle: {
|
|
break;
|
|
}
|
|
case AscFormat.phType_dgm: {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.SmartArt);
|
|
break;
|
|
}
|
|
case AscFormat.phType_dt: {
|
|
break;
|
|
}
|
|
case AscFormat.phType_ftr: {
|
|
break;
|
|
}
|
|
case AscFormat.phType_hdr: {
|
|
break;
|
|
}
|
|
case AscFormat.phType_media: {
|
|
if (isLocalDesktop) {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Video);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Audio);
|
|
}
|
|
break;
|
|
}
|
|
case AscFormat.phType_obj: {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Table);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Chart);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Image);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.ImageUrl);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.SmartArt);
|
|
if (isLocalDesktop) {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Video);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Audio);
|
|
}
|
|
break;
|
|
}
|
|
case AscFormat.phType_pic: {
|
|
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Image);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.ImageUrl);
|
|
break;
|
|
}
|
|
case AscFormat.phType_sldImg: {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Image);
|
|
aButtons.push(AscCommon.PlaceholderButtonType.ImageUrl);
|
|
break;
|
|
}
|
|
case AscFormat.phType_sldNum: {
|
|
break;
|
|
}
|
|
case AscFormat.phType_subTitle: {
|
|
break;
|
|
}
|
|
case AscFormat.phType_tbl: {
|
|
aButtons.push(AscCommon.PlaceholderButtonType.Table);
|
|
break;
|
|
}
|
|
case AscFormat.phType_title: {
|
|
break;
|
|
}
|
|
}
|
|
var nPageNum;
|
|
if (AscFormat.isSlideLikeObject(this.parent)) {
|
|
nPageNum = this.getParentNum();
|
|
} else if (this.worksheet) {
|
|
nPageNum = this.worksheet.workbook && this.worksheet.workbook.nActive;
|
|
} else {
|
|
nPageNum = this.GetAbsolutePage() || 0;
|
|
}
|
|
if (aButtons.length > 0) {
|
|
aControls.push(AscCommon.CreateDrawingPlaceholder(this.Id, aButtons, nPageNum, oRect, this.transform, isDisabled));
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.onSlicerUpdate = function (sName) {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.onSlicerLock = function (sName, bLock) {
|
|
};
|
|
CGraphicObjectBase.prototype.onSlicerDelete = function (sName) {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.onTimeSlicerDelete = function (sName) {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.onSlicerChangeName = function (sName, sNewName) {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.onUpdate = function (oRect) {
|
|
if (this.drawingBase) {
|
|
this.drawingBase.onUpdate(oRect);
|
|
} else {
|
|
if (this.group) {
|
|
this.group.onUpdate(oRect)
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getSlicerViewByName = function (name) {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.setParent2 = function (parent) {
|
|
this.setParent(parent);
|
|
if (Array.isArray(this.spTree)) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].setParent2(parent);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.documentCreateFontMap = function (oMap) {
|
|
};
|
|
CGraphicObjectBase.prototype.createFontMap = function (oMap) {
|
|
this.documentCreateFontMap(oMap);
|
|
};
|
|
CGraphicObjectBase.prototype.isComparable = function (oDrawing) {
|
|
var oPr = this.getCNvProps();
|
|
var oOtherPr = oDrawing.getCNvProps();
|
|
if (!oPr && !oOtherPr) {
|
|
return true;
|
|
}
|
|
if (!oPr) {
|
|
return false;
|
|
}
|
|
return oPr.hasSameNameAndId(oOtherPr);
|
|
};
|
|
CGraphicObjectBase.prototype.select = function (drawingObjectsController, pageIndex) {
|
|
if (!AscFormat.canSelectDrawing(this)) {
|
|
return;
|
|
}
|
|
this.selected = true;
|
|
this.selectStartPage = pageIndex;
|
|
var content = this.getDocContent && this.getDocContent();
|
|
if (content)
|
|
content.Set_StartPage(pageIndex);
|
|
var selected_objects;
|
|
if (!AscCommon.isRealObject(this.group))
|
|
selected_objects = drawingObjectsController ? drawingObjectsController.selectedObjects : [];
|
|
else
|
|
selected_objects = this.group.getMainGroup().selectedObjects;
|
|
for (var i = 0; i < selected_objects.length; ++i) {
|
|
if (selected_objects[i] === this)
|
|
break;
|
|
}
|
|
if (i === selected_objects.length)
|
|
selected_objects.push(this);
|
|
|
|
|
|
if (drawingObjectsController) {
|
|
drawingObjectsController.onChangeDrawingsSelection();
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.deselect = function (drawingObjectsController) {
|
|
this.selected = false;
|
|
var selected_objects;
|
|
if (!AscCommon.isRealObject(this.group))
|
|
selected_objects = drawingObjectsController ? drawingObjectsController.selectedObjects : [];
|
|
else
|
|
selected_objects = this.group.getMainGroup().selectedObjects;
|
|
for (var i = 0; i < selected_objects.length; ++i) {
|
|
if (selected_objects[i] === this) {
|
|
selected_objects.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
if (this.graphicObject) {
|
|
this.graphicObject.RemoveSelection();
|
|
}
|
|
|
|
if (drawingObjectsController) {
|
|
drawingObjectsController.onChangeDrawingsSelection();
|
|
}
|
|
return this;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.getDrawingObjectsController = function() {
|
|
if(AscFormat.CShape.prototype.getDrawingObjectsController) {
|
|
return AscFormat.CShape.prototype.getDrawingObjectsController.call(this);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
|
|
//TODO: refactor this methods: don't call functions from AscFormat.CShape.prototype
|
|
CGraphicObjectBase.prototype.getCanvasContext = function () {
|
|
if(AscFormat.CShape.prototype.getCanvasContext) {
|
|
return AscFormat.CShape.prototype.getCanvasContext.call(this);
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.IsUseInDocument = function () {
|
|
if (AscFormat.CShape.prototype.IsUseInDocument) {
|
|
return AscFormat.CShape.prototype.IsUseInDocument.call(this);
|
|
}
|
|
return true;
|
|
};
|
|
CGraphicObjectBase.prototype.Set_CurrentElement = function (bUpdate, pageIndex, bNoTextSelection) {
|
|
if (AscFormat.CShape.prototype.Set_CurrentElement) {
|
|
AscFormat.CShape.prototype.Set_CurrentElement.call(this, bUpdate, pageIndex, bNoTextSelection);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getParentObjects = function () {
|
|
if (AscFormat.CShape.prototype.getParentObjects) {
|
|
return AscFormat.CShape.prototype.getParentObjects.call(this);
|
|
}
|
|
return { slide: null, layout: null, master: null, theme: null};
|
|
};
|
|
CGraphicObjectBase.prototype.GetAbsoluteStartPage = function () {
|
|
if (AscFormat.CShape.prototype.GetAbsoluteStartPage) {
|
|
return AscFormat.CShape.prototype.GetAbsoluteStartPage.call(this);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.Get_Theme = function () {
|
|
if (AscFormat.CShape.prototype.Get_Theme) {
|
|
return AscFormat.CShape.prototype.Get_Theme.call(this);
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.Get_ColorMap = function () {
|
|
if (AscFormat.CShape.prototype.Get_ColorMap) {
|
|
return AscFormat.CShape.prototype.Get_ColorMap.call(this);
|
|
}
|
|
return null;
|
|
};
|
|
//------------------------------------------------------------------------------------
|
|
|
|
|
|
CGraphicObjectBase.prototype.SetControllerTextSelection = function (drawing_objects, nPageIndex) {
|
|
if (drawing_objects) {
|
|
var oContent = this.getDocContent && this.getDocContent();
|
|
drawing_objects.resetSelection(true);
|
|
if (this.group) {
|
|
var main_group = this.group.getMainGroup();
|
|
drawing_objects.selectObject(main_group, nPageIndex);
|
|
main_group.selectObject(this, nPageIndex);
|
|
if (oContent) {
|
|
main_group.selection.textSelection = this;
|
|
}
|
|
drawing_objects.selection.groupSelection = main_group;
|
|
} else {
|
|
drawing_objects.selectObject(this, nPageIndex);
|
|
if (oContent) {
|
|
drawing_objects.selection.textSelection = this;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.isForm = function () {
|
|
return (this.parent && this.parent.IsForm && this.parent.IsForm());
|
|
};
|
|
CGraphicObjectBase.prototype.getFormHorPadding = function () {
|
|
return 0;
|
|
};
|
|
CGraphicObjectBase.prototype.getInnerForm = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.isContainedInTopDocument = function () {
|
|
const oParaDrawing = this.GetParaDrawing();
|
|
if(!oParaDrawing) {
|
|
return true;
|
|
}
|
|
let oParentContent = oParaDrawing.GetDocumentContent();
|
|
if (!oParentContent) {
|
|
return true;
|
|
}
|
|
return (oParentContent === oParentContent.GetLogicDocument());
|
|
};
|
|
CGraphicObjectBase.prototype.isContainedInMainDoc = function () {
|
|
const oParaDrawing = this.GetParaDrawing();
|
|
if(!oParaDrawing) {
|
|
return true;
|
|
}
|
|
let oParentContent = oParaDrawing.GetDocumentContent();
|
|
if (!oParentContent) {
|
|
return true;
|
|
}
|
|
return (oParentContent.GetTopDocumentContent() === oParentContent.GetLogicDocument());
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.IsHdrFtr = function(bReturnHdrFtr) {
|
|
const oParaDrawing = this.GetParaDrawing();
|
|
if(oParaDrawing) {
|
|
return oParaDrawing.isHdrFtrChild(bReturnHdrFtr);
|
|
}
|
|
return bReturnHdrFtr ? null : false;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.IsFootnote = function(bReturnFootnote) {
|
|
const oParaDrawing = this.GetParaDrawing();
|
|
if(oParaDrawing) {
|
|
return oParaDrawing.isFootnoteChild(bReturnFootnote);
|
|
}
|
|
return bReturnFootnote ? null : false;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.Is_TopDocument = function(bReturn) {
|
|
if(!bReturn) {
|
|
//TODO: check this function
|
|
return false;
|
|
}
|
|
const oParaDrawing = this.GetParaDrawing();
|
|
if(oParaDrawing) {
|
|
return oParaDrawing.isInTopDocument(bReturn);
|
|
}
|
|
return bReturn ? null : false;
|
|
};
|
|
CGraphicObjectBase.prototype.getBoundsByDrawing = function (bMorph) {
|
|
const oCopy = this.bounds.copy();
|
|
if(this.shdwSp) {
|
|
this.shdwSp.recalculateBounds();
|
|
oCopy.checkByOther(this.shdwSp.bounds);
|
|
}
|
|
if(!bMorph) {
|
|
oCopy.l -= 3;
|
|
oCopy.r += 3;
|
|
oCopy.t -= 3;
|
|
oCopy.b += 3;
|
|
oCopy.checkWH();
|
|
return oCopy;//TODO: do not count shape rect
|
|
}
|
|
if(this.pen) {
|
|
const dCorrection = this.pen.getWidthMM() / 2;
|
|
oCopy.l -= dCorrection;
|
|
oCopy.r += dCorrection;
|
|
oCopy.t -= dCorrection;
|
|
oCopy.b += dCorrection;
|
|
}
|
|
oCopy.checkWH();
|
|
return oCopy;
|
|
};
|
|
CGraphicObjectBase.prototype.getPresentationSize = function () {
|
|
var oPresentation = editor.WordControl.m_oLogicDocument;
|
|
return {
|
|
w: oPresentation.GetWidthMM(),
|
|
h: oPresentation.GetHeightMM()
|
|
}
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.getAnimTexture = function (scale, bMorph, oAnimParams, bNoText, oBrushPen) {
|
|
const oBounds = this.getBoundsByDrawing(bMorph);
|
|
const oCanvas = oBounds.createCanvas(scale);
|
|
if(!oCanvas) {
|
|
return null;
|
|
}
|
|
const oGraphics = oBounds.createGraphicsFromCanvas(oCanvas, scale)
|
|
let nX = oBounds.x * oGraphics.m_oCoordTransform.sx;
|
|
let nY = oBounds.y * oGraphics.m_oCoordTransform.sy;
|
|
oGraphics.m_oCoordTransform.tx = -nX;
|
|
oGraphics.m_oCoordTransform.ty = -nY;
|
|
AscCommon.IsShapeToImageConverter = true;
|
|
let oOldBrush = this.brush;
|
|
let oOldPen = this.pen;
|
|
if(oAnimParams) {
|
|
this.brush = oAnimParams.brush;
|
|
this.pen = oAnimParams.pen;
|
|
}
|
|
let oCurrentBrush;
|
|
let oCurrentPen;
|
|
if (oBrushPen) {
|
|
this.brush = oBrushPen.brush;
|
|
this.pen = oBrushPen.pen;
|
|
oCurrentBrush = this.brush;
|
|
oCurrentPen = this.pen;
|
|
} else {
|
|
oCurrentBrush = this.getBrush();
|
|
oCurrentPen = this.getPen();
|
|
}
|
|
let oOldTextBody = this.txBody;
|
|
if (bNoText) {
|
|
this.txBody = null;
|
|
}
|
|
this.draw(oGraphics);
|
|
this.txBody = oOldTextBody;
|
|
this.brush = oOldBrush;
|
|
this.pen = oOldPen;
|
|
AscCommon.IsShapeToImageConverter = false;
|
|
let oTexture = new AscFormat.CBaseAnimTexture(oCanvas, scale, nX, nY, bNoText, oCurrentBrush, oCurrentPen);
|
|
if(oAnimParams && oAnimParams.transform) {
|
|
let oNewBounds = oBounds.copy();
|
|
oNewBounds.transformRect(oAnimParams.transform);
|
|
let oNewCanvas = oBounds.createCanvas(scale);
|
|
if(!oNewCanvas) {
|
|
return null;
|
|
}
|
|
let oNewGraphics = oNewBounds.createGraphicsFromCanvas(oNewCanvas, scale)
|
|
nX = oNewBounds.x * oGraphics.m_oCoordTransform.sx;
|
|
nY = oNewBounds.y * oGraphics.m_oCoordTransform.sy;
|
|
oNewGraphics.m_oCoordTransform.tx = -nX;
|
|
oNewGraphics.m_oCoordTransform.ty = -nY;
|
|
oTexture.draw(oNewGraphics, oAnimParams.transform);
|
|
oTexture = new AscFormat.CBaseAnimTexture(oNewCanvas, scale, nX, nY, bNoText, oCurrentBrush, oCurrentPen);
|
|
}
|
|
return oTexture;
|
|
};
|
|
CGraphicObjectBase.prototype.getDocStructure = function (oParagraphSplitOptions, oIdGenerator) {return null;};
|
|
CGraphicObjectBase.prototype.isOnProtectedSheet = function () {
|
|
if (this.worksheet) {
|
|
if (this.worksheet.getSheetProtection(Asc.c_oAscSheetProtectType.objects)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.isProtectedText = function () {
|
|
if (this.getProtectionLockText()) {
|
|
if (this.isOnProtectedSheet()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.isProtected = function () {
|
|
if (this.getProtectionLocked()) {
|
|
if (this.isOnProtectedSheet()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.canEditText = function () {
|
|
if (this.getObjectType() === AscDFH.historyitem_type_Shape) {
|
|
if (!AscFormat.CheckLinePresetForParagraphAdd(this.getPresetGeom()) && !this.signatureLine) {
|
|
if (this.isProtectedText()) {
|
|
return false;
|
|
}
|
|
if (this.isObjectInSmartArt()) {
|
|
return this.canEditTextInSmartArt();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.canEdit = function () {
|
|
if (this.isProtected()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
//for bug 52775. remove in the next version
|
|
CGraphicObjectBase.prototype.applySmartArtTextStyle = function () {
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.convertFromSmartArt = function () {
|
|
return this;
|
|
};
|
|
CGraphicObjectBase.prototype.getDefaultRotSA = function () {
|
|
if (this.isObjectInSmartArt()) {
|
|
var point = this.getSmartArtShapePoint();
|
|
if (point) {
|
|
var custAng = point.getCustAng();
|
|
if (custAng) {
|
|
var defaultRot = this.spPr && this.spPr.xfrm && this.spPr.xfrm.rot || 0;
|
|
if (custAng) {
|
|
if (custAng > defaultRot) {
|
|
defaultRot += Math.PI * 2 * Math.ceil(custAng / (Math.PI * 2));
|
|
}
|
|
defaultRot -= custAng;
|
|
return AscFormat.normalizeRotate(defaultRot);
|
|
}
|
|
}
|
|
}
|
|
return AscFormat.normalizeRotate(this.rot);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.changePositionInSmartArt = function (newX, newY) {
|
|
}
|
|
CGraphicObjectBase.prototype.changeRot = function (dAngle, bWord) {
|
|
var oSmartArt;
|
|
if (this.isObjectInSmartArt()) {
|
|
oSmartArt = this.group.group;
|
|
if (this.extX > oSmartArt.extX || this.extY > oSmartArt.extY || this.extX > oSmartArt.extY || this.extY > oSmartArt.extX) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (this.spPr && this.spPr.xfrm) {
|
|
var oXfrm = this.spPr.xfrm;
|
|
var originalRot = oXfrm.rot || 0;
|
|
var dRot = AscFormat.normalizeRotate(dAngle);
|
|
oXfrm.setRot(dRot);
|
|
if (this.isObjectInSmartArt()) {
|
|
oSmartArt = this.group.group;
|
|
var point = this.getSmartArtShapePoint();
|
|
if (point) {
|
|
var prSet = point.getPrSet();
|
|
if (prSet) {
|
|
var defaultRot = originalRot;
|
|
if (prSet.custAng) {
|
|
var oldCustAng = prSet.custAng;
|
|
if (oldCustAng > defaultRot) {
|
|
defaultRot += Math.PI * 2 * Math.ceil(oldCustAng / (Math.PI * 2));
|
|
}
|
|
defaultRot -= oldCustAng;
|
|
}
|
|
if (originalRot !== dRot) {
|
|
var currentAngle = dRot;
|
|
if (defaultRot > currentAngle) {
|
|
currentAngle += Math.PI * 2 * Math.ceil(defaultRot / (Math.PI * 2));
|
|
}
|
|
var newCustAng = (currentAngle - defaultRot);
|
|
prSet.setCustAng(newCustAng);
|
|
}
|
|
}
|
|
}
|
|
this.recalculate();
|
|
var oBounds = this.bounds;
|
|
var diffX = null, diffY = null;
|
|
var leftEdgeOfSmartArt = oSmartArt.x;
|
|
var topEdgeOfSmartArt = oSmartArt.y;
|
|
var rightEdgeOfSmartArt = oSmartArt.x + oSmartArt.extX;
|
|
var bottomEdgeOfSmartArt = oSmartArt.y + oSmartArt.extY;
|
|
if (bWord) {
|
|
oBounds = {
|
|
l: oBounds.l + leftEdgeOfSmartArt,
|
|
r: oBounds.r + leftEdgeOfSmartArt,
|
|
t: oBounds.t + topEdgeOfSmartArt,
|
|
b: oBounds.b + topEdgeOfSmartArt
|
|
};
|
|
}
|
|
if (oBounds.r > rightEdgeOfSmartArt) {
|
|
diffX = rightEdgeOfSmartArt - oBounds.r;
|
|
}
|
|
if (oBounds.l < leftEdgeOfSmartArt) {
|
|
diffX = leftEdgeOfSmartArt - oBounds.l;
|
|
}
|
|
if (oBounds.b > bottomEdgeOfSmartArt) {
|
|
diffY = bottomEdgeOfSmartArt - oBounds.b;
|
|
}
|
|
if (oBounds.t < topEdgeOfSmartArt) {
|
|
diffY = topEdgeOfSmartArt - oBounds.t;
|
|
}
|
|
|
|
if (diffX !== null) {
|
|
var newOffX = this.spPr.xfrm.offX + diffX;
|
|
this.spPr.xfrm.setOffX(newOffX);
|
|
this.txXfrm && this.txXfrm.setOffX(this.txXfrm.offX + diffX);
|
|
}
|
|
if (diffY !== null) {
|
|
var newOffY = this.spPr.xfrm.offY + diffY;
|
|
this.spPr.xfrm.setOffY(newOffY);
|
|
this.txXfrm && this.txXfrm.setOffY(this.txXfrm.offY + diffY);
|
|
}
|
|
|
|
var posX = this.spPr.xfrm.offX;
|
|
var posY = this.spPr.xfrm.offY;
|
|
this.changePositionInSmartArt(posX, posY);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.changeFlipH = function (bFlipH) {
|
|
if (this.spPr && this.spPr.xfrm) {
|
|
var oXfrm = this.spPr.xfrm;
|
|
oXfrm.setFlipH(bFlipH);
|
|
if (this.isObjectInSmartArt()) {
|
|
var point = this.getSmartArtShapePoint();
|
|
point && point.changeFlipH(bFlipH);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.changeFlipV = function (bFlipV) {
|
|
if (this.spPr && this.spPr.xfrm) {
|
|
var oXfrm = this.spPr.xfrm;
|
|
oXfrm.setFlipV(bFlipV);
|
|
if (this.isObjectInSmartArt()) {
|
|
var point = this.getSmartArtShapePoint();
|
|
point && point.changeFlipV(bFlipV);
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.compareForMorph = function(oDrawingToCheck, oCandidate, oMapPaired) {
|
|
if(oCandidate) {
|
|
return oCandidate;
|
|
}
|
|
if(oDrawingToCheck.getObjectType() === this.getObjectType()) {
|
|
const sName = this.getOwnName();
|
|
if(sName && sName.startsWith(AscFormat.OBJECT_MORPH_MARKER)) {
|
|
const sCheckName = oDrawingToCheck.getOwnName();
|
|
if(sName === sCheckName) {
|
|
return oDrawingToCheck;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getTypeName = function () {
|
|
return AscCommon.translateManager.getValue("Graphic Object");
|
|
};
|
|
CGraphicObjectBase.prototype.getOwnName = function() {
|
|
const oCNvPr = this.getCNvProps();
|
|
if (oCNvPr && typeof oCNvPr.name === "string" && oCNvPr.name.length > 0) {
|
|
return oCNvPr.name;
|
|
}
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getObjectName = function () {
|
|
const sOwnName = this.getOwnName();
|
|
if (sOwnName) {
|
|
return sOwnName;
|
|
}
|
|
return this.getTypeName() + " " + this.getFormatId();
|
|
};
|
|
CGraphicObjectBase.prototype.getPlaceholderName = function () {
|
|
if (!this.isPlaceholder()) {
|
|
return "";
|
|
}
|
|
var nPhType = this.getPlaceholderType();
|
|
var sText = AscFormat.pHText[nPhType];
|
|
if (!sText) {
|
|
sText = AscFormat.pHText[AscFormat.phType_body];
|
|
}
|
|
var sTrText = AscCommon.translateManager.getValue(sText);
|
|
return sTrText;
|
|
};
|
|
CGraphicObjectBase.prototype.checkRecalculateTransform = function() {
|
|
if(this.recalcInfo.recalcTransform) {
|
|
this.recalculateTransform();
|
|
this.recalcInfo.recalcTransform = false;
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.checkTransformBeforeApply = function() {
|
|
this.checkRecalculateTransform();
|
|
if(!this.group) {
|
|
AscFormat.CheckSpPrXfrm3(this, true);
|
|
}
|
|
else {
|
|
AscFormat.CheckSpPrXfrm(this, true);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.GetWidth = function () {
|
|
this.checkRecalculateTransform();
|
|
return this.extX;
|
|
};
|
|
CGraphicObjectBase.prototype.GetHeight = function () {
|
|
this.checkRecalculateTransform();
|
|
return this.extY;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.GetPosX = function () {
|
|
this.checkRecalculateTransform();
|
|
return this.x;
|
|
};
|
|
CGraphicObjectBase.prototype.GetPosY = function () {
|
|
this.checkRecalculateTransform();
|
|
return this.y;
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrm = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.shiftXfrm = function (dDX, dDY) {
|
|
let oXfrm = this.getXfrm();
|
|
if (oXfrm) {
|
|
oXfrm.shift(dDX, dDY);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrmOffX = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm.offX;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrmOffY = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm.offY;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrmExtX = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm.extX;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrmExtY = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm.extY;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrmRot = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm.rot;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrmFlipH = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm.flipH;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getXfrmFlipV = function () {
|
|
if (this.spPr && this.spPr.xfrm)
|
|
return this.spPr.xfrm.flipV;
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.checkEmptySpPrAndXfrm = function (_xfrm) {
|
|
if (!this.spPr) {
|
|
this.setSpPr(new AscFormat.CSpPr());
|
|
this.spPr.setParent(this);
|
|
}
|
|
this.bEmptyTransform = !AscCommon.isRealObject(this.spPr.xfrm) || undefined;
|
|
if (!_xfrm) {
|
|
_xfrm = new AscFormat.CXfrm();
|
|
_xfrm.setOffX(0);
|
|
_xfrm.setOffY(0);
|
|
_xfrm.setExtX(0);
|
|
_xfrm.setExtY(0);
|
|
}
|
|
if (this.getObjectType() === AscDFH.historyitem_type_GroupShape ||
|
|
this.getObjectType() === AscDFH.historyitem_type_SmartArt) {
|
|
if (_xfrm.chOffX === null) {
|
|
_xfrm.setChOffX(0);
|
|
}
|
|
if (_xfrm.chOffY === null) {
|
|
_xfrm.setChOffY(0);
|
|
}
|
|
if (_xfrm.chExtX === null) {
|
|
_xfrm.setChExtX(_xfrm.extX);
|
|
}
|
|
if (_xfrm.chExtY === null) {
|
|
_xfrm.setChExtY(_xfrm.extY);
|
|
}
|
|
}
|
|
this.spPr.setXfrm(_xfrm);
|
|
_xfrm.setParent(this.spPr);
|
|
};
|
|
CGraphicObjectBase.prototype.getPictureBase64Data = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.getBase64Img = function (bForceAsDraw, sImageFormat) {
|
|
if (!sImageFormat && typeof this.cachedImage === "string" && this.cachedImage.length > 0) {
|
|
return this.cachedImage;
|
|
}
|
|
if (this.parent) {
|
|
let nParentType = null;
|
|
if (this.parent.getObjectType) {
|
|
nParentType = this.parent.getObjectType();
|
|
}
|
|
if (nParentType === AscDFH.historyitem_type_Notes ||
|
|
nParentType === AscDFH.historyitem_type_NotesMaster) {
|
|
return "";
|
|
}
|
|
}
|
|
let oPictureData;
|
|
if(!bForceAsDraw) {
|
|
oPictureData = this.getPictureBase64Data();
|
|
}
|
|
if (!AscFormat.isRealNumber(this.x) || !AscFormat.isRealNumber(this.y) ||
|
|
!AscFormat.isRealNumber(this.extX) || !AscFormat.isRealNumber(this.extY)
|
|
|| (AscFormat.fApproxEqual(this.extX, 0) && AscFormat.fApproxEqual(this.extY, 0)))
|
|
return "";
|
|
|
|
let oImageData = AscCommon.ShapeToImageConverter(this, this.pageIndex, sImageFormat);
|
|
if (oImageData) {
|
|
if (oImageData.ImageNative) {
|
|
try {
|
|
this.cachedPixW = oImageData.ImageNative.width;
|
|
this.cachedPixH = oImageData.ImageNative.height;
|
|
} catch (e) {
|
|
this.cachedPixW = 50;
|
|
this.cachedPixH = 50;
|
|
}
|
|
}
|
|
if (oPictureData) {
|
|
return oPictureData.ImageUrl;
|
|
}
|
|
return oImageData.ImageUrl;
|
|
} else {
|
|
if (oPictureData) {
|
|
return oPictureData.ImageUrl;
|
|
}
|
|
return "";
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.deleteDrawingBase = function (bCheckPlaceholder) {
|
|
if (AscFormat.editorDeleteDrawingBase) {
|
|
return AscFormat.editorDeleteDrawingBase(this, bCheckPlaceholder);
|
|
}
|
|
return -1;
|
|
};
|
|
CGraphicObjectBase.prototype.addToDrawingObjects = function (pos, type) {
|
|
if (AscFormat.editorAddToDrawingObjects) {
|
|
return AscFormat.editorAddToDrawingObjects(this, pos, type);
|
|
}
|
|
return -1;
|
|
};
|
|
CGraphicObjectBase.prototype.checkDrawingUniNvPr = function () {
|
|
let oUniNvPr = this.getUniNvProps();
|
|
if (!oUniNvPr) {
|
|
oUniNvPr = new AscFormat.UniNvPr();
|
|
this.setNvSpPr(oUniNvPr);
|
|
}
|
|
if (Array.isArray(this.spTree)) {
|
|
for (let i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].checkDrawingUniNvPr();
|
|
}
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.setNvSpPr = function (oPr) {
|
|
};
|
|
CGraphicObjectBase.prototype.isMoveAnimObject = function () {
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.clearChartDataCache = function () {
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.pasteFormatting = function (oFormatData) {
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.pasteDrawingFormatting = function (oDrawing) {
|
|
if(!oDrawing) {
|
|
return;
|
|
}
|
|
if(!this.spPr || !this.setStyle) {
|
|
return;
|
|
}
|
|
if(oDrawing.spPr) {
|
|
let oSpPr = oDrawing.spPr;
|
|
let oFill = null, oLn = null;
|
|
if(oSpPr.Fill) {
|
|
oFill = oSpPr.Fill.createDuplicate();
|
|
}
|
|
if(oSpPr.ln) {
|
|
oLn = oSpPr.ln.createDuplicate();
|
|
}
|
|
if(!this.spPr) {
|
|
this.setSpPr(new AscFormat.CSpPr());
|
|
}
|
|
let oImgSpPr = this.spPr;
|
|
oImgSpPr.setFill(oFill);
|
|
oImgSpPr.setLn(oLn);
|
|
}
|
|
else {
|
|
if(this.spPr) {
|
|
this.setSpPr(null);
|
|
}
|
|
}
|
|
if(oDrawing.style) {
|
|
this.setStyle(oDrawing.style.createDuplicate());
|
|
}
|
|
else{
|
|
this.setStyle(null);
|
|
}
|
|
};
|
|
CGraphicObjectBase.prototype.getText = function () {
|
|
return "";
|
|
};
|
|
CGraphicObjectBase.prototype.getContentText = function () {
|
|
return "";
|
|
};
|
|
CGraphicObjectBase.prototype.getSpeechDescription = function () {
|
|
let sResult = this.getTypeName();
|
|
let sText = this.getContentText();
|
|
let sTitle = (this.getTitle() || "");
|
|
let sDescription = (this.getDescription() || "");
|
|
if(sText && sText.length > 0) {
|
|
sResult += (" " + sText)
|
|
}
|
|
if(sTitle && sTitle.length > 0) {
|
|
sResult += (" " + sTitle)
|
|
}
|
|
if(sDescription && sDescription.length > 0) {
|
|
sResult += (" " + sDescription)
|
|
}
|
|
return sResult;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.getParentNum = function() {
|
|
if(!this.parent) return -1;
|
|
if(this.parent && AscFormat.isRealNumber(this.parent.num)) {
|
|
return this.parent.num;
|
|
}
|
|
let oPresentation;
|
|
if(Asc.editor.private_GetLogicDocument) {
|
|
oPresentation = Asc.editor.private_GetLogicDocument();
|
|
if(oPresentation && oPresentation.GetSlideIndex) {
|
|
return oPresentation.GetSlideIndex(this.parent);
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
|
|
CGraphicObjectBase.prototype.applyDrawingSize = function(props) {
|
|
let oSpParent = this.parent;
|
|
AscFormat.CheckSpPrXfrm3(this);
|
|
let oXfrm = this.spPr.xfrm;
|
|
let scaleX = 1.0;
|
|
let scaleY = 1.0;
|
|
let oldExtX = oXfrm.extX;
|
|
let oldExtY = oXfrm.extY;
|
|
if (!props.SizeRelH && AscFormat.isRealNumber(props.Width)) {
|
|
scaleX = props.Width / oXfrm.extX;
|
|
oXfrm.setExtX(props.Width);
|
|
if (oSpParent instanceof AscCommonWord.ParaDrawing) {
|
|
oSpParent.SetSizeRelH({
|
|
RelativeFrom: AscCommon.c_oAscSizeRelFromH.sizerelfromhPage,
|
|
Percent: 0
|
|
});
|
|
}
|
|
}
|
|
if (!props.SizeRelV && AscFormat.isRealNumber(props.Height)) {
|
|
scaleY = props.Height / oXfrm.extY;
|
|
oXfrm.setExtY(props.Height);
|
|
if (oSpParent instanceof AscCommonWord.ParaDrawing) {
|
|
oSpParent.SetSizeRelV({
|
|
RelativeFrom: AscCommon.c_oAscSizeRelFromV.sizerelfromvPage,
|
|
Percent: 0
|
|
});
|
|
}
|
|
}
|
|
if (oSpParent instanceof AscCommonWord.ParaDrawing) {
|
|
if (oSpParent.SizeRelH && !oSpParent.SizeRelV) {
|
|
oSpParent.SetSizeRelV({
|
|
RelativeFrom: AscCommon.c_oAscSizeRelFromV.sizerelfromvPage,
|
|
Percent: 0
|
|
});
|
|
}
|
|
if (oSpParent.SizeRelV && !oSpParent.SizeRelH) {
|
|
oSpParent.SetSizeRelH({
|
|
RelativeFrom: AscCommon.c_oAscSizeRelFromH.sizerelfromhPage,
|
|
Percent: 0
|
|
});
|
|
}
|
|
}
|
|
this.ResetParametersWithResize(true);
|
|
if(this.isGroup()) {
|
|
oXfrm.setExtX(oldExtX);
|
|
oXfrm.setExtY(oldExtY);
|
|
this.changeSize(scaleX, scaleY);
|
|
}
|
|
this.checkDrawingBaseCoords();
|
|
};
|
|
CGraphicObjectBase.prototype.checkPlaceholders = function(oPlaceholders) {
|
|
if(this.isDependentPlaceholder(oPlaceholders)) {
|
|
this.setRecalculateInfo();
|
|
this.handleUpdateTheme();
|
|
this.recalculate();
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.isDependentPlaceholder = function(oPlaceholders) {
|
|
if(!this.isPlaceholder()) return false;
|
|
let aHierarchy = this.getHierarchy();
|
|
for(let nIdx = 0; nIdx < aHierarchy.length; ++nIdx) {
|
|
let oDrawing = aHierarchy[nIdx];
|
|
if(oDrawing && oPlaceholders[oDrawing.Id]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.handleUpdateTheme = function() {
|
|
|
|
};
|
|
CGraphicObjectBase.prototype.changeSize = function (kw, kh) {
|
|
AscFormat.CShape.prototype.changeSize.call(this, kw, kh);
|
|
};
|
|
CGraphicObjectBase.prototype.checkOnDeletePlaceholder = function(oPlaceholders) {
|
|
if(this.isDependentPlaceholder(oPlaceholders)) {
|
|
if(!(this.spPr && this.spPr.xfrm && this.spPr.xfrm.isNotNull())) {
|
|
AscFormat.CheckSpPrXfrm(this, true);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
CGraphicObjectBase.prototype.generateLocalDrawingPart = function () {};
|
|
CGraphicObjectBase.prototype.generateSmartArtDrawingPart = function () {};
|
|
CGraphicObjectBase.prototype.checkDrawingPartWithHistory = function () {};
|
|
CGraphicObjectBase.prototype.getAllInks = function (arrInks) {return arrInks || []};
|
|
CGraphicObjectBase.prototype.isShapeCrop = function () {return false};
|
|
CGraphicObjectBase.prototype.forEachAnimationDrawing = function(fCallback) {
|
|
return !!fCallback(this);
|
|
};
|
|
CGraphicObjectBase.prototype.forEachObjectToDraw = function(fCallback) {};
|
|
CGraphicObjectBase.prototype.onRemoveContent = function () {};
|
|
CGraphicObjectBase.prototype.getBrush = function() {
|
|
return this.brush;
|
|
};
|
|
CGraphicObjectBase.prototype.getPen = function() {
|
|
return this.pen;
|
|
};
|
|
CGraphicObjectBase.prototype.getGeometryBounds = function(oTransform) {
|
|
const oGeometry = this.getGeometry();
|
|
const oBoundsChecker = new AscFormat.CSlideBoundsChecker();
|
|
oBoundsChecker.transform3(oTransform);
|
|
if (!oGeometry || oGeometry.isEmpty() || !oBoundsChecker.IsShapeNeedBounds(oGeometry.preset)) {
|
|
oBoundsChecker._s();
|
|
oBoundsChecker._m(0, 0);
|
|
oBoundsChecker._l(this.extX, 0);
|
|
oBoundsChecker._l(this.extX, this.extY);
|
|
oBoundsChecker._l(0, this.extY);
|
|
oBoundsChecker._e();
|
|
} else {
|
|
oGeometry.check_bounds(oBoundsChecker);
|
|
}
|
|
const oBounds = oBoundsChecker.Bounds;
|
|
const oGraphicBounds = new CGraphicBounds(0, 0, 0, 0);
|
|
oGraphicBounds.reset(oBounds.min_x, oBounds.min_y, oBounds.max_x, oBounds.max_y);
|
|
return oGraphicBounds;
|
|
};
|
|
CGraphicObjectBase.prototype.getDocContent = function () {
|
|
return null;
|
|
};
|
|
CGraphicObjectBase.prototype.isControl = function() {
|
|
return false;
|
|
}
|
|
var ANIM_LABEL_WIDTH_PIX = 22;
|
|
var ANIM_LABEL_HEIGHT_PIX = 17;
|
|
|
|
|
|
function CRelSizeAnchor() {
|
|
CBaseObject.call(this);
|
|
this.fromX = null;
|
|
this.fromY = null;
|
|
|
|
this.toX = null;
|
|
this.toY = null;
|
|
|
|
this.object = null;
|
|
|
|
this.parent = null;
|
|
this.drawingBase = null;
|
|
}
|
|
|
|
CRelSizeAnchor.prototype = Object.create(CBaseObject.prototype);
|
|
CRelSizeAnchor.prototype.constructor = CRelSizeAnchor;
|
|
CRelSizeAnchor.prototype.setDrawingBase = function (drawingBase) {
|
|
this.drawingBase = drawingBase;
|
|
};
|
|
CRelSizeAnchor.prototype.getObjectType = function () {
|
|
return AscDFH.historyitem_type_RelSizeAnchor;
|
|
};
|
|
CRelSizeAnchor.prototype.setFromTo = function (fromX, fromY, toX, toY) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_RelSizeAnchorFromX, this.fromX, fromX));
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_RelSizeAnchorFromY, this.fromY, fromY));
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_RelSizeAnchorToX, this.toX, toX));
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_RelSizeAnchorToY, this.toY, toY));
|
|
this.fromX = fromX;
|
|
this.fromY = fromY;
|
|
this.toX = toX;
|
|
this.toY = toY;
|
|
};
|
|
CRelSizeAnchor.prototype.setObject = function (object) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_RelSizeAnchorObject, this.object, object));
|
|
this.object = object;
|
|
if (object) {
|
|
object.setParent(this);
|
|
}
|
|
};
|
|
CRelSizeAnchor.prototype.setParent = function (object) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_RelSizeAnchorParent, this.parent, object));
|
|
this.parent = object;
|
|
};
|
|
CRelSizeAnchor.prototype.copy = function (oPr) {
|
|
var copy = new CRelSizeAnchor();
|
|
copy.setFromTo(this.fromX, this.fromY, this.toX, this.toY);
|
|
if (this.object) {
|
|
copy.setObject(this.object.copy(oPr));
|
|
}
|
|
return copy;
|
|
};
|
|
CRelSizeAnchor.prototype.Refresh_RecalcData = function () {
|
|
if (this.parent && this.parent.Refresh_RecalcData2) {
|
|
this.parent.Refresh_RecalcData2();
|
|
}
|
|
};
|
|
CRelSizeAnchor.prototype.Refresh_RecalcData2 = function () {
|
|
if (this.parent && this.parent.Refresh_RecalcData2) {
|
|
this.parent.Refresh_RecalcData2();
|
|
}
|
|
};
|
|
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_RelSizeAnchorFromX] = function (oClass, value) {
|
|
oClass.fromX = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_RelSizeAnchorFromY] = function (oClass, value) {
|
|
oClass.fromY = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_RelSizeAnchorToX] = function (oClass, value) {
|
|
oClass.toX = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_RelSizeAnchorToY] = function (oClass, value) {
|
|
oClass.toY = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_RelSizeAnchorObject] = function (oClass, value) {
|
|
oClass.object = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_RelSizeAnchorParent] = function (oClass, value) {
|
|
oClass.parent = value;
|
|
};
|
|
|
|
AscDFH.changesFactory[AscDFH.historyitem_RelSizeAnchorFromX] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_RelSizeAnchorFromY] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_RelSizeAnchorToX] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_RelSizeAnchorToY] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_RelSizeAnchorObject] = window['AscDFH'].CChangesDrawingsObject;
|
|
AscDFH.changesFactory[AscDFH.historyitem_RelSizeAnchorParent] = window['AscDFH'].CChangesDrawingsObject;
|
|
|
|
|
|
function CAbsSizeAnchor() {
|
|
CBaseObject.call(this);
|
|
this.fromX = null;
|
|
this.fromY = null;
|
|
this.toX = null;
|
|
this.toY = null;
|
|
this.object = null;
|
|
|
|
this.parent = null;
|
|
this.drawingBase = null;
|
|
}
|
|
|
|
CAbsSizeAnchor.prototype = Object.create(CBaseObject.prototype);
|
|
CAbsSizeAnchor.prototype.constructor = CAbsSizeAnchor;
|
|
CAbsSizeAnchor.prototype.setDrawingBase = function (drawingBase) {
|
|
this.drawingBase = drawingBase;
|
|
};
|
|
CAbsSizeAnchor.prototype.getObjectType = function () {
|
|
return AscDFH.historyitem_type_AbsSizeAnchor;
|
|
};
|
|
CAbsSizeAnchor.prototype.setFromTo = function (fromX, fromY, extX, extY) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_AbsSizeAnchorFromX, this.fromX, fromX));
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_AbsSizeAnchorFromY, this.fromY, fromY));
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_AbsSizeAnchorExtX, this.toX, extX));
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsDouble(this, AscDFH.historyitem_AbsSizeAnchorExtY, this.toY, extY));
|
|
this.fromX = fromX;
|
|
this.fromY = fromY;
|
|
this.toX = extX;
|
|
this.toY = extY;
|
|
};
|
|
CAbsSizeAnchor.prototype.setObject = function (object) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_AbsSizeAnchorObject, this.object, object));
|
|
this.object = object;
|
|
if (object) {
|
|
object.setParent(this);
|
|
}
|
|
};
|
|
CAbsSizeAnchor.prototype.setParent = function (object) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_AbsSizeAnchorParent, this.parent, object));
|
|
this.parent = object;
|
|
};
|
|
CAbsSizeAnchor.prototype.copy = function (oPr) {
|
|
var copy = new CRelSizeAnchor();
|
|
copy.setFromTo(this.fromX, this.fromY, this.toX, this.toY);
|
|
if (this.object) {
|
|
copy.setObject(this.object.copy(oPr));
|
|
}
|
|
return copy;
|
|
};
|
|
CAbsSizeAnchor.prototype.Refresh_RecalcData = function (drawingDocument) {
|
|
if (this.parent && this.parent.Refresh_RecalcData2) {
|
|
this.parent.Refresh_RecalcData2();
|
|
}
|
|
};
|
|
CAbsSizeAnchor.prototype.Refresh_RecalcData2 = function (drawingDocument) {
|
|
if (this.parent && this.parent.Refresh_RecalcData2) {
|
|
this.parent.Refresh_RecalcData2();
|
|
}
|
|
};
|
|
|
|
function CalculateSrcRect(parentCropTransform, bounds, oInvertTransformCrop, cropExtX, cropExtY) {
|
|
var lt_x_abs = parentCropTransform.TransformPointX(bounds.min_x, bounds.min_y);
|
|
var lt_y_abs = parentCropTransform.TransformPointY(bounds.min_x, bounds.min_y);
|
|
var rb_x_abs = parentCropTransform.TransformPointX(bounds.max_x, bounds.max_y);
|
|
var rb_y_abs = parentCropTransform.TransformPointY(bounds.max_x, bounds.max_y);
|
|
|
|
var lt_x_rel = oInvertTransformCrop.TransformPointX(lt_x_abs, lt_y_abs);
|
|
var lt_y_rel = oInvertTransformCrop.TransformPointY(lt_x_abs, lt_y_abs);
|
|
var rb_x_rel = oInvertTransformCrop.TransformPointX(rb_x_abs, rb_y_abs);
|
|
var rb_y_rel = oInvertTransformCrop.TransformPointY(rb_x_abs, rb_y_abs);
|
|
var srcRect = new AscFormat.CSrcRect();
|
|
var _l = (100 * lt_x_rel / cropExtX);
|
|
var _t = (100 * lt_y_rel / cropExtY);
|
|
var _r = (100 * rb_x_rel / cropExtX);
|
|
var _b = (100 * rb_y_rel / cropExtY);
|
|
srcRect.l = Math.min(_l, _r);
|
|
srcRect.t = Math.min(_t, _b);
|
|
srcRect.r = Math.max(_l, _r);
|
|
srcRect.b = Math.max(_t, _b);
|
|
|
|
return srcRect;
|
|
}
|
|
|
|
function canSelectDrawing(oDrawing) {
|
|
if (typeof oDrawing.canSelect === "function") {
|
|
return oDrawing.canSelect();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_AbsSizeAnchorFromX] = function (oClass, value) {
|
|
oClass.fromX = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_AbsSizeAnchorFromY] = function (oClass, value) {
|
|
oClass.fromY = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_AbsSizeAnchorExtX] = function (oClass, value) {
|
|
oClass.toX = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_AbsSizeAnchorExtY] = function (oClass, value) {
|
|
oClass.toY = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_AbsSizeAnchorObject] = function (oClass, value) {
|
|
oClass.object = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_AbsSizeAnchorParent] = function (oClass, value) {
|
|
oClass.parent = value;
|
|
};
|
|
|
|
AscDFH.changesFactory[AscDFH.historyitem_AbsSizeAnchorFromX] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AbsSizeAnchorFromY] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AbsSizeAnchorExtX] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AbsSizeAnchorExtY] = window['AscDFH'].CChangesDrawingsDouble;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AbsSizeAnchorObject] = window['AscDFH'].CChangesDrawingsObject;
|
|
AscDFH.changesFactory[AscDFH.historyitem_AbsSizeAnchorParent] = window['AscDFH'].CChangesDrawingsObject;
|
|
|
|
function IsTrueDrawing(oDrawing) {
|
|
if(!oDrawing) {
|
|
return false;
|
|
}
|
|
if(oDrawing instanceof CGraphicObjectBase) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
window['AscFormat'] = window['AscFormat'] || {};
|
|
window['AscFormat'].CGraphicObjectBase = CGraphicObjectBase;
|
|
window['AscFormat'].CGraphicBounds = CGraphicBounds;
|
|
window['AscFormat'].checkNormalRotate = checkNormalRotate;
|
|
window['AscFormat'].normalizeRotate = normalizeRotate;
|
|
window['AscFormat'].CRelSizeAnchor = CRelSizeAnchor;
|
|
window['AscFormat'].CAbsSizeAnchor = CAbsSizeAnchor;
|
|
window['AscFormat'].CalculateSrcRect = CalculateSrcRect;
|
|
window['AscFormat'].CCopyObjectProperties = CCopyObjectProperties;
|
|
window['AscFormat'].CClientData = CClientData;
|
|
window['AscFormat'].LOCKS_MASKS = LOCKS_MASKS;
|
|
window['AscFormat'].MACRO_PREFIX = "jsaProject_";
|
|
window['AscFormat'].canSelectDrawing = canSelectDrawing;
|
|
window['AscFormat'].IsTrueDrawing = IsTrueDrawing;
|
|
})(window);
|