1805 lines
56 KiB
JavaScript
1805 lines
56 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2024
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
(
|
|
/**
|
|
* @param {Window} window
|
|
* @param {undefined} undefined
|
|
*/
|
|
function (window, undefined) {
|
|
// Import
|
|
var c_oAscSizeRelFromH = AscCommon.c_oAscSizeRelFromH;
|
|
var c_oAscSizeRelFromV = AscCommon.c_oAscSizeRelFromV;
|
|
var isRealObject = AscCommon.isRealObject;
|
|
var global_MatrixTransformer = AscCommon.global_MatrixTransformer;
|
|
|
|
var CShape = AscFormat.CShape;
|
|
|
|
|
|
AscDFH.changesFactory[AscDFH.historyitem_GroupShapeSetNvGrpSpPr] = AscDFH.CChangesDrawingsObject;
|
|
AscDFH.changesFactory[AscDFH.historyitem_GroupShapeSetSpPr] = AscDFH.CChangesDrawingsObject;
|
|
AscDFH.changesFactory[AscDFH.historyitem_GroupShapeSetParent] = AscDFH.CChangesDrawingsObject;
|
|
AscDFH.changesFactory[AscDFH.historyitem_GroupShapeAddToSpTree] = AscDFH.CChangesDrawingsContent;
|
|
AscDFH.changesFactory[AscDFH.historyitem_GroupShapeSetGroup] = AscDFH.CChangesDrawingsObject;
|
|
AscDFH.changesFactory[AscDFH.historyitem_GroupShapeRemoveFromSpTree] = AscDFH.CChangesDrawingsContent;
|
|
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_GroupShapeSetNvGrpSpPr] = function (oClass, value) {
|
|
oClass.nvGrpSpPr = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_GroupShapeSetSpPr] = function (oClass, value) {
|
|
oClass.spPr = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_GroupShapeSetParent] = function (oClass, value) {
|
|
oClass.oldParent = oClass.parent;
|
|
oClass.parent = value;
|
|
};
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_GroupShapeSetGroup] = function (oClass, value) {
|
|
oClass.group = value;
|
|
};
|
|
|
|
AscDFH.drawingContentChanges[AscDFH.historyitem_GroupShapeAddToSpTree] = AscDFH.drawingContentChanges[AscDFH.historyitem_GroupShapeRemoveFromSpTree] = function (oClass) {
|
|
return oClass.spTree;
|
|
};
|
|
|
|
/**
|
|
* @extends CGraphicObjectBase
|
|
* @constructor
|
|
*/
|
|
function CGroupShape() {
|
|
AscFormat.CGraphicObjectBase.call(this);
|
|
this.nvGrpSpPr = null;
|
|
this.spTree = [];
|
|
|
|
|
|
this.invertTransform = null;
|
|
this.scaleCoefficients = {cx: 1, cy: 1};
|
|
|
|
this.arrGraphicObjects = [];
|
|
this.selectedObjects = [];
|
|
|
|
|
|
this.selection =
|
|
{
|
|
groupSelection: null,
|
|
chartSelection: null,
|
|
textSelection: null
|
|
};
|
|
}
|
|
|
|
AscFormat.InitClass(CGroupShape, AscFormat.CGraphicObjectBase, AscDFH.historyitem_type_GroupShape);
|
|
|
|
CGroupShape.prototype.GetAllDrawingObjects = function (DrawingObjects) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].GetAllDrawingObjects) {
|
|
this.spTree[i].GetAllDrawingObjects(DrawingObjects);
|
|
}
|
|
}
|
|
};
|
|
CGroupShape.prototype.getRelativePosition = function (obj) {
|
|
let result = obj || {x: 0, y: 0};
|
|
result.x += this.x;
|
|
result.y += this.y;
|
|
if (this.group) {
|
|
this.group.getRelativePosition(result);
|
|
}
|
|
return result;
|
|
};
|
|
CGroupShape.prototype.hasSmartArt = function (bRetSmartArt) {
|
|
let hasSmartArt = false;
|
|
for (let i = 0; i < this.spTree.length; i += 1) {
|
|
if (hasSmartArt) {
|
|
return hasSmartArt;
|
|
}
|
|
if (this.spTree[i].hasSmartArt) {
|
|
hasSmartArt = this.spTree[i].hasSmartArt(bRetSmartArt);
|
|
}
|
|
}
|
|
return hasSmartArt;
|
|
};
|
|
|
|
CGroupShape.prototype.recalcTransformText = function () {
|
|
this.spTree.forEach(function (oDrawing) {
|
|
if (oDrawing.recalcTransformText) {
|
|
oDrawing.recalcTransformText();
|
|
}
|
|
});
|
|
};
|
|
|
|
CGroupShape.prototype.documentGetAllFontNames = function (allFonts) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].documentGetAllFontNames)
|
|
this.spTree[i].documentGetAllFontNames(allFonts);
|
|
}
|
|
};
|
|
CGroupShape.prototype.getImageFromBulletsMap = function (oImages) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].getImageFromBulletsMap)
|
|
this.spTree[i].getImageFromBulletsMap(oImages);
|
|
}
|
|
};
|
|
CGroupShape.prototype.getDocContentsWithImageBullets = function (arrContents) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].getDocContentsWithImageBullets)
|
|
this.spTree[i].getDocContentsWithImageBullets(arrContents);
|
|
}
|
|
};
|
|
CGroupShape.prototype.handleAllContents = function (fCallback) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].handleAllContents(fCallback);
|
|
}
|
|
};
|
|
CGroupShape.prototype.getAllDocContents = function (aDocContents) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].getAllDocContents)
|
|
this.spTree[i].getAllDocContents(aDocContents);
|
|
}
|
|
};
|
|
CGroupShape.prototype.checkRunContent = function (fCallback) {
|
|
let aGraphics = this.getArrGraphicObjects();
|
|
for (let nIdx = 0; nIdx < aGraphics.length; ++nIdx) {
|
|
aGraphics[nIdx].checkRunContent(fCallback);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.documentCreateFontMap = function (allFonts) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].documentCreateFontMap)
|
|
this.spTree[i].documentCreateFontMap(allFonts);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setBDeleted2 = function (pr) {
|
|
this.setBDeleted(pr);
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].setBDeleted2) {
|
|
this.spTree[i].setBDeleted2(pr);
|
|
} else {
|
|
this.spTree[i].setBDeleted(pr);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.documentUpdateSelectionState = function () {
|
|
if (this.selection.textSelection) {
|
|
this.selection.textSelection.updateSelectionState();
|
|
} else if (this.selection.groupSelection) {
|
|
this.selection.groupSelection.documentUpdateSelectionState();
|
|
} else if (this.selection.chartSelection) {
|
|
this.selection.chartSelection.documentUpdateSelectionState();
|
|
} else {
|
|
this.getDrawingDocument().SelectClear();
|
|
this.getDrawingDocument().TargetEnd();
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.drawSelectionPage = function (pageIndex) {
|
|
var oMatrix = null;
|
|
if (this.selection.textSelection) {
|
|
if (this.selection.textSelection.transformText) {
|
|
oMatrix = this.selection.textSelection.transformText.CreateDublicate();
|
|
}
|
|
this.getDrawingDocument().UpdateTargetTransform(oMatrix);
|
|
this.selection.textSelection.getDocContent().DrawSelectionOnPage(pageIndex);
|
|
} else if (this.selection.chartSelection && this.selection.chartSelection.selection.textSelection) {
|
|
if (this.selection.chartSelection.selection.textSelection.transformText) {
|
|
oMatrix = this.selection.chartSelection.selection.textSelection.transformText.CreateDublicate();
|
|
}
|
|
this.getDrawingDocument().UpdateTargetTransform(oMatrix);
|
|
this.selection.chartSelection.selection.textSelection.getDocContent().DrawSelectionOnPage(pageIndex);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setNvGrpSpPr = function (pr) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_GroupShapeSetNvGrpSpPr, this.nvGrpSpPr, pr));
|
|
this.nvGrpSpPr = pr;
|
|
};
|
|
|
|
CGroupShape.prototype.setSpPr = function (pr) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_GroupShapeSetSpPr, this.spPr, pr));
|
|
this.spPr = pr;
|
|
if (pr) {
|
|
pr.setParent(this);
|
|
}
|
|
};
|
|
CGroupShape.prototype.getSpCount = function () {
|
|
return this.spTree.length;
|
|
};
|
|
CGroupShape.prototype.addToSpTree = function (pos, item) {
|
|
if (!AscFormat.isRealNumber(pos))
|
|
pos = this.spTree.length;
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsContent(this, AscDFH.historyitem_GroupShapeAddToSpTree, pos, [item], true));
|
|
this.handleUpdateSpTree();
|
|
if (item.group !== this) {
|
|
item.setGroup(this);
|
|
}
|
|
this.spTree.splice(pos, 0, item);
|
|
};
|
|
|
|
CGroupShape.prototype.setParent = function (pr) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_GroupShapeSetParent, this.parent, pr));
|
|
this.parent = pr;
|
|
};
|
|
|
|
CGroupShape.prototype.setGroup = function (group) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_GroupShapeSetGroup, this.group, group));
|
|
this.group = group;
|
|
};
|
|
|
|
CGroupShape.prototype.getPosInSpTree = function (id) {
|
|
for (var i = this.spTree.length - 1; i > -1; --i) {
|
|
if (this.spTree[i].Get_Id() === id) {
|
|
return i;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.removeFromSpTree = function (id) {
|
|
var nPos = this.getPosInSpTree(id);
|
|
if (nPos !== null) {
|
|
return this.removeFromSpTreeByPos(nPos);
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.removeFromSpTreeByPos = function (pos) {
|
|
var aSplicedShape = this.spTree.splice(pos, 1);
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsContent(this, AscDFH.historyitem_GroupShapeRemoveFromSpTree, pos, aSplicedShape, false));
|
|
this.handleUpdateSpTree();
|
|
return aSplicedShape[0];
|
|
};
|
|
|
|
CGroupShape.prototype.handleUpdateSpTree = function () {
|
|
if (!this.group) {
|
|
this.recalcInfo.recalculateArrGraphicObjects = true;
|
|
this.recalcBounds();
|
|
this.addToRecalculate();
|
|
} else {
|
|
this.recalcInfo.recalculateArrGraphicObjects = true;
|
|
this.group.handleUpdateSpTree();
|
|
this.recalcBounds();
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.handleUpdateExtents = function() {
|
|
this.recalcTransform();
|
|
for(let nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].handleUpdateExtents();
|
|
}
|
|
if(!this.group) {
|
|
if(this.addToRecalculate) {
|
|
this.addToRecalculate();
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.copy = function (oPr) {
|
|
var copy = new CGroupShape();
|
|
this.copy2(copy, oPr);
|
|
return copy;
|
|
};
|
|
CGroupShape.prototype.copy2 = function (copy, oPr) {
|
|
if (this.nvGrpSpPr) {
|
|
copy.setNvGrpSpPr(this.nvGrpSpPr.createDuplicate());
|
|
}
|
|
if (this.spPr) {
|
|
copy.setSpPr(this.spPr.createDuplicate());
|
|
copy.spPr.setParent(copy);
|
|
}
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
var _copy;
|
|
if (this.spTree[i].isGroupObject()) {
|
|
_copy = this.spTree[i].copy(oPr);
|
|
} else {
|
|
if (oPr && oPr.bSaveSourceFormatting) {
|
|
_copy = this.spTree[i].getCopyWithSourceFormatting();
|
|
} else {
|
|
_copy = this.spTree[i].copy(oPr);
|
|
}
|
|
|
|
}
|
|
if (oPr && AscCommon.isRealObject(oPr.idMap)) {
|
|
oPr.idMap[this.spTree[i].Id] = _copy.Id;
|
|
}
|
|
copy.addToSpTree(copy.spTree.length, _copy);
|
|
copy.spTree[copy.spTree.length - 1].setGroup(copy);
|
|
}
|
|
copy.setBDeleted(this.bDeleted);
|
|
if (this.macro !== null) {
|
|
copy.setMacro(this.macro);
|
|
}
|
|
if (this.textLink !== null) {
|
|
copy.setTextLink(this.textLink);
|
|
}
|
|
if (this.clientData) {
|
|
copy.setClientData(this.clientData.createDuplicate());
|
|
}
|
|
if (this.fLocksText !== null) {
|
|
copy.setFLocksText(this.fLocksText);
|
|
}
|
|
if (!oPr || false !== oPr.cacheImage) {
|
|
copy.cachedImage = this.getBase64Img();
|
|
copy.cachedPixH = this.cachedPixH;
|
|
copy.cachedPixW = this.cachedPixW;
|
|
}
|
|
copy.setLocks(this.locks);
|
|
return copy;
|
|
};
|
|
|
|
CGroupShape.prototype.getAllImages = function (images) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].getAllImages === "function") {
|
|
this.spTree[i].getAllImages(images);
|
|
}
|
|
}
|
|
};
|
|
CGroupShape.prototype.clearLang = function () {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].clearLang === "function") {
|
|
this.spTree[i].clearLang();
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.convertToWord = function (document) {
|
|
this.setBDeleted(true);
|
|
var c = new CGroupShape();
|
|
c.setBDeleted(false);
|
|
if (this.nvGrpSpPr) {
|
|
c.setNvSpPr(this.nvGrpSpPr.createDuplicate());
|
|
}
|
|
if (this.spPr) {
|
|
c.setSpPr(this.spPr.createDuplicate());
|
|
c.spPr.setParent(c);
|
|
}
|
|
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
c.addToSpTree(c.spTree.length, this.spTree[i].convertToWord(document));
|
|
c.spTree[c.spTree.length - 1].setGroup(c);
|
|
}
|
|
c.removePlaceholder();
|
|
return c;
|
|
};
|
|
|
|
CGroupShape.prototype.convertToPPTX = function (drawingDocument, worksheet) {
|
|
var c = new CGroupShape();
|
|
c.setBDeleted(false);
|
|
c.setWorksheet(worksheet);
|
|
if (this.nvGrpSpPr) {
|
|
c.setNvSpPr(this.nvGrpSpPr.createDuplicate());
|
|
}
|
|
if (this.spPr) {
|
|
c.setSpPr(this.spPr.createDuplicate());
|
|
c.spPr.setParent(c);
|
|
}
|
|
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
c.addToSpTree(c.spTree.length, this.spTree[i].convertToPPTX(drawingDocument, worksheet));
|
|
c.spTree[c.spTree.length - 1].setGroup(c);
|
|
}
|
|
return c;
|
|
};
|
|
|
|
CGroupShape.prototype.getAllFonts = function (fonts) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].getAllFonts === "function")
|
|
this.spTree[i].getAllFonts(fonts);
|
|
}
|
|
};
|
|
|
|
|
|
CGroupShape.prototype.isPlaceholder = function () {
|
|
return !!(this.nvGrpSpPr != null && this.nvGrpSpPr.nvPr && this.nvGrpSpPr.nvPr.ph);
|
|
};
|
|
|
|
CGroupShape.prototype.getAllRasterImages = function (images) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].getAllRasterImages)
|
|
this.spTree[i].getAllRasterImages(images);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.getAllSlicerViews = function (aSlicerView) {
|
|
for (var nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].getAllSlicerViews(aSlicerView);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.hit = function (x, y) {
|
|
for (var i = this.spTree.length - 1; i > -1; --i) {
|
|
if (this.spTree[i].hit(x, y)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
CGroupShape.prototype.onMouseMove = function (e, x, y) {
|
|
for (var i = this.spTree.length - 1; i > -1; --i) {
|
|
if (this.spTree[i].onMouseMove(e, x, y)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* @memberOf CGroupShape
|
|
*/
|
|
CGroupShape.prototype.draw = function (graphics) {
|
|
if (this.checkNeedRecalculate && this.checkNeedRecalculate()) {
|
|
return;
|
|
}
|
|
if (graphics.animationDrawer) {
|
|
graphics.animationDrawer.drawObject(this, graphics);
|
|
return;
|
|
}
|
|
var oClipRect;
|
|
if (!graphics.isBoundsChecker()) {
|
|
oClipRect = this.getClipRect();
|
|
}
|
|
if (oClipRect) {
|
|
graphics.SaveGrState();
|
|
graphics.AddClipRect(oClipRect.x, oClipRect.y, oClipRect.w, oClipRect.h);
|
|
}
|
|
for (var i = 0; i < this.spTree.length; ++i)
|
|
this.spTree[i].draw(graphics);
|
|
|
|
|
|
this.drawLocks(this.transform, graphics);
|
|
if (oClipRect) {
|
|
graphics.RestoreGrState();
|
|
}
|
|
graphics.reset();
|
|
graphics.SetIntegerGrid(true);
|
|
};
|
|
|
|
CGroupShape.prototype.deselectObject = function (object) {
|
|
for (var i = 0; i < this.selectedObjects.length; ++i) {
|
|
if (this.selectedObjects[i] === object) {
|
|
object.selected = false;
|
|
this.selectedObjects.splice(i, 1);
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
CGroupShape.prototype.resetInternalSelectionObject = function (oSelectedObject) {
|
|
if (this.selection.textSelection === oSelectedObject) {
|
|
if (this.selection.textSelection.getObjectType() === AscDFH.historyitem_type_GraphicFrame) {
|
|
if (this.selection.textSelection.graphicObject) {
|
|
this.selection.textSelection.graphicObject.RemoveSelection();
|
|
}
|
|
} else {
|
|
const oContent = this.selection.textSelection.getDocContent();
|
|
oContent && oContent.RemoveSelection();
|
|
}
|
|
}
|
|
if (this.selection.chartSelection === oSelectedObject) {
|
|
this.selection.chartSelection.resetSelection();
|
|
this.selection.chartSelection = null;
|
|
}
|
|
};
|
|
CGroupShape.prototype.deselectInternal = function(oController) {
|
|
const oMainGroup = this.getMainGroup();
|
|
if (oMainGroup.selectedObjects.length) {
|
|
const oSelectedObjects = {};
|
|
for (let i = oMainGroup.selectedObjects.length - 1; i >= 0; i -= 1) {
|
|
const oSelectedObject = oMainGroup.selectedObjects[i];
|
|
if (oSelectedObject.bDeleted) {
|
|
oMainGroup.deselectObject(oSelectedObject);
|
|
oMainGroup.resetInternalSelectionObject(oSelectedObject);
|
|
} else {
|
|
oSelectedObjects[oSelectedObject.Get_Id()] = oSelectedObject;
|
|
}
|
|
}
|
|
|
|
const arrGroups = [this];
|
|
while (arrGroups.length) {
|
|
const oGroup = arrGroups.pop();
|
|
for (let i = 0; i < oGroup.spTree.length; i += 1) {
|
|
const oShape = oGroup.spTree[i];
|
|
if (oShape.isGroup()) {
|
|
arrGroups.push(oShape);
|
|
} else if (oSelectedObjects[oShape.Get_Id()]) {
|
|
oMainGroup.deselectObject(oShape);
|
|
oMainGroup.resetInternalSelectionObject(oShape);
|
|
}
|
|
}
|
|
}
|
|
if (!oMainGroup.selectedObjects.length) {
|
|
oController.selection.groupSelection = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
CGroupShape.prototype.getLocalTransform = function () {
|
|
if (this.recalcInfo.recalculateTransform) {
|
|
this.recalculateTransform();
|
|
this.recalcInfo.recalculateTransform = false;
|
|
}
|
|
return this.localTransform;
|
|
};
|
|
|
|
CGroupShape.prototype.getArrGraphicObjects = function () {
|
|
if (this.recalcInfo.recalculateArrGraphicObjects)
|
|
this.recalculateArrGraphicObjects();
|
|
return this.arrGraphicObjects;
|
|
};
|
|
|
|
CGroupShape.prototype.getInvertTransform = function () {
|
|
return this.invertTransform;
|
|
};
|
|
|
|
CGroupShape.prototype.getResultScaleCoefficients = function () {
|
|
if (this.recalcInfo.recalculateScaleCoefficients) {
|
|
var cx, cy;
|
|
if (this.spPr && this.spPr.xfrm && this.spPr.xfrm.isNotNullForGroup()) {
|
|
|
|
var dExtX = this.spPr.xfrm.extX, dExtY = this.spPr.xfrm.extY;
|
|
|
|
|
|
if (this.drawingBase && !this.group) {
|
|
var metrics = this.drawingBase.getGraphicObjectMetrics();
|
|
var rot = 0;
|
|
if (this.spPr && this.spPr.xfrm) {
|
|
if (AscFormat.isRealNumber(this.spPr.xfrm.rot)) {
|
|
rot = AscFormat.normalizeRotate(this.spPr.xfrm.rot);
|
|
}
|
|
}
|
|
|
|
var metricExtX, metricExtY;
|
|
// if(!(this instanceof AscFormat.CGroupShape))
|
|
{
|
|
if (AscFormat.checkNormalRotate(rot)) {
|
|
dExtX = metrics.extX;
|
|
dExtY = metrics.extY;
|
|
} else {
|
|
dExtX = metrics.extY;
|
|
dExtY = metrics.extX;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.spPr.xfrm.chExtX > 0)
|
|
cx = dExtX / this.spPr.xfrm.chExtX;
|
|
else
|
|
cx = 1;
|
|
|
|
if (this.spPr.xfrm.chExtY > 0)
|
|
cy = dExtY / this.spPr.xfrm.chExtY;
|
|
else
|
|
cy = 1;
|
|
} else {
|
|
cx = 1;
|
|
cy = 1;
|
|
}
|
|
if (isRealObject(this.group)) {
|
|
var group_scale_coefficients = this.group.getResultScaleCoefficients();
|
|
cx *= group_scale_coefficients.cx;
|
|
cy *= group_scale_coefficients.cy;
|
|
} else {
|
|
let oParaDrawing = AscFormat.getParaDrawing(this);
|
|
if (oParaDrawing) {
|
|
let dScaleCoefficient = oParaDrawing.GetScaleCoefficient();
|
|
cx *= dScaleCoefficient;
|
|
cy *= dScaleCoefficient;
|
|
}
|
|
}
|
|
|
|
this.scaleCoefficients.cx = cx;
|
|
this.scaleCoefficients.cy = cy;
|
|
this.recalcInfo.recalculateScaleCoefficients = false;
|
|
}
|
|
return this.scaleCoefficients;
|
|
};
|
|
|
|
CGroupShape.prototype.getCompiledTransparent = function () {
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.selectObject = function (object, pageIndex) {
|
|
object.select(this, pageIndex);
|
|
};
|
|
CGroupShape.prototype.onChangeDrawingsSelection = function () {
|
|
};
|
|
|
|
CGroupShape.prototype.recalculate = function () {
|
|
var recalcInfo = this.recalcInfo;
|
|
|
|
if (recalcInfo.recalculateBrush) {
|
|
this.recalculateBrush();
|
|
recalcInfo.recalculateBrush = false;
|
|
}
|
|
if (recalcInfo.recalculatePen) {
|
|
this.recalculatePen();
|
|
recalcInfo.recalculatePen = false;
|
|
}
|
|
if (recalcInfo.recalculateScaleCoefficients) {
|
|
this.getResultScaleCoefficients();
|
|
recalcInfo.recalculateScaleCoefficients = false;
|
|
}
|
|
|
|
if (recalcInfo.recalculateTransform) {
|
|
this.recalculateTransform();
|
|
recalcInfo.recalculateTransform = false;
|
|
}
|
|
if (recalcInfo.recalculateArrGraphicObjects)
|
|
this.recalculateArrGraphicObjects();
|
|
for (var i = 0; i < this.spTree.length; ++i)
|
|
this.spTree[i].recalculate();
|
|
if (recalcInfo.recalculateBounds) {
|
|
this.recalculateBounds();
|
|
recalcInfo.recalculateBounds = false;
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.recalcTransform = function () {
|
|
this.recalcInfo.recalculateTransform = true;
|
|
this.recalcInfo.recalculateScaleCoefficients = true;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].recalcTransform)
|
|
this.spTree[i].recalcTransform();
|
|
else {
|
|
this.spTree[i].recalcInfo.recalculateTransform = true;
|
|
this.spTree[i].recalcInfo.recalculateTransformText = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.canRotate = function () {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (!this.spTree[i].canRotate())
|
|
return false;
|
|
}
|
|
return AscFormat.CGraphicObjectBase.prototype.canRotate.call(this);
|
|
};
|
|
|
|
CGroupShape.prototype.canResize = function () {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (!this.spTree[i].canResize())
|
|
return false
|
|
}
|
|
return AscFormat.CGraphicObjectBase.prototype.canResize.call(this);
|
|
};
|
|
|
|
CGroupShape.prototype.drawAdjustments = function () {
|
|
};
|
|
|
|
CGroupShape.prototype.recalculateBrush = function () {
|
|
};
|
|
|
|
CGroupShape.prototype.recalculatePen = function () {
|
|
};
|
|
|
|
CGroupShape.prototype.recalculateArrGraphicObjects = function () {
|
|
this.arrGraphicObjects.length = 0;
|
|
for (let nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
let oSp = this.spTree[nSp];
|
|
if (oSp.isGroup() || oSp.isSmartArtObject()) {
|
|
let aGraphicObjets = oSp.getArrGraphicObjects();
|
|
for (let nGr = 0; nGr < aGraphicObjets.length; ++nGr) {
|
|
this.arrGraphicObjects.push(aGraphicObjets[nGr]);
|
|
}
|
|
} else {
|
|
this.arrGraphicObjects.push(oSp);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.paragraphAdd = function (paraItem, bRecalculate) {
|
|
if (this.selection.textSelection) {
|
|
this.selection.textSelection.paragraphAdd(paraItem, bRecalculate);
|
|
} else if (this.selection.chartSelection) {
|
|
this.selection.chartSelection.paragraphAdd(paraItem, bRecalculate);
|
|
} else {
|
|
var i;
|
|
if (paraItem.Type === para_TextPr) {
|
|
AscFormat.DrawingObjectsController.prototype.applyDocContentFunction.call(this, CDocumentContent.prototype.AddToParagraph, [paraItem, bRecalculate], CTable.prototype.AddToParagraph);
|
|
} else if (this.selectedObjects.length === 1
|
|
&& this.selectedObjects[0].getObjectType() === AscDFH.historyitem_type_Shape
|
|
&& this.selectedObjects[0].canEditText()) {
|
|
this.selection.textSelection = this.selectedObjects[0];
|
|
this.selection.textSelection.paragraphAdd(paraItem, bRecalculate);
|
|
if (AscFormat.isRealNumber(this.selection.textSelection.selectStartPage))
|
|
this.selection.textSelection.select(this, this.selection.textSelection.selectStartPage);
|
|
} else if (this.selectedObjects.length > 0) {
|
|
if (this.parent) {
|
|
this.parent.GoToText();
|
|
this.resetSelection();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.applyTextFunction = AscFormat.DrawingObjectsController.prototype.applyTextFunction;
|
|
|
|
CGroupShape.prototype.applyDocContentFunction = AscFormat.DrawingObjectsController.prototype.applyDocContentFunction;
|
|
|
|
CGroupShape.prototype.applyAllAlign = function (val) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].applyAllAlign === "function") {
|
|
this.spTree[i].applyAllAlign(val);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.applyAllSpacing = function (val) {
|
|
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].applyAllSpacing === "function") {
|
|
this.spTree[i].applyAllSpacing(val);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.applyAllNumbering = function (val) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].applyAllNumbering === "function") {
|
|
this.spTree[i].applyAllNumbering(val);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.applyAllIndent = function (val) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].applyAllIndent === "function") {
|
|
this.spTree[i].applyAllIndent(val);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.checkExtentsByDocContent = function (bForce, bNeedRecalc) {
|
|
var bRet = false;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (typeof this.spTree[i].checkExtentsByDocContent === "function") {
|
|
if (this.spTree[i].checkExtentsByDocContent(bForce, bNeedRecalc)) {
|
|
bRet = true;
|
|
}
|
|
}
|
|
}
|
|
return bRet;
|
|
};
|
|
|
|
CGroupShape.prototype.changeSize = function (kw, kh) {
|
|
if (this.spPr && this.spPr.xfrm && this.spPr.xfrm.isNotNullForGroup()) {
|
|
var xfrm = this.spPr.xfrm;
|
|
xfrm.setOffX(xfrm.offX * kw);
|
|
xfrm.setOffY(xfrm.offY * kh);
|
|
xfrm.setExtX(xfrm.extX * kw);
|
|
xfrm.setExtY(xfrm.extY * kh);
|
|
xfrm.setChExtX(xfrm.chExtX * kw);
|
|
xfrm.setChExtY(xfrm.chExtY * kh);
|
|
xfrm.setChOffX(xfrm.chOffX * kw);
|
|
xfrm.setChOffY(xfrm.chOffY * kh);
|
|
}
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].changeSize(kw, kh);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.recalculateTransform = function () {
|
|
this.cachedImage = null;
|
|
var xfrm;
|
|
if (this.spPr.xfrm.isNotNullForGroup())
|
|
xfrm = this.spPr.xfrm;
|
|
else {
|
|
xfrm = new AscFormat.CXfrm();
|
|
xfrm.offX = 0;
|
|
xfrm.offY = 0;
|
|
xfrm.extX = 5;
|
|
xfrm.extY = 5;
|
|
xfrm.chOffX = 0;
|
|
xfrm.chOffY = 0;
|
|
xfrm.chExtX = 5;
|
|
xfrm.chExtY = 5;
|
|
}
|
|
|
|
if (!isRealObject(this.group)) {
|
|
this.x = xfrm.offX;
|
|
this.y = xfrm.offY;
|
|
this.extX = xfrm.extX;
|
|
this.extY = xfrm.extY;
|
|
this.rot = AscFormat.isRealNumber(xfrm.rot) ? xfrm.rot : 0;
|
|
this.flipH = this.flipH === true;
|
|
this.flipV = this.flipV === true;
|
|
} else {
|
|
var scale_scale_coefficients = this.group.getResultScaleCoefficients();
|
|
this.x = scale_scale_coefficients.cx * (xfrm.offX - this.group.spPr.xfrm.chOffX);
|
|
this.y = scale_scale_coefficients.cy * (xfrm.offY - this.group.spPr.xfrm.chOffY);
|
|
this.extX = scale_scale_coefficients.cx * xfrm.extX;
|
|
this.extY = scale_scale_coefficients.cy * xfrm.extY;
|
|
this.rot = AscFormat.isRealNumber(xfrm.rot) ? xfrm.rot : 0;
|
|
this.flipH = xfrm.flipH === true;
|
|
this.flipV = xfrm.flipV === true;
|
|
}
|
|
this.transform.Reset();
|
|
var hc = this.extX * 0.5;
|
|
var vc = this.extY * 0.5;
|
|
global_MatrixTransformer.TranslateAppend(this.transform, -hc, -vc);
|
|
if (this.flipH)
|
|
global_MatrixTransformer.ScaleAppend(this.transform, -1, 1);
|
|
if (this.flipV)
|
|
global_MatrixTransformer.ScaleAppend(this.transform, 1, -1);
|
|
global_MatrixTransformer.RotateRadAppend(this.transform, -this.rot);
|
|
global_MatrixTransformer.TranslateAppend(this.transform, this.x + hc, this.y + vc);
|
|
if (isRealObject(this.group)) {
|
|
global_MatrixTransformer.MultiplyAppend(this.transform, this.group.getTransformMatrix());
|
|
}
|
|
this.invertTransform = global_MatrixTransformer.Invert(this.transform);
|
|
//if(this.drawingBase && !this.group)
|
|
//{
|
|
// this.drawingBase.setGraphicObjectCoords();
|
|
//}
|
|
};
|
|
|
|
CGroupShape.prototype.getTransformMatrix = function () {
|
|
if (this.recalcInfo.recalculateTransform) {
|
|
this.recalculateTransform();
|
|
}
|
|
return this.transform;
|
|
};
|
|
|
|
CGroupShape.prototype.getSnapArrays = function (snapX, snapY) {
|
|
var transform = this.getTransformMatrix();
|
|
snapX.push(transform.tx);
|
|
snapX.push(transform.tx + this.extX * 0.5);
|
|
snapX.push(transform.tx + this.extX);
|
|
snapY.push(transform.ty);
|
|
snapY.push(transform.ty + this.extY * 0.5);
|
|
snapY.push(transform.ty + this.extY);
|
|
for (var i = 0; i < this.arrGraphicObjects.length; ++i) {
|
|
if (this.arrGraphicObjects[i].getSnapArrays) {
|
|
this.arrGraphicObjects[i].getSnapArrays(snapX, snapY);
|
|
}
|
|
}
|
|
};
|
|
CGroupShape.prototype.getSelectedArray = function () {
|
|
return this.selectedObjects;
|
|
};
|
|
CGroupShape.prototype.getSelectionState = function () {
|
|
var selection_state = {};
|
|
if (this.selection.textSelection) {
|
|
selection_state.textObject = this.selection.textSelection;
|
|
selection_state.selectStartPage = this.selection.textSelection.selectStartPage;
|
|
selection_state.textSelection = this.selection.textSelection.getDocContent().GetSelectionState();
|
|
} else if (this.selection.chartSelection) {
|
|
selection_state.chartObject = this.selection.chartSelection;
|
|
selection_state.selectStartPage = this.selection.chartSelection.selectStartPage;
|
|
selection_state.chartSelection = this.selection.chartSelection.getSelectionState();
|
|
} else {
|
|
selection_state.selection = [];
|
|
for (var i = 0; i < this.selectedObjects.length; ++i) {
|
|
selection_state.selection.push({
|
|
object: this.selectedObjects[i],
|
|
pageIndex: this.selectedObjects[i].selectStartPage
|
|
});
|
|
}
|
|
}
|
|
return selection_state;
|
|
};
|
|
|
|
CGroupShape.prototype.setSelectionState = function (selection_state) {
|
|
this.resetSelection(this);
|
|
if (selection_state.textObject) {
|
|
this.selectObject(selection_state.textObject, selection_state.selectStartPage);
|
|
this.selection.textSelection = selection_state.textObject;
|
|
selection_state.textObject.getDocContent().SetSelectionState(selection_state.textSelection, selection_state.textSelection.length - 1);
|
|
} else if (selection_state.chartSelection) {
|
|
this.selectObject(selection_state.chartObject, selection_state.selectStartPage);
|
|
this.selection.chartSelection = selection_state.chartObject;
|
|
selection_state.chartObject.setSelectionState(selection_state.chartSelection);
|
|
} else {
|
|
for (var i = 0; i < selection_state.selection.length; ++i) {
|
|
this.selectObject(selection_state.selection[i].object, selection_state.selection[i].pageIndex);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.documentUpdateRulersState = function () {
|
|
if (this.selectedObjects.length === 1 && this.selectedObjects[0].documentUpdateRulersState)
|
|
this.selectedObjects[0].documentUpdateRulersState();
|
|
};
|
|
|
|
CGroupShape.prototype.CheckNeedRecalcAutoFit = function (oSectPr) {
|
|
var bRet = false;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].CheckNeedRecalcAutoFit && this.spTree[i].CheckNeedRecalcAutoFit(oSectPr)) {
|
|
bRet = true;
|
|
}
|
|
}
|
|
if (bRet) {
|
|
this.recalcWrapPolygon();
|
|
}
|
|
return bRet;
|
|
};
|
|
|
|
CGroupShape.prototype.CheckGroupSizes = function () {
|
|
var bRet = false;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].checkExtentsByDocContent) {
|
|
if (this.spTree[i].checkExtentsByDocContent(undefined, false)) {
|
|
bRet = true;
|
|
}
|
|
}
|
|
}
|
|
if (bRet) {
|
|
if (!this.group) {
|
|
this.updateCoordinatesAfterInternalResize();
|
|
}
|
|
if (this.parent instanceof AscCommonWord.ParaDrawing) {
|
|
this.parent.CheckWH();
|
|
}
|
|
}
|
|
return bRet;
|
|
};
|
|
|
|
CGroupShape.prototype.GetRevisionsChangeElement = function (SearchEngine) {
|
|
var i;
|
|
if (this.selectedObjects.length === 0) {
|
|
if (SearchEngine.GetDirection() > 0) {
|
|
i = 0;
|
|
} else {
|
|
i = this.arrGraphicObjects.length - 1;
|
|
}
|
|
} else {
|
|
if (SearchEngine.GetDirection() > 0) {
|
|
for (i = 0; i < this.arrGraphicObjects.length; ++i) {
|
|
if (this.arrGraphicObjects[i].selected) {
|
|
break;
|
|
}
|
|
}
|
|
if (i === this.arrGraphicObjects.length) {
|
|
return;
|
|
}
|
|
} else {
|
|
for (i = this.arrGraphicObjects.length - 1; i > -1; --i) {
|
|
if (this.arrGraphicObjects[i].selected) {
|
|
break;
|
|
}
|
|
}
|
|
if (i === -1) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
while (!SearchEngine.IsFound()) {
|
|
if (this.arrGraphicObjects[i].GetRevisionsChangeElement) {
|
|
this.arrGraphicObjects[i].GetRevisionsChangeElement(SearchEngine);
|
|
}
|
|
if (SearchEngine.GetDirection() > 0) {
|
|
if (i === this.arrGraphicObjects.length - 1) {
|
|
break;
|
|
}
|
|
++i;
|
|
} else {
|
|
if (i === 0) {
|
|
break;
|
|
}
|
|
--i;
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.Search = function (SearchEngine, Type) {
|
|
var Len = this.arrGraphicObjects.length;
|
|
for (var i = 0; i < Len; ++i) {
|
|
if (this.arrGraphicObjects[i].Search) {
|
|
this.arrGraphicObjects[i].Search(SearchEngine, Type);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.GetSearchElementId = function (bNext, bCurrent) {
|
|
var Current = -1;
|
|
var Len = this.arrGraphicObjects.length;
|
|
|
|
var Id = null;
|
|
if (true === bCurrent) {
|
|
for (var i = 0; i < Len; ++i) {
|
|
if (this.arrGraphicObjects[i] === this.selection.textSelection) {
|
|
Current = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (true === bNext) {
|
|
var Start = (-1 !== Current ? Current : 0);
|
|
|
|
for (var i = Start; i < Len; i++) {
|
|
if (this.arrGraphicObjects[i].GetSearchElementId) {
|
|
Id = this.arrGraphicObjects[i].GetSearchElementId(true, i === Current ? true : false);
|
|
if (null !== Id)
|
|
return Id;
|
|
}
|
|
}
|
|
} else {
|
|
var Start = (-1 !== Current ? Current : Len - 1);
|
|
|
|
for (var i = Start; i >= 0; i--) {
|
|
if (this.arrGraphicObjects[i].GetSearchElementId) {
|
|
Id = this.arrGraphicObjects[i].GetSearchElementId(false, i === Current ? true : false);
|
|
if (null !== Id)
|
|
return Id;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.FindNextFillingForm = function (isNext, isCurrent) {
|
|
if (this.graphicObject)
|
|
return this.graphicObject.FindNextFillingForm(isNext, isCurrent);
|
|
|
|
var Current = -1;
|
|
var Len = this.arrGraphicObjects.length;
|
|
|
|
var Id = null;
|
|
if (true === isCurrent) {
|
|
for (var i = 0; i < Len; ++i) {
|
|
if (this.arrGraphicObjects[i] === this.selection.textSelection) {
|
|
Current = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (true === isNext) {
|
|
var Start = (-1 !== Current ? Current : 0);
|
|
|
|
for (var i = Start; i < Len; i++) {
|
|
if (this.arrGraphicObjects[i].FindNextFillingForm) {
|
|
Id = this.arrGraphicObjects[i].FindNextFillingForm(true, i === Current, i === Current);
|
|
if (Id)
|
|
return Id;
|
|
}
|
|
}
|
|
} else {
|
|
var Start = (-1 !== Current ? Current : Len - 1);
|
|
|
|
for (var i = Start; i >= 0; i--) {
|
|
if (this.arrGraphicObjects[i].FindNextFillingForm) {
|
|
Id = this.arrGraphicObjects[i].FindNextFillingForm(false, i === Current, i === Current);
|
|
if (Id)
|
|
return Id;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.getCompiledFill = function () {
|
|
this.compiledFill = null;
|
|
if (isRealObject(this.spPr) && isRealObject(this.spPr.Fill) && isRealObject(this.spPr.Fill.fill)) {
|
|
this.compiledFill = this.spPr.Fill.createDuplicate();
|
|
if (this.compiledFill && this.compiledFill.fill && this.compiledFill.fill.type === Asc.c_oAscFill.FILL_TYPE_GRP) {
|
|
if (this.group) {
|
|
var group_compiled_fill = this.group.getCompiledFill();
|
|
if (isRealObject(group_compiled_fill) && isRealObject(group_compiled_fill.fill)) {
|
|
this.compiledFill = group_compiled_fill.createDuplicate();
|
|
} else {
|
|
this.compiledFill = null;
|
|
}
|
|
} else {
|
|
this.compiledFill = null;
|
|
}
|
|
}
|
|
} else if (isRealObject(this.group)) {
|
|
var group_compiled_fill = this.group.getCompiledFill();
|
|
if (isRealObject(group_compiled_fill) && isRealObject(group_compiled_fill.fill)) {
|
|
this.compiledFill = group_compiled_fill.createDuplicate();
|
|
} else {
|
|
var hierarchy = this.getHierarchy();
|
|
for (var i = 0; i < hierarchy.length; ++i) {
|
|
if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.Fill) && isRealObject(hierarchy[i].spPr.Fill.fill)) {
|
|
this.compiledFill = hierarchy[i].spPr.Fill.createDuplicate();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
var hierarchy = this.getHierarchy();
|
|
for (var i = 0; i < hierarchy.length; ++i) {
|
|
if (isRealObject(hierarchy[i]) && isRealObject(hierarchy[i].spPr) && isRealObject(hierarchy[i].spPr.Fill) && isRealObject(hierarchy[i].spPr.Fill.fill)) {
|
|
this.compiledFill = hierarchy[i].spPr.Fill.createDuplicate();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return this.compiledFill;
|
|
};
|
|
|
|
CGroupShape.prototype.getCompiledLine = function () {
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.setVerticalAlign = function (align) {
|
|
for (var _shape_index = 0; _shape_index < this.spTree.length; ++_shape_index) {
|
|
if (this.spTree[_shape_index].setVerticalAlign) {
|
|
this.spTree[_shape_index].setVerticalAlign(align);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setVert = function (vert) {
|
|
for (var _shape_index = 0; _shape_index < this.spTree.length; ++_shape_index) {
|
|
if (this.spTree[_shape_index].setVert) {
|
|
this.spTree[_shape_index].setVert(vert);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setPaddings = function (paddings) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].setPaddings) {
|
|
this.spTree[i].setPaddings(paddings);
|
|
}
|
|
}
|
|
};
|
|
CGroupShape.prototype.setTextFitType = function (type) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].setTextFitType) {
|
|
this.spTree[i].setTextFitType(type);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setVertOverflowType = function (type) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].setVertOverflowType) {
|
|
this.spTree[i].setVertOverflowType(type);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setColumnNumber = function (num) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].setColumnNumber) {
|
|
this.spTree[i].setColumnNumber(num);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setColumnSpace = function (spcCol) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].setColumnSpace) {
|
|
this.spTree[i].setColumnSpace(spcCol);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.changePresetGeom = function (preset) {
|
|
for (var _shape_index = 0; _shape_index < this.spTree.length; ++_shape_index) {
|
|
if (this.spTree[_shape_index].getObjectType() === AscDFH.historyitem_type_Shape) {
|
|
this.spTree[_shape_index].changePresetGeom(preset);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.changeShadow = function (oShadow) {
|
|
|
|
for (var _shape_index = 0; _shape_index < this.spTree.length; ++_shape_index) {
|
|
if (this.spTree[_shape_index].changeShadow) {
|
|
this.spTree[_shape_index].changeShadow(oShadow);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.changeFill = function (fill) {
|
|
for (var _shape_index = 0; _shape_index < this.spTree.length; ++_shape_index) {
|
|
if (this.spTree[_shape_index].changeFill) {
|
|
this.spTree[_shape_index].changeFill(fill);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.changeLine = function (line) {
|
|
for (var _shape_index = 0; _shape_index < this.spTree.length; ++_shape_index) {
|
|
if (this.spTree[_shape_index].changeLine) {
|
|
this.spTree[_shape_index].changeLine(line);
|
|
}
|
|
}
|
|
};
|
|
CGroupShape.prototype.isGroup = function () {
|
|
return true;
|
|
};
|
|
CGroupShape.prototype.normalize = function () {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].normalize();
|
|
}
|
|
AscFormat.CGraphicObjectBase.prototype.normalize.call(this);
|
|
var xfrm = this.spPr.xfrm;
|
|
xfrm.setChExtX(xfrm.extX);
|
|
xfrm.setChExtY(xfrm.extY);
|
|
xfrm.setChOffX(0);
|
|
xfrm.setChOffY(0);
|
|
};
|
|
|
|
CGroupShape.prototype.updateCoordinatesAfterInternalResize = function () {
|
|
this.normalize();
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].isGroup())
|
|
this.spTree[i].updateCoordinatesAfterInternalResize();
|
|
}
|
|
|
|
var sp_tree = this.spTree;
|
|
|
|
var min_x, max_x, min_y, max_y;
|
|
var sp = sp_tree[0];
|
|
var xfrm = sp.spPr.xfrm;
|
|
var rot = xfrm.rot == null ? 0 : xfrm.rot;
|
|
var xc, yc;
|
|
if (AscFormat.checkNormalRotate(rot)) {
|
|
min_x = xfrm.offX;
|
|
min_y = xfrm.offY;
|
|
max_x = xfrm.offX + xfrm.extX;
|
|
max_y = xfrm.offY + xfrm.extY;
|
|
} else {
|
|
xc = xfrm.offX + xfrm.extX * 0.5;
|
|
yc = xfrm.offY + xfrm.extY * 0.5;
|
|
min_x = xc - xfrm.extY * 0.5;
|
|
min_y = yc - xfrm.extX * 0.5;
|
|
max_x = xc + xfrm.extY * 0.5;
|
|
max_y = yc + xfrm.extX * 0.5;
|
|
}
|
|
var cur_max_x, cur_min_x, cur_max_y, cur_min_y;
|
|
for (i = 1; i < sp_tree.length; ++i) {
|
|
sp = sp_tree[i];
|
|
xfrm = sp.spPr.xfrm;
|
|
rot = xfrm.rot == null ? 0 : xfrm.rot;
|
|
|
|
if (AscFormat.checkNormalRotate(rot)) // || (this.getName && this.getName() === 'Drawing')
|
|
{
|
|
cur_min_x = xfrm.offX;
|
|
cur_min_y = xfrm.offY;
|
|
cur_max_x = xfrm.offX + xfrm.extX;
|
|
cur_max_y = xfrm.offY + xfrm.extY;
|
|
} else {
|
|
xc = xfrm.offX + xfrm.extX * 0.5;
|
|
yc = xfrm.offY + xfrm.extY * 0.5;
|
|
cur_min_x = xc - xfrm.extY * 0.5;
|
|
cur_min_y = yc - xfrm.extX * 0.5;
|
|
cur_max_x = xc + xfrm.extY * 0.5;
|
|
cur_max_y = yc + xfrm.extX * 0.5;
|
|
}
|
|
if (cur_max_x > max_x)
|
|
max_x = cur_max_x;
|
|
if (cur_min_x < min_x)
|
|
min_x = cur_min_x;
|
|
|
|
if (cur_max_y > max_y)
|
|
max_y = cur_max_y;
|
|
if (cur_min_y < min_y)
|
|
min_y = cur_min_y;
|
|
}
|
|
|
|
var temp;
|
|
var x_min_clear = min_x;
|
|
var y_min_clear = min_y;
|
|
if (this.spPr.xfrm.flipH === true) {
|
|
temp = max_x;
|
|
max_x = this.spPr.xfrm.extX - min_x;
|
|
min_x = this.spPr.xfrm.extX - temp;
|
|
}
|
|
|
|
if (this.spPr.xfrm.flipV === true) {
|
|
temp = max_y;
|
|
max_y = this.spPr.xfrm.extY - min_y;
|
|
min_y = this.spPr.xfrm.extY - temp;
|
|
}
|
|
|
|
var old_x0, old_y0;
|
|
var xfrm = this.spPr.xfrm;
|
|
var rot = xfrm.rot == null ? 0 : xfrm.rot;
|
|
var hc = xfrm.extX * 0.5;
|
|
var vc = xfrm.extY * 0.5;
|
|
old_x0 = this.spPr.xfrm.offX + hc - (hc * Math.cos(rot) - vc * Math.sin(rot));
|
|
old_y0 = this.spPr.xfrm.offY + vc - (hc * Math.sin(rot) + vc * Math.cos(rot));
|
|
var t_dx = min_x * Math.cos(rot) - min_y * Math.sin(rot);
|
|
var t_dy = min_x * Math.sin(rot) + min_y * Math.cos(rot);
|
|
var new_x0, new_y0;
|
|
new_x0 = old_x0 + t_dx;
|
|
new_y0 = old_y0 + t_dy;
|
|
var new_hc = Math.abs(max_x - min_x) * 0.5;
|
|
var new_vc = Math.abs(max_y - min_y) * 0.5;
|
|
var new_xc = new_x0 + (new_hc * Math.cos(rot) - new_vc * Math.sin(rot));
|
|
var new_yc = new_y0 + (new_hc * Math.sin(rot) + new_vc * Math.cos(rot));
|
|
|
|
var pos_x, pos_y;
|
|
pos_x = new_xc - new_hc;
|
|
pos_y = new_yc - new_vc;
|
|
|
|
var xfrm = this.spPr.xfrm;
|
|
if (this.group || !(editor && editor.isDocumentEditor)) {
|
|
xfrm.setOffX(pos_x);
|
|
xfrm.setOffY(pos_y);
|
|
}
|
|
xfrm.setExtX(Math.abs(max_x - min_x));
|
|
xfrm.setExtY(Math.abs(max_y - min_y));
|
|
xfrm.setChExtX(Math.abs(max_x - min_x));
|
|
xfrm.setChExtY(Math.abs(max_y - min_y));
|
|
xfrm.setChOffX(0);
|
|
xfrm.setChOffY(0);
|
|
for (i = 0; i < sp_tree.length; ++i) {
|
|
sp_tree[i].spPr.xfrm.setOffX(sp_tree[i].spPr.xfrm.offX - x_min_clear);
|
|
sp_tree[i].spPr.xfrm.setOffY(sp_tree[i].spPr.xfrm.offY - y_min_clear);
|
|
}
|
|
this.checkDrawingBaseCoords();
|
|
return {posX: pos_x, posY: pos_y};
|
|
};
|
|
|
|
|
|
CGroupShape.prototype.getParentObjects = function () {
|
|
var parents = {slide: null, layout: null, master: null, theme: null};
|
|
return parents;
|
|
};
|
|
|
|
CGroupShape.prototype.applyTextArtForm = function (sPreset) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].applyTextArtForm) {
|
|
this.spTree[i].applyTextArtForm(sPreset);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.createRotateTrack = function () {
|
|
return new AscFormat.RotateTrackGroup(this);
|
|
};
|
|
|
|
CGroupShape.prototype.createMoveTrack = function () {
|
|
return new AscFormat.MoveGroupTrack(this);
|
|
};
|
|
|
|
CGroupShape.prototype.createResizeTrack = function (cardDirection) {
|
|
return new AscFormat.ResizeTrackGroup(this, cardDirection);
|
|
};
|
|
|
|
CGroupShape.prototype.resetSelection = function (graphicObjects) {
|
|
this.selection.textSelection = null;
|
|
if (this.selection.chartSelection) {
|
|
this.selection.chartSelection.resetSelection();
|
|
}
|
|
this.selection.chartSelection = null;
|
|
|
|
for (var i = this.selectedObjects.length - 1; i > -1; --i) {
|
|
var old_gr = this.selectedObjects[i].group;
|
|
var obj = this.selectedObjects[i];
|
|
obj.group = this;
|
|
obj.deselect(graphicObjects);
|
|
obj.group = old_gr;
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.resetInternalSelection = AscFormat.DrawingObjectsController.prototype.resetInternalSelection;
|
|
|
|
CGroupShape.prototype.recalculateCurPos = AscFormat.DrawingObjectsController.prototype.recalculateCurPos;
|
|
|
|
CGroupShape.prototype.loadDocumentStateAfterLoadChanges = AscFormat.DrawingObjectsController.prototype.loadDocumentStateAfterLoadChanges;
|
|
CGroupShape.prototype.getAllConnectors = AscFormat.DrawingObjectsController.prototype.getAllConnectors;
|
|
CGroupShape.prototype.getAllShapes = AscFormat.DrawingObjectsController.prototype.getAllShapes;
|
|
|
|
|
|
CGroupShape.prototype.calculateSnapArrays = function (snapArrayX, snapArrayY) {
|
|
var sp;
|
|
for (var i = 0; i < this.arrGraphicObjects.length; ++i) {
|
|
sp = this.arrGraphicObjects[i];
|
|
sp.calculateSnapArrays(snapArrayX, snapArrayY);
|
|
sp.recalculateSnapArrays();
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.setNvSpPr = function (pr) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsObject(this, AscDFH.historyitem_GroupShapeSetNvGrpSpPr, this.nvGrpSpPr, pr));
|
|
this.nvGrpSpPr = pr;
|
|
};
|
|
|
|
CGroupShape.prototype.RestartSpellCheck = function () {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].RestartSpellCheck && this.spTree[i].RestartSpellCheck();
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.recalculateLocalTransform = CShape.prototype.recalculateLocalTransform;
|
|
|
|
CGroupShape.prototype.bringToFront = function ()//перемещаем заселекченые объекты наверх
|
|
{
|
|
var i;
|
|
var arrDrawings = [];
|
|
for (i = this.spTree.length - 1; i > -1; --i) {
|
|
if (this.spTree[i].isGroupObject()) {
|
|
this.spTree[i].bringToFront();
|
|
} else if (this.spTree[i].selected) {
|
|
arrDrawings.push(this.removeFromSpTreeByPos(i));
|
|
}
|
|
}
|
|
for (i = arrDrawings.length - 1; i > -1; --i) {
|
|
this.addToSpTree(null, arrDrawings[i]);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.bringForward = function () {
|
|
var i;
|
|
for (i = this.spTree.length - 1; i > -1; --i) {
|
|
if (this.spTree[i].isGroupObject()) {
|
|
this.spTree[i].bringForward();
|
|
} else if (i < this.spTree.length - 1 && this.spTree[i].selected && !this.spTree[i + 1].selected) {
|
|
var item = this.removeFromSpTreeByPos(i);
|
|
this.addToSpTree(i + 1, item);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.sendToBack = function () {
|
|
var i, arrDrawings = [];
|
|
for (i = this.spTree.length - 1; i > -1; --i) {
|
|
if (this.spTree[i].isGroupObject()) {
|
|
this.spTree[i].sendToBack();
|
|
} else if (this.spTree[i].selected) {
|
|
arrDrawings.push(this.removeFromSpTreeByPos(i));
|
|
}
|
|
}
|
|
arrDrawings.reverse();
|
|
for (i = 0; i < arrDrawings.length; ++i) {
|
|
this.addToSpTree(i, arrDrawings[i]);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.bringBackward = function () {
|
|
var i;
|
|
for (i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].isGroupObject()) {
|
|
this.spTree[i].bringBackward();
|
|
} else if (i > 0 && this.spTree[i].selected && !this.spTree[i - 1].selected) {
|
|
this.addToSpTree(i - 1, this.removeFromSpTreeByPos(i));
|
|
}
|
|
}
|
|
};
|
|
CGroupShape.prototype.recalcSmartArtConnections = function () {};
|
|
CGroupShape.prototype.Refresh_RecalcData = function (oData) {
|
|
if (oData) {
|
|
switch (oData.Type) {
|
|
case AscDFH.historyitem_AutoShapes_AddToDrawingObjects: {
|
|
if (!this.bDeleted) {
|
|
this.addToRecalculate();
|
|
}
|
|
break;
|
|
}
|
|
case AscDFH.historyitem_ShapeSetBDeleted: {
|
|
if (!this.bDeleted) {
|
|
this.addToRecalculate();
|
|
}
|
|
break;
|
|
}
|
|
case AscDFH.historyitem_GroupShapeAddToSpTree:
|
|
case AscDFH.historyitem_GroupShapeRemoveFromSpTree: {
|
|
if (!this.bDeleted) {
|
|
this.handleUpdateSpTree();
|
|
this.recalcSmartArtConnections();
|
|
}
|
|
break;
|
|
}
|
|
case AscDFH.historyitem_SmartArtDrawing: {
|
|
if (!this.bDeleted) {
|
|
this.addToRecalculate();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.checkTypeCorrect = function () {
|
|
if (!this.spPr) {
|
|
return false;
|
|
}
|
|
if (this.spTree.length === 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
};
|
|
|
|
CGroupShape.prototype.resetGroups = function () {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
if (this.spTree[i].resetGroups) {
|
|
this.spTree[i].resetGroups();
|
|
}
|
|
if (this.spTree[i].group !== this) {
|
|
this.spTree[i].setGroup(this);
|
|
}
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.findConnector = function (x, y) {
|
|
for (var i = this.spTree.length - 1; i > -1; --i) {
|
|
var oConInfo = this.spTree[i].findConnector(x, y);
|
|
if (oConInfo) {
|
|
return oConInfo;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.findConnectionShape = function (x, y) {
|
|
for (var i = this.spTree.length - 1; i > -1; --i) {
|
|
var _ret = this.spTree[i].findConnectionShape(x, y);
|
|
if (_ret) {
|
|
return _ret;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
CGroupShape.prototype.GetAllContentControls = function (arrContentControls) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].GetAllContentControls(arrContentControls);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.getCopyWithSourceFormatting = function (oIdMap) {
|
|
var oPr = new AscFormat.CCopyObjectProperties();
|
|
oPr.idMap = oIdMap;
|
|
oPr.bSaveSourceFormatting = true;
|
|
return this.copy(oPr);
|
|
};
|
|
|
|
CGroupShape.prototype.GetAllFields = function (isUseSelection, arrFields) {
|
|
var _arrFields = arrFields ? arrFields : [], i;
|
|
if (isUseSelection) {
|
|
for (i = 0; i < this.selectedObjects.length; ++i) {
|
|
this.selectedObjects[i].GetAllFields(isUseSelection, _arrFields);
|
|
}
|
|
} else {
|
|
for (i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].GetAllFields(isUseSelection, _arrFields);
|
|
}
|
|
}
|
|
return _arrFields;
|
|
};
|
|
CGroupShape.prototype.GetAllSeqFieldsByType = function (sType, aFields) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].GetAllSeqFieldsByType(sType, aFields)
|
|
}
|
|
};
|
|
CGroupShape.prototype.createPlaceholderControl = function (aControls) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].createPlaceholderControl(aControls);
|
|
}
|
|
};
|
|
CGroupShape.prototype.onSlicerUpdate = function (sName) {
|
|
var bRet = false;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
bRet = bRet || this.spTree[i].onSlicerUpdate(sName);
|
|
}
|
|
return bRet;
|
|
};
|
|
CGroupShape.prototype.onSlicerDelete = function (sName) {
|
|
var bRet = false;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
bRet = bRet || this.spTree[i].onSlicerDelete(sName);
|
|
}
|
|
return bRet;
|
|
};
|
|
CGroupShape.prototype.onTimeSlicerDelete = function (sName) {
|
|
var bRet = false;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
bRet = bRet || this.spTree[i].onTimeSlicerDelete(sName);
|
|
}
|
|
return bRet;
|
|
};
|
|
CGroupShape.prototype.onSlicerLock = function (sName, bLock) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].onSlicerLock(sName, bLock);
|
|
}
|
|
};
|
|
CGroupShape.prototype.onSlicerChangeName = function (sName, sNewName) {
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
this.spTree[i].onSlicerChangeName(sName, sNewName);
|
|
}
|
|
};
|
|
CGroupShape.prototype.getSlicerViewByName = function (name) {
|
|
var res = null;
|
|
for (var i = 0; i < this.spTree.length; ++i) {
|
|
res = this.spTree[i].getSlicerViewByName(name);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
|
|
CGroupShape.prototype.handleObject = function (fCallback) {
|
|
fCallback(this);
|
|
for (var nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].handleObject(fCallback);
|
|
}
|
|
};
|
|
|
|
//for bug 52775. remove in the next version
|
|
CGroupShape.prototype.applySmartArtTextStyle = function () {
|
|
for (var nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].applySmartArtTextStyle();
|
|
}
|
|
};
|
|
CGroupShape.prototype.getTypeName = function () {
|
|
return AscCommon.translateManager.getValue("Group");
|
|
};
|
|
CGroupShape.prototype.GetAllOleObjects = function (sPluginId, arrObjects) {
|
|
for (let nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].GetAllOleObjects(sPluginId, arrObjects);
|
|
}
|
|
};
|
|
|
|
|
|
CGroupShape.prototype.checkXfrm = function () {
|
|
if (!this.spPr) {
|
|
return;
|
|
}
|
|
if (!this.spPr.xfrm && this.spTree.length > 0) {
|
|
var oXfrm = new AscFormat.CXfrm();
|
|
oXfrm.setOffX(0);
|
|
oXfrm.setOffY(0);
|
|
oXfrm.setChOffX(0);
|
|
oXfrm.setChOffY(0);
|
|
oXfrm.setExtX(50);
|
|
oXfrm.setExtY(50);
|
|
oXfrm.setChExtX(50);
|
|
oXfrm.setChExtY(50);
|
|
this.spPr.setXfrm(oXfrm);
|
|
this.updateCoordinatesAfterInternalResize();
|
|
this.spPr.xfrm.setParent(this.spPr);
|
|
}
|
|
};
|
|
CGroupShape.prototype.clearChartDataCache = function () {
|
|
for (let nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].clearChartDataCache();
|
|
}
|
|
};
|
|
CGroupShape.prototype.pasteFormatting = function (oFormatData) {
|
|
if(!oFormatData) {
|
|
return;
|
|
}
|
|
for (let nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
this.spTree[nSp].pasteFormatting(oFormatData);
|
|
}
|
|
};
|
|
|
|
CGroupShape.prototype.compareForMorph = function(oDrawingToCheck, oCurCandidate, oMapPaired) {
|
|
if(this.getObjectType() !== oDrawingToCheck.getObjectType()) {
|
|
return oCurCandidate;
|
|
}
|
|
const sName = this.getOwnName();
|
|
if(sName && sName.startsWith(AscFormat.OBJECT_MORPH_MARKER)) {
|
|
const sCheckName = oDrawingToCheck.getOwnName();
|
|
if(sName !== sCheckName) {
|
|
return oCurCandidate;
|
|
}
|
|
return oDrawingToCheck;
|
|
}
|
|
if(this.spTree.length !== oDrawingToCheck.spTree.length) {
|
|
return oCurCandidate;
|
|
}
|
|
for(let nSp = 0; nSp < this.spTree.length; ++nSp) {
|
|
let oSp = this.spTree[nSp];
|
|
let oSpCheck = oDrawingToCheck.spTree[nSp];
|
|
if(!oSp.compareForMorph(oSpCheck, null)) {
|
|
return oCurCandidate;
|
|
}
|
|
}
|
|
if(!oCurCandidate) {
|
|
if(oMapPaired && oMapPaired[oDrawingToCheck.Id]) {
|
|
let oParedDrawing = oMapPaired[oDrawingToCheck.Id].drawing;
|
|
if(oParedDrawing.getOwnName() === oDrawingToCheck.getOwnName()) {
|
|
return oCurCandidate;
|
|
}
|
|
|
|
let dDistMCheck = oParedDrawing.getDistanceL1(oDrawingToCheck);
|
|
let dDistMCur = this.getDistanceL1(oDrawingToCheck);
|
|
if(dDistMCheck < dDistMCur) {
|
|
return oCurCandidate;
|
|
}
|
|
|
|
let dSizeMCandidate = Math.abs(oParedDrawing.extX - oDrawingToCheck.extX) + Math.abs(oParedDrawing.extY - oDrawingToCheck.extY);
|
|
let dSizeMCheck = Math.abs(oDrawingToCheck.extX - this.extX) + Math.abs(oDrawingToCheck.extY - this.extY);
|
|
if(dSizeMCandidate < dSizeMCheck) {
|
|
return oCurCandidate;
|
|
}
|
|
}
|
|
return oDrawingToCheck;
|
|
}
|
|
const dDistCheck = this.getDistanceL1(oDrawingToCheck);
|
|
const dDistCur = this.getDistanceL1(oCurCandidate);
|
|
let dSizeMCandidate = Math.abs(oCurCandidate.extX - this.extX) + Math.abs(oCurCandidate.extY - this.extY);
|
|
let dSizeMCheck = Math.abs(oDrawingToCheck.extX - this.extX) + Math.abs(oDrawingToCheck.extY - this.extY);
|
|
if(dDistCur < dDistCheck) {
|
|
return oCurCandidate;
|
|
}
|
|
else {
|
|
if(dSizeMCandidate < dSizeMCheck) {
|
|
return oCurCandidate;
|
|
}
|
|
}
|
|
if(!oMapPaired || !oMapPaired[oDrawingToCheck.Id]) {
|
|
return oDrawingToCheck;
|
|
}
|
|
else {
|
|
let oParedDrawing = oMapPaired[oDrawingToCheck.Id].drawing;
|
|
if(oParedDrawing.getOwnName() === oDrawingToCheck.getOwnName()) {
|
|
return oCurCandidate;
|
|
}
|
|
else {
|
|
return oDrawingToCheck;
|
|
}
|
|
}
|
|
return oCurCandidate;
|
|
};
|
|
CGroupShape.prototype.checkDrawingPartWithHistory = function() {};
|
|
CGroupShape.prototype.generateSmartArtDrawingPart = function () {
|
|
for (let i = 0; i < this.spTree.length; i += 1) {
|
|
this.spTree[i].generateSmartArtDrawingPart();
|
|
}
|
|
};
|
|
CGroupShape.prototype.isHaveOnlyInks = function () {
|
|
if (!this.spTree.length) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < this.spTree.length; i++) {
|
|
const oDrawing = this.spTree[i];
|
|
if (!(oDrawing.isInk() || oDrawing.isHaveOnlyInks())) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
CGroupShape.prototype.getAllInks = function (arrInks) {
|
|
arrInks = arrInks || [];
|
|
for (let i = this.spTree.length - 1; i >= 0; i -= 1) {
|
|
const oDrawing = this.spTree[i];
|
|
if (oDrawing.isInk() || oDrawing.isHaveOnlyInks()) {
|
|
arrInks.push(oDrawing);
|
|
} else {
|
|
oDrawing.getAllInks(arrInks);
|
|
}
|
|
}
|
|
return arrInks;
|
|
};
|
|
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
window['AscFormat'] = window['AscFormat'] || {};
|
|
window['AscFormat'].CGroupShape = CGroupShape;
|
|
})(window);
|