11777 lines
372 KiB
JavaScript
11777 lines
372 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";
|
|
|
|
(function(window, undefined){
|
|
|
|
var prot;
|
|
// Import
|
|
var g_nodeAttributeEnd = AscCommon.g_nodeAttributeEnd;
|
|
|
|
var c_oAscShdClear = Asc.c_oAscShdClear;
|
|
var c_oAscColor = Asc.c_oAscColor;
|
|
var c_oAscFill = Asc.c_oAscFill;
|
|
|
|
var c_dScalePPTXSizes = 36000;
|
|
function IsHiddenObj(object)
|
|
{
|
|
if (!object)
|
|
return false;
|
|
var _uniProps = object.getUniNvProps && object.getUniNvProps();
|
|
if (!_uniProps)
|
|
return false;
|
|
|
|
if (_uniProps.cNvPr && _uniProps.cNvPr.isHidden)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
function CBuilderImages(blip_fill, full_url, image_shape, sp_pr, ln, text_pr, para_text_pr, run, paragraph, bullet)
|
|
{
|
|
this.Url = full_url;
|
|
this.BlipFill = blip_fill;
|
|
this.ImageShape = image_shape;
|
|
this.SpPr = sp_pr;
|
|
this.Ln = ln;
|
|
|
|
this.TextPr = text_pr;
|
|
this.ParaTextPr = para_text_pr;
|
|
this.Run = run;
|
|
this.Paragraph = paragraph;
|
|
this.Bullet = bullet;
|
|
this.AdditionalUrls = [];//для wmf, ole
|
|
}
|
|
CBuilderImages.prototype =
|
|
{
|
|
SetUrl : function(url)
|
|
{
|
|
if(url !== "error")
|
|
{
|
|
var oCopyFill, oCopyBlipFill, oCopyLn;
|
|
if(!this.Ln && this.SpPr && this.SpPr.Fill)
|
|
{
|
|
oCopyFill = this.SpPr.Fill.createDuplicate();
|
|
if(oCopyFill.fill && oCopyFill.fill.type === c_oAscFill.FILL_TYPE_BLIP)
|
|
{
|
|
oCopyFill.fill.setRasterImageId(url);
|
|
this.SpPr.setFill(oCopyFill);
|
|
}
|
|
}
|
|
if(this.Ln && this.SpPr && this.SpPr === this.Ln && this.Ln.Fill && this.Ln.Fill.fill && this.Ln.Fill.fill.type === c_oAscFill.FILL_TYPE_BLIP)
|
|
{
|
|
oCopyLn = this.Ln.createDuplicate();
|
|
oCopyLn.Fill.fill.setRasterImageId(url);
|
|
this.SpPr.setLn(oCopyLn);
|
|
}
|
|
if(this.ImageShape && this.ImageShape.blipFill)
|
|
{
|
|
oCopyBlipFill = this.ImageShape.blipFill.createDuplicate();
|
|
oCopyBlipFill.setRasterImageId(url);
|
|
this.ImageShape.setBlipFill(oCopyBlipFill);
|
|
}
|
|
if(this.TextPr && !this.Ln)
|
|
{
|
|
if(this.Paragraph)
|
|
{
|
|
var oPr = this.Paragraph.Pr;
|
|
if(oPr.DefaultRunPr && oPr.DefaultRunPr.Unifill && oPr.DefaultRunPr.Unifill.fill && oPr.DefaultRunPr.Unifill.fill.type === c_oAscFill.FILL_TYPE_BLIP)
|
|
{
|
|
var Pr = this.Paragraph.Pr.Copy();
|
|
Pr.DefaultRunPr.Unifill.fill.setRasterImageId(url);
|
|
this.Paragraph.Set_Pr(Pr);
|
|
}
|
|
}
|
|
else if(this.ParaTextPr || this.Run)
|
|
{
|
|
if(this.ParaTextPr && this.ParaTextPr.Value && this.ParaTextPr.Value.Unifill && this.ParaTextPr.Value.Unifill.fill && this.ParaTextPr.Value.Unifill.fill.type === c_oAscFill.FILL_TYPE_BLIP)
|
|
{
|
|
oCopyFill = this.ParaTextPr.Value.Unifill.createDuplicate();
|
|
oCopyFill.fill.setRasterImageId(url);
|
|
this.ParaTextPr.Set_Unifill(oCopyFill);
|
|
}
|
|
if(this.Run && this.Run.Pr && this.Run.Pr.Unifill && this.Run.Pr.Unifill.fill && this.Run.Pr.Unifill.fill.type === c_oAscFill.FILL_TYPE_BLIP)
|
|
{
|
|
oCopyFill = this.Run.Pr.Unifill.createDuplicate();
|
|
oCopyFill.fill.setRasterImageId(url);
|
|
this.Run.Set_Unifill(oCopyFill);
|
|
}
|
|
}
|
|
}
|
|
if(this.Bullet)
|
|
{
|
|
if(this.Paragraph)
|
|
{
|
|
var oPr = this.Paragraph.Pr;
|
|
var oBullet = oPr.Bullet;
|
|
if(oBullet.getImageBulletURL())
|
|
{
|
|
var oNewPr = oPr.Copy();
|
|
oNewPr.Bullet.fillBulletImage(url);
|
|
this.Paragraph.Set_Pr(oNewPr);
|
|
}
|
|
}
|
|
}
|
|
this.BlipFill.RasterImageId = url;
|
|
}
|
|
}
|
|
};
|
|
|
|
function BinaryPPTYLoader()
|
|
{
|
|
this.stream = null;
|
|
this.presentation = null;
|
|
this.DrawingDocument = null;
|
|
this.TempGroupObject = null;
|
|
this.TempMainObject = null;
|
|
|
|
this.IsFillingSmartArt = false;
|
|
this.IsThemeLoader = false;
|
|
this.Api = null;
|
|
|
|
this.map_table_styles = {};
|
|
|
|
this.ImageMapChecker = null;
|
|
|
|
this.IsUseFullUrl = false;
|
|
this.insertDocumentUrlsData = null;
|
|
this.RebuildImages = [];
|
|
|
|
this.aSlideLayouts = [];
|
|
this.aThemes = [];
|
|
|
|
this.oConnectedObjects = {};
|
|
this.map_shapes_by_id = {};
|
|
this.fields = [];
|
|
this.smartarts = [];
|
|
|
|
|
|
this.ClearConnectedObjects = function(){
|
|
this.oConnectedObjects = {};
|
|
this.map_shapes_by_id = {};
|
|
};
|
|
this.AddConnectedObject = function(oObject){
|
|
this.oConnectedObjects[oObject.Id] = oObject;
|
|
};
|
|
this.AssignConnectedObjects = function () {
|
|
for(var sId in this.oConnectedObjects) {
|
|
if(this.oConnectedObjects.hasOwnProperty(sId)) {
|
|
this.oConnectedObjects[sId].assignConnection(this.map_shapes_by_id);
|
|
}
|
|
}
|
|
this.ClearConnectedObjects();
|
|
};
|
|
|
|
this.Start_UseFullUrl = function(insertDocumentUrlsData)
|
|
{
|
|
this.IsUseFullUrl = true;
|
|
this.insertDocumentUrlsData = insertDocumentUrlsData;
|
|
};
|
|
|
|
this.End_UseFullUrl = function()
|
|
{
|
|
var _result = this.RebuildImages;
|
|
|
|
this.IsUseFullUrl = false;
|
|
this.RebuildImages = [];
|
|
|
|
return _result;
|
|
};
|
|
|
|
this.Load = function(base64_ppty, presentation)
|
|
{
|
|
this.presentation = presentation;
|
|
this.DrawingDocument = null;
|
|
if(presentation)
|
|
{
|
|
this.DrawingDocument = presentation.DrawingDocument;
|
|
}
|
|
else
|
|
{
|
|
this.DrawingDocument = null;
|
|
}
|
|
this.ImageMapChecker = {};
|
|
|
|
var isBase64 = typeof base64_ppty === 'string';
|
|
var srcLen = isBase64 ? base64_ppty.length : base64_ppty.length;
|
|
var nWritten = 0;
|
|
|
|
var index = 0;
|
|
var read_main_prop = "";
|
|
while (true)
|
|
{
|
|
var _c = isBase64 ? base64_ppty.charCodeAt(index) : base64_ppty[index];
|
|
if (_c == ";".charCodeAt(0))
|
|
break;
|
|
|
|
read_main_prop += String.fromCharCode(_c);
|
|
index++;
|
|
}
|
|
index++;
|
|
|
|
if ("PPTY" != read_main_prop)
|
|
return false;
|
|
|
|
read_main_prop = "";
|
|
while (true)
|
|
{
|
|
var _c = isBase64 ? base64_ppty.charCodeAt(index) : base64_ppty[index];
|
|
if (_c == ";".charCodeAt(0))
|
|
break;
|
|
|
|
read_main_prop += String.fromCharCode(_c);
|
|
index++;
|
|
}
|
|
index++;
|
|
|
|
var _version_num_str = read_main_prop.substring(1);
|
|
var version = 1;
|
|
if(_version_num_str.length > 0)
|
|
{
|
|
version = _version_num_str - 0;
|
|
}
|
|
read_main_prop = "";
|
|
while (true)
|
|
{
|
|
var _c = isBase64 ? base64_ppty.charCodeAt(index) : base64_ppty[index];
|
|
if (_c == ";".charCodeAt(0))
|
|
break;
|
|
|
|
read_main_prop += String.fromCharCode(_c);
|
|
index++;
|
|
}
|
|
index++;
|
|
|
|
if (Asc.c_nVersionNoBase64 !== version) {
|
|
var dstLen_str = read_main_prop;
|
|
|
|
var dstLen = parseInt(dstLen_str);
|
|
var memoryData = AscCommon.Base64.decode(base64_ppty, false, dstLen, index);
|
|
this.stream = new AscCommon.FileStream(memoryData, memoryData.length);
|
|
} else {
|
|
this.stream = new AscCommon.FileStream();
|
|
this.stream.obj = null;
|
|
this.stream.data = base64_ppty;
|
|
this.stream.size = base64_ppty.length;
|
|
//skip header
|
|
this.stream.EnterFrame(index);
|
|
this.stream.Seek2(index);
|
|
}
|
|
|
|
this.presentation.ImageMap = {};
|
|
this.presentation.Fonts = [];
|
|
this.fields.length = 0;
|
|
|
|
this.LoadDocument();
|
|
if(AscFonts.IsCheckSymbols)
|
|
{
|
|
var bLoad = AscCommon.g_oIdCounter.m_bLoad;
|
|
AscCommon.g_oIdCounter.Set_Load(false);
|
|
for(var nField = 0; nField < this.fields.length; ++nField)
|
|
{
|
|
var oField = this.fields[nField];
|
|
var sValue = oField.private_GetString();
|
|
if(typeof sValue === "string" && sValue.length > 0)
|
|
{
|
|
AscFonts.FontPickerByCharacter.getFontsByString(sValue);
|
|
}
|
|
}
|
|
AscCommon.g_oIdCounter.Set_Load(bLoad);
|
|
}
|
|
this.fields.length = 0;
|
|
AscFormat.checkPlaceholdersText();
|
|
|
|
this.ImageMapChecker = null;
|
|
};
|
|
this.GenerateSmartArts = function () {
|
|
while (this.smartarts.length) {
|
|
const smartart = this.smartarts.pop();
|
|
smartart.generateDrawingPart();
|
|
}
|
|
};
|
|
this.ClearSmartArts = function () {
|
|
this.smartarts.length = 0;
|
|
};
|
|
|
|
this.LoadDocument = function()
|
|
{
|
|
// чтение формата ppty
|
|
var _main_tables = {};
|
|
var s = this.stream;
|
|
var err = 0;
|
|
|
|
err = s.EnterFrame(5 * 30);
|
|
if (err != 0)
|
|
return err;
|
|
|
|
for (var i = 0; i < 30; i++)
|
|
{
|
|
var _type = s.GetUChar();
|
|
if (0 == _type)
|
|
break;
|
|
|
|
_main_tables["" + _type] = s.GetULong();
|
|
}
|
|
|
|
if (undefined != _main_tables["255"])
|
|
{
|
|
// signature
|
|
s.Seek2(_main_tables["255"]);
|
|
var _sign = s.GetString1(4);
|
|
var _ver = s.GetULong();
|
|
}
|
|
|
|
if (!this.IsThemeLoader)
|
|
{
|
|
if (undefined != _main_tables["1"])
|
|
{
|
|
// app
|
|
s.Seek2(_main_tables["1"]);
|
|
|
|
this.presentation.App = new AscCommon.CApp();
|
|
this.presentation.App.fromStream(s);
|
|
}
|
|
|
|
if (undefined != _main_tables["2"])
|
|
{
|
|
// core
|
|
s.Seek2(_main_tables["2"]);
|
|
|
|
this.presentation.Core = new AscCommon.CCore();
|
|
this.presentation.Core.fromStream(s);
|
|
}
|
|
|
|
if (undefined != _main_tables["8"])
|
|
{
|
|
// Customs
|
|
let nCustomPos = _main_tables["8"];
|
|
s.Seek2(nCustomPos);
|
|
|
|
let customXmlManager = this.presentation.getCustomXmlManager();
|
|
(new AscCommon.BinaryCustomsTableReader(customXmlManager, s)).ReadPPTY();
|
|
}
|
|
|
|
if (undefined != _main_tables["48"])
|
|
{
|
|
// CustomProperties
|
|
s.Seek2(_main_tables["48"]);
|
|
|
|
this.presentation.CustomProperties.fromStream(s);
|
|
}
|
|
}
|
|
|
|
if (undefined != _main_tables["3"])
|
|
{
|
|
// core
|
|
s.Seek2(_main_tables["3"]);
|
|
|
|
this.presentation.pres = new AscCommon.CPres();
|
|
var pres = this.presentation.pres;
|
|
|
|
pres.fromStream(s, this);
|
|
|
|
if(!this.IsThemeLoader)
|
|
{
|
|
if(pres.attrShowSpecialPlsOnTitleSld !== null)
|
|
{
|
|
this.presentation.setShowSpecialPlsOnTitleSld(pres.attrShowSpecialPlsOnTitleSld);
|
|
}
|
|
|
|
if(pres.attrFirstSlideNum !== null)
|
|
{
|
|
this.presentation.setFirstSlideNum(pres.attrFirstSlideNum);
|
|
}
|
|
}
|
|
|
|
this.presentation.defaultTextStyle = pres.defaultTextStyle;
|
|
}
|
|
|
|
if (!this.IsThemeLoader)
|
|
{
|
|
if (undefined != _main_tables["4"])
|
|
{
|
|
// view props
|
|
s.Seek2(_main_tables["4"]);
|
|
this.presentation.setViewPr(this.ReadViewProps());
|
|
}
|
|
|
|
if (undefined != _main_tables["5"])
|
|
{
|
|
// vmldrawing
|
|
s.Seek2(_main_tables["5"]);
|
|
this.presentation.VmlDrawing = this.ReadVmlDrawing();
|
|
}
|
|
|
|
if (undefined != _main_tables["6"])
|
|
{
|
|
// tablestyles
|
|
s.Seek2(_main_tables["6"]);
|
|
this.presentation.TableStyles = this.ReadTableStyles();
|
|
}
|
|
if (undefined != _main_tables["7"])
|
|
{
|
|
// presprops
|
|
s.Seek2(_main_tables["7"]);
|
|
this.ReadPresProps(this.presentation);
|
|
}
|
|
}
|
|
|
|
this.aThemes.length = 0;
|
|
if (undefined != _main_tables["20"])
|
|
{
|
|
// themes
|
|
s.Seek2(_main_tables["20"]);
|
|
|
|
var _themes_count = s.GetULong();
|
|
for (var i = 0; i < _themes_count; i++)
|
|
this.aThemes[i] = this.ReadTheme();
|
|
}
|
|
|
|
if (undefined != _main_tables["22"])
|
|
{
|
|
// slide masters
|
|
s.Seek2(_main_tables["22"]);
|
|
|
|
var _sm_count = s.GetULong();
|
|
for (var i = 0; i < _sm_count; i++)
|
|
{
|
|
this.presentation.slideMasters[i] = this.ReadSlideMaster();
|
|
this.presentation.slideMasters[i].setSlideSize(this.presentation.GetWidthMM(), this.presentation.GetHeightMM());
|
|
}
|
|
}
|
|
|
|
this.aSlideLayouts.length = 0;
|
|
if (undefined != _main_tables["23"])
|
|
{
|
|
// slide masters
|
|
s.Seek2(_main_tables["23"]);
|
|
|
|
var _sl_count = s.GetULong();
|
|
for (var i = 0; i < _sl_count; i++)
|
|
{
|
|
this.aSlideLayouts[i] = this.ReadSlideLayout();
|
|
this.aSlideLayouts[i].setSlideSize(this.presentation.GetWidthMM(), this.presentation.GetHeightMM());
|
|
}
|
|
}
|
|
|
|
if (!this.IsThemeLoader)
|
|
{
|
|
if (undefined != _main_tables["24"])
|
|
{
|
|
// slides
|
|
s.Seek2(_main_tables["24"]);
|
|
|
|
var _s_count = s.GetULong();
|
|
var bOldVal;
|
|
if(this.Api)
|
|
{
|
|
bOldVal = this.Api.bNoSendComments;
|
|
this.Api.bNoSendComments = true;
|
|
}
|
|
for (var i = 0; i < _s_count; i++)
|
|
{
|
|
this.presentation.insertSlide(i, this.ReadSlide(i)) ;
|
|
}
|
|
if(this.Api)
|
|
{
|
|
this.Api.bNoSendComments = bOldVal;
|
|
}
|
|
}
|
|
|
|
if (undefined != _main_tables["25"])
|
|
{
|
|
// slides
|
|
s.Seek2(_main_tables["25"]);
|
|
|
|
var _nm_count = s.GetULong();
|
|
for (var i = 0; i < _nm_count; i++){
|
|
this.presentation.notesMasters[i] = this.ReadNoteMaster();
|
|
this.presentation.notesMasters[i].setTheme(this.aThemes[0]);//TODO: убрать после того как будут сделаны рельсы
|
|
}
|
|
}
|
|
|
|
if (undefined != _main_tables["26"])
|
|
{
|
|
// slides
|
|
s.Seek2(_main_tables["26"]);
|
|
|
|
var _n_count = s.GetULong();
|
|
for (var i = 0; i < _n_count; i++)
|
|
this.presentation.notes[i] = this.ReadNote();
|
|
}
|
|
}
|
|
|
|
// теперь нужно прочитать используемые в презентации шрифты и картинки
|
|
if (null == this.ImageMapChecker)
|
|
{
|
|
if (undefined != _main_tables["42"])
|
|
{
|
|
s.Seek2(_main_tables["42"]);
|
|
|
|
var _type = s.GetUChar();
|
|
var _len = s.GetULong();
|
|
|
|
s.Skip2(1); // strat attr
|
|
|
|
var _cur_ind = 0;
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var image_id = s.GetString2();
|
|
if (this.IsThemeLoader)
|
|
{
|
|
image_id = "theme" + (this.Api.ThemeLoader.CurrentLoadThemeIndex + 1) + "/media/" + image_id;
|
|
}
|
|
|
|
this.presentation.ImageMap[_cur_ind++] = image_id;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var _cur_ind = 0;
|
|
for (var k in this.ImageMapChecker)
|
|
{
|
|
if (this.IsThemeLoader)
|
|
{
|
|
image_id = "theme" + (this.Api.ThemeLoader.CurrentLoadThemeIndex + 1) + "/media/" + k;
|
|
}
|
|
|
|
this.presentation.ImageMap[_cur_ind++] = k;
|
|
}
|
|
}
|
|
|
|
if (undefined != _main_tables["43"])
|
|
{
|
|
s.Seek2(_main_tables["43"]);
|
|
|
|
var _type = s.GetUChar();
|
|
var _len = s.GetULong();
|
|
|
|
s.Skip2(1); // strat attr
|
|
|
|
var _cur_ind = 0;
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var f_name = s.GetString2();
|
|
|
|
this.presentation.Fonts[this.presentation.Fonts.length] = new AscFonts.CFont(f_name);
|
|
}
|
|
}
|
|
|
|
// все загружено, осталось расставить связи и загрузить картинки тем и шаблонов
|
|
if (undefined != _main_tables["41"])
|
|
{
|
|
s.Seek2(_main_tables["41"]);
|
|
|
|
s.Skip2(5); // type + len
|
|
|
|
var _count = s.GetULong();
|
|
|
|
for (var i = 0; i < _count; i++)
|
|
{
|
|
var _master_type = s.GetUChar(); // must be 0
|
|
this.ReadMasterInfo(i);
|
|
}
|
|
}
|
|
|
|
if (!this.IsThemeLoader)
|
|
{
|
|
if (undefined != _main_tables["40"])
|
|
{
|
|
s.Seek2(_main_tables["40"]);
|
|
|
|
s.Skip2(6); // type + len + start attr
|
|
|
|
var _slideNum = 0;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var indexL = s.GetULong();
|
|
this.presentation.Slides[_slideNum].setLayout(this.aSlideLayouts[indexL]);
|
|
_slideNum++;
|
|
}
|
|
}
|
|
if (undefined != _main_tables["45"])
|
|
{
|
|
s.Seek2(_main_tables["45"]);
|
|
s.Skip2(6); // type + len + start attr
|
|
|
|
var _slideNum = 0;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var indexL = s.GetLong();
|
|
this.presentation.Slides[_slideNum].setNotes(this.presentation.notes[indexL]);
|
|
++_slideNum;
|
|
}
|
|
}
|
|
if (undefined != _main_tables["46"])
|
|
{
|
|
s.Seek2(_main_tables["46"]);
|
|
s.Skip2(6); // type + len + start attr
|
|
|
|
var _noteNum = 0;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var indexL = s.GetLong();
|
|
this.presentation.notes[_noteNum].setNotesMaster(this.presentation.notesMasters[indexL]);
|
|
_noteNum++;
|
|
}
|
|
}
|
|
if (undefined != _main_tables["47"])
|
|
{
|
|
s.Seek2(_main_tables["47"]);
|
|
s.Skip2(6); // type + len + start attr
|
|
|
|
var _noteMasterNum = 0;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var indexL = s.GetLong();
|
|
var notesMaster = this.presentation.notesMasters[_noteMasterNum];
|
|
var notesMasterTheme = this.aThemes[indexL];
|
|
if (notesMaster && notesMasterTheme) {
|
|
notesMaster.setTheme(notesMasterTheme);
|
|
}
|
|
_noteMasterNum++;
|
|
}
|
|
}
|
|
}
|
|
if (this.IsThemeLoader) {
|
|
this.ClearSmartArts();
|
|
} else {
|
|
this.GenerateSmartArts();
|
|
}
|
|
|
|
if (this.Api != null && !this.IsThemeLoader)
|
|
{
|
|
this.presentation.createNecessaryObjectsIfNoPresent();
|
|
}
|
|
else if (this.Api != null && this.IsThemeLoader)
|
|
{
|
|
var theme_loader = this.Api.ThemeLoader;
|
|
var _info = theme_loader.themes_info_editor[theme_loader.CurrentLoadThemeIndex];
|
|
_info.ImageMap = this.presentation.ImageMap;
|
|
_info.FontMap = this.presentation.Fonts;
|
|
}
|
|
};
|
|
|
|
this.ReadMasterInfo = function(indexMaster)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
var master = this.presentation.slideMasters[indexMaster];
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var indexTh = s.GetULong();
|
|
master.setTheme(this.aThemes[indexTh]);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.GetString2A();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
var _lay_count = s.GetULong();
|
|
for (var i = 0; i < _lay_count; i++)
|
|
{
|
|
s.Skip2(6); // type + len
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var indexL = s.GetULong();
|
|
master.addToSldLayoutLstToPos(master.sldLayoutLst.length, this.aSlideLayouts[indexL]);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.GetString2A();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
|
|
if (this.Api != null && this.IsThemeLoader)
|
|
{
|
|
var theme_loader = this.Api.ThemeLoader;
|
|
|
|
var theme_load_info = new CThemeLoadInfo();
|
|
theme_load_info.Master = master;
|
|
theme_load_info.Theme = master.Theme;
|
|
|
|
var _lay_cnt = master.sldLayoutLst.length;
|
|
for (var i = 0; i < _lay_cnt; i++)
|
|
theme_load_info.Layouts[i] = master.sldLayoutLst[i];
|
|
|
|
theme_loader.themes_info_editor[theme_loader.CurrentLoadThemeIndex] = theme_load_info;
|
|
}
|
|
};
|
|
|
|
this.ReadViewProps = function()
|
|
{
|
|
//this.stream.SkipRecord();
|
|
//return null;
|
|
let oViewPr = new AscFormat.CViewPr();
|
|
this.stream.GetUChar();
|
|
oViewPr.fromPPTY(this);
|
|
return oViewPr;
|
|
};
|
|
this.ReadVmlDrawing = function()
|
|
{
|
|
return null;
|
|
};
|
|
this.ReadPresProps = function(presentation)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _type = s.GetUChar();
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
presentation.showPr = this.ReadShowPr();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
this.ReadShowPr = function()
|
|
{
|
|
var showPr = new CShowPr();
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
showPr.loop = s.GetBool();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
showPr.showAnimation = s.GetBool();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
showPr.showNarration = s.GetBool();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
showPr.useTimings = s.GetBool();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
//todo browseShowScrollbar
|
|
showPr.browse = true;
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
this.ReadShowPrCustShow(showPr);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
this.ReadShowPrKiosk(showPr);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
showPr.penClr = this.ReadUniColor();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
showPr.present = true;
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if (!showPr.show){
|
|
showPr.show = {showAll: null, range: null, custShow: null};
|
|
}
|
|
showPr.show.showAll = true;
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
this.ReadShowPrSldRg(showPr);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return showPr;
|
|
};
|
|
this.ReadShowPrCustShow = function(showPr)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
if (!showPr.show){
|
|
showPr.show = {showAll: null, range: null, custShow: null};
|
|
}
|
|
showPr.show.custShow = s.GetLong();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
this.ReadShowPrKiosk = function(showPr)
|
|
{
|
|
showPr.kiosk = {restart: null};
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
showPr.kiosk.restart = s.GetLong();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
this.ReadShowPrSldRg = function(showPr)
|
|
{
|
|
if (!showPr.show){
|
|
showPr.show = {showAll: null, range: null, custShow: null};
|
|
}
|
|
showPr.show.range = {start: null, end: null};
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
showPr.show.range.start = s.GetLong();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
showPr.show.range.end = s.GetLong();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
this.ReadTableStyles = function()
|
|
{
|
|
//var _styles = this.presentation.globalTableStyles;
|
|
var s = this.stream;
|
|
|
|
var _type = s.GetUChar();
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
let sNewDefaultStyleStyleId;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
sNewDefaultStyleStyleId = s.GetString2();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
var _type = s.GetUChar(); // 0!!!
|
|
s.Skip2(4); // len
|
|
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
s.Skip2(1);
|
|
this.ReadTableStyle();
|
|
}
|
|
if(typeof sNewDefaultStyleStyleId === 'string' && this.presentation && this.presentation.globalTableStyles)
|
|
{
|
|
const oDefaultStyle = this.presentation.globalTableStyles.GetStyleByStyleId(sNewDefaultStyleStyleId);
|
|
if (oDefaultStyle)
|
|
{
|
|
this.presentation.DefaultTableStyleId = oDefaultStyle.Id;
|
|
}
|
|
}
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadTableStyle = function(bNotAddStyle)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _style = new CStyle("", null, null, styletype_Table);
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var _id = s.GetString2();
|
|
_style.SetStyleId(_id);
|
|
// _style.Id = _id;
|
|
if(AscCommon.isRealObject(this.presentation.TableStylesIdMap) && !bNotAddStyle)
|
|
this.presentation.TableStylesIdMap[_style.Id] = true;
|
|
|
|
if (this.presentation && this.presentation.globalTableStyles)
|
|
{
|
|
const oOldStyle = this.presentation.globalTableStyles.GetStyleByStyleId(_id);
|
|
if (oOldStyle)
|
|
{
|
|
this.presentation.globalTableStyles.Remove(oOldStyle.GetId());
|
|
this.presentation.globalTableStyles.Add(_style);
|
|
}
|
|
else
|
|
{
|
|
this.map_table_styles[_id] = _style;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_style.Name = s.GetString2();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var _end_rec2 = s.cur + s.GetLong() + 4;
|
|
|
|
while (s.cur < _end_rec2)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
switch (_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
var _end_rec3 = s.cur + s.GetLong() + 4;
|
|
while (s.cur < _end_rec3)
|
|
{
|
|
var _at3 = s.GetUChar();
|
|
switch (_at3)
|
|
{
|
|
case 0:
|
|
{
|
|
var _unifill = this.ReadUniFill();
|
|
if (_unifill && _unifill.fill !== undefined && _unifill.fill != null)
|
|
{
|
|
if (undefined === _style.TablePr.Shd || null == _style.TablePr.Shd)
|
|
{
|
|
_style.TablePr.Shd = new CDocumentShd();
|
|
_style.TablePr.Shd.Value = c_oAscShdClear;
|
|
}
|
|
_style.TablePr.Shd.Unifill = _unifill;
|
|
}
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
if (undefined === _style.TablePr.Shd || null == _style.TablePr.Shd)
|
|
{
|
|
_style.TablePr.Shd = new CDocumentShd();
|
|
_style.TablePr.Shd.Value = c_oAscShdClear;
|
|
}
|
|
_style.TablePr.Shd.FillRef = this.ReadStyleRef();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec2);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_style.TableWholeTable = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
_style.TableBand1Horz = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
_style.TableBand2Horz = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
_style.TableBand1Vert = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
_style.TableBand2Vert = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
_style.TableLastCol = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
_style.TableFirstCol = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
_style.TableFirstRow = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
_style.TableLastRow = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
_style.TableBRCell = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 11:
|
|
{
|
|
_style.TableBLCell = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 12:
|
|
{
|
|
_style.TableTRCell = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
case 13:
|
|
{
|
|
_style.TableTLCell = this.ReadTableStylePart();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
_style.wholeToTablePr();
|
|
if(bNotAddStyle)
|
|
{
|
|
return _style;
|
|
}
|
|
else
|
|
{
|
|
if(this.presentation && this.presentation.globalTableStyles)
|
|
this.presentation.globalTableStyles.Add(_style);
|
|
}
|
|
};
|
|
|
|
this.ReadTableStylePart = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _part = new CTableStylePr();
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var _end_rec2 = s.cur + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
var _i, _b;
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
_i = s.GetUChar();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_b = s.GetUChar();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(_i === 0)
|
|
{
|
|
_part.TextPr.Italic = true;
|
|
}
|
|
else if(_i === 1)
|
|
{
|
|
_part.TextPr.Italic = false;
|
|
}
|
|
|
|
if(_b === 0)
|
|
{
|
|
_part.TextPr.Bold = true;
|
|
}
|
|
else if(_b === 1)
|
|
{
|
|
_part.TextPr.Bold = false;
|
|
}
|
|
|
|
while (s.cur < _end_rec2)
|
|
{
|
|
var _at3 = s.GetUChar();
|
|
switch (_at3)
|
|
{
|
|
case 0:
|
|
{
|
|
_part.TextPr.FontRef = this.ReadFontRef();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var _Unicolor = this.ReadUniColor();
|
|
if(_Unicolor && _Unicolor.color)
|
|
{
|
|
_part.TextPr.Unifill = AscFormat.CreateUniFillByUniColor(_Unicolor);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec2);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var _end_rec2 = s.cur + s.GetLong() + 4;
|
|
|
|
while (s.cur < _end_rec2)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
switch (_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadTcBdr(_part);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
if (undefined === _part.TableCellPr.Shd || null == _part.TableCellPr.Shd)
|
|
{
|
|
_part.TableCellPr.Shd = new CDocumentShd();
|
|
_part.TableCellPr.Shd.Value = c_oAscShdClear;
|
|
}
|
|
_part.TableCellPr.Shd.FillRef = this.ReadStyleRef();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var _end_rec3 = s.cur + s.GetLong() + 4;
|
|
while (s.cur < _end_rec3)
|
|
{
|
|
var _at3 = s.GetUChar();
|
|
switch (_at3)
|
|
{
|
|
case 0:
|
|
{
|
|
var _unifill = this.ReadUniFill();
|
|
if (_unifill && _unifill.fill !== undefined && _unifill.fill != null)
|
|
{
|
|
if (undefined === _part.TableCellPr.Shd || null == _part.TableCellPr.Shd)
|
|
{
|
|
_part.TableCellPr.Shd = new CDocumentShd();
|
|
_part.TableCellPr.Shd.Value = c_oAscShdClear;
|
|
}
|
|
_part.TableCellPr.Shd.Unifill = _unifill;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec2);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return _part;
|
|
};
|
|
|
|
this.ReadTcBdr = function(_part)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_part.TableCellPr.TableCellBorders.Left = new CDocumentBorder();
|
|
this.ReadTableBorderLineStyle(_part.TableCellPr.TableCellBorders.Left);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_part.TableCellPr.TableCellBorders.Right = new CDocumentBorder();
|
|
this.ReadTableBorderLineStyle(_part.TableCellPr.TableCellBorders.Right);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
_part.TableCellPr.TableCellBorders.Top = new CDocumentBorder();
|
|
this.ReadTableBorderLineStyle(_part.TableCellPr.TableCellBorders.Top);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
_part.TableCellPr.TableCellBorders.Bottom = new CDocumentBorder();
|
|
this.ReadTableBorderLineStyle(_part.TableCellPr.TableCellBorders.Bottom);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
_part.TablePr.TableBorders.InsideH = new CDocumentBorder();
|
|
this.ReadTableBorderLineStyle(_part.TablePr.TableBorders.InsideH);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
_part.TablePr.TableBorders.InsideV = new CDocumentBorder();
|
|
this.ReadTableBorderLineStyle(_part.TablePr.TableBorders.InsideV);
|
|
break;
|
|
}
|
|
case 6:
|
|
case 7:
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return _part;
|
|
};
|
|
|
|
this.ReadTableBorderLineStyle = function(_border)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var ln = this.ReadLn();
|
|
ln.fillDocumentBorder(_border);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_border.LineRef = this.ReadStyleRef();
|
|
_border.Value = border_Single;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
// UNICOLOR ---------------------------------
|
|
|
|
this.ReadUniColor = function()
|
|
{
|
|
var s = this.stream;
|
|
var _len = s.GetULong();
|
|
var read_start = s.cur;
|
|
var read_end = read_start + _len;
|
|
|
|
var uni_color = new AscFormat.CUniColor();
|
|
|
|
if (s.cur < read_end)
|
|
{
|
|
var _type = s.GetUChar();
|
|
|
|
var _e = s.cur + s.GetULong() + 4;
|
|
|
|
switch (_type)
|
|
{
|
|
case c_oAscColor.COLOR_TYPE_PRST:
|
|
{
|
|
s.Skip2(2);
|
|
uni_color.setColor(new AscFormat.CPrstColor());
|
|
uni_color.color.setId(s.GetString2());
|
|
s.Skip2(1);
|
|
|
|
if (s.cur < _e)
|
|
{
|
|
if (0 == s.GetUChar())
|
|
{
|
|
uni_color.setMods(this.ReadColorMods());
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case c_oAscColor.COLOR_TYPE_SCHEME:
|
|
{
|
|
s.Skip2(2);
|
|
uni_color.setColor(new AscFormat.CSchemeColor());
|
|
uni_color.color.setId(s.GetUChar());
|
|
s.Skip2(1);
|
|
|
|
if (s.cur < _e)
|
|
{
|
|
if (0 == s.GetUChar())
|
|
{
|
|
uni_color.setMods(this.ReadColorMods());
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case c_oAscColor.COLOR_TYPE_SRGB:
|
|
{
|
|
var r, g, b;
|
|
s.Skip2(1);
|
|
uni_color.setColor(new AscFormat.CRGBColor());
|
|
s.Skip2(1);
|
|
r = s.GetUChar();
|
|
s.Skip2(1);
|
|
g = s.GetUChar();
|
|
s.Skip2(1);
|
|
b = s.GetUChar();
|
|
s.Skip2(1);
|
|
uni_color.color.setColor(r, g, b);
|
|
if (s.cur < _e)
|
|
{
|
|
if (0 == s.GetUChar())
|
|
{
|
|
uni_color.setMods(this.ReadColorMods());
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case c_oAscColor.COLOR_TYPE_SYS:
|
|
{
|
|
s.Skip2(1);
|
|
uni_color.setColor(new AscFormat.CSysColor());
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
uni_color.color.setId(s.GetString2());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
uni_color.color.setR(s.GetUChar());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
uni_color.color.setG(s.GetUChar());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
uni_color.color.setB(s.GetUChar());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (s.cur < _e)
|
|
{
|
|
if (0 == s.GetUChar())
|
|
{
|
|
uni_color.setMods(this.ReadColorMods());
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case c_oAscColor.COLOR_TYPE_STYLE:
|
|
{
|
|
var oColor = new AscFormat.CStyleColor();
|
|
s.Skip2(1);
|
|
while(true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
switch (_at2) {
|
|
case 0:
|
|
{
|
|
oColor.val = s.GetULong();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
oColor.bAuto = s.GetBool();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
uni_color.setColor(oColor);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!uni_color.color){
|
|
return null;
|
|
}
|
|
|
|
s.Seek2(read_end);
|
|
return uni_color;
|
|
};
|
|
|
|
this.ReadColorMods = function()
|
|
{
|
|
var ret = new AscFormat.CColorModifiers();
|
|
var _mods = this.ReadColorModifiers();
|
|
if(_mods)
|
|
{
|
|
for(var i = 0; i < _mods.length; ++i)
|
|
ret.addMod(_mods[i]);
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
this.ReadColorMod = function()
|
|
{
|
|
var s = this.stream;
|
|
var _s1 = s.cur;
|
|
var _e1 = _s1 + s.GetULong() + 4;
|
|
var _mod = null;
|
|
if (_s1 < _e1)
|
|
{
|
|
s.Skip2(1);
|
|
_mod = new AscFormat.CColorMod();
|
|
while (true)
|
|
{
|
|
var _type = s.GetUChar();
|
|
|
|
if (0 == _type)
|
|
{
|
|
_mod.setName(s.GetString2());
|
|
var _find = _mod.name.indexOf(":");
|
|
if (_find >= 0 && _find < (_mod.name.length - 1))
|
|
_mod.setName(_mod.name.substring(_find + 1));
|
|
}
|
|
else if (1 == _type)
|
|
_mod.setVal(s.GetLong());
|
|
else if (g_nodeAttributeEnd == _type)
|
|
break;
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
s.Seek2(_e1);
|
|
return _mod;
|
|
};
|
|
|
|
this.ReadColorModifiers = function()
|
|
{
|
|
var s = this.stream;
|
|
var _start = s.cur;
|
|
var _end = _start + s.GetULong() + 4;
|
|
|
|
var _ret = null;
|
|
|
|
var _count = s.GetULong();
|
|
for (var i = 0; i < _count; i++)
|
|
{
|
|
if (s.cur > _end)
|
|
break;
|
|
|
|
s.Skip2(1);
|
|
|
|
var _mod = this.ReadColorMod();
|
|
if(_mod)
|
|
{
|
|
if (null == _ret)
|
|
_ret = [];
|
|
_ret[_ret.length] = _mod;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end);
|
|
return _ret;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
// UNIFILL ----------------------------------
|
|
|
|
this.ReadRect = function(bIsMain)
|
|
{
|
|
let _ret = {};
|
|
|
|
let s = this.stream;
|
|
|
|
let _rec_start = s.cur;
|
|
let _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
let _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_ret.l = s.GetPercentage();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_ret.t = s.GetPercentage();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
_ret.r = s.GetPercentage();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
_ret.b = s.GetPercentage();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
|
|
if (null == _ret.l && null == _ret.t && null == _ret.r && null == _ret.b)
|
|
return null;
|
|
|
|
if (_ret.l == null)
|
|
_ret.l = 0;
|
|
if (_ret.t == null)
|
|
_ret.t = 0;
|
|
if (_ret.r == null)
|
|
_ret.r = 0;
|
|
if (_ret.b == null)
|
|
_ret.b = 0;
|
|
|
|
if (!bIsMain)
|
|
{
|
|
var _absW = Math.abs(_ret.l) + Math.abs(_ret.r) + 100;
|
|
var _absH = Math.abs(_ret.t) + Math.abs(_ret.b) + 100;
|
|
|
|
_ret.l = -100 * _ret.l / _absW;
|
|
_ret.t = -100 * _ret.t / _absH;
|
|
_ret.r = -100 * _ret.r / _absW;
|
|
_ret.b = -100 * _ret.b / _absH;
|
|
}
|
|
|
|
_ret.r = 100 - _ret.r;
|
|
_ret.b = 100 - _ret.b;
|
|
|
|
if (_ret.l > _ret.r)
|
|
{
|
|
let tmp = _ret.l;
|
|
_ret.l = _ret.r;
|
|
_ret.r = tmp;
|
|
}
|
|
if (_ret.t > _ret.b)
|
|
{
|
|
let tmp = _ret.t;
|
|
_ret.t = _ret.b;
|
|
_ret.b = tmp;
|
|
}
|
|
return new AscFormat.CSrcRect(_ret.l, _ret.t, _ret.r, _ret.b);
|
|
};
|
|
|
|
this.ReadGradLin = function()
|
|
{
|
|
var _lin = new AscFormat.GradLin();
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_lin.setAngle(s.GetLong());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_lin.setScale(s.GetBool());
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return _lin;
|
|
};
|
|
|
|
this.ReadGradPath = function()
|
|
{
|
|
var _path = new AscFormat.GradPath();
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_path.setPath(s.GetUChar());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return _path;
|
|
};
|
|
|
|
|
|
this.ReadBlur = function()
|
|
{
|
|
var nRecStart, nRecLen, nRecEnd;
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.CBlur();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.rad = s.GetULong(); break;
|
|
case 1: oEffect.grow = s.GetBool(); break;
|
|
}
|
|
}
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadFillOverlay = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var nRecStart, nRecLen, nRecEnd;
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.CFillOverlay();
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.blend = s.GetUChar();
|
|
else break;
|
|
}
|
|
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.fill = this.ReadUniFill();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadGlow = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var nRecStart = s.cur;
|
|
var nRecLen = s.GetLong();
|
|
var nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.CGlow();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.rad = s.GetLong();
|
|
else break;
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.color = this.ReadUniColor();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadInnerShdw = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var nRecStart = s.cur;
|
|
var nRecLen = s.GetLong();
|
|
var nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.CInnerShdw();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.dir = s.GetLong(); break;
|
|
case 1: oEffect.dist = s.GetLong(); break;
|
|
case 2: oEffect.blurRad = s.GetLong(); break;
|
|
}
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.color = this.ReadUniColor();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadOuterShdw = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
|
|
var nRecStart = s.cur;
|
|
var nRecLen = s.GetLong();
|
|
var nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.COuterShdw();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.algn = s.GetUChar(); break;
|
|
case 1: oEffect.blurRad = s.GetLong(); break;
|
|
case 2: oEffect.dir = s.GetLong(); break;
|
|
case 3: oEffect.dist = s.GetLong(); break;
|
|
case 4: oEffect.kx = s.GetLong(); break;
|
|
case 5: oEffect.ky = s.GetLong(); break;
|
|
case 6: oEffect.sx = s.GetLong(); break;
|
|
case 7: oEffect.sy = s.GetLong(); break;
|
|
case 8: oEffect.rotWithShape = s.GetBool(); break;
|
|
}
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.color = this.ReadUniColor();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadPrstShdw = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var nRecStart = s.cur;
|
|
var nRecLen = s.GetLong();
|
|
var nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.CPrstShdw();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.dir = s.GetLong(); break;
|
|
case 1: oEffect.dist = s.GetLong(); break;
|
|
case 2: oEffect.prst = s.GetUChar(); break;
|
|
}
|
|
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.color = this.ReadUniColor();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadReflection = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var nRecStart = s.cur;
|
|
var nRecLen = s.GetLong();
|
|
var nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.CReflection();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.algn = ( s.GetUChar());
|
|
}break;
|
|
case 1: oEffect.blurRad = s.GetLong(); break;
|
|
case 2: oEffect.stA = s.GetLong(); break;
|
|
case 3: oEffect.endA = s.GetLong(); break;
|
|
case 4: oEffect.stPos = s.GetLong(); break;
|
|
case 5: oEffect.endPos = s.GetLong(); break;
|
|
case 6: oEffect.dir = s.GetLong(); break;
|
|
case 7: oEffect.fadeDir = s.GetLong(); break;
|
|
case 8: oEffect.dist = s.GetLong(); break;
|
|
case 9: oEffect.kx = s.GetLong(); break;
|
|
case 10:oEffect.ky = s.GetLong(); break;
|
|
case 11:oEffect.sx = s.GetLong(); break;
|
|
case 12:oEffect.sy = s.GetLong(); break;
|
|
case 13:oEffect.rotWithShape = s.GetBool(); break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadSoftEdge = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var nRecStart = s.cur;
|
|
var nRecLen = s.GetLong();
|
|
var nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffect = new AscFormat.CSoftEdge();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0) oEffect.rad = s.GetULong();
|
|
else break;
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadEffect = function()
|
|
{
|
|
|
|
var s = this.stream;
|
|
var pos = s.cur;
|
|
var nUniEffectLength = s.GetLong(); // len
|
|
if(nUniEffectLength === 0)
|
|
{
|
|
return null;
|
|
}
|
|
var nEffectType = s.GetUChar();
|
|
s.Seek2(pos);
|
|
var nRecStart, nRecLen, nRecEnd;
|
|
var oEffect = null;
|
|
switch(nEffectType)
|
|
{
|
|
case 0:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_NONE =
|
|
}
|
|
case 1:
|
|
{
|
|
oEffect = this.ReadOuterShdw();
|
|
break;//var EFFECT_TYPE_OUTERSHDW =
|
|
}
|
|
case 2:
|
|
{
|
|
oEffect = this.ReadGlow();
|
|
break;//var EFFECT_TYPE_GLOW =
|
|
}
|
|
case 3:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CDuotone();
|
|
var count = s.GetULong();
|
|
for (var i = 0; i < count; ++i)
|
|
{
|
|
s.Skip2(1); // type
|
|
|
|
var oUniColor = this.ReadUniColor();
|
|
if(oUniColor.color)
|
|
{
|
|
oEffect.colors.push(oUniColor);
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_DUOTONE =
|
|
}
|
|
case 4:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CXfrmEffect();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.kx = s.GetLong(); break;
|
|
case 1: oEffect.ky = s.GetLong(); break;
|
|
case 2: oEffect.sx = s.GetLong(); break;
|
|
case 3: oEffect.sy = s.GetLong(); break;
|
|
case 4: oEffect.tx = s.GetULong(); break;
|
|
case 5: oEffect.ty = s.GetULong(); break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_XFRM =
|
|
}
|
|
case 5:
|
|
{
|
|
oEffect = this.ReadBlur();
|
|
break;//var EFFECT_TYPE_BLUR =
|
|
}
|
|
case 6:
|
|
{
|
|
oEffect = this.ReadPrstShdw();
|
|
break;//var EFFECT_TYPE_PRSTSHDW =
|
|
}
|
|
case 7:
|
|
{
|
|
oEffect = this.ReadInnerShdw();
|
|
break;//var EFFECT_TYPE_INNERSHDW =
|
|
}
|
|
case 8:
|
|
{
|
|
oEffect = this.ReadReflection();
|
|
break;//var EFFECT_TYPE_REFLECTION =
|
|
}
|
|
case 9:
|
|
{
|
|
oEffect = this.ReadSoftEdge();
|
|
break;//var EFFECT_TYPE_SOFTEDGE =
|
|
}
|
|
case 10:
|
|
{
|
|
oEffect = this.ReadFillOverlay();
|
|
break;//var EFFECT_TYPE_FILLOVERLAY =
|
|
}
|
|
case 11:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaCeiling();
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHACEILING =
|
|
}
|
|
case 12:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaFloor();
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHAFLOOR =
|
|
}
|
|
case 13:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CTintEffect();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.amt = s.GetLong(); break;
|
|
case 1: oEffect.hue = s.GetLong(); break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_TINTEFFECT =
|
|
}
|
|
case 14:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CRelOff();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.tx = s.GetLong(); break;
|
|
case 1: oEffect.ty = s.GetLong(); break;
|
|
}
|
|
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_RELOFF =
|
|
}
|
|
case 15:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CLumEffect();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0: oEffect.bright = s.GetLong(); break;
|
|
case 1: oEffect.contrast = s.GetLong(); break;
|
|
}
|
|
}
|
|
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_LUM =
|
|
}
|
|
case 16:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CHslEffect();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
oEffect.hue = s.GetLong(); break;
|
|
case 1:
|
|
oEffect.lum = s.GetLong(); break;
|
|
case 2:
|
|
oEffect.sat = s.GetLong(); break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_HSL =
|
|
}
|
|
case 17:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CGrayscl();
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_GRAYSCL =
|
|
}
|
|
case 18:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CEffectElement();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.ref = s.GetString2();
|
|
else break;
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ELEMENT =
|
|
}
|
|
case 19:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaRepl();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.a = s.GetLong();
|
|
else break;
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHAREPL =
|
|
}
|
|
case 20:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaOutset();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.rad = s.GetULong();
|
|
else break;
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHAOUTSET =
|
|
}
|
|
case 21:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaModFix();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.amt = s.GetLong();
|
|
else break;
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHAMODFIX =
|
|
}
|
|
case 22:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaBiLevel();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.thresh = s.GetLong();
|
|
else break;
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHABILEVEL =
|
|
}
|
|
case 23:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CBiLevel();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.thresh = s.GetLong();
|
|
else break;
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_BILEVEL =
|
|
}
|
|
case 24:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CEffectContainer();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
oEffect.name = s.GetString2(); break;
|
|
case 1:
|
|
{
|
|
oEffect.type = (s.GetUChar());
|
|
}break;
|
|
}
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var count_effects2 = s.GetULong();
|
|
for (var _eff2 = 0; _eff2 < count_effects2; ++_eff2)
|
|
{
|
|
s.Skip2(1); // type
|
|
var eff2 = this.ReadEffect();
|
|
if(!eff2)
|
|
{
|
|
oEffect.effectList.push(eff2);
|
|
}
|
|
}
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_DAG =
|
|
}
|
|
case 25:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CFillEffect();
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
}
|
|
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.fill = this.ReadUniFill();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_FILL =
|
|
}
|
|
case 26:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CClrRepl();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.color = this.ReadUniColor();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_CLRREPL =
|
|
}
|
|
case 27:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CClrChange();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
oEffect.useA = s.GetBool(); break;
|
|
}
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.clrFrom = this.ReadUniColor();
|
|
}break;
|
|
case 1:
|
|
{
|
|
oEffect.clrTo = this.ReadUniColor();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_CLRCHANGE =
|
|
}
|
|
case 28:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaInv();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.color = this.ReadUniColor();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHAINV =
|
|
}
|
|
case 29:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CAlphaMod();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.cont = this.ReadEffectDag();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_ALPHAMOD =
|
|
}
|
|
case 30:
|
|
{
|
|
s.GetLong();
|
|
s.GetUChar();
|
|
nRecStart = s.cur;
|
|
nRecLen = s.GetLong();
|
|
nRecEnd = nRecStart + nRecLen + 4;
|
|
oEffect = new AscFormat.CBlend();
|
|
s.Skip2(1);
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
oEffect.blend = (s.GetUChar());
|
|
else break;
|
|
}
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffect.cont = this.ReadEffectDag();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(nRecEnd);
|
|
break;//var EFFECT_TYPE_BLEND =
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;//var
|
|
}
|
|
}
|
|
|
|
return oEffect;
|
|
};
|
|
|
|
this.ReadEffectDag = function ()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var _start_pos = s.cur;
|
|
var _end_rec = _start_pos + s.GetLong() + 4;
|
|
s.Skip(1);
|
|
|
|
var ret = new AscFormat.CEffectContainer();
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
ret.name = s.GetString2(); break;
|
|
}
|
|
case 1:
|
|
{
|
|
ret.type = (s.GetUChar()); break;
|
|
}
|
|
}
|
|
}
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var count_effects = s.GetULong();
|
|
for (var _eff = 0; _eff < count_effects; ++_eff)
|
|
{
|
|
s.Skip2(1); // type
|
|
var effect = this.ReadEffect();
|
|
if(effect)
|
|
{
|
|
ret.effectList.push(effect);
|
|
}
|
|
}
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek(_end_rec);
|
|
return ret;
|
|
};
|
|
|
|
this.ReadBlip = function (uni_fill, oSpPr, oImageShape, oLn, oParagraph, oBullet) {
|
|
var s = this.stream;
|
|
var _s2 = s.cur;
|
|
var _e2 = _s2 + s.GetLong() + 4;
|
|
|
|
s.Skip2(1);
|
|
|
|
let builderImage = null;
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (g_nodeAttributeEnd == _at)
|
|
break;
|
|
|
|
if (_at == 0)
|
|
s.Skip2(1);
|
|
}
|
|
|
|
while (s.cur < _e2)
|
|
{
|
|
var _t = s.GetUChar();
|
|
|
|
switch (_t)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
{
|
|
// id. embed / link
|
|
s.Skip2(4);
|
|
break;
|
|
}
|
|
case 10:
|
|
case 11:
|
|
{
|
|
// id. embed / link
|
|
uni_fill.fill.embed = s.GetString2();
|
|
if (this.IsUseFullUrl)
|
|
{
|
|
if(!builderImage)
|
|
{
|
|
builderImage = new CBuilderImages(uni_fill.fill, null, oImageShape, oSpPr, oLn, undefined, undefined, undefined, oParagraph, oBullet);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var len2 = s.GetLong();
|
|
|
|
var _end_rec_effect = s.cur + len2;
|
|
|
|
var count_effects = s.GetULong();
|
|
for (var _eff = 0; _eff < count_effects; ++_eff)
|
|
{
|
|
|
|
s.Skip2(1); // type
|
|
var oEffect = this.ReadEffect();
|
|
if(oEffect)
|
|
{
|
|
uni_fill.fill.Effects.push(oEffect);
|
|
}
|
|
}
|
|
s.Seek2(_end_rec_effect);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
s.Skip2(6); // len + start attributes + type
|
|
|
|
var sReadPath = s.GetString2();
|
|
if (this.IsUseFullUrl && this.insertDocumentUrlsData && this.insertDocumentUrlsData.imageMap) {
|
|
var sReadPathNew = this.insertDocumentUrlsData.imageMap[AscCommon.g_oDocumentUrls.mediaPrefix + sReadPath];
|
|
if(sReadPathNew){
|
|
sReadPath = sReadPathNew;
|
|
}
|
|
}
|
|
if(this.IsUseFullUrl) {
|
|
if(window["native"] && window["native"]["CopyTmpToMedia"]){
|
|
if(!(window.documentInfo && window.documentInfo["iscoauthoring"])){
|
|
var sMedia = window["native"]["CopyTmpToMedia"](sReadPath);
|
|
if(typeof sMedia === "string" && sMedia.length > 0){
|
|
sReadPath = sMedia;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
uni_fill.fill.setRasterImageId(sReadPath);
|
|
|
|
// TEST version ---------------
|
|
var _s = sReadPath;
|
|
var indS = _s.lastIndexOf("emf");
|
|
if (indS == -1)
|
|
indS = _s.lastIndexOf("wmf");
|
|
|
|
if (indS != -1 && (indS == (_s.length - 3)))
|
|
{
|
|
_s = _s.substring(0, indS);
|
|
_s += "svg";
|
|
sReadPath = _s;
|
|
uni_fill.fill.setRasterImageId(_s);
|
|
}
|
|
// ----------------------------
|
|
|
|
if (this.IsThemeLoader)
|
|
{
|
|
sReadPath = "theme" + (this.Api.ThemeLoader.CurrentLoadThemeIndex + 1) + "/media/" + sReadPath;
|
|
uni_fill.fill.setRasterImageId(sReadPath);
|
|
}
|
|
|
|
if (this.ImageMapChecker != null)
|
|
{
|
|
let bAddToMap = true;
|
|
if(oImageShape && oImageShape instanceof AscFormat.COleObject)
|
|
{
|
|
if(sReadPath.indexOf(".") === -1)
|
|
{
|
|
bAddToMap = false;
|
|
}
|
|
}
|
|
if(bAddToMap)
|
|
{
|
|
this.ImageMapChecker[sReadPath] = true;
|
|
}
|
|
}
|
|
|
|
if (this.IsUseFullUrl)
|
|
{
|
|
|
|
if(!builderImage)
|
|
{
|
|
builderImage = new CBuilderImages(uni_fill.fill, sReadPath, oImageShape, oSpPr, oLn, undefined, undefined, undefined, oParagraph, oBullet);
|
|
}
|
|
else
|
|
{
|
|
builderImage.Url = sReadPath;
|
|
}
|
|
}
|
|
s.Skip2(1); // end attribute
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.IsUseFullUrl && builderImage)
|
|
{
|
|
this.RebuildImages.push(builderImage);
|
|
}
|
|
s.Seek2(_e2);
|
|
}
|
|
|
|
|
|
this.ReadUniFill = function(oSpPr, oImageShape, oLn, oParagraph, oBullet)
|
|
{
|
|
var s = this.stream;
|
|
var read_start = s.cur;
|
|
var read_end = read_start + s.GetULong() + 4;
|
|
|
|
var uni_fill = new AscFormat.CUniFill();
|
|
|
|
if (s.cur < read_end)
|
|
{
|
|
var _type = s.GetUChar();
|
|
var _e = s.cur + s.GetULong() + 4;
|
|
|
|
switch (_type)
|
|
{
|
|
case c_oAscFill.FILL_TYPE_BLIP:
|
|
{
|
|
s.Skip2(1);
|
|
|
|
uni_fill.setFill(new AscFormat.CBlipFill());
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
s.Skip2(4); // dpi
|
|
break;
|
|
case 1:
|
|
uni_fill.fill.rotWithShape = s.GetBool();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _e)
|
|
{
|
|
var rec = s.GetUChar();
|
|
|
|
switch (rec)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadBlip(uni_fill, oSpPr, oImageShape, oLn, oParagraph, oBullet);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
uni_fill.fill.setSrcRect(this.ReadRect(true));
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var oBlipTile = new AscFormat.CBlipFillTile();
|
|
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oBlipTile.sx = s.GetLong();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
oBlipTile.sy = s.GetLong();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
oBlipTile.tx = s.GetLong();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
oBlipTile.ty = s.GetLong();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
oBlipTile.algn = s.GetUChar();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
oBlipTile.flip = s.GetUChar();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_rec);
|
|
uni_fill.fill.setTile(oBlipTile);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
const stretch = new AscFormat.CBlipFillStretch();
|
|
uni_fill.fill.setStretch(stretch);
|
|
|
|
var _e2 = s.cur + s.GetLong() + 4;
|
|
while (s.cur < _e2)
|
|
{
|
|
var _t = s.GetUChar();
|
|
|
|
switch (_t)
|
|
{
|
|
case 0:
|
|
{
|
|
const fillRect = this.ReadRect(true);
|
|
if (fillRect != null)
|
|
stretch.setFillRect(fillRect);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_e2);
|
|
break;
|
|
}
|
|
case 101:
|
|
{
|
|
var oBuilderImages = this.RebuildImages[this.RebuildImages.length - 1];
|
|
if (this.IsUseFullUrl && oBuilderImages) {
|
|
s.Skip2(4);
|
|
var urlsCount = s.GetUChar();
|
|
for (var i = 0; i < urlsCount; ++i) {
|
|
oBuilderImages.AdditionalUrls.push(s.GetString2());
|
|
}
|
|
} else {
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// пока никаких настроек градиента нет
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case c_oAscFill.FILL_TYPE_GRAD:
|
|
{
|
|
s.Skip2(1);
|
|
|
|
uni_fill.setFill(new AscFormat.CGradFill());
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
s.Skip2(1);
|
|
break;
|
|
case 1:
|
|
uni_fill.fill.rotateWithShape = s.GetBool();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _e)
|
|
{
|
|
var rec = s.GetUChar();
|
|
|
|
switch (rec)
|
|
{
|
|
case 0:
|
|
{
|
|
var _s1 = s.cur;
|
|
var _e1 = _s1 + s.GetULong() + 4;
|
|
|
|
var _count = s.GetULong();
|
|
var colors_ = [];
|
|
for (var i = 0; i < _count; i++)
|
|
{
|
|
if (s.cur >= _e1)
|
|
break;
|
|
|
|
s.Skip2(1); // type
|
|
s.Skip2(4); // len
|
|
|
|
var _gs = new AscFormat.CGs();
|
|
|
|
s.Skip2(1); // start attr
|
|
s.Skip2(1); // pos type
|
|
let pos = s.GetLong();
|
|
pos = AscCommon.clampNumber(pos, 0, 100000);
|
|
_gs.pos = pos;
|
|
|
|
s.Skip2(1); // end attr
|
|
|
|
s.Skip2(1);
|
|
_gs.color = this.ReadUniColor();
|
|
|
|
colors_[colors_.length] = _gs;
|
|
}
|
|
|
|
s.Seek2(_e1);
|
|
colors_.sort(function(a,b){return a.pos- b.pos;});
|
|
|
|
for(var z = 0; z < colors_.length; ++z)
|
|
{
|
|
uni_fill.fill.addColor(colors_[z]);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
uni_fill.fill.setLin(this.ReadGradLin());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
uni_fill.fill.setPath(this.ReadGradPath());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// пока никаких настроек градиента нет
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
if (null != uni_fill.fill.lin && null != uni_fill.fill.path)
|
|
{
|
|
// ms office не открывает такие файлы.
|
|
uni_fill.fill.setPath(null);
|
|
}
|
|
|
|
if(uni_fill.fill.colors.length < 2)
|
|
{
|
|
if(uni_fill.fill.colors.length === 1)
|
|
{
|
|
var oUniColor = uni_fill.fill.colors[0].color;
|
|
uni_fill.fill = new AscFormat.CSolidFill();
|
|
uni_fill.fill.color = oUniColor;
|
|
}
|
|
else
|
|
{
|
|
uni_fill.fill = new AscFormat.CSolidFill();
|
|
uni_fill.fill.color = AscFormat.CreateUniColorRGB(0, 0, 0);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case c_oAscFill.FILL_TYPE_PATT:
|
|
{
|
|
uni_fill.setFill(new AscFormat.CPattFill());
|
|
|
|
s.Skip2(1);
|
|
while (true)
|
|
{
|
|
var _atPF = s.GetUChar();
|
|
if (_atPF == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_atPF)
|
|
{
|
|
case 0:
|
|
{
|
|
uni_fill.fill.setFType(s.GetUChar());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _e)
|
|
{
|
|
var rec = s.GetUChar();
|
|
|
|
switch (rec)
|
|
{
|
|
case 0:
|
|
{
|
|
uni_fill.fill.setFgColor(this.ReadUniColor());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
uni_fill.fill.setBgColor(this.ReadUniColor());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// пока никаких настроек градиента нет
|
|
s.SkipRecord();
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case c_oAscFill.FILL_TYPE_SOLID:
|
|
{
|
|
s.Skip2(1); // type + len
|
|
|
|
uni_fill.setFill(new AscFormat.CSolidFill());
|
|
uni_fill.fill.setColor(this.ReadUniColor());
|
|
if(uni_fill.fill.color && !uni_fill.fill.color.Mods){
|
|
uni_fill.fill.color.setMods(new AscFormat.CColorModifiers());
|
|
}
|
|
break;
|
|
}
|
|
case c_oAscFill.FILL_TYPE_NOFILL:
|
|
{
|
|
uni_fill.setFill(new AscFormat.CNoFill());
|
|
break;
|
|
}
|
|
case c_oAscFill.FILL_TYPE_GRP:
|
|
{
|
|
uni_fill.setFill(new AscFormat.CGrpFill());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(read_end);
|
|
if(!uni_fill.fill){
|
|
return null;
|
|
}
|
|
uni_fill.checkTransparent();
|
|
return uni_fill;
|
|
};
|
|
|
|
this.initAfterBlipFill = function(sReadPath, blipFill)
|
|
{
|
|
if (this.IsUseFullUrl && this.insertDocumentUrlsData && this.insertDocumentUrlsData.imageMap) {
|
|
var sReadPathNew = this.insertDocumentUrlsData.imageMap[AscCommon.g_oDocumentUrls.mediaPrefix + sReadPath];
|
|
if(sReadPathNew){
|
|
sReadPath = sReadPathNew;
|
|
}
|
|
}
|
|
if(this.IsUseFullUrl) {
|
|
if(window["native"] && window["native"]["CopyTmpToMedia"]){
|
|
if(!(window.documentInfo && window.documentInfo["iscoauthoring"])){
|
|
var sMedia = window["native"]["CopyTmpToMedia"](sReadPath);
|
|
if(typeof sMedia === "string" && sMedia.length > 0){
|
|
sReadPath = sMedia;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
blipFill.setRasterImageId(sReadPath);
|
|
|
|
let oApi = Asc.editor || editor;
|
|
if(!oApi.isOpenOOXInBrowser) {
|
|
// TEST version ---------------
|
|
var _s = sReadPath;
|
|
var indS = _s.lastIndexOf("emf");
|
|
if (indS == -1)
|
|
indS = _s.lastIndexOf("wmf");
|
|
|
|
if (indS != -1 && (indS == (_s.length - 3)))
|
|
{
|
|
_s = _s.substring(0, indS);
|
|
_s += "svg";
|
|
sReadPath = _s;
|
|
blipFill.setRasterImageId(_s);
|
|
}
|
|
// ----------------------------
|
|
}
|
|
|
|
if (this.IsThemeLoader)
|
|
{
|
|
sReadPath = "theme" + (this.Api.ThemeLoader.CurrentLoadThemeIndex + 1) + "/media/" + sReadPath;
|
|
blipFill.setRasterImageId(sReadPath);
|
|
}
|
|
|
|
if (this.ImageMapChecker != null)
|
|
this.ImageMapChecker[sReadPath] = true;
|
|
|
|
if (this.IsUseFullUrl)
|
|
this.RebuildImages.push(new CBuilderImages(blipFill, sReadPath));
|
|
}
|
|
// ------------------------------------------
|
|
|
|
// COLOR SCHEME -----------------------------
|
|
|
|
this.ReadExtraColorScheme = function()
|
|
{
|
|
var extra = new AscFormat.ExtraClrScheme();
|
|
|
|
var s = this.stream;
|
|
var _e = s.cur + s.GetULong() + 4;
|
|
|
|
while (s.cur < _e)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
extra.setClrScheme(new AscFormat.ClrScheme());
|
|
this.ReadClrScheme(extra.clrScheme);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
extra.setClrMap(new AscFormat.ClrMap());
|
|
this.ReadClrMap(extra.clrMap);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_e);
|
|
return extra;
|
|
};
|
|
|
|
this.ReadClrScheme = function(clrscheme)
|
|
{
|
|
const t = this;
|
|
var s = this.stream;
|
|
var _e = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attribute
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
clrscheme.setName(s.GetString2());
|
|
}
|
|
|
|
while (s.cur < _e)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
if (_rec === 20)
|
|
{
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
if (!clrscheme.clrSchemeExtLst) {
|
|
clrscheme.clrSchemeExtLst = new AscFormat.CClrSchemeExtLst();
|
|
}
|
|
clrscheme.clrSchemeExtLst.background = new AscFormat.CVarColor();
|
|
clrscheme.clrSchemeExtLst.background.unicolor = t.ReadUniColor();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, this);
|
|
}
|
|
else if (_rec === 21)
|
|
{
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
if (!clrscheme.clrSchemeExtLst) {
|
|
clrscheme.clrSchemeExtLst = new AscFormat.CClrSchemeExtLst();
|
|
}
|
|
let variationClrScheme = new AscFormat.CVariationClrScheme();
|
|
variationClrScheme.fromPPTY(pReader);
|
|
clrscheme.clrSchemeExtLst.variationClrSchemeLst.push(variationClrScheme);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, this);
|
|
}
|
|
else if (_rec === 22)
|
|
{
|
|
clrscheme.clrSchemeExtLst.schemeEnum = this.ReadExtSchemeId();
|
|
}
|
|
else
|
|
{
|
|
clrscheme.addColor(_rec,this.ReadUniColor());
|
|
}
|
|
}
|
|
|
|
s.Seek2(_e);
|
|
};
|
|
|
|
this.ReadExtSchemeId = function()
|
|
{
|
|
let schemeEnum = null;
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readAttributes: AscFormat.CBaseFormatNoIdObject.prototype.readAttributes,
|
|
readAttribute: function(attrType, pReader) {
|
|
if (attrType === 0) {
|
|
schemeEnum = pReader.stream.GetLong();
|
|
} else if(attrType == 1) {
|
|
//todo schemeGUID
|
|
pReader.stream.GetString2();
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}, this);
|
|
return schemeEnum;
|
|
};
|
|
|
|
this.ReadExtScheme = function()
|
|
{
|
|
let schemeEnum = null;
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
schemeEnum = pReader.ReadExtSchemeId();
|
|
}
|
|
return false;
|
|
}
|
|
}, this);
|
|
return schemeEnum;
|
|
};
|
|
|
|
this.ReadClrMap = function(clrmap)
|
|
{
|
|
var s = this.stream;
|
|
var _e = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start sttribute
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
clrmap.setClr(_at, s.GetUChar());
|
|
}
|
|
|
|
s.Seek2(_e);
|
|
};
|
|
|
|
this.ReadClrOverride = function()
|
|
{
|
|
var s = this.stream;
|
|
var _e = s.cur + s.GetULong() + 4;
|
|
|
|
var clr_map = null;
|
|
if (s.cur < _e)
|
|
{
|
|
clr_map = new AscFormat.ClrMap();
|
|
s.Skip2(1); // "0"-rectype
|
|
this.ReadClrMap(clr_map);
|
|
}
|
|
|
|
s.Seek2(_e);
|
|
return clr_map;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
// LINE PROPERTIES --------------------------
|
|
|
|
this.ReadLn = function(spPr)
|
|
{
|
|
var ln = new AscFormat.CLn();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
ln.setAlgn(s.GetUChar());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ln.setCap(s.GetUChar());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
ln.setCmpd(s.GetUChar());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
ln.setW(s.GetLong());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
// themeElements
|
|
ln.setFill(this.ReadUniFill(spPr, null, ln));
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ln.setPrstDash(this.ReadLineDash());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
ln.setJoin(this.ReadLineJoin());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
ln.setHeadEnd(this.ReadLineEnd());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
ln.setTailEnd(this.ReadLineEnd());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return ln;
|
|
};
|
|
|
|
this.ReadLineEnd = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
var endL = new AscFormat.EndArrow();
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
endL.setType(s.GetUChar());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
endL.setW(s.GetUChar());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
endL.setLen(s.GetUChar());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return endL;
|
|
};
|
|
|
|
this.ReadLineDash = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
var _dash = 6; // solid
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_dash = s.GetUChar();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return _dash;
|
|
};
|
|
|
|
this.ReadLineJoin = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
var join = new AscFormat.LineJoin();
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
join.setType(s.GetLong());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
join.setLimit(s.GetLong());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
if( AscFormat.LineJoinType.Empty === join.type ||
|
|
AscFormat.LineJoinType.Round === join.type ||
|
|
AscFormat.LineJoinType.Bevel === join.type ||
|
|
AscFormat.LineJoinType.Miter === join.type ||
|
|
null === join.type) {
|
|
return join;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
// SLIDE MASTER -----------------------------
|
|
|
|
this.ReadSlideMaster = function()
|
|
{
|
|
var master = new MasterSlide(this.presentation, null);
|
|
this.ClearConnectedObjects();
|
|
this.TempMainObject = master;
|
|
|
|
var s = this.stream;
|
|
|
|
s.Skip2(1); // type
|
|
var end = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
master.setPreserve(s.GetBool());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < end)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
var cSld = new AscFormat.CSld(master);
|
|
this.ReadCSld(cSld);
|
|
AscCommonSlide.fFillFromCSld(master, cSld);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var clrMap = new AscFormat.ClrMap();
|
|
this.ReadClrMap(clrMap);
|
|
master.setClMapOverride(clrMap);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var _transition = this.ReadTransition();
|
|
master.applyTransition(_transition);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var oTiming = new AscFormat.CTiming();
|
|
oTiming.fromPPTY(this);
|
|
master.setTiming(oTiming);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
master.setHF(this.ReadHF());
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
master.setTxStyles(this.ReadTxStyles());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(end);
|
|
this.TempMainObject = null;
|
|
this.AssignConnectedObjects();
|
|
return master;
|
|
};
|
|
|
|
this.ReadTxStyles = function()
|
|
{
|
|
var txStyles = new AscFormat.CTextStyles();
|
|
|
|
var s = this.stream;
|
|
var end = s.cur + s.GetULong() + 4;
|
|
|
|
while (s.cur < end)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
txStyles.titleStyle = this.ReadTextListStyle();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
txStyles.bodyStyle = this.ReadTextListStyle();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
txStyles.otherStyle = this.ReadTextListStyle();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(end);
|
|
return txStyles;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
// SLIDE LAYOUT -----------------------------
|
|
|
|
this.ReadSlideLayout = function()
|
|
{
|
|
var layout = new SlideLayout(null);
|
|
this.ClearConnectedObjects();
|
|
this.TempMainObject = layout;
|
|
|
|
var s = this.stream;
|
|
|
|
s.Skip2(1); // type
|
|
var end = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
layout.setMatchingName(s.GetString2());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
layout.setPreserve(s.GetBool());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
layout.setShowPhAnim(s.GetBool());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
layout.setShowMasterSp(s.GetBool());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
layout.userDrawn = s.GetBool();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
layout.setType(s.GetUChar());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < end)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
var cSld = new AscFormat.CSld(layout);
|
|
this.ReadCSld(cSld);
|
|
AscCommonSlide.fFillFromCSld(layout, cSld);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
layout.setClMapOverride(this.ReadClrOverride());
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
var _transition = this.ReadTransition();
|
|
layout.applyTransition(_transition);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var oTiming = new AscFormat.CTiming();
|
|
oTiming.fromPPTY(this);
|
|
layout.setTiming(oTiming);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
layout.setHF(this.ReadHF());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(end);
|
|
this.TempMainObject = null;
|
|
this.AssignConnectedObjects();
|
|
return layout;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
// SLIDE ------------------------------------
|
|
|
|
this.ReadSlide = function(sldIndex)
|
|
{
|
|
var slide = new Slide(this.presentation, null, sldIndex);
|
|
this.ClearConnectedObjects();
|
|
this.TempMainObject = slide;
|
|
|
|
var s = this.stream;
|
|
s.Skip2(1); // type
|
|
var end = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
slide.setShow(s.GetBool());
|
|
else if (1 == _at)
|
|
slide.setShowPhAnim(s.GetBool());
|
|
else if (2 == _at)
|
|
slide.setShowMasterSp(s.GetBool());
|
|
}
|
|
|
|
while (s.cur < end)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
var cSld = new AscFormat.CSld(slide);
|
|
this.ReadCSld(cSld);
|
|
AscCommonSlide.fFillFromCSld(slide, cSld);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
slide.setClMapOverride(this.ReadClrOverride());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var _transition = this.ReadTransition();
|
|
slide.applyTransition(_transition);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var oTiming = new AscFormat.CTiming();
|
|
oTiming.fromPPTY(this);
|
|
slide.setTiming(oTiming);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
this.ReadComments(slide.writecomments);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
slide.Load_Comments(this.presentation.CommentAuthors);
|
|
|
|
s.Seek2(end);
|
|
this.TempMainObject = null;
|
|
this.AssignConnectedObjects();
|
|
return slide;
|
|
};
|
|
|
|
this.ReadComments = function(writecomments)
|
|
{
|
|
var s = this.stream;
|
|
var end2 = s.cur + s.GetLong() + 4;
|
|
while (s.cur < end2)
|
|
{
|
|
var _rec2 = s.GetUChar();
|
|
switch (_rec2)
|
|
{
|
|
case 0:
|
|
{
|
|
s.Skip2(4); // len
|
|
var lCount = s.GetULong();
|
|
|
|
for (var i = 0; i < lCount; i++)
|
|
{
|
|
s.Skip2(1);
|
|
|
|
var _comment = new AscCommon.CWriteCommentData();
|
|
|
|
var _end_rec3 = s.cur + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
while (true)
|
|
{
|
|
var _at3 = s.GetUChar();
|
|
if (_at3 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at3)
|
|
{
|
|
case 0:
|
|
_comment.WriteAuthorId = s.GetLong();
|
|
break;
|
|
case 1:
|
|
_comment.WriteTime = s.GetString2();
|
|
break;
|
|
case 2:
|
|
_comment.WriteCommentId = s.GetLong();
|
|
break;
|
|
case 3:
|
|
_comment.x = s.GetLong();
|
|
break;
|
|
case 4:
|
|
_comment.y = s.GetLong();
|
|
break;
|
|
case 5:
|
|
_comment.WriteText = s.GetString2();
|
|
break;
|
|
case 6:
|
|
_comment.WriteParentAuthorId = s.GetLong();
|
|
break;
|
|
case 7:
|
|
_comment.WriteParentCommentId = s.GetLong();
|
|
break;
|
|
case 8:
|
|
_comment.AdditionalData = s.GetString2();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec3)
|
|
{
|
|
var _rec3 = s.GetUChar();
|
|
switch (_rec3)
|
|
{
|
|
case 0:
|
|
{
|
|
var _end_rec4 = s.cur + s.GetLong() + 4;
|
|
s.Skip2(1); // start attributes
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 9: { _comment.timeZoneBias = s.GetLong(); break; }
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
s.Seek2(_end_rec4);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec3);
|
|
|
|
_comment.Calculate2();
|
|
writecomments.push(_comment);
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(end2);
|
|
};
|
|
|
|
this.ReadTransition = function()
|
|
{
|
|
var _transition = new Asc.CAscSlideTransition();
|
|
_transition.setDefaultParams();
|
|
|
|
var s = this.stream;
|
|
var end = s.cur + s.GetULong() + 4;
|
|
|
|
if (s.cur == end)
|
|
return _transition;
|
|
|
|
s.Skip2(1); // attribute start
|
|
var _presentDuration = false;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
{
|
|
_transition.SlideAdvanceOnMouseClick = s.GetBool();
|
|
}
|
|
else if (1 == _at)
|
|
{
|
|
_transition.SlideAdvanceAfter = true;
|
|
_transition.SlideAdvanceDuration = s.GetULong();
|
|
}
|
|
else if (2 == _at)
|
|
{
|
|
_transition.TransitionDuration = s.GetULong();
|
|
_presentDuration = true;
|
|
}
|
|
else if (3 == _at)
|
|
{
|
|
var _spd = s.GetUChar();
|
|
if (!_presentDuration)
|
|
{
|
|
_transition.TransitionDuration = 500;
|
|
if (_spd == 1)
|
|
_transition.TransitionDuration = 750;
|
|
else if (_spd == 2)
|
|
_transition.TransitionDuration = 1000;
|
|
}
|
|
}
|
|
}
|
|
|
|
while (s.cur < end)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
var _type = "";
|
|
var _paramNames = [];
|
|
var _paramValues = [];
|
|
|
|
var _end_rec2 = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
_type = s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_paramNames.push(s.GetString2());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
_paramValues.push(s.GetString2());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
_transition.parseXmlParameters(_type, _paramNames, _paramValues);
|
|
s.Seek2(_end_rec2);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(end);
|
|
return _transition;
|
|
};
|
|
|
|
this.ReadHF = function()
|
|
{
|
|
var hf = new AscFormat.HF();
|
|
|
|
var s = this.stream;
|
|
var _e = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
hf.setDt(s.GetBool());
|
|
else if (1 == _at)
|
|
hf.setFtr(s.GetBool());
|
|
else if (2 == _at)
|
|
hf.setHdr(s.GetBool());
|
|
else if (3 == _at)
|
|
hf.setSldNum(s.GetBool());
|
|
}
|
|
|
|
s.Seek2(_e);
|
|
return hf;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
this.ReadNoteMaster = function()
|
|
{
|
|
var oNotesMaster = new AscCommonSlide.CNotesMaster();
|
|
this.ClearConnectedObjects();
|
|
this.TempMainObject = oNotesMaster;
|
|
this.stream.Skip2(1); // type
|
|
var end = this.stream.cur + this.stream.GetLong() + 4;
|
|
while(this.stream.cur < end){
|
|
var at = this.stream.GetUChar();
|
|
switch (at)
|
|
{
|
|
case 0:
|
|
{
|
|
var cSld = new AscFormat.CSld(oNotesMaster);
|
|
this.ReadCSld(cSld);
|
|
for(var i = 0; i < cSld.spTree.length; ++i){
|
|
oNotesMaster.addToSpTreeToPos(i, cSld.spTree[i]);
|
|
}
|
|
if(cSld.Bg)
|
|
{
|
|
oNotesMaster.changeBackground(cSld.Bg);
|
|
}
|
|
oNotesMaster.setCSldName(cSld.name);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
let clrMap = new AscFormat.ClrMap();
|
|
this.ReadClrMap(clrMap);
|
|
oNotesMaster.setClrMap(clrMap);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
oNotesMaster.setHF(this.ReadHF());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
oNotesMaster.setNotesStyle(this.ReadTextListStyle());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
this.stream.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.stream.Seek2(end);
|
|
this.TempMainObject = null;
|
|
this.AssignConnectedObjects()
|
|
return oNotesMaster;
|
|
};
|
|
|
|
this.ReadNote = function()
|
|
{
|
|
var oNotes = new AscCommonSlide.CNotes();
|
|
this.ClearConnectedObjects()
|
|
this.TempMainObject = oNotes;
|
|
var _s = this.stream;
|
|
_s.Skip2(1); // type
|
|
var _end = _s.cur + _s.GetLong() + 4;
|
|
|
|
_s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at = _s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
oNotes.setShowMasterPhAnim(_s.GetBool());
|
|
else if (1 == _at)
|
|
oNotes.setShowMasterSp(_s.GetBool());
|
|
}
|
|
|
|
while (_s.cur < _end)
|
|
{
|
|
var _rec = _s.GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
var cSld = new AscFormat.CSld(oNotes);
|
|
this.ReadCSld(cSld);
|
|
for(var i = 0; i < cSld.spTree.length; ++i){
|
|
oNotes.addToSpTreeToPos(i, cSld.spTree[i]);
|
|
}
|
|
if(cSld.Bg)
|
|
{
|
|
oNotes.changeBackground(cSld.Bg);
|
|
}
|
|
oNotes.setCSldName(cSld.name);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
oNotes.setClMapOverride(this.ReadClrOverride());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
_s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.TempMainObject = null;
|
|
_s.Seek2(_end);
|
|
this.AssignConnectedObjects();
|
|
return oNotes;
|
|
};
|
|
|
|
this.ReadCSld = function(csld)
|
|
{
|
|
var s = this.stream;
|
|
var _end_rec = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
csld.name = s.GetString2();
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
// themeElements
|
|
csld.Bg = this.ReadBg();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
csld.spTree = this.ReadGroupShapeMain();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.Seek2(_end_rec);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadBg = function()
|
|
{
|
|
var bg = new AscFormat.CBg();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
bg.bwMode = s.GetUChar();
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
// themeElements
|
|
bg.bgPr = this.ReadBgPr();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
bg.bgRef = this.ReadStyleRef();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return bg;
|
|
};
|
|
|
|
this.ReadBgPr = function()
|
|
{
|
|
var bgpr = new AscFormat.CBgPr();
|
|
|
|
var s = this.stream;
|
|
var _end_rec = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
bgpr.shadeToTitle = s.GetBool();
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
// themeElements
|
|
bgpr.Fill = this.ReadUniFill();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return bgpr;
|
|
};
|
|
|
|
this.ReadStyleRef = function()
|
|
{
|
|
var ref = new AscFormat.StyleRef();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
ref.setIdx(s.GetLong());
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
// themeElements
|
|
ref.setColor(this.ReadUniColor());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return ref;
|
|
};
|
|
|
|
this.ReadFontRef = function()
|
|
{
|
|
var ref = new AscFormat.FontRef();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
ref.setIdx(s.GetUChar());
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
// themeElements
|
|
ref.setColor(this.ReadUniColor());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return ref;
|
|
};
|
|
|
|
// THEME ------------------------------------
|
|
|
|
this.ReadTheme = function()
|
|
{
|
|
var theme = new AscFormat.CTheme();
|
|
theme.presentation = this.presentation;
|
|
|
|
var s = this.stream;
|
|
var type = s.GetUChar();
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
theme.setName(s.GetString2());
|
|
else if (1 == _at)
|
|
theme.setIsThemeOverride(s.GetBool());
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
// themeElements
|
|
var themeElements = new AscFormat.ThemeElements(theme);
|
|
this.ReadThemeElements(themeElements);
|
|
theme.setFontScheme(themeElements.fontScheme);
|
|
theme.setFormatScheme(themeElements.fmtScheme);
|
|
theme.setColorScheme(themeElements.clrScheme);
|
|
theme.setThemeExt(themeElements.themeExt);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
theme.setSpDef(this.ReadDefaultShapeProperties());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
theme.setLnDef(this.ReadDefaultShapeProperties());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
theme.setTxDef(this.ReadDefaultShapeProperties());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _len = s.GetULong();
|
|
for (var i = 0; i < _len; i++)
|
|
{
|
|
s.Skip2(1); // type
|
|
theme.extraClrSchemeLst[i] = this.ReadExtraColorScheme();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return theme;
|
|
};
|
|
|
|
this.ReadThemeElements = function(thelems)
|
|
{
|
|
let t = this;
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadClrScheme(thelems.clrScheme);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
this.ReadFontScheme(thelems.fontScheme);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
this.ReadFmtScheme(thelems.fmtScheme);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
thelems.themeExt.fmtConnectorScheme = new AscFormat.FmtScheme();
|
|
this.ReadFmtScheme(thelems.themeExt.fmtConnectorScheme);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readAttributes: AscFormat.CBaseFormatNoIdObject.prototype.readAttributes,
|
|
readAttribute: function(attrType, pReader) {
|
|
if (attrType === 0) {
|
|
thelems.themeExt.fillStyles.push({pattern: pReader.stream.GetULong()});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, t);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, this);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readAttributes: AscFormat.CBaseFormatNoIdObject.prototype.readAttributes,
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
const lineStyle = new AscFormat.CLineStyle();
|
|
lineStyle.fromPPTY(pReader);
|
|
thelems.themeExt.lineStyles.fmtConnectorSchemeLineStyles.push(lineStyle);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, t);
|
|
return true;
|
|
} else if (elementType === 1) {
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
const lineStyle = new AscFormat.CLineStyle();
|
|
lineStyle.fromPPTY(pReader);
|
|
thelems.themeExt.lineStyles.fmtSchemeLineStyles.push(lineStyle);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, t);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, this);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
const fontProps = new AscFormat.CFontProps();
|
|
fontProps.fromPPTY(pReader);
|
|
thelems.themeExt.fontStylesGroup.connectorFontStyles.push(fontProps);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, t);
|
|
return true;
|
|
} else if (elementType === 1) {
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
const fontProps = new AscFormat.CFontProps();
|
|
fontProps.fromPPTY(pReader);
|
|
thelems.themeExt.fontStylesGroup.fontStyles.push(fontProps);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, t);
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, this);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
|
|
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
|
|
readChild: function(elementType, pReader) {
|
|
if (elementType === 0) {
|
|
const variationStyleScheme = new AscFormat.CVariationStyleScheme();
|
|
variationStyleScheme.fromPPTY(pReader);
|
|
thelems.themeExt.variationStyleSchemeLst.push(variationStyleScheme);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}, this);
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
thelems.themeExt.themeSchemeSchemeEnum = this.ReadExtScheme();
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
thelems.themeExt.fmtSchemeExSchemeEnum = this.ReadExtScheme();
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
if (!thelems.themeExt)
|
|
{
|
|
thelems.themeExt = new AscFormat.CThemeExt();
|
|
}
|
|
thelems.themeExt.fmtConnectorSchemeExSchemeEnum = this.ReadExtScheme();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadFontScheme = function(fontscheme)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
fontscheme.setName(s.GetString2());
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadFontCollection(fontscheme.majorFont);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
this.ReadFontCollection(fontscheme.minorFont);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadFontCollection = function(fontcolls)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
fontcolls.setLatin(this.ReadTextFontTypeface());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
fontcolls.setEA(this.ReadTextFontTypeface());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
fontcolls.setCS(this.ReadTextFontTypeface());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadTextFontTypeface = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var charset = "";
|
|
var panose = "";
|
|
var pitchFamily = "";
|
|
var typeface = "";
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
charset = s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
panose = s.GetString2();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
pitchFamily = s.GetString2();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
typeface = s.GetString2();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
|
|
return typeface;
|
|
};
|
|
|
|
this.ReadFmtScheme = function(fmt)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
fmt.setName(s.GetString2());
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1); // type
|
|
fmt.fillStyleLst[i] = this.ReadUniFill();
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1); // type1
|
|
fmt.lnStyleLst[i] = this.ReadLn();
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _c = s.GetULong();
|
|
for (let i = 0; i < _c; i += 1) {
|
|
s.Skip2(1);
|
|
fmt.effectStyleLst[i] = new AscFormat.CEffectStyle();
|
|
fmt.effectStyleLst[i].fromPPTY(this);
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1); // type
|
|
fmt.bgFillStyleLst[i] = this.ReadUniFill();
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadDefaultShapeProperties = function()
|
|
{
|
|
var def = new AscFormat.DefaultShapeDefinition();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadSpPr(def.spPr);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
|
|
// bodyPr
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
|
|
// textstyles
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
def.style = this.ReadShapeStyle();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return def;
|
|
};
|
|
|
|
this.ReadEffectLst = function()
|
|
{
|
|
var s = this.stream;
|
|
s.GetULong();
|
|
s.GetUChar();
|
|
var nRecStart = s.cur;
|
|
var nRecLen = s.GetLong();
|
|
var nRecEnd = nRecStart + nRecLen + 4;
|
|
var oEffectLst = new AscFormat.CEffectLst();
|
|
|
|
while (s.cur < nRecEnd)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
oEffectLst.blur = this.ReadBlur();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
oEffectLst.fillOverlay = this.ReadFillOverlay();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
oEffectLst.glow = this.ReadGlow();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
oEffectLst.innerShdw = this.ReadInnerShdw();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
oEffectLst.outerShdw = this.ReadOuterShdw();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
oEffectLst.prstShdw = this.ReadPrstShdw();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
oEffectLst.reflection = this.ReadReflection();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
oEffectLst.softEdge = this.ReadSoftEdge();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(nRecEnd);
|
|
return oEffectLst;
|
|
};
|
|
|
|
this.ReadEffectProperties = function()
|
|
{
|
|
var s = this.stream;
|
|
var pos = s.cur;
|
|
var nLength = s.GetLong();
|
|
if(nLength === 0)
|
|
{
|
|
return null;
|
|
}
|
|
var type = s.GetUChar();
|
|
s.Seek2(pos);
|
|
var oEffectProperties = new AscFormat.CEffectProperties();
|
|
if(type === 1)
|
|
{
|
|
oEffectProperties.EffectLst = this.ReadEffectLst();
|
|
}
|
|
else
|
|
{
|
|
|
|
oEffectProperties.EffectDag = this.ReadEffectDag();
|
|
}
|
|
return oEffectProperties;
|
|
};
|
|
|
|
this.ReadSpPr = function(spPr)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
spPr.setBwMode(s.GetUChar());
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
spPr.setXfrm(this.ReadXfrm());
|
|
spPr.xfrm.setParent(spPr);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
spPr.setGeometry(this.ReadGeometry(spPr.xfrm));
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
spPr.setFill(this.ReadUniFill(spPr, null, null));
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
spPr.setLn(this.ReadLn(spPr));
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
spPr.setEffectPr(this.ReadEffectProperties());
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadGrSpPr = function(spPr)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
spPr.setBwMode(s.GetUChar());
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
spPr.setXfrm(this.ReadXfrm());
|
|
spPr.xfrm.setParent(spPr);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
spPr.setFill(this.ReadUniFill(spPr, null, null));
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadXfrm = function()
|
|
{
|
|
var ret = new AscFormat.CXfrm();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
ret.setOffX(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ret.setOffY(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
ret.setExtX(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
ret.setExtY(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
ret.setChOffX(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
ret.setChOffY(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
ret.setChExtX(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
ret.setChExtY(s.GetLong() / c_dScalePPTXSizes);
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
ret.setFlipH(s.GetBool());
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
ret.setFlipV(s.GetBool());
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
ret.setRot((s.GetLong()/60000)*Math.PI/180);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return ret;
|
|
};
|
|
|
|
this.ReadSignatureLine = function()
|
|
{
|
|
var ret = new AscFormat.CSignatureLine();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.GetBool();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.GetUChar();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
ret.id = s.GetString2();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
s.GetBool();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
s.GetString2();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
ret.showDate = s.GetBool();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
ret.instructions = s.GetString2();
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
s.GetBool();
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
s.GetString2();
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
ret.signer = s.GetString2();
|
|
break;
|
|
}
|
|
case 11:
|
|
{
|
|
ret.signer2 = s.GetString2();
|
|
break;
|
|
}
|
|
case 12:
|
|
{
|
|
ret.email = s.GetString2();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return ret;
|
|
};
|
|
|
|
this.ReadShapeStyle = function()
|
|
{
|
|
var def = new AscFormat.CShapeStyle();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
def.setLnRef(this.ReadStyleRef());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
def.setFillRef(this.ReadStyleRef());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
def.setEffectRef(this.ReadStyleRef());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
def.setFontRef(this.ReadFontRef());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return def;
|
|
};
|
|
|
|
this.ReadOleInfo = function(ole)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
var dxaOrig = 0;
|
|
var dyaOrig = 0;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
ole.setApplicationId(s.GetString2());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ole.setData(s.GetString2());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
dxaOrig = s.GetULong();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
dyaOrig = s.GetULong();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
const drawAspect = s.GetUChar();
|
|
ole.setDrawAspect(drawAspect);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
s.GetUChar();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
s.GetUChar();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
ole.setObjectFile(s.GetString2());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
var oleType = null;
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 1:
|
|
{
|
|
s.GetLong();//length
|
|
oleType = s.GetUChar();
|
|
ole.setOleType(oleType);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
|
|
var binary_length;
|
|
switch(oleType)
|
|
{
|
|
case 0:
|
|
{
|
|
binary_length = s.GetULong();
|
|
ole.setBinaryData(s.data.slice(s.cur, s.cur + binary_length));
|
|
s.Seek2(s.cur + binary_length);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ole.setObjectFile("maskFile.docx");
|
|
binary_length = s.GetULong();
|
|
ole.setBinaryData(s.data.slice(s.cur, s.cur + binary_length));
|
|
s.Seek2(s.cur + binary_length);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
ole.setObjectFile("maskFile.xlsx");
|
|
binary_length = s.GetULong();
|
|
ole.setBinaryData(s.data.slice(s.cur, s.cur + binary_length));
|
|
s.Seek2(s.cur + binary_length);
|
|
break;
|
|
}
|
|
case 4://Equation
|
|
{
|
|
binary_length = s.GetLong();//length
|
|
var type2 = s.GetUChar();
|
|
if (AscCommonWord.c_oSer_OMathContentType.OMath === type2)
|
|
{
|
|
var oReadResult = new AscCommonWord.DocReadResult(null);
|
|
var oMathPara = this.ReadMathObject(s, oReadResult, new AscWord.Paragraph(null, true));
|
|
ole.setMathObject(oMathPara);
|
|
}
|
|
else
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (dxaOrig > 0 && dyaOrig > 0) {
|
|
var ratio = 4 / 3 / 20;//twips to px
|
|
ole.setPixSizes(ratio * dxaOrig, ratio * dyaOrig);
|
|
}
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadMathObject = function(oStream, oReadResult, oParagraph)
|
|
{
|
|
var length2 = oStream.GetLong();
|
|
var _stream = new AscCommon.FT_Stream2();
|
|
_stream.data = oStream.data;
|
|
_stream.pos = oStream.pos;
|
|
_stream.cur = oStream.cur;
|
|
_stream.size = oStream.size;
|
|
var boMathr = new Binary_oMathReader(_stream, oReadResult, null);
|
|
var oMathPara = new ParaMath();
|
|
boMathr.bcr.Read1(length2, function(t, l){
|
|
return boMathr.ReadMathArg(t,l,oMathPara.Root,oParagraph);
|
|
});
|
|
oMathPara.Root.Correct_Content(true);
|
|
return oMathPara;
|
|
};
|
|
|
|
this.ReadGeometry = function(_xfrm)
|
|
{
|
|
var geom = null;
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
if (s.cur < _end_rec)
|
|
{
|
|
var _t = s.GetUChar();
|
|
|
|
if (1 == _t)
|
|
{
|
|
// preset shape
|
|
|
|
var _len = s.GetULong();
|
|
var _s = s.cur;
|
|
var _e = _s + _len;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
{
|
|
var tmpStr = s.GetString2();
|
|
geom = AscFormat.CreateGeometry(tmpStr);
|
|
geom.isLine = tmpStr == "line";
|
|
geom.setPreset(tmpStr);
|
|
}
|
|
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _e)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadGeomAdj(geom);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (2 == _t)
|
|
{
|
|
var _len = s.GetULong();
|
|
var _s = s.cur;
|
|
var _e = _s + _len;
|
|
|
|
geom = AscFormat.CreateGeometry("");
|
|
geom.preset = null;
|
|
while (s.cur < _e)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadGeomAdj(geom);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
this.ReadGeomGd(geom);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
this.ReadGeomAh(geom);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
this.ReadGeomCxn(geom);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
this.ReadGeomPathLst(geom, _xfrm);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
this.ReadGeomRect(geom);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return geom;
|
|
};
|
|
|
|
this.ReadGeomAdj = function(geom)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(6); // type + len + start attributes
|
|
|
|
var arr = [];
|
|
var cp = 0;
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (cp == 1)
|
|
arr[cp] = s.GetLong();
|
|
else
|
|
arr[cp] = s.GetString2();
|
|
cp++;
|
|
}
|
|
|
|
if (arr.length >= 3)
|
|
geom.AddAdj(arr[0], arr[1], arr[2]);
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadGeomGd = function(geom)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(6); // type + len + start attributes
|
|
|
|
var arr = [];
|
|
var cp = 0;
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (cp == 1)
|
|
arr[cp] = s.GetLong();
|
|
else
|
|
arr[cp] = s.GetString2();
|
|
cp++;
|
|
}
|
|
|
|
geom.AddGuide(arr[0], arr[1], arr[2], arr[3], arr[4]);
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadGeomAh = function(geom)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
var _type1 = s.GetUChar();
|
|
s.Skip2(4); // len
|
|
var _type = s.GetUChar();
|
|
s.Skip2(5); // len + start attributes
|
|
|
|
var arr = [];
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
arr[_at] = s.GetString2();
|
|
}
|
|
|
|
if (1 == _type)
|
|
geom.AddHandlePolar(arr[2], arr[6], arr[4], arr[3], arr[7], arr[5], arr[0], arr[1]);
|
|
else
|
|
geom.AddHandleXY(arr[2], arr[6], arr[4], arr[3], arr[7], arr[5], arr[0], arr[1]);
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadGeomCxn = function(geom)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
var _type = s.GetUChar();
|
|
s.Skip2(5); // len + start attributes
|
|
|
|
var arr = [];
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
arr[_at] = s.GetString2();
|
|
}
|
|
|
|
geom.AddCnx(arr[2], arr[0], arr[1]);
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadGeomRect = function(geom)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
var arr = [];
|
|
arr[0] = "l";
|
|
arr[1] = "t";
|
|
arr[2] = "r";
|
|
arr[3] = "b";
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
arr[_at] = s.GetString2();
|
|
}
|
|
|
|
geom.AddRect(arr[0], arr[1], arr[2], arr[3]);
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadGeomPathLst = function(geom, _xfrm)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var _c = s.GetULong();
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
var _type = s.GetUChar();
|
|
var _len = s.GetULong();
|
|
|
|
var _s = s.cur;
|
|
var _e = _s + _len;
|
|
s.Skip2(1); // start attributes
|
|
|
|
var extrusionOk = false;
|
|
var fill = 5;
|
|
var stroke = true;
|
|
var w = undefined;
|
|
var h = undefined;
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
extrusionOk = s.GetBool();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
fill = s.GetUChar();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
h = s.GetLong();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
stroke = s.GetBool();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
w = s.GetLong();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
geom.AddPathCommand(0, extrusionOk, (fill == 4) ? "none" : "norm", stroke, w, h);
|
|
var isKoords = false;
|
|
|
|
while (s.cur < _e)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.Skip2(4); // len
|
|
|
|
var _cc = s.GetULong();
|
|
|
|
for (var j = 0; j < _cc; j++)
|
|
{
|
|
s.Skip2(5); // type + len
|
|
isKoords |= this.ReadUniPath2D(geom);
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_e);
|
|
}
|
|
|
|
var _path = geom.pathLst[geom.pathLst.length - 1];
|
|
// if (isKoords && undefined === _path.pathW && undefined === _path.pathH)
|
|
// {
|
|
// if(_xfrm)
|
|
// {
|
|
// _path.pathW = _xfrm.extX * c_dScalePPTXSizes;
|
|
// _path.pathH = _xfrm.extY * c_dScalePPTXSizes;
|
|
// }
|
|
// }
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadUniPath2D = function(geom)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _type = s.GetUChar();
|
|
var _len = s.GetULong();
|
|
|
|
var _s = s.cur;
|
|
var _e = _s + _len;
|
|
|
|
if (3 == _type)
|
|
{
|
|
geom.AddPathCommand(6);
|
|
s.Seek2(_e);
|
|
return;
|
|
}
|
|
|
|
s.Skip2(1);
|
|
|
|
var isKoord = false;
|
|
|
|
var arr = [];
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
arr[_at] = s.GetString2();
|
|
|
|
if (!isKoord && !isNaN(parseInt(arr[_at])))
|
|
isKoord = true;
|
|
}
|
|
|
|
switch (_type)
|
|
{
|
|
case 1:
|
|
{
|
|
geom.AddPathCommand(1, arr[0], arr[1]);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
geom.AddPathCommand(2, arr[0], arr[1]);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
geom.AddPathCommand(6);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
geom.AddPathCommand(5, arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
geom.AddPathCommand(3, arr[0], arr[1], arr[2], arr[3]);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
geom.AddPathCommand(4, arr[0], arr[1], arr[2], arr[3]);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_e);
|
|
|
|
return isKoord;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
this.ReadGraphicObject = function()
|
|
{
|
|
var s = this.stream;
|
|
var _type = s.GetUChar();
|
|
var _object = null;
|
|
|
|
switch (_type)
|
|
{
|
|
case 1:
|
|
{
|
|
_object = this.ReadShape();
|
|
break;
|
|
}
|
|
case 2://pic
|
|
case 6://ole
|
|
case 7://video
|
|
case 8://audio
|
|
{
|
|
_object = this.ReadPic(_type);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
_object = this.ReadCxn();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
_object = this.ReadGroupShape();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
_object = this.ReadGrFrame();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
|
|
return _object;
|
|
};
|
|
|
|
// SHAPE PROPERTIES -------------------------
|
|
|
|
this.ReadShape = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var shape = Asc.editor.isPdfEditor() ? new AscPDF.CPdfShape(this.TempMainObject) : new AscFormat.CShape(this.TempMainObject);
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
shape.setBDeleted(false);
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
shape.setUseBgFill(s.GetBool());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
var txXfrm = null;
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var pr = this.ReadNvUniProp(shape);
|
|
shape.setNvSpPr(pr);
|
|
if(AscFormat.isRealNumber(pr.locks))
|
|
{
|
|
shape.setLocks(pr.locks);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var sp_pr = new AscFormat.CSpPr();
|
|
this.ReadSpPr(sp_pr);
|
|
shape.setSpPr(sp_pr);
|
|
sp_pr.setParent(shape);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
shape.setStyle(this.ReadShapeStyle());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
shape.setTxBody(this.ReadTextBody(shape));
|
|
shape.txBody.setParent(shape);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
txXfrm = this.ReadXfrm();
|
|
shape.setTxXfrm(txXfrm);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
shape.setSignature(this.ReadSignatureLine());
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
if(typeof AscFormat.SmartArt !== undefined)
|
|
{
|
|
s.GetULong();//length
|
|
s.GetUChar();//attr type - 0
|
|
shape.setModelId(s.GetString2());
|
|
}
|
|
else
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
s.GetULong();//length
|
|
s.GetUChar();//attr type - 0
|
|
shape.setFLocksText(s.GetBool());
|
|
break;
|
|
}
|
|
case 0xA1:
|
|
{
|
|
shape.readMacro(s);
|
|
break;
|
|
}
|
|
case 0x64:
|
|
{
|
|
let lenRec = s.GetULong();
|
|
let rIdOverride = s.GetString2();
|
|
this.ResetImageId(shape, rIdOverride);
|
|
break;
|
|
}
|
|
case 0xFF:
|
|
{
|
|
shape.ReadRedactIds(s);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(txXfrm ){
|
|
shape.convertFromSmartArt();
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return shape;
|
|
};
|
|
|
|
this.ResetImageId = function(drawing, rIdOverride) {
|
|
if (this.IsUseFullUrl) {
|
|
for (let idx = 0; idx < this.RebuildImages.length; ++idx) {
|
|
let builderImage = this.RebuildImages[idx];
|
|
if (builderImage.ImageShape === drawing || builderImage.SpPr && builderImage.SpPr.parent === drawing) {
|
|
if (builderImage.BlipFill) {
|
|
builderImage.BlipFill.embed = rIdOverride;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.CheckGroupXfrm = function(oGroup){
|
|
if(!oGroup){
|
|
return;
|
|
}
|
|
oGroup.checkXfrm();
|
|
};
|
|
|
|
this.ReadGroupShape = function(type)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var shape;
|
|
if(type === 9){
|
|
shape = new AscFormat.CLockedCanvas();
|
|
}
|
|
else {
|
|
shape = new AscFormat.CGroupShape();
|
|
}
|
|
shape.setBDeleted(false);
|
|
this.TempGroupObject = shape;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var pr = this.ReadNvUniProp(shape);
|
|
shape.setNvSpPr(pr);
|
|
if(AscFormat.isRealNumber(pr.locks))
|
|
{
|
|
shape.setLocks(pr.locks);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var spPr = new AscFormat.CSpPr();
|
|
this.ReadGrSpPr(spPr);
|
|
shape.setSpPr(spPr);
|
|
spPr.setParent(shape);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _c = s.GetULong();
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1);
|
|
var __len = s.GetULong();
|
|
if (__len == 0)
|
|
continue;
|
|
|
|
var _type = s.GetUChar();
|
|
|
|
var _object = null;
|
|
|
|
switch (_type)
|
|
{
|
|
case 1:
|
|
{
|
|
_object = this.ReadShape();
|
|
if (!IsHiddenObj(_object) && _object.spPr && _object.spPr.xfrm)
|
|
{
|
|
shape.addToSpTree(shape.spTree.length,_object);
|
|
shape.spTree[shape.spTree.length-1].setGroup(shape);
|
|
}
|
|
break;
|
|
}
|
|
case 6:
|
|
case 2:
|
|
case 7:
|
|
case 8:
|
|
{
|
|
_object = this.ReadPic(_type);
|
|
if (!IsHiddenObj(_object) && _object.spPr && _object.spPr.xfrm)
|
|
{
|
|
shape.addToSpTree(shape.spTree.length,_object);
|
|
shape.spTree[shape.spTree.length-1].setGroup(shape);
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
_object = this.ReadCxn();
|
|
if (!IsHiddenObj(_object) && _object.spPr && _object.spPr.xfrm)
|
|
{
|
|
shape.addToSpTree(shape.spTree.length,_object);
|
|
shape.spTree[shape.spTree.length-1].setGroup(shape);
|
|
}
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
_object = this.ReadGroupShape();
|
|
if (!IsHiddenObj(_object) && _object.spPr && _object.spPr.xfrm && _object.spTree.length > 0)
|
|
{
|
|
shape.addToSpTree(shape.spTree.length,_object);
|
|
shape.spTree[shape.spTree.length-1].setGroup(shape);
|
|
this.TempGroupObject = shape;
|
|
}
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
var _ret = null;
|
|
if ("undefined" != typeof(AscFormat.CGraphicFrame))
|
|
_ret = this.ReadGrFrame();
|
|
else
|
|
_ret = this.ReadChartDataInGroup(shape);
|
|
if (null != _ret)
|
|
{
|
|
shape.addToSpTree(shape.spTree.length, _ret);
|
|
shape.spTree[shape.spTree.length-1].setGroup(shape);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 0xFF:
|
|
{
|
|
shape.ReadRedactIds(s);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.CheckGroupXfrm(shape);
|
|
s.Seek2(_end_rec);
|
|
this.TempGroupObject = null;
|
|
return shape;
|
|
};
|
|
|
|
this.IsNoSlideSpTree = function ()
|
|
{
|
|
return this.TempMainObject && AscFormat.isRealNumber(this.TempMainObject.kind) && (this.TempMainObject.kind !== AscFormat.TYPE_KIND.SLIDE);
|
|
};
|
|
this.ReadSpTreeElement = function()
|
|
{
|
|
let s = this.stream;
|
|
|
|
let bIsNoSlideSpTree = this.IsNoSlideSpTree();
|
|
let _type = s.GetUChar();
|
|
let _object;
|
|
switch (_type)
|
|
{
|
|
case 1:
|
|
{
|
|
_object = this.ReadShape();
|
|
if (!IsHiddenObj(_object) || bIsNoSlideSpTree)
|
|
{
|
|
_object.setParent2(this.TempMainObject);
|
|
}
|
|
else
|
|
{
|
|
_object = null;
|
|
}
|
|
break;
|
|
}
|
|
case 6:
|
|
case 2:
|
|
case 7:
|
|
case 8:
|
|
{
|
|
_object = this.ReadPic(_type);
|
|
if(_type === 6 && !_object.checkCorrect())
|
|
{
|
|
_object = null;
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
_object = this.ReadCxn();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
_object = this.ReadGroupShape();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
_object = this.ReadGrFrame();
|
|
break;
|
|
}
|
|
case 0x99:
|
|
{
|
|
_object = this.ReadSpTreeElement();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
if(_object)
|
|
{
|
|
if (!IsHiddenObj(_object) || bIsNoSlideSpTree)
|
|
{
|
|
_object.setParent2(this.TempMainObject);
|
|
}
|
|
else
|
|
{
|
|
_object = null
|
|
}
|
|
}
|
|
let nCurPos = s.cur;
|
|
let nType = s.GetUChar();
|
|
let oAltDrawing = null;
|
|
if(nType === 0x99)
|
|
{
|
|
let nAltContentLen = s.GetULong();
|
|
let nEndPos = s.cur + nAltContentLen;
|
|
if(!_object || !_object.isSupported())
|
|
oAltDrawing = this.ReadSpTreeElement();
|
|
if(oAltDrawing)
|
|
{
|
|
_object = oAltDrawing;
|
|
}
|
|
s.Seek2(nEndPos);
|
|
}
|
|
else
|
|
{
|
|
s.Seek2(nCurPos);
|
|
}
|
|
return _object;
|
|
};
|
|
this.ReadGroupShapeMain = function()
|
|
{
|
|
let s = this.stream;
|
|
|
|
let shapes = [];
|
|
|
|
let _rec_start = s.cur;
|
|
let _end_rec = _rec_start + s.GetULong() + 4;
|
|
let _object;
|
|
|
|
s.Skip2(5); // type SPTREE + len
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _c = s.GetULong();
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1);
|
|
var __len = s.GetULong();
|
|
if (__len == 0)
|
|
continue;
|
|
|
|
_object = this.ReadSpTreeElement();
|
|
|
|
if(_object)
|
|
{
|
|
const objectId = _object.getFormatId();
|
|
const objectCNvProps = _object.getCNvProps();
|
|
if (objectId !== null && objectCNvProps !== null) {
|
|
if (this.map_shapes_by_id[objectCNvProps.id]) {
|
|
objectCNvProps.setId(AscCommon.CreateDurableId());
|
|
}
|
|
}
|
|
shapes[shapes.length] = _object;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return shapes;
|
|
};
|
|
|
|
|
|
this.ReadPic = function(type)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var isOle = (type === 6);
|
|
var pic;
|
|
if (isOle)
|
|
{
|
|
pic = new AscFormat.COleObject(this.TempMainObject)
|
|
}
|
|
else
|
|
{
|
|
if (Asc.editor.isPdfEditor())
|
|
pic = new AscPDF.CPdfImage();
|
|
else
|
|
pic = new AscFormat.CImageShape(this.TempMainObject);
|
|
}
|
|
|
|
pic.setBDeleted(false);
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var sMaskFileName;
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var pr = this.ReadNvUniProp(pic);
|
|
pic.setNvSpPr(pr);
|
|
if(AscFormat.isRealNumber(pr.locks)){
|
|
pic.setLocks(pr.locks);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
pic.setBlipFill(this.ReadUniFill(null, pic, null).fill);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
|
|
var spPr = new AscFormat.CSpPr();
|
|
spPr.setParent(pic);
|
|
this.ReadSpPr(spPr);
|
|
pic.setSpPr(spPr);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
pic.setStyle(this.ReadShapeStyle());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
if(isOle) {
|
|
this.ReadOleInfo(pic);
|
|
} else {
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if(type === 7 || type === 8){//video or audio
|
|
s.GetLong();
|
|
s.GetUChar();//start attributes
|
|
|
|
while(true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
switch (_at2) {
|
|
case 0:
|
|
{
|
|
sMaskFileName = s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.GetBool();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
else{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 0xA1:
|
|
{
|
|
pic.readMacro(s);
|
|
break;
|
|
}
|
|
case 0x64:
|
|
{
|
|
let lenRec = s.GetULong();
|
|
let rIdOverride = s.GetString2();
|
|
this.ResetImageId(pic, rIdOverride);
|
|
break;
|
|
}
|
|
case 0xFF:
|
|
{
|
|
pic.ReadRedactIds(s);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
this.stream.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(type === 7 || type === 8){//video or audio
|
|
if(typeof sMaskFileName === "string" && sMaskFileName.length > 0 &&
|
|
pic.nvPicPr && pic.nvPicPr.nvPr /*&& pic.nvPicPr.nvPr.unimedia*/){
|
|
var oUniMedia = new AscFormat.UniMedia();
|
|
oUniMedia.type = type;
|
|
oUniMedia.media = sMaskFileName;
|
|
pic.nvPicPr.nvPr.setUniMedia(oUniMedia);
|
|
}
|
|
}
|
|
s.Seek2(_end_rec);
|
|
return pic;
|
|
};
|
|
this.ReadCxn = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var shape = false == Asc.editor.isPdfEditor() ? new AscFormat.CConnectionShape() : new AscPDF.CPdfConnectionShape();
|
|
shape.setBDeleted(false);
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var pr = this.ReadNvUniProp(shape);
|
|
shape.setNvSpPr(pr);
|
|
if(AscFormat.isRealNumber(pr.locks)){
|
|
shape.setLocks(pr.locks);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var spPr = new AscFormat.CSpPr();
|
|
spPr.setParent(shape);
|
|
this.ReadSpPr(spPr);
|
|
shape.setSpPr(spPr);
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
shape.setStyle(this.ReadShapeStyle());
|
|
break;
|
|
}
|
|
case 0xA1:
|
|
{
|
|
shape.readMacro(s);
|
|
break;
|
|
}
|
|
case 0xFF:
|
|
{
|
|
shape.ReadRedactIds(s);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.AddConnectedObject(shape);
|
|
s.Seek2(_end_rec);
|
|
return shape;
|
|
};
|
|
|
|
this.ReadChartDataInGroup = function(group)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
this.TempGroupObject = group;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var spid = s.GetString2();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
var _nvGraphicFramePr = null;
|
|
var _xfrm = null;
|
|
var _chart = null;
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_nvGraphicFramePr = this.ReadNvUniProp(AscFormat.ExecuteNoHistory(function () {
|
|
return new AscFormat.CGraphicFrame();
|
|
}, this, []));
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_xfrm = this.ReadXfrm();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var _length = s.GetLong();
|
|
var _pos = s.cur;
|
|
|
|
var _stream = new AscCommon.FT_Stream2();
|
|
_stream.data = s.data;
|
|
_stream.pos = s.pos;
|
|
_stream.cur = s.cur;
|
|
_stream.size = s.size;
|
|
|
|
_chart = new AscFormat.CChartSpace();
|
|
_chart.setBDeleted(false);
|
|
var oBinaryChartReader = new AscCommon.BinaryChartReader(_stream);
|
|
oBinaryChartReader.ExternalReadCT_ChartSpace(_length, _chart, this.presentation);
|
|
_chart.setBDeleted(false);
|
|
if(AscCommon.isRealObject(_nvGraphicFramePr) && AscFormat.isRealNumber(_nvGraphicFramePr.locks))
|
|
{
|
|
_chart.setLocks(_nvGraphicFramePr.locks);
|
|
}
|
|
if(_xfrm)
|
|
{
|
|
if(!_chart.spPr)
|
|
{
|
|
_chart.setSpPr(new AscFormat.CSpPr());
|
|
_chart.spPr.setParent(_chart);
|
|
}
|
|
|
|
_chart.spPr.setXfrm(_xfrm);
|
|
_xfrm.setParent(_chart.spPr);
|
|
}
|
|
|
|
s.Seek2(_pos + _length);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
|
|
this.TempGroupObject = null;
|
|
if (_chart == null || !_chart.hasCharts())
|
|
return null;
|
|
|
|
return _chart;
|
|
};
|
|
|
|
this.ReadGrFrame = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var _graphic_frame = Asc.editor.isPdfEditor() ? new AscPDF.CPdfGraphicFrame() : new AscFormat.CGraphicFrame();
|
|
_graphic_frame.setParent2(this.TempMainObject);
|
|
this.TempGroupObject = _graphic_frame;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var spid = s.GetString2();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
var _nvGraphicFramePr = null;
|
|
var _xfrm = null;
|
|
var _table = null;
|
|
var _chart = null;
|
|
var _slicer = null;
|
|
var _timeslicer = null;
|
|
var _smartArt = null;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_nvGraphicFramePr = this.ReadNvUniProp(_graphic_frame);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_xfrm = this.ReadXfrm();
|
|
// has no rotate in other editors
|
|
if (false == Asc.editor.isPdfEditor()) {
|
|
_xfrm.setRot(0);
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
_table = this.ReadTable(_xfrm, _graphic_frame);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var _length = s.GetLong();
|
|
var _pos = s.cur;
|
|
|
|
if(typeof AscFormat.CChartSpace !== "undefined" && _length)
|
|
{
|
|
var _stream = new AscCommon.FT_Stream2();
|
|
_stream.data = s.data;
|
|
_stream.pos = s.pos;
|
|
_stream.cur = s.cur;
|
|
_stream.size = s.size;
|
|
_chart = Asc.editor.isPdfEditor() ? new AscPDF.CPdfChartSpace() : new AscFormat.CChartSpace();
|
|
_chart.setBDeleted(false);
|
|
AscCommon.pptx_content_loader.ImageMapChecker = this.ImageMapChecker;
|
|
AscCommon.pptx_content_loader.Reader.ImageMapChecker = this.ImageMapChecker;
|
|
var oBinaryChartReader = new AscCommon.BinaryChartReader(_stream);
|
|
oBinaryChartReader.ExternalReadCT_ChartSpace(_length, _chart, this.presentation);
|
|
if(!_chart.hasCharts())
|
|
{
|
|
_chart = null;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_pos + _length);
|
|
break;
|
|
}
|
|
case 5:
|
|
case 6:
|
|
{
|
|
if (typeof AscFormat.CSlicer !== "undefined")
|
|
{
|
|
_slicer = new AscFormat.CSlicer();
|
|
_slicer.fromStream(s);
|
|
}
|
|
else
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 7: // chartEx
|
|
{
|
|
var _length = s.GetLong();
|
|
var _pos = s.cur;
|
|
|
|
if(typeof AscFormat.CChartSpace !== "undefined" && _length)
|
|
{
|
|
var _stream = new AscCommon.FT_Stream2();
|
|
_stream.data = s.data;
|
|
_stream.pos = s.pos;
|
|
_stream.cur = s.cur;
|
|
_stream.size = s.size;
|
|
_chart = new AscFormat.CChartSpace();
|
|
_chart.setBDeleted(false);
|
|
AscCommon.pptx_content_loader.ImageMapChecker = this.ImageMapChecker;
|
|
AscCommon.pptx_content_loader.Reader.ImageMapChecker = this.ImageMapChecker;
|
|
var oBinaryChartReader = new AscCommon.BinaryChartReader(_stream);
|
|
oBinaryChartReader.ExternalReadCT_ChartExSpace(_length, _chart, this.presentation);
|
|
if(!_chart.hasCharts())
|
|
{
|
|
_chart = null;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_pos + _length);
|
|
break;
|
|
}
|
|
case 8://smartArt
|
|
{
|
|
_smartArt = this.ReadSmartArt();
|
|
this.smartarts.push(_smartArt);
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
if (typeof AscFormat.CTimeslicer !== "undefined")
|
|
{
|
|
_timeslicer = new AscFormat.CTimeslicer();
|
|
_timeslicer.fromStream(s);
|
|
}
|
|
else
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 0xA1:
|
|
{
|
|
_graphic_frame.readMacro(s);
|
|
break;
|
|
}
|
|
case 0xFF:
|
|
{
|
|
if (_table) {
|
|
_graphic_frame.ReadRedactIds(s);
|
|
}
|
|
else if (_chart) {
|
|
_chart.ReadRedactIds(s);
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
|
|
this.TempGroupObject = null;
|
|
if (_table == null && _chart == null && _slicer == null && _smartArt == null && _timeslicer == null)
|
|
return null;
|
|
|
|
if (_table != null)
|
|
{
|
|
_graphic_frame.checkEmptySpPrAndXfrm(_xfrm);
|
|
_graphic_frame.setNvSpPr(_nvGraphicFramePr);
|
|
if(AscCommon.isRealObject(_nvGraphicFramePr) && AscFormat.isRealNumber(_nvGraphicFramePr.locks))
|
|
{
|
|
_graphic_frame.setLocks(_nvGraphicFramePr.locks);
|
|
}
|
|
_graphic_frame.setGraphicObject(_table);
|
|
_graphic_frame.setBDeleted(false);
|
|
}
|
|
else if (_chart != null)
|
|
{
|
|
_chart.checkEmptySpPrAndXfrm(_xfrm);
|
|
if(AscCommon.isRealObject(_nvGraphicFramePr) )
|
|
{
|
|
_chart.setNvSpPr(_nvGraphicFramePr);
|
|
if(AscFormat.isRealNumber(_nvGraphicFramePr.locks))
|
|
{
|
|
_chart.setLocks(_nvGraphicFramePr.locks);
|
|
}
|
|
if(_nvGraphicFramePr.cNvPr)
|
|
{
|
|
this.map_shapes_by_id[_nvGraphicFramePr.cNvPr.id] = _chart;
|
|
}
|
|
}
|
|
return _chart;
|
|
}
|
|
else if(_slicer != null)
|
|
{
|
|
_slicer.setBDeleted(false);
|
|
_slicer.checkEmptySpPrAndXfrm(_xfrm);
|
|
if(AscCommon.isRealObject(_nvGraphicFramePr) )
|
|
{
|
|
_slicer.setNvSpPr(_nvGraphicFramePr);
|
|
if(AscFormat.isRealNumber(_nvGraphicFramePr.locks))
|
|
{
|
|
_slicer.setLocks(_nvGraphicFramePr.locks);
|
|
}
|
|
}
|
|
return _slicer;
|
|
}
|
|
else if(_timeslicer != null)
|
|
{
|
|
_timeslicer.setBDeleted(false);
|
|
_timeslicer.checkEmptySpPrAndXfrm(_xfrm);
|
|
if(AscCommon.isRealObject(_nvGraphicFramePr) )
|
|
{
|
|
_timeslicer.setNvSpPr(_nvGraphicFramePr);
|
|
if(AscFormat.isRealNumber(_nvGraphicFramePr.locks))
|
|
{
|
|
_timeslicer.setLocks(_nvGraphicFramePr.locks);
|
|
}
|
|
}
|
|
return _timeslicer;
|
|
}
|
|
else if(_smartArt != null)
|
|
{
|
|
_smartArt.checkEmptySpPrAndXfrm(_xfrm);
|
|
if(AscCommon.isRealObject(_nvGraphicFramePr) )
|
|
{
|
|
_smartArt.setNvSpPr(_nvGraphicFramePr);
|
|
if(AscFormat.isRealNumber(_nvGraphicFramePr.locks))
|
|
{
|
|
_smartArt.setLocks(_nvGraphicFramePr.locks);
|
|
}
|
|
if(_nvGraphicFramePr.cNvPr)
|
|
{
|
|
this.map_shapes_by_id[_nvGraphicFramePr.cNvPr.id] = _smartArt;
|
|
}
|
|
}
|
|
return _smartArt;
|
|
}
|
|
|
|
return _graphic_frame;
|
|
};
|
|
|
|
this.ReadSmartArt = function(CDrawing)
|
|
{
|
|
var s = this.stream;
|
|
var _smartArt;
|
|
if(typeof AscFormat.SmartArt !== "undefined" && !CDrawing)
|
|
{
|
|
_smartArt = Asc.editor.isPdfEditor() ? new AscPDF.CPdfSmartArt() : new AscFormat.SmartArt();
|
|
_smartArt.fromPPTY(this);
|
|
_smartArt.setBDeleted(false);
|
|
_smartArt.generateDefaultStructures();
|
|
_smartArt.checkDataModel();
|
|
_smartArt.checkNodePointsAfterRead();
|
|
_smartArt.correctUngeneratedSmartArtContent();
|
|
}
|
|
else
|
|
{
|
|
//read drawing part of smartArt as a group
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
//no attributes
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
//DiagramDrawing
|
|
_smartArt = this.ReadSmartArtGroup(CDrawing);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_rec);
|
|
_smartArt.setType(_smartArt.getTypeOfSmartArt());
|
|
return _smartArt;
|
|
};
|
|
|
|
this.ReadSmartArtGroup = function(CDrawing)
|
|
{
|
|
var _smartArt;
|
|
var s = this.stream;
|
|
var _rec_start2 = s.cur;
|
|
var _end_rec2 = _rec_start2 + s.GetULong() + 4;
|
|
while (s.cur < _end_rec2)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
switch (_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
//_smartArt = this.ReadGroupShape();
|
|
var shapes = this.ReadGroupShapeMain();
|
|
if (CDrawing) {
|
|
_smartArt = CDrawing;
|
|
} else {
|
|
_smartArt = new AscFormat.CGroupShape();
|
|
}
|
|
_smartArt.setBDeleted(false);
|
|
for(var nSp = 0; nSp < shapes.length; ++nSp)
|
|
{
|
|
var oSp = shapes[nSp];
|
|
_smartArt.addToSpTree(undefined, oSp);
|
|
oSp.setGroup(_smartArt);
|
|
}
|
|
|
|
_smartArt.setParent(this.TempMainObject == null ? this.ParaDrawing : null);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_rec2);
|
|
return _smartArt;
|
|
};
|
|
|
|
this.ReadNvUniProp = function(drawing)
|
|
{
|
|
var prop = new AscFormat.UniNvPr();
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadCNvPr(prop.cNvPr);
|
|
if(AscCommon.isRealObject(drawing))
|
|
{
|
|
this.map_shapes_by_id[prop.cNvPr.id] = drawing;
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
|
|
var end = s.cur + s.GetULong() + 4;
|
|
var locks = 0;
|
|
if(AscCommon.isRealObject(drawing))
|
|
{
|
|
var drawingType = drawing.getObjectType();
|
|
switch(drawingType)
|
|
{
|
|
case AscDFH.historyitem_type_Shape:
|
|
{
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var value;
|
|
switch(_at2)
|
|
{
|
|
case 0:{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.txBox, value);
|
|
break;
|
|
}
|
|
case 1 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noAdjustHandles, value);
|
|
break;
|
|
}
|
|
case 2 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noChangeArrowheads, value);
|
|
break;
|
|
}
|
|
case 3 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noChangeAspect, value);
|
|
break;
|
|
}
|
|
case 4 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noChangeShapeType, value);
|
|
break;
|
|
}
|
|
case 5 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noEditPoints, value);
|
|
break;
|
|
}
|
|
case 6 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noGrp, value);
|
|
break;
|
|
}
|
|
case 7 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noMove, value);
|
|
break;
|
|
}
|
|
case 8 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noResize, value);
|
|
break;
|
|
}
|
|
case 9 :{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noRot, value);
|
|
break;
|
|
}
|
|
case 10:{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noSelect, value);
|
|
break;
|
|
}
|
|
case 11:{
|
|
value = s.GetBool();
|
|
locks = AscFormat.fUpdateLocksValue(locks, AscFormat.LOCKS_MASKS.noTextEdit, value);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
prop.locks = locks;
|
|
break;
|
|
}
|
|
case AscDFH.historyitem_type_GroupShape:
|
|
{
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var value;
|
|
switch(_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeAspect | (value ? AscFormat.LOCKS_MASKS.noChangeAspect << 1 : 0));
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noGrp | (value ? AscFormat.LOCKS_MASKS.noGrp << 1 : 0));
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noMove | (value ? AscFormat.LOCKS_MASKS.noMove << 1 : 0));
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noResize | (value ? AscFormat.LOCKS_MASKS.noResize << 1 : 0));
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noRot | (value ? AscFormat.LOCKS_MASKS.noRot << 1 : 0));
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noSelect | (value ? AscFormat.LOCKS_MASKS.noSelect << 1 : 0));
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noUngrp | (value ? AscFormat.LOCKS_MASKS.noUngrp << 1 : 0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
prop.locks = locks;
|
|
break;
|
|
}
|
|
case AscDFH.historyitem_type_ImageShape:
|
|
{
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var value;
|
|
switch(_at2)
|
|
{
|
|
case 0 :{
|
|
value = s.GetBool();
|
|
break;
|
|
}
|
|
case 1 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noAdjustHandles | (value ? AscFormat.LOCKS_MASKS.noAdjustHandles << 1 : 0));
|
|
break;
|
|
}
|
|
case 2 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeArrowheads | (value ? AscFormat.LOCKS_MASKS.noChangeArrowheads << 1 : 0));
|
|
break;
|
|
}
|
|
case 3 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeAspect | (value ? AscFormat.LOCKS_MASKS.noChangeAspect << 1 : 0));
|
|
break;
|
|
}
|
|
case 4 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeShapeType | (value ? AscFormat.LOCKS_MASKS.noChangeShapeType << 1 : 0));
|
|
break;
|
|
}
|
|
case 5 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noCrop | (value ? AscFormat.LOCKS_MASKS.noCrop << 1 : 0));
|
|
break;
|
|
}
|
|
case 6 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noEditPoints | (value ? AscFormat.LOCKS_MASKS.noEditPoints << 1 : 0));
|
|
break;
|
|
}
|
|
case 7 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noGrp | (value ? AscFormat.LOCKS_MASKS.noGrp << 1 : 0));
|
|
break;
|
|
}
|
|
case 8 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noMove | (value ? AscFormat.LOCKS_MASKS.noMove << 1 : 0));
|
|
break;
|
|
}
|
|
case 9 :{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noResize | (value ? AscFormat.LOCKS_MASKS.noResize << 1 : 0));
|
|
break;
|
|
}
|
|
case 10:{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noRot | (value ? AscFormat.LOCKS_MASKS.noRot << 1 : 0));
|
|
break;
|
|
}
|
|
case 11:{
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noSelect | (value ? AscFormat.LOCKS_MASKS.noSelect << 1 : 0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
prop.locks = locks;
|
|
break;
|
|
}
|
|
case AscDFH.historyitem_type_GraphicFrame:
|
|
case AscDFH.historyitem_type_ChartSpace:
|
|
case AscDFH.historyitem_type_SmartArt:
|
|
{
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var value;
|
|
switch(_at2)
|
|
{
|
|
case 0: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeAspect | (value ? AscFormat.LOCKS_MASKS.noChangeAspect << 1 : 0));
|
|
break;
|
|
}
|
|
case 1: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noDrilldown | (value ? AscFormat.LOCKS_MASKS.noDrilldown << 1 : 0));
|
|
break;
|
|
}
|
|
case 2: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noGrp | (value ? AscFormat.LOCKS_MASKS.noGrp << 1 : 0));
|
|
break;
|
|
}
|
|
case 3: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noMove | (value ? AscFormat.LOCKS_MASKS.noMove << 1 : 0));
|
|
break;
|
|
}
|
|
case 4: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noResize | (value ? AscFormat.LOCKS_MASKS.noResize << 1 : 0));
|
|
break;
|
|
}
|
|
case 5: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noSelect | (value ? AscFormat.LOCKS_MASKS.noSelect << 1 : 0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
prop.locks = locks;
|
|
break;
|
|
}
|
|
case AscDFH.historyitem_type_Cnx:{
|
|
|
|
s.Skip2(1); // attribute start
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
var value;
|
|
switch(_at2)
|
|
{
|
|
case 0: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noAdjustHandles | (value ? AscFormat.LOCKS_MASKS.noAdjustHandles << 1 : 0));
|
|
break;
|
|
}
|
|
case 1: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeArrowheads | (value ? AscFormat.LOCKS_MASKS.noChangeArrowheads << 1 : 0));
|
|
break;
|
|
}
|
|
case 2: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeAspect | (value ? AscFormat.LOCKS_MASKS.noChangeAspect << 1 : 0));
|
|
break;
|
|
}
|
|
case 3: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noChangeShapeType | (value ? AscFormat.LOCKS_MASKS.noChangeShapeType << 1 : 0));
|
|
break;
|
|
}
|
|
case 4: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noEditPoints | (value ? AscFormat.LOCKS_MASKS.noEditPoints << 1 : 0));
|
|
break;
|
|
}
|
|
case 5: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noGrp | (value ? AscFormat.LOCKS_MASKS.noGrp << 1 : 0));
|
|
break;
|
|
}
|
|
case 6: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noMove | (value ? AscFormat.LOCKS_MASKS.noMove << 1 : 0));
|
|
break;
|
|
}
|
|
case 7: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noResize | (value ? AscFormat.LOCKS_MASKS.noResize << 1 : 0));
|
|
break;
|
|
}
|
|
case 8: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noRot | (value ? AscFormat.LOCKS_MASKS.noRot << 1 : 0));
|
|
break;
|
|
}
|
|
case 9: {
|
|
value = s.GetBool();
|
|
locks |= (AscFormat.LOCKS_MASKS.noSelect | (value ? AscFormat.LOCKS_MASKS.noSelect << 1 : 0));
|
|
break;
|
|
}
|
|
case 10:{
|
|
prop.nvUniSpPr.stCnxId = s.GetULong();
|
|
break;
|
|
}
|
|
case 11:{
|
|
prop.nvUniSpPr.stCnxIdx = s.GetULong();
|
|
break;
|
|
}
|
|
case 12:{
|
|
prop.nvUniSpPr.endCnxId = s.GetULong();
|
|
break;
|
|
}
|
|
case 13:{
|
|
prop.nvUniSpPr.endCnxIdx = s.GetULong();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
prop.locks = locks;
|
|
prop.setUniSpPr(prop.nvUniSpPr.copy());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(end);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
this.ReadNvPr(prop.nvPr);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return prop;
|
|
};
|
|
|
|
this.ReadCNvPr = function(cNvPr)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
cNvPr.setId(s.GetLong());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
cNvPr.setName(s.GetString2());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
cNvPr.setIsHidden((1 == s.GetUChar()) ? true : false);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
cNvPr.setTitle(s.GetString2());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
cNvPr.setDescr(s.GetString2());
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
cNvPr.form = s.GetBool();
|
|
break;
|
|
}
|
|
default:{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
while(s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch(_at){
|
|
case 0:{
|
|
cNvPr.setHlinkClick(this.ReadHyperlink());
|
|
break;
|
|
}
|
|
case 1:{
|
|
cNvPr.setHlinkHover(this.ReadHyperlink());
|
|
break;
|
|
}
|
|
default:{
|
|
this.stream.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadTable = function(_xfrm, _graphic_frame)
|
|
{
|
|
if (_xfrm == null)
|
|
{
|
|
this.stream.SkipRecord();
|
|
return null;
|
|
}
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var cols = null;
|
|
var rows = null;
|
|
var _return_to_rows = 0;
|
|
var props = null;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
props = this.ReadTablePr();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.Skip2(4);
|
|
var _len = s.GetULong();
|
|
cols = new Array(_len);
|
|
for (var i = 0; i < _len; i++)
|
|
{
|
|
s.Skip2(7); // type, len + startAttr + 0 (attrType)
|
|
cols[i] = s.GetULong() / 36000;
|
|
s.Skip2(1); // endAttr
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var _end_rec2 = s.cur + s.GetULong() + 4;
|
|
rows = s.GetULong();
|
|
_return_to_rows = s.cur;
|
|
s.Seek2(_end_rec2);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(cols.length === 0)
|
|
{
|
|
cols.push(_xfrm.extX);
|
|
}
|
|
var _table = new CTable(this.presentation.DrawingDocument, _graphic_frame, false, rows, cols.length, cols, true);
|
|
_table.Reset(0, 0, _xfrm.extX, 100000, 0, 0, 1);
|
|
if (null != props)
|
|
{
|
|
var style;
|
|
if(this.map_table_styles[props.style])
|
|
{
|
|
_table.Set_TableStyle(this.map_table_styles[props.style].Id);
|
|
}
|
|
else if (this.presentation && this.presentation.globalTableStyles && this.presentation.globalTableStyles.GetStyleByStyleId(props.style))
|
|
{
|
|
style = this.presentation.globalTableStyles.GetStyleByStyleId(props.style);
|
|
_table.Set_TableStyle(style.GetId());
|
|
}
|
|
_table.Set_Pr(props.props);
|
|
_table.Set_TableLook(props.look);
|
|
}
|
|
_table.SetTableLayout(tbllayout_Fixed);
|
|
|
|
s.Seek2(_return_to_rows);
|
|
|
|
for (var i = 0; i < rows; i++)
|
|
{
|
|
s.Skip2(1); // 0!
|
|
this.ReadTableRow(_table.Content[i]);
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
|
|
return _table;
|
|
};
|
|
|
|
this.ReadTableRow = function(row)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
var fRowHeight = 5;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
fRowHeight = s.GetULong() / 36000;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Skip2(5); // type + len
|
|
var _count = s.GetULong();
|
|
_count = Math.min(_count, row.Content.length);
|
|
for (var i = 0; i < _count; i++)
|
|
{
|
|
s.Skip2(1);
|
|
var bIsNoHMerge = this.ReadCell(row.Content[i]);
|
|
if (bIsNoHMerge === false)
|
|
{
|
|
row.Remove_Cell(i);
|
|
i--;
|
|
_count--;
|
|
}
|
|
var _gridCol = 1;
|
|
if ("number" == typeof (row.Content[i].Pr.GridSpan))
|
|
{
|
|
_gridCol = row.Content[i].Pr.GridSpan;
|
|
}
|
|
|
|
if (_gridCol > (_count - i))
|
|
{
|
|
_gridCol = _count - i;
|
|
row.Content[i].Pr.GridSpan = _gridCol;
|
|
if (1 == row.Content[i].Pr.GridSpan)
|
|
row.Content[i].Pr.GridSpan = undefined;
|
|
}
|
|
|
|
_gridCol--;
|
|
while (_gridCol > 0)
|
|
{
|
|
i++;
|
|
if (i >= _count)
|
|
break;
|
|
|
|
s.Skip2(1);
|
|
this.ReadCell(row.Content[i]);
|
|
|
|
// удаляем
|
|
row.Remove_Cell(i);
|
|
i--;
|
|
_count--;
|
|
|
|
--_gridCol;
|
|
}
|
|
}
|
|
|
|
if(this.presentation && Array.isArray(this.presentation.Slides) || Asc.editor.isPdfEditor()){
|
|
AscFormat.updateRowHeightAfterOpen(row, fRowHeight);
|
|
}
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadCell = function(cell)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var _id = s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var rowSpan = s.GetULong();
|
|
if (1 < rowSpan)
|
|
{
|
|
cell.SetVMerge(vmerge_Restart);
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
cell.Set_GridSpan(s.GetULong());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var bIsHMerge = s.GetBool();
|
|
if (bIsHMerge && cell.Index > 0)
|
|
{
|
|
s.Seek2(_end_rec);
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
var bIsVMerge = s.GetBool();
|
|
if (bIsVMerge && cell.Pr.VMerge != vmerge_Restart)
|
|
{
|
|
cell.SetVMerge(vmerge_Continue);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var props = new CTableCellPr();
|
|
this.ReadCellProps(props);
|
|
props.Merge(cell.Pr);
|
|
cell.Set_Pr(props);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
this.ReadTextBody2(cell.Content);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return true;
|
|
};
|
|
|
|
this.ReadCellProps = function(props)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
//props.TableCellMar = {};
|
|
//props.TableCellMar.Top = new CTableMeasurement(tblwidth_Mm, 1.27);
|
|
//props.TableCellMar.Left = new CTableMeasurement(tblwidth_Mm, 2.54);
|
|
//props.TableCellMar.Bottom = new CTableMeasurement(tblwidth_Mm, 1.27);
|
|
//props.TableCellMar.Right = new CTableMeasurement(tblwidth_Mm, 2.54);
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
if(props.TableCellMar == null)
|
|
props.TableCellMar = {};
|
|
props.TableCellMar.Left = new CTableMeasurement(tblwidth_Mm, s.GetULong() / 36000);
|
|
//props.TableCellMar.Left.W = s.GetULong() / 36000;
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
if(props.TableCellMar == null)
|
|
props.TableCellMar = {};
|
|
props.TableCellMar.Top = new CTableMeasurement(tblwidth_Mm, s.GetULong() / 36000);
|
|
|
|
// props.TableCellMar.Top.W = s.GetULong() / 36000;
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
if(props.TableCellMar == null)
|
|
props.TableCellMar = {};
|
|
props.TableCellMar.Right = new CTableMeasurement(tblwidth_Mm, s.GetULong() / 36000);
|
|
// props.TableCellMar.Right.W = s.GetULong() / 36000;
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
if(props.TableCellMar == null)
|
|
props.TableCellMar = {};
|
|
props.TableCellMar.Bottom = new CTableMeasurement(tblwidth_Mm, s.GetULong() / 36000);
|
|
|
|
//props.TableCellMar.Bottom.W = s.GetULong() / 36000;
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
s.Skip2(1);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
var nVert = s.GetUChar();
|
|
switch (nVert)
|
|
{
|
|
case 0: props.TextDirection = Asc.c_oAscCellTextDirection.TBRL; break;
|
|
case 1: props.TextDirection = Asc.c_oAscCellTextDirection.LRTB;/*_T("horz"); */break;
|
|
case 2: props.TextDirection = Asc.c_oAscCellTextDirection.TBRL; break;
|
|
case 3: props.TextDirection = Asc.c_oAscCellTextDirection.TBRL; break;
|
|
case 4: props.TextDirection = Asc.c_oAscCellTextDirection.BTLR; break;
|
|
case 5: props.TextDirection = Asc.c_oAscCellTextDirection.BTLR; break;
|
|
case 6: props.TextDirection = Asc.c_oAscCellTextDirection.TBRL; break;
|
|
default:
|
|
props.TextDirection = Asc.c_oAscCellTextDirection.LRTB;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
var nVertAlign = s.GetUChar();
|
|
switch (nVertAlign)
|
|
{
|
|
case 0://bottom
|
|
{
|
|
props.VAlign = vertalignjc_Bottom;
|
|
break;
|
|
}
|
|
case 1://ctr
|
|
case 2://dist
|
|
case 3: //just
|
|
{
|
|
props.VAlign = vertalignjc_Center;
|
|
break;
|
|
}
|
|
case 4://top
|
|
{
|
|
props.VAlign = vertalignjc_Top;
|
|
break;
|
|
}
|
|
}
|
|
//s.Skip2(1);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
s.Skip2(1);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
if(!props.TableCellBorders)
|
|
{
|
|
props.TableCellBorders = {};
|
|
}
|
|
props.TableCellBorders.Left = this.ReadTableBorderLn();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
if(!props.TableCellBorders)
|
|
{
|
|
props.TableCellBorders = {};
|
|
}
|
|
props.TableCellBorders.Top = this.ReadTableBorderLn();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
if(!props.TableCellBorders)
|
|
{
|
|
props.TableCellBorders = {};
|
|
}
|
|
props.TableCellBorders.Right = this.ReadTableBorderLn();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
if(!props.TableCellBorders)
|
|
{
|
|
props.TableCellBorders = {};
|
|
}
|
|
props.TableCellBorders.Bottom = this.ReadTableBorderLn();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
var _unifill = this.ReadUniFill();
|
|
|
|
if (_unifill && _unifill.fill !== undefined && _unifill.fill != null)
|
|
{
|
|
props.Shd = new CDocumentShd();
|
|
props.Shd.Value = c_oAscShdClear;
|
|
props.Shd.Unifill = _unifill;
|
|
}
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadTableBorderLn = function()
|
|
{
|
|
var ln = this.ReadLn();
|
|
|
|
var border = new CDocumentBorder();
|
|
ln.fillDocumentBorder(border);
|
|
|
|
return border;
|
|
};
|
|
|
|
this.ReadTablePr = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
var obj = {};
|
|
obj.props = new CTablePr();
|
|
obj.look = new AscCommon.CTableLook(false, false, false, false, false, false);
|
|
obj.style = -1;
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
//var ind = this.map_table_styles[s.GetString2()];
|
|
//if (undefined !== ind)
|
|
obj.style = s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.Skip2(1);// rtl
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
obj.look.SetFirstRow(s.GetBool());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
obj.look.SetFirstCol(s.GetBool());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
obj.look.SetLastRow(s.GetBool());
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
obj.look.SetLastCol(s.GetBool());
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
obj.look.SetBandHor(s.GetBool());
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
obj.look.SetBandVer(s.GetBool());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var _unifill = this.ReadUniFill();
|
|
if (_unifill && _unifill.fill !== undefined && _unifill.fill != null)
|
|
{
|
|
obj.props.Shd = new CDocumentShd();
|
|
obj.props.Shd.Value = c_oAscShdClear;
|
|
obj.props.Shd.Unifill = _unifill;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return obj;
|
|
};
|
|
|
|
this.ReadNvPr = function(nvPr)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
nvPr.setIsPhoto(s.GetBool());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
nvPr.setUserDrawn(s.GetBool());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
nvPr.setPh(this.ReadPH());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
nvPr.setUniMedia(new AscFormat.UniMedia());
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadPH = function()
|
|
{
|
|
var ph = new AscFormat.Ph();
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
ph.setHasCustomPrompt(s.GetBool());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ph.setIdx(s.GetString2());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
ph.setOrient(s.GetUChar());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
ph.setSz(s.GetUChar());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
ph.setType(s.GetUChar());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return ph;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
|
|
// TEXT PROPERTIES --------------------------
|
|
|
|
this.ReadRunProperties = function()
|
|
{
|
|
var rPr = new CTextPr();
|
|
|
|
var s = this.stream;
|
|
var _end_rec = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var altLang = s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
rPr.Bold = s.GetBool();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var baseline = s.GetLong();
|
|
|
|
if (baseline < 0)
|
|
rPr.VertAlign = AscCommon.vertalign_SubScript;
|
|
else if (baseline > 0)
|
|
rPr.VertAlign = AscCommon.vertalign_SuperScript;
|
|
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var bmk = s.GetString2();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
var _cap = s.GetUChar();
|
|
if (_cap == 0)
|
|
{
|
|
rPr.Caps = true;
|
|
rPr.SmallCaps = false;
|
|
}
|
|
else if (_cap == 1)
|
|
{
|
|
rPr.Caps = false;
|
|
rPr.SmallCaps = true;
|
|
}
|
|
else if (_cap == 2)
|
|
{
|
|
rPr.SmallCaps = false;
|
|
rPr.Caps = false;
|
|
}
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
s.Skip2(1); // dirty
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
s.Skip2(1); // error
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
rPr.Italic = s.GetBool();
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
s.Skip2(4); // kern
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
s.Skip2(1); // kumimoji
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
var lang = s.GetString2();
|
|
if(!(this.IsThemeLoader || this.IsFillingSmartArt))
|
|
{
|
|
var nLcid = Asc.g_oLcidNameToIdMap[lang];
|
|
if(nLcid)
|
|
rPr.Lang.Val = nLcid;
|
|
}
|
|
break;
|
|
}
|
|
case 11:
|
|
{
|
|
s.Skip2(1); // noproof
|
|
break;
|
|
}
|
|
case 12:
|
|
{
|
|
s.Skip2(1); // normalizeH
|
|
break;
|
|
}
|
|
case 13:
|
|
{
|
|
s.Skip2(1); // smtClean
|
|
break;
|
|
}
|
|
case 14:
|
|
{
|
|
s.Skip2(4); // smtId
|
|
break;
|
|
}
|
|
case 15:
|
|
{
|
|
//s.Skip2(4); // spc
|
|
rPr.Spacing = s.GetLong() * 25.4 / 7200;
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
var _strike = s.GetUChar();
|
|
if (0 == _strike)
|
|
{
|
|
rPr.Strikeout = false;
|
|
rPr.DStrikeout = true;
|
|
}
|
|
else if (2 == _strike)
|
|
{
|
|
rPr.Strikeout = true;
|
|
rPr.DStrikeout = false;
|
|
}
|
|
else
|
|
{
|
|
rPr.Strikeout = false;
|
|
rPr.DStrikeout = false;
|
|
}
|
|
break;
|
|
}
|
|
case 17:
|
|
{
|
|
var _size = s.GetLong() / 100;
|
|
_size = ((_size * 2) + 0.5) >> 0;
|
|
_size /= 2;
|
|
rPr.FontSize = _size;
|
|
rPr.FontSizeCS = _size;
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
rPr.Underline = (s.GetUChar() != 12);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
rPr.TextOutline = this.ReadLn();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var oUniFill = this.ReadUniFill();
|
|
if(oUniFill && oUniFill.fill){
|
|
rPr.Unifill = oUniFill;
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
//latin
|
|
rPr.RFonts.Ascii = { Name: this.ReadTextFontTypeface(), Index : -1 };
|
|
rPr.RFonts.HAnsi = { Name: rPr.RFonts.Ascii.Name, Index : -1 };
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
//ea
|
|
rPr.RFonts.EastAsia = { Name: this.ReadTextFontTypeface(), Index : -1 };
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
//cs
|
|
rPr.RFonts.CS = { Name: this.ReadTextFontTypeface(), Index : -1 };
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
//sym
|
|
|
|
s.SkipRecord();
|
|
//rPr.RFonts.HAnsi = { Name: this.ReadTextFontTypeface(), Index : -1 };
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
rPr.hlink = this.ReadHyperlink();
|
|
if (null == rPr.hlink)
|
|
delete rPr.hlink;
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 12:
|
|
{
|
|
//highlight
|
|
var end_rec__ = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
var at__;
|
|
while (true)
|
|
{
|
|
at__ = s.GetUChar();
|
|
if (at__ === g_nodeAttributeEnd)
|
|
break;
|
|
}
|
|
while (s.cur < end_rec__)
|
|
{
|
|
at__ = s.GetUChar();
|
|
switch (at__)
|
|
{
|
|
case 0:
|
|
{
|
|
rPr.HighlightColor = this.ReadUniColor();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(end_rec__);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
//checkTextPr(rPr);
|
|
return rPr;
|
|
};
|
|
|
|
this.CorrectHyperlink = function (hyper) {
|
|
if (hyper.action == null || hyper.action == "") {
|
|
return;
|
|
}
|
|
|
|
switch (hyper.action) {
|
|
case "ppaction://hlinkshowjump?jump=firstslide":
|
|
case "ppaction://hlinkshowjump?jump=lastslide":
|
|
case "ppaction://hlinkshowjump?jump=nextslide":
|
|
case "ppaction://hlinkshowjump?jump=previousslide":
|
|
hyper.id = hyper.action;
|
|
break;
|
|
|
|
case "ppaction://hlinksldjump":
|
|
if (hyper.id == null || hyper.id.indexOf("slide") != 0) {
|
|
hyper.id = null;
|
|
break;
|
|
}
|
|
|
|
const regex = /^slide(\d+)\.xml$/;
|
|
const match = hyper.id.match(regex);
|
|
|
|
let slideNum = match ? parseInt(match[1]) : 1;
|
|
if (isNaN(slideNum))
|
|
slideNum = 1;
|
|
|
|
hyper.id = hyper.action + "slide" + (slideNum - 1);
|
|
break;
|
|
|
|
case "ppaction://hlinkfile":
|
|
hyper.id = hyper.action + '?file=' + hyper.id;
|
|
break;
|
|
|
|
default:
|
|
hyper.id = null;
|
|
}
|
|
};
|
|
|
|
this.ReadHyperlink = function()
|
|
{
|
|
var hyper = new AscFormat.CT_Hyperlink();
|
|
var s = this.stream;
|
|
var _end_rec = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
hyper.id = s.GetString2();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
hyper.invalidUrl = s.GetString2();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
hyper.action = s.GetString2();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
hyper.tgtFrame = s.GetString2();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
hyper.tooltip = s.GetString2();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
hyper.history = s.GetBool();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
hyper.highlightClick = s.GetBool();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
hyper.endSnd = s.GetBool();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
|
|
this.CorrectHyperlink(hyper);
|
|
|
|
if (hyper.id == null)
|
|
return null;
|
|
|
|
return hyper;
|
|
};
|
|
|
|
this.CorrectBodyPr = function(bodyPr)
|
|
{
|
|
|
|
//TODO: сделать через методы
|
|
var s = this.stream;
|
|
var _end_rec = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
bodyPr.flatTx = s.GetLong();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
bodyPr.anchor = s.GetUChar();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
bodyPr.anchorCtr = s.GetBool();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
bodyPr.bIns = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
bodyPr.compatLnSpc = s.GetBool();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
bodyPr.forceAA = s.GetBool();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
bodyPr.fromWordArt = s.GetBool();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
bodyPr.horzOverflow = s.GetUChar();
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
bodyPr.lIns = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
bodyPr.numCol = s.GetLong();
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
bodyPr.rIns = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 11:
|
|
{
|
|
bodyPr.rot = s.GetLong();
|
|
break;
|
|
}
|
|
case 12:
|
|
{
|
|
bodyPr.rtlCol = s.GetBool();
|
|
break;
|
|
}
|
|
case 13:
|
|
{
|
|
bodyPr.spcCol = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 14:
|
|
{
|
|
bodyPr.spcFirstLastPara = s.GetBool();
|
|
break;
|
|
}
|
|
case 15:
|
|
{
|
|
bodyPr.tIns = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 16:
|
|
{
|
|
bodyPr.upright = s.GetBool();
|
|
break;
|
|
}
|
|
case 17:
|
|
{
|
|
bodyPr.setVertOpen(s.GetUChar());
|
|
break;
|
|
}
|
|
case 18:
|
|
{
|
|
bodyPr.vertOverflow = s.GetUChar();
|
|
break;
|
|
}
|
|
case 19:
|
|
{
|
|
bodyPr.wrap = s.GetUChar();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0://prstTxWarp
|
|
{
|
|
var _end_rec3 = s.cur + s.GetULong() + 4;
|
|
s.Skip2(1);// start attributes
|
|
while(true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
switch (_at2) {
|
|
case 0:
|
|
{
|
|
var sPrst = s.GetUChar();
|
|
bodyPr.prstTxWarp = AscFormat.CreatePrstTxWarpGeometry(AscFormat.getPrstByNumber(sPrst));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while (s.cur < _end_rec3)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
this.ReadGeomAdj(bodyPr.prstTxWarp );
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_rec3);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var _end_rec2 = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
var txFit = new AscFormat.CTextFit();
|
|
txFit.type = -1;
|
|
|
|
while (true)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
txFit.type = s.GetLong() - 1;
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
txFit.fontScale = s.GetLong();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
txFit.lnSpcReduction = s.GetLong();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (txFit.type != -1)
|
|
{
|
|
bodyPr.textFit = txFit;
|
|
}
|
|
|
|
s.Seek2(_end_rec2);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadBodyPr = function()
|
|
{
|
|
var bodyPr = new AscFormat.CBodyPr();
|
|
this.CorrectBodyPr(bodyPr);
|
|
return bodyPr;
|
|
};
|
|
|
|
this.ReadTextParagraphPr = function(par)
|
|
{
|
|
|
|
var para_pr = new CParaPr();
|
|
var s = this.stream;
|
|
var _end_rec = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var _align = s.GetUChar();
|
|
switch (_align)
|
|
{
|
|
case 0: { para_pr.Jc = AscCommon.align_Center; break; }
|
|
case 1: { para_pr.Jc = AscCommon.align_Justify; break; }
|
|
case 2: { para_pr.Jc = AscCommon.align_Justify; break; }
|
|
case 3: { para_pr.Jc = AscCommon.align_Justify; break; }
|
|
case 4: { para_pr.Jc = AscCommon.align_Left; break; }
|
|
case 5: { para_pr.Jc = AscCommon.align_Right; break; }
|
|
case 6: { para_pr.Jc = AscCommon.align_Justify; break; }
|
|
default:
|
|
para_pr.Jc = AscCommon.align_Center;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
para_pr.DefaultTab = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(1); // eaLnBrk
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
s.Skip2(1); // font align
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
s.Skip2(1); // hangingPunct
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
para_pr.Ind.FirstLine = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
s.Skip2(1); // latinLnBrk
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
para_pr.Lvl = s.GetLong();
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
para_pr.Ind.Left = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
para_pr.Ind.Right = s.GetLong()/36000;
|
|
break;
|
|
}
|
|
case 10:
|
|
{
|
|
para_pr.Bidi = s.GetBool();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
var bullet = new AscFormat.CBullet();
|
|
var b_bullet = false;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.Skip2(5); // len start attr
|
|
|
|
var Pts = null;
|
|
var Pct = null;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
Pct = s.GetLong();
|
|
para_pr.Spacing.Line = Pct/100000;
|
|
para_pr.Spacing.LineRule = Asc.linerule_Auto;
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
Pts = s.GetLong();
|
|
para_pr.Spacing.Line = Pts*0.00352777778;
|
|
para_pr.Spacing.LineRule = Asc.linerule_Exact;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// lnSpc
|
|
// TODO:
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.Skip2(5); // len + start attr
|
|
|
|
var Pts = null;
|
|
var Pct = null;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
Pct = s.GetLong();
|
|
para_pr.Spacing.After = 0;
|
|
para_pr.Spacing.AfterPct = Pct;
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
Pts = s.GetLong();
|
|
para_pr.Spacing.After = Pts*0.00352777778;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
// spcAft
|
|
// TODO:
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(5); // len + start attr
|
|
|
|
var Pts = null;
|
|
var Pct = null;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
Pct = s.GetLong();
|
|
para_pr.Spacing.Before = 0;
|
|
para_pr.Spacing.BeforePct = Pct;
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
Pts = s.GetLong();
|
|
para_pr.Spacing.Before = Pts*0.00352777778;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// spcBef
|
|
// TODO:
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
|
|
var cur_pos = s.cur;
|
|
var _len = s.GetULong();
|
|
if (0 != _len)
|
|
{
|
|
b_bullet = true;
|
|
bullet.bulletColor = new AscFormat.CBulletColor();
|
|
bullet.bulletColor.type = s.GetUChar();
|
|
|
|
if (bullet.bulletColor.type == AscFormat.BULLET_TYPE_COLOR_CLRTX)
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
else
|
|
{
|
|
var _l = s.GetULong();
|
|
if (0 !== _l) {
|
|
s.Skip2(1);
|
|
bullet.bulletColor.UniColor = this.ReadUniColor();
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(cur_pos + _len + 4);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
var cur_pos = s.cur;
|
|
var _len = s.GetULong();
|
|
if (0 != _len)
|
|
{
|
|
b_bullet = true;
|
|
bullet.bulletSize = new AscFormat.CBulletSize();
|
|
|
|
bullet.bulletSize.type = s.GetUChar();
|
|
|
|
if (bullet.bulletSize.type == AscFormat.BULLET_TYPE_SIZE_TX)
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
else
|
|
{
|
|
var _l = s.GetULong();
|
|
s.Skip2(2); // start attributes + type
|
|
bullet.bulletSize.val = s.GetLong();
|
|
s.Skip2(1); // end attributes
|
|
}
|
|
}
|
|
s.Seek2(cur_pos + _len + 4);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
|
|
var cur_pos = s.cur;
|
|
var _len = s.GetULong();
|
|
if (0 != _len)
|
|
{
|
|
b_bullet = true;
|
|
bullet.bulletTypeface = new AscFormat.CBulletTypeface();
|
|
bullet.bulletTypeface.type = s.GetUChar();
|
|
|
|
if (bullet.bulletTypeface.type == AscFormat.BULLET_TYPE_TYPEFACE_BUFONT)
|
|
{
|
|
bullet.bulletTypeface.typeface = this.ReadTextFontTypeface();
|
|
}
|
|
else
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
}
|
|
s.Seek2(cur_pos + _len + 4);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
|
|
var cur_pos = s.cur;
|
|
var _len = s.GetULong();
|
|
if (0 != _len)
|
|
{
|
|
b_bullet = true;
|
|
bullet.bulletType = new AscFormat.CBulletType();
|
|
bullet.bulletType.type = s.GetUChar();
|
|
|
|
if (bullet.bulletType.type == AscFormat.BULLET_TYPE_BULLET_NONE)
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
else if (bullet.bulletType.type == AscFormat.BULLET_TYPE_BULLET_BLIP)
|
|
{
|
|
s.Skip2(5);
|
|
var buBlip = new AscFormat.CBuBlip();
|
|
buBlip.fromPPTY(this, par, bullet);
|
|
bullet.bulletType.setBlip(buBlip);
|
|
}
|
|
else if (bullet.bulletType.type == AscFormat.BULLET_TYPE_BULLET_AUTONUM)
|
|
{
|
|
s.Skip2(5); // len + type + start attr
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
bullet.bulletType.AutoNumType = s.GetUChar();
|
|
if(AscFonts.IsCheckSymbols) {
|
|
var adaptedVal = window['AscCommonWord'].getAdaptedNumberingFormat(bullet.bulletType.AutoNumType);
|
|
switch (adaptedVal) {
|
|
case Asc.c_oAscNumberingFormat.LowerLetter:
|
|
case Asc.c_oAscNumberingFormat.UpperLetter:
|
|
case Asc.c_oAscNumberingFormat.LowerRoman:
|
|
case Asc.c_oAscNumberingFormat.UpperRoman:
|
|
for (var nValue = 0; nValue < 26; ++nValue)
|
|
{
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(97 + nValue);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(65 + nValue);
|
|
}
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.ArabicAlpha:
|
|
case Asc.c_oAscNumberingFormat.ArabicAbjad:
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0623);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0628);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x062A);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x062B);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x062C);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x062D);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x062E);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x062F);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0630);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0631);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0632);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0633);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0634);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0635);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0636);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0637);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0638);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0639);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x063A);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0641);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0642);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0643);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0644);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0645);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0646);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0647);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0648);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x064A);
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.DecimalFullWidth:
|
|
for (var i = 0; i < 10; i += 1) {
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0xFF10 + i);
|
|
}
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.Decimal:
|
|
for (var i = 0; i < 10; i += 1) {
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x30 + i);
|
|
}
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.DecimalEnclosedCircle:
|
|
for (var nValue = 0; nValue < 20; ++nValue)
|
|
{
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x2460 + nValue);
|
|
}
|
|
for (var i = 0; i < 10; i += 1) {
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x30 + i);
|
|
}
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.ChineseCounting:
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x25CB);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x4E00);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x4E8C);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x4E09);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x56DB);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x4E94);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x516D);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x4E03);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x516B);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x4E5D);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x5341);
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.Hebrew2:
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D0);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D1);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D2);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D3);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D4);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D5);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D6);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D7);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D8);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05D9);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05DB);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05DC);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05DE);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E0);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E1);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E2);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E4);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E6);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E7);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E8);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05E9);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x05EA);
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.HindiConsonants:
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(2306);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(2307);
|
|
for (var i = 0x0905; i <= 0x0914; i += 1) {
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(i);
|
|
}
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.HindiVowels:
|
|
for (var i = 0x0915; i <= 0x0939; i += 1) {
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(i);
|
|
}
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.HindiNumbers:
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0967);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0968);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0969);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x096A);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x096B);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x096C);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x096D);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x096E);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x096F);
|
|
break;
|
|
case Asc.c_oAscNumberingFormat.ThaiLetters:
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E01);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E02);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E04);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E25);
|
|
for (var i = 0x0E07; i <= 0x0E23; i += 1) {
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(i);
|
|
}
|
|
for (var i = 0x0E27; i <= 0x0E2E; i += 1) {
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(i);
|
|
}
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.ThaiNumbers:
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E50);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E51);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E52);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E53);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E54);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E55);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E56);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E57);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E58);
|
|
AscFonts.FontPickerByCharacter.getFontBySymbol(0x0E59);
|
|
break;
|
|
|
|
case Asc.c_oAscNumberingFormat.None:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
bullet.bulletType.startAt = s.GetLong();
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (bullet.bulletType.type == AscFormat.BULLET_TYPE_BULLET_CHAR)
|
|
{
|
|
s.Skip2(6);
|
|
bullet.bulletType.Char = s.GetString2();
|
|
AscFonts.FontPickerByCharacter.getFontsByString(bullet.bulletType.Char);
|
|
s.Skip2(1);
|
|
}
|
|
}
|
|
s.Seek2(cur_pos + _len + 4);
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
s.Skip2(4);
|
|
var _c = s.GetULong();
|
|
|
|
if (0 != _c)
|
|
{
|
|
para_pr.Tabs = new CParaTabs();
|
|
var _value, _pos;
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(6); // type, len, start attr
|
|
_value = null;
|
|
_pos = null;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
_value = s.GetUChar();
|
|
|
|
if (_value == 0)
|
|
_value = tab_Center;
|
|
else if (_value == 3)
|
|
_value = tab_Right;
|
|
else
|
|
_value = tab_Left;
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_pos = s.GetLong() / 36000;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
para_pr.Tabs.Add(new CParaTab(_value, _pos))
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
var OldBlipCount = 0;
|
|
|
|
if (this.IsUseFullUrl && par)
|
|
OldBlipCount = this.RebuildImages.length;
|
|
|
|
var r_pr = this.ReadRunProperties();
|
|
if(r_pr)
|
|
{
|
|
para_pr.DefaultRunPr = new CTextPr();
|
|
|
|
if(r_pr.Unifill && !r_pr.Unifill.fill)
|
|
{
|
|
r_pr.Unifill = undefined;
|
|
}
|
|
para_pr.DefaultRunPr.Set_FromObject(r_pr);
|
|
|
|
|
|
if (this.IsUseFullUrl && par)
|
|
{
|
|
|
|
if(this.RebuildImages.length > OldBlipCount)
|
|
{
|
|
for(var _t = OldBlipCount; _t < this.RebuildImages.length; ++_t)
|
|
{
|
|
var oTextPr = new CTextPr();
|
|
oTextPr.Set_FromObject(r_pr);
|
|
this.RebuildImages[_t].TextPr = oTextPr;
|
|
this.RebuildImages[_t].Paragraph = par;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
}
|
|
}
|
|
|
|
if(b_bullet)
|
|
para_pr.Bullet = bullet;
|
|
// пока записи не поддерживаем
|
|
s.Seek2(_end_rec);
|
|
return para_pr;
|
|
};
|
|
|
|
this.ReadTextListStyle = function()
|
|
{
|
|
var styles = new AscFormat.TextListStyle();
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
styles.levels[_at] = this.ReadTextParagraphPr();
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return styles;
|
|
};
|
|
|
|
this.ReadTextBody = function(shape)
|
|
{
|
|
var txbody;
|
|
|
|
if(shape)
|
|
{
|
|
if(shape.txBody)
|
|
{
|
|
txbody = shape.txBody;
|
|
}
|
|
else
|
|
{
|
|
txbody = new AscFormat.CTextBody();
|
|
txbody.setParent(shape);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
txbody = new AscFormat.CTextBody();
|
|
}
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
txbody.setBodyPr(this.ReadBodyPr());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
txbody.setLstStyle(this.ReadTextListStyle());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4);
|
|
var _c = s.GetULong();
|
|
txbody.setContent(new AscFormat.CDrawingDocContent(txbody, this.DrawingDocument, 0, 0, 0, 0, 0, 0, true));
|
|
if(_c>0)
|
|
{
|
|
txbody.content.Internal_Content_RemoveAll();
|
|
}
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1); // type
|
|
var _paragraph = this.ReadParagraph(txbody.content);
|
|
txbody.content.Internal_Content_Add(txbody.content.Content.length, _paragraph);
|
|
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return txbody;
|
|
};
|
|
|
|
this.ReadTextBodyTxPr = function(shape)
|
|
{
|
|
var txbody;
|
|
|
|
if(shape.txPr)
|
|
txbody = shape.txPr;
|
|
else
|
|
{
|
|
shape.txPr = new AscFormat.CTextBody();
|
|
txbody = shape.txPr;
|
|
}
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
shape.setBodyPr(this.ReadBodyPr());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
txbody.setLstStyle(this.ReadTextListStyle());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4);
|
|
var _c = s.GetULong();
|
|
/*if(History != null)
|
|
{
|
|
History.TurnOff();
|
|
}*/
|
|
if(!txbody.content)
|
|
txbody.content = new AscFormat.CDrawingDocContent(shape, this.DrawingDocument, 0, 0, 0, 0, 0, 0, true);
|
|
if(_c>0)
|
|
{
|
|
txbody.content.Internal_Content_RemoveAll();
|
|
}
|
|
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1); // type
|
|
var _paragraph = this.ReadParagraph(txbody.content);
|
|
_paragraph.Set_Parent(txbody.content);
|
|
txbody.content.Internal_Content_Add(txbody.content.Content.length, _paragraph);
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return txbody;
|
|
};
|
|
|
|
this.ReadTextBody2 = function(content)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
var oBodyPr;
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4);
|
|
var _c = s.GetULong();
|
|
if(_c > 0)
|
|
{
|
|
content.Internal_Content_RemoveAll();
|
|
}
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1); // type
|
|
var _paragraph = this.ReadParagraph(content);
|
|
content.Internal_Content_Add(content.Content.length, _paragraph);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.ReadParagraph = function(DocumentContent)
|
|
{
|
|
var par = new AscWord.Paragraph(DocumentContent, true);
|
|
|
|
var EndPos = 0;
|
|
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
par.Set_Pr(this.ReadTextParagraphPr(par));
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var OldImgCount = 0;
|
|
if(this.IsUseFullUrl)
|
|
{
|
|
OldImgCount = this.RebuildImages.length;
|
|
}
|
|
var endRunPr = this.ReadRunProperties();
|
|
var _value_text_pr = new CTextPr();
|
|
if(endRunPr.Unifill && !endRunPr.Unifill.fill)
|
|
{
|
|
endRunPr.Unifill = undefined;
|
|
}
|
|
_value_text_pr.Set_FromObject(endRunPr);
|
|
par.TextPr.Apply_TextPr(_value_text_pr);//endRunProperties
|
|
var oTextPrEnd = new CTextPr();
|
|
oTextPrEnd.Set_FromObject(endRunPr);
|
|
par.Content[0].Set_Pr(oTextPrEnd);
|
|
if(this.IsUseFullUrl)
|
|
{
|
|
if(this.RebuildImages.length > OldImgCount)
|
|
{
|
|
for(var _t = OldImgCount; _t < this.RebuildImages.length; ++_t)
|
|
{
|
|
var _text_pr = new CTextPr();
|
|
_text_pr.Set_FromObject(endRunPr);
|
|
this.RebuildImages[_t].TextPr = _text_pr;
|
|
this.RebuildImages[_t].ParaTextPr = par.TextPr;
|
|
this.RebuildImages[_t].Run = par.Content[0];
|
|
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4);
|
|
|
|
var _c = s.GetULong();
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(5); // type (0) + len
|
|
var _type = s.GetUChar();
|
|
|
|
switch (_type)
|
|
{
|
|
case AscFormat.PARRUN_TYPE_RUN:
|
|
{
|
|
var _end = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attr
|
|
|
|
var _text = "";
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
_text = s.GetString2();
|
|
}
|
|
|
|
var OldImgCount = 0;
|
|
if(this.IsUseFullUrl)
|
|
{
|
|
OldImgCount = this.RebuildImages.length;
|
|
}
|
|
|
|
var _run = null;
|
|
while (s.cur < _end)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
if (0 == _rec)
|
|
_run = this.ReadRunProperties();
|
|
else
|
|
s.SkipRecord();
|
|
}
|
|
|
|
s.Seek2(_end);
|
|
|
|
|
|
var new_run = new ParaRun(par, false), hyperlink = null;
|
|
if (null != _run)
|
|
{
|
|
|
|
var text_pr = new CTextPr();
|
|
if(_run.Unifill && !_run.Unifill.fill)
|
|
{
|
|
_run.Unifill = undefined;
|
|
}
|
|
if (_run.hlink !== undefined)
|
|
{
|
|
hyperlink = new ParaHyperlink();
|
|
hyperlink.SetValue(_run.hlink.id);
|
|
if (_run.hlink.tooltip) {
|
|
hyperlink.SetToolTip(_run.hlink.tooltip);
|
|
}
|
|
// if(!_run.Unifill)
|
|
// {
|
|
// _run.Unifill = AscFormat.CreateUniFillSchemeColorWidthTint(11, 0);
|
|
// }
|
|
_run.Underline = true;
|
|
}
|
|
text_pr.Set_FromObject(_run);
|
|
new_run.Set_Pr(text_pr);
|
|
if(this.IsUseFullUrl)
|
|
{
|
|
if(this.RebuildImages.length > OldImgCount)
|
|
{
|
|
for(var _t = OldImgCount; _t < this.RebuildImages.length; ++_t)
|
|
{
|
|
var _text_pr = new CTextPr();
|
|
_text_pr.Set_FromObject(text_pr);
|
|
this.RebuildImages[_t].TextPr = _text_pr;
|
|
this.RebuildImages[_t].Run = new_run;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
new_run.AddText(_text);
|
|
|
|
if (hyperlink !== null)
|
|
{
|
|
hyperlink.Add_ToContent(0, new_run, false);
|
|
par.Internal_Content_Add(EndPos++, hyperlink);
|
|
}
|
|
else
|
|
{
|
|
par.Internal_Content_Add(EndPos++, new_run);
|
|
}
|
|
|
|
break;
|
|
}
|
|
case AscFormat.PARRUN_TYPE_FLD:
|
|
{
|
|
var _end = s.cur + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attr
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
var f_id = s.GetString2();
|
|
else if (1 == _at)
|
|
var f_type = s.GetString2();
|
|
else
|
|
var f_text = s.GetString2();
|
|
}
|
|
|
|
var _rPr = null, _pPr = null;
|
|
while (s.cur < _end)
|
|
{
|
|
var _at2 = s.GetUChar();
|
|
switch (_at2)
|
|
{
|
|
case 0:
|
|
{
|
|
_rPr = this.ReadRunProperties();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
_pPr = this.ReadTextParagraphPr();
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
var Fld = new AscCommonWord.CPresentationField(par);
|
|
if(f_id)
|
|
{
|
|
Fld.SetGuid(f_id);
|
|
}
|
|
if(f_type)
|
|
{
|
|
Fld.SetFieldType(f_type);
|
|
}
|
|
if(f_text)
|
|
{
|
|
Fld.CanAddToContent = true;
|
|
Fld.AddText(f_text);
|
|
Fld.CanAddToContent = false;
|
|
}
|
|
if(_rPr)
|
|
{
|
|
Fld.SetPr(_rPr);
|
|
}
|
|
if(_pPr)
|
|
{
|
|
Fld.SetPPr(_pPr);
|
|
}
|
|
|
|
par.Internal_Content_Add(EndPos++, new ParaRun(par, false));
|
|
par.Internal_Content_Add(EndPos++, Fld);
|
|
par.Internal_Content_Add(EndPos++, new ParaRun(par, false));
|
|
s.Seek2(_end);
|
|
this.fields.push(Fld);
|
|
break;
|
|
}
|
|
case AscFormat.PARRUN_TYPE_BR:
|
|
{
|
|
var _end = s.cur + s.GetULong() + 4;
|
|
|
|
var _run = null;
|
|
while (s.cur < _end)
|
|
{
|
|
var _rec = s.GetUChar();
|
|
|
|
if (0 == _rec)
|
|
_run = this.ReadRunProperties();
|
|
else
|
|
s.SkipRecord();
|
|
}
|
|
|
|
s.Seek2(_end);
|
|
|
|
var new_run = new ParaRun(par, false), hyperlink = null;
|
|
if (null != _run)
|
|
{
|
|
if (_run.hlink !== undefined)
|
|
{
|
|
hyperlink = new ParaHyperlink();
|
|
hyperlink.SetValue(_run.hlink.id);
|
|
if (_run.hlink.tooltip) {
|
|
hyperlink.SetToolTip(_run.hlink.tooltip);
|
|
}
|
|
}
|
|
var text_pr = new CTextPr();
|
|
if(_run.Unifill && !_run.Unifill.fill)
|
|
{
|
|
_run.Unifill = undefined;
|
|
}
|
|
text_pr.Set_FromObject(_run);
|
|
new_run.Set_Pr(text_pr);
|
|
}
|
|
new_run.Add_ToContent( 0, new AscWord.CRunBreak(AscWord.break_Line));
|
|
if (hyperlink !== null)
|
|
{
|
|
hyperlink.Add_ToContent(0, new_run, false);
|
|
par.Internal_Content_Add(EndPos++, hyperlink);
|
|
}
|
|
else
|
|
{
|
|
par.Internal_Content_Add(EndPos++, new_run);
|
|
}
|
|
break;
|
|
}
|
|
case AscFormat.PARRUN_TYPE_MATHPARA:
|
|
case AscFormat.PARRUN_TYPE_MATH:
|
|
{
|
|
var _end = s.cur + s.GetULong() + 4;
|
|
|
|
var _stream = new AscCommon.FT_Stream2();
|
|
_stream.data = s.data;
|
|
_stream.pos = s.pos;
|
|
_stream.cur = s.cur;
|
|
_stream.size = s.size;
|
|
var parContentOld = par.Content.length;
|
|
|
|
var oReadResult = new AscCommonWord.DocReadResult(null);
|
|
var boMathr = new Binary_oMathReader(_stream, oReadResult, null);
|
|
var nDocLength = _stream.GetULongLE();
|
|
if (AscFormat.PARRUN_TYPE_MATHPARA == _type) {
|
|
var props = {};
|
|
boMathr.bcr.Read1(nDocLength, function(t, l){
|
|
return boMathr.ReadMathOMathPara(t,l,par, props);
|
|
});
|
|
} else {
|
|
var oMath = new ParaMath();
|
|
par.AddToContentToEnd(oMath);
|
|
boMathr.bcr.Read1(nDocLength, function(t, l){
|
|
return boMathr.ReadMathArg(t,l,oMath.Root,par);
|
|
});
|
|
oMath.Root.Correct_Content(true);
|
|
}
|
|
s.Seek2(_end);
|
|
|
|
EndPos += par.Content.length - parContentOld;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_rec);
|
|
par.Correct_Content();
|
|
return par;
|
|
};
|
|
|
|
// ------------------------------------------
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function CPPTXContentLoader()
|
|
{
|
|
this.Reader = new AscCommon.BinaryPPTYLoader();
|
|
this.Writer = null;
|
|
|
|
this.stream = null;
|
|
this.TempMainObject = null;
|
|
this.ParaDrawing = null;
|
|
this.LogicDocument = null;
|
|
this.BaseReader = null;
|
|
|
|
this.ImageMapChecker = {};
|
|
|
|
this.Start_UseFullUrl = function(insertDocumentUrlsData)
|
|
{
|
|
this.Reader.Start_UseFullUrl(insertDocumentUrlsData);
|
|
};
|
|
this.End_UseFullUrl = function()
|
|
{
|
|
return this.Reader.End_UseFullUrl();
|
|
};
|
|
this.CheckStreamStart = function(oOtherStream) {
|
|
if (!this.Reader) {
|
|
this.Reader = new AscCommon.BinaryPPTYLoader();
|
|
}
|
|
this.Reader.ImageMapChecker = this.ImageMapChecker;
|
|
if (!this.stream ||
|
|
this.stream.data !== oOtherStream.data ||
|
|
this.stream.size !== oOtherStream.size) {
|
|
this.stream = new AscCommon.FileStream();
|
|
this.stream.obj = oOtherStream.obj;
|
|
this.stream.data = oOtherStream.data;
|
|
this.stream.size = oOtherStream.size;
|
|
}
|
|
this.stream.pos = oOtherStream.pos;
|
|
this.stream.cur = oOtherStream.cur;
|
|
this.Reader.stream = this.stream;
|
|
};
|
|
this.CheckStreamEnd = function(oOtherStream) {
|
|
oOtherStream.pos = this.stream.pos;
|
|
oOtherStream.cur = this.stream.cur;
|
|
};
|
|
this.ReadPPTXElement = function(reader, stream, fReadFunction) {
|
|
var oOldReader = this.BaseReader;
|
|
var oOldLogicDocument = this.LogicDocument;
|
|
var oOldStream = this.stream;
|
|
if(reader) {
|
|
this.BaseReader = reader;
|
|
}
|
|
this.CheckStreamStart(stream);
|
|
var oStream = this.stream;
|
|
var oResult = fReadFunction();
|
|
this.CheckStreamEnd(stream);
|
|
|
|
|
|
this.BaseReader = oOldReader;
|
|
this.LogicDocument = oOldLogicDocument;
|
|
this.stream = oOldStream;
|
|
return oResult;
|
|
};
|
|
this.ReadBodyPr = function(reader, stream) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
oThis.stream.GetUChar();
|
|
return oThis.Reader.ReadBodyPr();
|
|
});
|
|
};
|
|
this.ReadFontRef = function(reader, stream) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
oThis.stream.GetUChar();
|
|
return oThis.Reader.ReadFontRef();
|
|
});
|
|
};
|
|
this.ReadStyleRef = function(reader, stream) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
oThis.stream.GetUChar();
|
|
return oThis.Reader.ReadStyleRef();
|
|
});
|
|
};
|
|
this.ReadUniColor = function(reader, stream) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
oThis.stream.GetUChar();
|
|
return oThis.Reader.ReadUniColor();
|
|
});
|
|
};
|
|
this.ReadColorMod = function(reader, stream) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
oThis.stream.GetUChar();
|
|
return oThis.Reader.ReadColorMod();
|
|
});
|
|
};
|
|
|
|
|
|
this.ReadTheme = function(reader, stream) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
return oThis.Reader.ReadTheme();
|
|
});
|
|
};
|
|
|
|
this.ReadDrawing = function(reader, stream, logicDocument, paraDrawing) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function () {
|
|
if (null != paraDrawing)
|
|
{
|
|
oThis.ParaDrawing = paraDrawing;
|
|
oThis.TempMainObject = null;
|
|
}
|
|
oThis.LogicDocument = logicDocument;
|
|
oThis.Reader.presentation = logicDocument;
|
|
if(logicDocument)
|
|
{
|
|
oThis.Reader.DrawingDocument = logicDocument.DrawingDocument;
|
|
}
|
|
else
|
|
{
|
|
oThis.Reader.DrawingDocument = null;
|
|
}
|
|
|
|
var GrObject = null;
|
|
|
|
var s = oThis.stream;
|
|
var _main_type = s.GetUChar(); // 0!!!
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
if (s.cur < _end_rec){
|
|
s.Skip2(5); // 1 + 4 byte - len
|
|
|
|
var _type = s.GetUChar();
|
|
switch (_type)
|
|
{
|
|
case 1:
|
|
{
|
|
GrObject = oThis.ReadShape();
|
|
break;
|
|
}
|
|
case 6:
|
|
case 2:
|
|
case 7:
|
|
case 8:
|
|
{
|
|
GrObject = oThis.ReadPic(_type);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
GrObject = oThis.ReadCxn();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
GrObject = oThis.ReadGroupShape();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
|
|
var oGrFrDrawing = oThis.Reader.ReadGrFrame();
|
|
if(oGrFrDrawing) {
|
|
if(oGrFrDrawing.getObjectType() === AscDFH.historyitem_type_GroupShape) {
|
|
GrObject = oGrFrDrawing.convertToWord(oThis.LogicDocument);
|
|
if(paraDrawing){
|
|
GrObject.setParent(paraDrawing);
|
|
}
|
|
}
|
|
else if(oGrFrDrawing.getObjectType() === AscDFH.historyitem_type_SmartArt) {
|
|
GrObject = oGrFrDrawing;
|
|
if(paraDrawing){
|
|
GrObject.setParent(paraDrawing);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 9:
|
|
{
|
|
GrObject = oThis.Reader.ReadGroupShape(9);
|
|
if(paraDrawing){
|
|
GrObject.setParent(paraDrawing);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return GrObject;
|
|
});
|
|
};
|
|
|
|
this.ReadGraphicObject = function(stream, presentation, drawingDocument) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(undefined, stream, function() {
|
|
if(presentation)
|
|
{
|
|
oThis.Reader.presentation = presentation;
|
|
}
|
|
if(drawingDocument)
|
|
{
|
|
oThis.Reader.DrawingDocument = drawingDocument;
|
|
}
|
|
oThis.LogicDocument = null;
|
|
var s = oThis.stream;
|
|
var _main_type = s.GetUChar(); // 0!!!
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(5); // 1 + 4 byte - len
|
|
|
|
var GrObject = oThis.Reader.ReadGraphicObject();
|
|
|
|
s.Seek2(_end_rec);
|
|
return GrObject;
|
|
});
|
|
};
|
|
this.ReadGraphicObject2 = function(stream, presentation, drawingDocument) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(undefined, stream, function() {
|
|
if(presentation)
|
|
{
|
|
oThis.Reader.presentation = presentation;
|
|
}
|
|
if(drawingDocument)
|
|
{
|
|
oThis.Reader.DrawingDocument = drawingDocument;
|
|
}
|
|
oThis.LogicDocument = null;
|
|
var s = oThis.stream;
|
|
var GrObject = oThis.Reader.ReadGraphicObject();
|
|
return GrObject;
|
|
});
|
|
};
|
|
|
|
this.ReadTextBody = function(reader, stream, shape, presentation, drawingDocument) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
if(presentation)
|
|
oThis.Reader.presentation = presentation;
|
|
if(drawingDocument)
|
|
oThis.Reader.DrawingDocument = drawingDocument;
|
|
oThis.LogicDocument = null;
|
|
var s = oThis.stream;
|
|
var _main_type = s.GetUChar(); // 0!!!
|
|
return oThis.Reader.ReadTextBody(shape);
|
|
});
|
|
};
|
|
|
|
this.ReadTextBodyTxPr = function(reader, stream, shape) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(reader, stream, function() {
|
|
oThis.LogicDocument = null;
|
|
var s = oThis.stream;
|
|
var _main_type = s.GetUChar(); // 0!!!
|
|
return oThis.Reader.ReadTextBodyTxPr(shape);
|
|
});
|
|
|
|
};
|
|
|
|
this.ReadShapeProperty = function(stream, type) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(undefined, stream, function() {
|
|
oThis.LogicDocument = null;
|
|
var s = oThis.stream;
|
|
var _main_type = s.GetUChar(); // 0!!!
|
|
|
|
var oNewSpPr;
|
|
if(0 == type){
|
|
oNewSpPr = oThis.Reader.ReadLn()
|
|
}
|
|
else if(1 == type){
|
|
oNewSpPr = oThis.Reader.ReadUniFill();
|
|
}
|
|
else{
|
|
oNewSpPr = new AscFormat.CSpPr();
|
|
oThis.Reader.ReadSpPr(oNewSpPr);
|
|
}
|
|
return oNewSpPr;
|
|
});
|
|
};
|
|
|
|
this.ReadRunProperties = function(stream, type) {
|
|
var oThis = this;
|
|
return this.ReadPPTXElement(undefined, stream, function() {
|
|
oThis.LogicDocument = null;
|
|
var s = oThis.stream;
|
|
var _main_type = s.GetUChar(); // 0!!!
|
|
return oThis.Reader.ReadRunProperties();
|
|
});
|
|
};
|
|
|
|
this.ReadShape = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var shape = new AscFormat.CShape();
|
|
shape.setWordShape(true);
|
|
shape.setBDeleted(false);
|
|
shape.setParent(this.TempMainObject == null ? this.ParaDrawing : null);
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == AscCommon.g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
shape.setUseBgFill(s.GetBool());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
var oXFRM = null;
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var pr = this.Reader.ReadNvUniProp(shape);
|
|
shape.setNvSpPr(pr);
|
|
if(AscFormat.isRealNumber(pr.locks))
|
|
{
|
|
shape.setLocks(pr.locks);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var spPr = new AscFormat.CSpPr();
|
|
this.ReadSpPr(spPr);
|
|
shape.setSpPr(spPr);
|
|
shape.spPr.setParent(shape);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
shape.setStyle(this.Reader.ReadShapeStyle());
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
var oThis = this.BaseReader;
|
|
|
|
shape.setTextBoxContent(new CDocumentContent(shape, this.LogicDocument.DrawingDocument, 0, 0, 0, 0, false, false));
|
|
|
|
var _old_cont = shape.textBoxContent.Content[0];
|
|
|
|
shape.textBoxContent.Internal_Content_RemoveAll();
|
|
|
|
s.Skip2(4); // rec len
|
|
|
|
oThis.stream.pos = s.pos;
|
|
oThis.stream.cur = s.cur;
|
|
|
|
var oBinary_DocumentTableReader = new Binary_DocumentTableReader(shape.textBoxContent, oThis.oReadResult, oThis.openParams, oThis.stream, false, oThis.oComments);
|
|
var nDocLength = oThis.stream.GetULongLE();
|
|
var content_arr = [];
|
|
var oCurParaDrawing = this.ParaDrawing;
|
|
oThis.bcr.Read1(nDocLength, function(t,l){
|
|
return oBinary_DocumentTableReader.ReadDocumentContent(t,l, content_arr);
|
|
});
|
|
oThis.oReadResult.checkDocumentContentReviewType(content_arr);
|
|
this.ParaDrawing = oCurParaDrawing;
|
|
for(var i = 0, length = content_arr.length; i < length; ++i){
|
|
if(i == length - 1)
|
|
shape.textBoxContent.Internal_Content_Add(i, content_arr[i], true);
|
|
else
|
|
shape.textBoxContent.Internal_Content_Add(i, content_arr[i], false);
|
|
}
|
|
|
|
s.pos = oThis.stream.pos;
|
|
s.cur = oThis.stream.cur;
|
|
|
|
if (shape.textBoxContent.Content.length == 0)
|
|
shape.textBoxContent.Internal_Content_Add(0, _old_cont);
|
|
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
var bodyPr = new AscFormat.CBodyPr();
|
|
this.Reader.CorrectBodyPr(bodyPr);
|
|
shape.setBodyPr(bodyPr);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
oXFRM = this.Reader.ReadXfrm();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
shape.setSignature(this.Reader.ReadSignatureLine());
|
|
break;
|
|
}
|
|
case 8:
|
|
{
|
|
if(typeof AscFormat.SmartArt !== undefined)
|
|
{
|
|
s.GetULong();//length
|
|
s.GetUChar();//attr type - 0
|
|
shape.setModelId(s.GetString2());
|
|
}
|
|
else
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 0xA1:
|
|
{
|
|
shape.readMacro(s);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(oXFRM)
|
|
{
|
|
var oRet = new AscFormat.CGroupShape();
|
|
shape.setParent(null);
|
|
oRet.setParent(this.TempMainObject == null ? this.ParaDrawing : null);
|
|
oRet.setBDeleted(false);
|
|
var oSpPr = new AscFormat.CSpPr();
|
|
var oXfrm = new AscFormat.CXfrm();
|
|
oXfrm.setOffX(shape.spPr.xfrm.offX);
|
|
oXfrm.setOffY(shape.spPr.xfrm.offY);
|
|
oXfrm.setExtX(shape.spPr.xfrm.extX);
|
|
oXfrm.setExtY(shape.spPr.xfrm.extY);
|
|
oXfrm.setChExtX(shape.spPr.xfrm.extX);
|
|
oXfrm.setChExtY(shape.spPr.xfrm.extY);
|
|
oXfrm.setChOffX(0);
|
|
oXfrm.setChOffY(0);
|
|
oSpPr.setXfrm(oXfrm);
|
|
oXfrm.setParent(oSpPr);
|
|
shape.spPr.xfrm.setOffX(0);
|
|
shape.spPr.xfrm.setOffY(0);
|
|
oRet.setSpPr(oSpPr);
|
|
oSpPr.setParent(oRet);
|
|
oRet.addToSpTree(0, shape);
|
|
var oShape2 = new AscFormat.CShape();
|
|
var oSpPr2 = new AscFormat.CSpPr();
|
|
oShape2.setSpPr(oSpPr2);
|
|
oSpPr2.setParent(oShape2);
|
|
var oXfrm2 = oXFRM;
|
|
oXfrm2.setParent(oSpPr2);
|
|
oSpPr2.setXfrm(oXfrm2);
|
|
oXfrm2.setOffX(oXfrm2.offX - oXfrm.offX);
|
|
oXfrm2.setOffY(oXfrm2.offY - oXfrm.offY);
|
|
oSpPr2.setFill(AscFormat.CreateNoFillUniFill());
|
|
oSpPr2.setLn(AscFormat.CreateNoFillLine());
|
|
oShape2.setTxBody(shape.txBody);
|
|
shape.setTxBody(null);
|
|
shape.setGroup(oRet);
|
|
oShape2.setBDeleted(false);
|
|
oShape2.setWordShape(true);
|
|
if(shape.spPr.xfrm && AscFormat.isRealNumber(shape.spPr.xfrm.rot))
|
|
{
|
|
oXfrm2.setRot((AscFormat.isRealNumber(oXfrm2.rot) ? oXfrm2.rot : 0) + shape.spPr.xfrm.rot);
|
|
}
|
|
if(oShape2.txBody)
|
|
{
|
|
oShape2.txBody.setParent(oShape2);
|
|
}
|
|
if(shape.textBoxContent)
|
|
{
|
|
oShape2.setTextBoxContent(shape.textBoxContent.Copy(oShape2, shape.textBoxContent.DrawingDocument));
|
|
shape.setTextBoxContent(null);
|
|
}
|
|
if(shape.bodyPr)
|
|
{
|
|
oShape2.setBodyPr(shape.bodyPr);
|
|
shape.setBodyPr(null);
|
|
}
|
|
oRet.addToSpTree(1, oShape2);
|
|
oShape2.setGroup(oRet);
|
|
s.Seek2(_end_rec);
|
|
return oRet;
|
|
}
|
|
s.Seek2(_end_rec);
|
|
return shape;
|
|
|
|
};
|
|
this.ReadCxn = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var shape = new AscFormat.CConnectionShape( );
|
|
shape.setWordShape(true);
|
|
shape.setParent(this.TempMainObject == null ? this.ParaDrawing : null);
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var spPr = new AscFormat.CSpPr();
|
|
this.ReadSpPr(spPr);
|
|
shape.setSpPr(spPr);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
shape.setStyle(this.Reader.ReadShapeStyle());
|
|
break;
|
|
}
|
|
case 0xA1:
|
|
{
|
|
shape.readMacro(s);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return shape;
|
|
};
|
|
this.ReadPic = function(type)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var isOle = (type === 6);
|
|
var pic;
|
|
if (isOle)
|
|
{
|
|
pic = new AscFormat.COleObject(this.TempMainObject)
|
|
}
|
|
else
|
|
{
|
|
if (Asc.editor.isPdfEditor())
|
|
pic = new AscPDF.CPdfImage();
|
|
else
|
|
pic = new AscFormat.CImageShape(this.TempMainObject);
|
|
}
|
|
|
|
pic.setBDeleted(false);
|
|
pic.setParent(this.TempMainObject == null ? this.ParaDrawing : null);
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
var sMaskFileName = "";
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
var pr = this.Reader.ReadNvUniProp(pic);
|
|
pic.setNvSpPr(pr);
|
|
if(AscFormat.isRealNumber(pr.locks))
|
|
{
|
|
pic.setLocks(pr.locks);
|
|
}
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var unifill = this.Reader.ReadUniFill(null, pic, null);
|
|
pic.setBlipFill(unifill.fill);//this.Reader.ReadUniFill();
|
|
|
|
//pic.spPr.Fill = new AscFormat.CUniFill();
|
|
//pic.spPr.Fill.fill = pic.blipFill;
|
|
//pic.brush = pic.spPr.Fill;
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var spPr = new AscFormat.CSpPr();
|
|
this.ReadSpPr(spPr);
|
|
pic.setSpPr(spPr);
|
|
pic.spPr.setParent(pic);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
pic.setStyle(this.Reader.ReadShapeStyle());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
if(isOle) {
|
|
this.ReadOleInfo(pic);
|
|
} else {
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if(type === 7 || type === 8){//video or audio
|
|
s.GetLong();
|
|
s.GetUChar();//start attributes
|
|
while(true){
|
|
var _at2 = s.GetUChar();
|
|
if (_at2 == g_nodeAttributeEnd)
|
|
break;
|
|
switch (_at2) {
|
|
case 0:
|
|
{
|
|
sMaskFileName = s.GetString2();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
case 0xA1:
|
|
{
|
|
pic.readMacro(s);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(type === 7 || type === 8){//video or audio
|
|
if(typeof sMaskFileName === "string" && sMaskFileName.length > 0 &&
|
|
pic.nvPicPr && pic.nvPicPr.nvPr /*&& pic.nvPicPr.nvPr.unimedia*/){
|
|
var oUniMedia = new AscFormat.UniMedia();
|
|
oUniMedia.type = type;
|
|
oUniMedia.media = sMaskFileName;
|
|
pic.nvPicPr.nvPr.setUniMedia(oUniMedia);
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
return pic;
|
|
};
|
|
this.ReadOleInfo = function(ole)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetLong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
var dxaOrig = 0;
|
|
var dyaOrig = 0;
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == g_nodeAttributeEnd)
|
|
break;
|
|
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
ole.setApplicationId(s.GetString2());
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ole.setData(s.GetString2());
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
dxaOrig = s.GetULong();
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
dyaOrig = s.GetULong();
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
const drawAspect = s.GetUChar();
|
|
ole.setDrawAspect(drawAspect);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
s.GetUChar();
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
s.GetUChar();
|
|
break;
|
|
}
|
|
case 7:
|
|
{
|
|
ole.setObjectFile(s.GetString2());
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
var oleType = null;
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 1:
|
|
{
|
|
s.GetLong();//length
|
|
oleType = s.GetUChar();
|
|
ole.setOleType(oleType);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
|
|
var binary_length;
|
|
switch(oleType)
|
|
{
|
|
case 0:
|
|
{
|
|
binary_length = s.GetULong();
|
|
ole.setBinaryData(s.data.slice(s.cur, s.cur + binary_length));
|
|
s.Seek2(s.cur + binary_length);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
ole.setObjectFile("maskFile.docx");
|
|
binary_length = s.GetULong();
|
|
ole.setBinaryData(s.data.slice(s.cur, s.cur + binary_length));
|
|
s.Seek2(s.cur + binary_length);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
ole.setObjectFile("maskFile.xlsx");
|
|
binary_length = s.GetULong();
|
|
ole.setBinaryData(s.data.slice(s.cur, s.cur + binary_length));
|
|
s.Seek2(s.cur + binary_length);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
s.GetLong();//length
|
|
|
|
var type2 = s.GetUChar();
|
|
if (AscCommonWord.c_oSer_OMathContentType.OMath === type2 && ole.parent && ole.parent.Parent)
|
|
{
|
|
var oReadResult = this.BaseReader ? this.BaseReader.oReadResult : new AscCommonWord.DocReadResult(null);
|
|
ole.parent.ParaMath = this.Reader.ReadMathObject(s, oReadResult, ole.parent.Parent);
|
|
}
|
|
else
|
|
{
|
|
s.SkipRecord();
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dxaOrig > 0 && dyaOrig > 0) {
|
|
var ratio = 4 / 3 / 20;//twips to px
|
|
ole.setPixSizes(ratio * dxaOrig, ratio * dyaOrig);
|
|
}
|
|
s.Seek2(_end_rec);
|
|
};
|
|
this.ReadGroupShape = function()
|
|
{
|
|
var s = this.stream;
|
|
|
|
var shape = new AscFormat.CGroupShape();
|
|
|
|
shape.setBDeleted(false);
|
|
shape.setParent(this.TempMainObject == null ? this.ParaDrawing : null);
|
|
this.TempGroupObject = shape;
|
|
|
|
var oldParaDrawing = this.ParaDrawing;
|
|
this.ParaDrawing = null;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var spPr = new AscFormat.CSpPr();
|
|
this.Reader.ReadGrSpPr(spPr);
|
|
shape.setSpPr(spPr);
|
|
shape.spPr.setParent(shape);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
s.Skip2(4); // len
|
|
var _c = s.GetULong();
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
s.Skip2(1);
|
|
var __len = s.GetULong();
|
|
if (__len == 0)
|
|
continue;
|
|
|
|
var _type = s.GetUChar();
|
|
|
|
var sp;
|
|
switch (_type)
|
|
{
|
|
case 1:
|
|
{
|
|
sp = this.ReadShape();
|
|
if(!IsHiddenObj(sp) && sp.spPr && sp.spPr.xfrm){
|
|
sp.setGroup(shape);
|
|
shape.addToSpTree(shape.spTree.length, sp);
|
|
}
|
|
break;
|
|
}
|
|
case 6:
|
|
case 2:
|
|
case 7:
|
|
case 8:
|
|
{
|
|
sp = this.ReadPic(_type);
|
|
if(!IsHiddenObj(sp) && sp.spPr && sp.spPr.xfrm){
|
|
sp.setGroup(shape);
|
|
shape.addToSpTree(shape.spTree.length, sp);
|
|
}
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
sp = this.ReadCxn();
|
|
if(!IsHiddenObj(sp) && sp.spPr && sp.spPr.xfrm) {
|
|
sp.setGroup(shape);
|
|
shape.addToSpTree(shape.spTree.length, sp);
|
|
}
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
sp = this.ReadGroupShape();
|
|
if(sp && !IsHiddenObj(sp) && sp.spPr && sp.spPr.xfrm && sp.spTree.length > 0 ) {
|
|
sp.setGroup(shape);
|
|
shape.addToSpTree(shape.spTree.length, sp);
|
|
}
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
var _chart = null;
|
|
if ("undefined" != typeof(AscFormat.CGraphicFrame))
|
|
_chart = this.Reader.ReadGrFrame();
|
|
else
|
|
_chart = this.Reader.ReadChartDataInGroup(shape);
|
|
if (null != _chart)
|
|
{
|
|
_chart.setGroup(shape);
|
|
shape.addToSpTree(shape.spTree.length, _chart);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(oldParaDrawing && shape.spPr && !shape.spPr.xfrm){
|
|
shape.bEmptyTransform = true;
|
|
}
|
|
if(!oldParaDrawing){
|
|
this.Reader.CheckGroupXfrm(shape);
|
|
}
|
|
this.ParaDrawing = oldParaDrawing;
|
|
s.Seek2(_end_rec);
|
|
this.TempGroupObject = null;
|
|
// if(shape.spTree.length === 0){
|
|
// return null;
|
|
// }
|
|
return shape;
|
|
};
|
|
|
|
this.ReadSpPr = function(spPr)
|
|
{
|
|
var s = this.stream;
|
|
|
|
var _rec_start = s.cur;
|
|
var _end_rec = _rec_start + s.GetULong() + 4;
|
|
|
|
s.Skip2(1); // start attributes
|
|
|
|
while (true)
|
|
{
|
|
var _at = s.GetUChar();
|
|
if (_at == AscCommon.g_nodeAttributeEnd)
|
|
break;
|
|
|
|
if (0 == _at)
|
|
spPr.bwMode = s.GetUChar();
|
|
else
|
|
break;
|
|
}
|
|
|
|
while (s.cur < _end_rec)
|
|
{
|
|
var _at = s.GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
spPr.setXfrm(this.Reader.ReadXfrm());
|
|
spPr.xfrm.setParent(spPr);
|
|
//this.CorrectXfrm(spPr.xfrm);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
spPr.setGeometry(this.Reader.ReadGeometry(spPr.xfrm));
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
spPr.setFill(this.Reader.ReadUniFill(spPr, null, null));
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
spPr.setLn(this.Reader.ReadLn());
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
spPr.setEffectPr(this.Reader.ReadEffectProperties());
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
case 6:
|
|
{
|
|
var _len = s.GetULong();
|
|
s.Skip2(_len);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
s.SkipRecord();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s.Seek2(_end_rec);
|
|
};
|
|
|
|
this.CorrectXfrm = function(_xfrm)
|
|
{
|
|
if (!_xfrm)
|
|
return;
|
|
|
|
if (null == _xfrm.rot)
|
|
return;
|
|
|
|
var nInvertRotate = 0;
|
|
if (true === _xfrm.flipH)
|
|
nInvertRotate += 1;
|
|
if (true === _xfrm.flipV)
|
|
nInvertRotate += 1;
|
|
|
|
var _rot = _xfrm.rot;
|
|
var _del = 2 * Math.PI;
|
|
|
|
if (nInvertRotate)
|
|
_rot = -_rot;
|
|
|
|
if (_rot >= _del)
|
|
{
|
|
var _intD = (_rot / _del) >> 0;
|
|
_rot = _rot - _intD * _del;
|
|
}
|
|
else if (_rot < 0)
|
|
{
|
|
var _intD = (-_rot / _del) >> 0;
|
|
_intD = 1 + _intD;
|
|
_rot = _rot + _intD * _del;
|
|
}
|
|
|
|
_xfrm.rot = _rot;
|
|
};
|
|
|
|
|
|
this.CheckImagesNeeds = function(logicDoc)
|
|
{
|
|
var index = 0;
|
|
logicDoc.ImageMap = {};
|
|
for (var i in this.ImageMapChecker)
|
|
{
|
|
logicDoc.ImageMap[index++] = i;
|
|
}
|
|
};
|
|
|
|
this.Clear = function(bClearStreamOnly)
|
|
{
|
|
//вызывается пока только перед вставкой
|
|
this.Reader.stream = null;
|
|
this.stream = null;
|
|
this.BaseReader = null;
|
|
if(!bClearStreamOnly)
|
|
this.ImageMapChecker = {};
|
|
this.Reader.ClearSmartArts();
|
|
};
|
|
}
|
|
|
|
//----------------------------------------------------------export----------------------------------------------------
|
|
window['AscCommon'] = window['AscCommon'] || {};
|
|
window['AscCommon'].c_dScalePPTXSizes = c_dScalePPTXSizes;
|
|
window['AscCommon'].CBuilderImages = CBuilderImages;
|
|
window['AscCommon'].BinaryPPTYLoader = BinaryPPTYLoader;
|
|
window['AscCommon'].IsHiddenObj = IsHiddenObj;
|
|
window['AscCommon'].pptx_content_loader = new CPPTXContentLoader();
|
|
|
|
|
|
|
|
|
|
})(window);
|