Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8f5cb6a648a79c0ac5a5cfe6e6b7c3d059936737
DocumentServer-v-9.2.0/sdkjs/visio/model/SerializeReader.js
Yajbir Singh f1b860b25c
Some checks failed
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

3481 lines
86 KiB
JavaScript
Raw Blame History

/*
* (c) Copyright Ascensio System SIA 2010-2023
*
* 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, document)
{
function BinaryVSDYLoader()
{
this.stream = null;
this.document = null;
this.ImageMapChecker = {};
this.binaryPPTYLoader = new AscCommon.BinaryPPTYLoader();
this.Load = function(base64_ppty, document)
{
this.document = document;
this.DrawingDocument = null;
if(document)
{
this.DrawingDocument = document.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 ("VSDY" != 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++;
const c_nVersionNoBase64 = 1;//todo Asc.c_nVersionNoBase64
if (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.binaryPPTYLoader.stream = this.stream;
this.binaryPPTYLoader.presentation = this.document;
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;
};
/**
* Loads a Visio document from binary stream and processes its components.
*
* @param {BinaryVSDYLoader} pReader - The binary reader
*/
this.LoadDocument = function()
{
let res = c_oSerConstants.ReadOk;
const stream = this.stream;
// Define table types
const TABLE_TYPES = {
DOCUMENT: 1,
APP: 2,
CORE: 3,
CUSTOM_PROPERTIES: 4
};
// Read the main table length
const mtLen = stream.GetUChar();
// Read and process sections immediately
for (let i = 0; i < mtLen; ++i) {
const sectionType = stream.GetUChar();
const sectionOffset = stream.GetULong();
// Store current position to return after processing section
const currentPos = stream.GetCurPos();
// Seek to section and process based on type
res = stream.Seek2(sectionOffset);
if (c_oSerConstants.ReadOk !== res) {
return res;
}
switch (sectionType) {
case TABLE_TYPES.APP:
this.document.app = new AscCommon.CApp();
this.document.app.fromStream(stream);
break;
case TABLE_TYPES.CORE:
this.document.core = new AscCommon.CCore();
this.document.core.fromStream(stream);
break;
case TABLE_TYPES.CUSTOM_PROPERTIES:
if (this.document.customProperties) {
this.document.customProperties.fromStream(stream);
}
break;
case TABLE_TYPES.DOCUMENT:
stream.Skip2(1);//type
this.document.fromPPTY(this);
break;
}
// Return to position after section type and offset
res = stream.Seek2(currentPos);
if (c_oSerConstants.ReadOk !== res) {
return res;
}
}
return res;
};
}
// /**
// * Loads a Visio document from a binary stream
// *
// * @param {BinaryVSDYLoader} pReader - The binary reader
// */
// AscVisio.CVisioDocument.prototype.fromPPTY = function(pReader) {
// const stream = pReader.stream;
// stream.Skip2(1);
//
// const startPos = stream.GetCurPos();
// const recordSize = stream.GetLong();
// const endPos = startPos + recordSize + 4;
//
// while (stream.GetCurPos() < endPos) {
// const recordType = stream.GetUChar();
//
// // this.readChild(recordType, pReader);
// const res = this.readChild(recordType, pReader);
// if (false === res) {
// stream.SkipRecord();
// }
// }
//
// stream.Seek2(endPos);
// };
AscVisio.CVisioDocument.prototype.readAttribute = undefined;
/**
* Read child elements from stream for CVisioDocument
*
* @param {BinaryVSDYLoader} pReader - The binary reader
* @param {number} elementType - The type of child element
*/
AscVisio.CVisioDocument.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
let t = this;
switch (elementType) {
case 0:
if (!this.documentSettings) {
this.documentSettings = new AscVisio.DocumentSettings_Type();
}
this.documentSettings.fromPPTY(pReader);
break;
case 1:
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const colorEntry = new AscVisio.ColorEntry_Type();
colorEntry.fromPPTY(pReader);
t.colors.push(colorEntry);
return true;
}
return false;
}
}, pReader);
break;
case 2:
//CFaceNames
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const faceName = new AscVisio.FaceName_Type();
faceName.fromPPTY(pReader);
t.faceNames.push(faceName);
return true;
}
return false;
}
}, pReader);
break;
case 3:
//CStyleSheets
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const styleSheet = new AscVisio.StyleSheet_Type();
styleSheet.fromPPTY(pReader);
t.styleSheets.push(styleSheet);
return true;
}
return false;
}
}, pReader);
break;
case 4:
this.documentSheet = new AscVisio.DocumentSheet_Type();
this.documentSheet.fromPPTY(pReader);
break;
case 5:
//CEventList
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const styleSheet = new AscVisio.EventItem_Type();
styleSheet.fromPPTY(pReader);
t.eventList.push(styleSheet);
return true;
}
return false;
}
}, pReader);
break;
case 6:
if (!this.headerFooter) {
this.headerFooter = new AscVisio.HeaderFooter_Type();
}
this.headerFooter.fromPPTY(pReader);
break;
case 7:
if (!this.masters) {
this.masters = new AscVisio.CMasters();
}
this.masters.fromPPTY(pReader);
break;
case 8:
if (!this.pages) {
this.pages = new AscVisio.CPages();
}
this.pages.fromPPTY(pReader);
break;
case 9:
//DataConnections
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
t.dataConnections = new AscVisio.CDataConnections();
t.dataConnections.fromPPTY(pReader);
return true;
}
return false;
}
}, pReader);
break;
case 10:
//Recordsets
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
t.dataRecordSets = new AscVisio.CDataRecordSets();
t.dataRecordSets.fromPPTY(pReader);
return true;
}
return false;
}
}, pReader);
break;
case 11:
//Solutions
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
if (!t.solutions) {
t.solutions = new AscVisio.CSolutions();
}
t.solutions.fromPPTY(pReader);
return true;
}
return false;
}
}, pReader);
break;
case 12:
if (!this.validation) {
this.validation = new AscVisio.CValidation();
}
this.validation.fromPPTY(pReader);
break;
case 13:
//Comments
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
t.commentsPart = new AscVisio.CComments();
t.commentsPart.fromPPTY(pReader);
return true;
}
return false;
}
}, pReader);
break;
case 14:
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
if (elementType === 0 && !t.windows) {
t.windows = new AscVisio.CWindows();
t.windows.fromPPTY(pReader);
return true;
}
return false;
}
}, pReader);
break;
case 15:
const len =stream.GetULong(4);//len
if (len > 0) {
//Themes
let theme = pReader.binaryPPTYLoader.ReadTheme()
this.themes.push(theme);
}
break;
// //todo VbaProject
// case 16:
// break;
//
// //todo JsaProject
// case 17:
// break;
default:
return false;
}
};
/**
* Read attributes from stream for DocumentSettings_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DocumentSettings_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.topPage = stream.GetULong();
break;
case 1:
this.defaultTextStyle = stream.GetULong();
break;
case 2:
this.defaultLineStyle = stream.GetULong();
break;
case 3:
this.defaultFillStyle = stream.GetULong();
break;
case 4:
this.defaultGuideStyle = stream.GetULong();
break;
case 5:
this.glueSettings = stream.GetLong();
break;
case 6:
this.snapSettings = stream.GetLong();
break;
case 7:
this.snapExtensions = stream.GetLong();
break;
case 9:
this.dynamicGridEnabled = stream.GetBool();
break;
case 10:
this.protectStyles = stream.GetBool();
break;
case 11:
this.protectShapes = stream.GetBool();
break;
case 12:
this.protectBkgnds = stream.GetBool();
break;
case 13:
this.protectMasters = stream.GetBool();
break;
case 14:
this.customMenusFile = stream.GetString2();
break;
case 15:
this.customToolbarsFile = stream.GetString2();
break;
case 16:
this.attachedToolbars = stream.GetString2();
break;
default:
return false;
}
return true;
};
/**
* Read children from stream for DocumentSettings_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DocumentSettings_Type.prototype.readChild = function(elementType, pReader) {
const t = this;
switch (elementType) {
case 0:
// Read Shape_Type
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
if (elementType === 0) {
const snapAngle = new AscVisio.SnapAngle_Type();
snapAngle.fromPPTY(pReader);
t.snapAngles.push(snapAngle);
return true;
}
return false;
}
}, pReader);
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for ColorEntry_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.ColorEntry_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.ix = stream.GetULong();
break;
case 1:
this.rgb = stream.GetString2();
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for FaceName_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.FaceName_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.nameU = stream.GetString2();
break;
case 1:
this.unicodeRanges = stream.GetString2();
break;
case 2:
this.charSets = stream.GetString2();
break;
case 3:
this.panos = stream.GetString2();
break;
case 4:
this.panose = stream.GetString2();
break;
case 5:
this.flags = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for StyleSheet_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.StyleSheet_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.nameU = stream.GetString2();
break;
case 2:
this.name = stream.GetString2();
break;
case 3:
this.isCustomName = stream.GetBool();
break;
case 4:
this.isCustomNameU = stream.GetBool();
break;
case 5:
this.lineStyle = stream.GetULong();
break;
case 6:
this.fillStyle = stream.GetULong();
break;
case 7:
this.textStyle = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for StyleSheet_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.StyleSheet_Type.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
switch (elementType) {
case 0: {
const cell = new AscVisio.Cell_Type();
cell.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(cell);
this.elements[key] = cell;
break;
}
case 1: {
const trigger = new AscVisio.Trigger_Type();
trigger.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(trigger);
this.elements[key] = trigger;
break;
}
case 2: {
const section = new AscVisio.Section_Type();
section.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(section);
this.elements[key] = section;
break;
}
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Cell_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Cell_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.n = stream.GetString2Utf8();
break;
case 1:
this.u = stream.GetString2Utf8();
break;
case 2:
this.e = stream.GetString2Utf8();
break;
case 3:
this.f = stream.GetString2Utf8();
break;
case 4:
this.v = stream.GetString2Utf8();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Cell_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Cell_Type.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const refBy = new AscVisio.RefBy_Type();
refBy.fromPPTY(pReader);
this.refBy.push(refBy);
return true;
}
return false;
};
/**
* Read attributes from stream for EventItem_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.EventItem_Type.prototype.readAttribute = function(attrType, pReader) {
switch (attrType) {
case 0:
this.id = pReader.stream.GetULong();
return true;
case 1:
this.action = pReader.stream.GetULong();
return true;
case 2:
this.eventCode = pReader.stream.GetULong();
return true;
case 3:
this.enabled = pReader.stream.GetBool();
return true;
case 4:
this.target = pReader.stream.GetString2();
return true;
case 5:
this.targetArgs = pReader.stream.GetString2();
return true;
}
return false;
};
/**
* Read attributes from stream for HeaderFooter_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.HeaderFooter_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.headerMargin = stream.GetDouble();
break;
case 1:
this.footerMargin = stream.GetDouble();
break;
case 2:
this.headerLeft = stream.GetString2();
break;
case 3:
this.headerCenter = stream.GetString2();
break;
case 4:
this.headerRight = stream.GetString2();
break;
case 5:
this.footerLeft = stream.GetString2();
break;
case 6:
this.footerCenter = stream.GetString2();
break;
case 7:
this.footerRight = stream.GetString2();
break;
case 8:
this.headerFooterFont = stream.GetString2();
break;
default:
return false;
}
return true;
};
AscVisio.CMasters.prototype.readAttribute = undefined;
/**
* Read child elements from stream for CMasters
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CMasters.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const master = new AscVisio.Master_Type();
master.fromPPTY(pReader);
this.master.push(master);
return true;
}
return false;
};
/**
* Read attributes from stream for Master_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Master_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.name = stream.GetString2();
break;
case 2:
this.nameU = stream.GetString2();
break;
case 3:
this.baseID = stream.GetString2();
break;
case 4:
this.uniqueID = stream.GetString2();
break;
case 5:
this.matchByName = stream.GetBool();
break;
case 6:
this.isCustomName = stream.GetBool();
break;
case 7:
this.isCustomNameU = stream.GetBool();
break;
case 8:
this.iconSize = stream.GetULong();
break;
case 9:
this.patternFlags = stream.GetULong();
break;
case 10:
this.prompt = stream.GetString2();
break;
case 11:
this.hidden = stream.GetBool();
break;
case 12:
this.iconUpdate = stream.GetBool();
break;
case 13:
this.alignName = stream.GetULong();
break;
case 14:
this.masterType = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Master_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Master_Type.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
switch (elementType) {
case 0: {
this.pageSheet = new AscVisio.PageSheet_Type();
this.pageSheet.fromPPTY(pReader);
break;
}
case 1: {
this.icon = new AscVisio.Icon_Type();
this.icon.fromPPTY(pReader);
break;
}
case 2: {
const masterContents = new AscVisio.CMasterContents();
masterContents.fromPPTY(pReader);
this.content = masterContents;
break;
}
default:
return false;
}
return true;
};
AscVisio.CMasterContents.prototype.readAttribute = undefined;
/**
* Read child elements from stream for CMasterContents
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CMasterContents.prototype.readChild = function(elementType, pReader) {
let t = this;
switch (elementType) {
case 0: {
// Read Shapes
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
if (elementType === 0) {
const shape = new AscVisio.Shape_Type();
shape.fromPPTY(pReader);
t.shapes.push(shape);
return true;
}
return false;
}
}, pReader);
break;
}
case 1: {
// Read Connects
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
if (elementType === 0) {
const connect = new AscVisio.Connect_Type();
connect.fromPPTY(pReader);
t.connects.push(connect);
return true;
}
return false;
}
}, pReader);
break;
}
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Connect_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Connect_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.fromSheet = stream.GetULong();
break;
case 1:
this.fromCell = stream.GetString2Utf8();
break;
case 2:
this.fromPart = stream.GetLong();
break;
case 3:
this.toSheet = stream.GetULong();
break;
case 4:
this.toCell = stream.GetString2Utf8();
break;
case 5:
this.toPart = stream.GetLong();
break;
default:
return false;
}
return true;
};
AscVisio.CPages.prototype.readAttribute = undefined;
/**
* Read child elements from stream for CPages
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CPages.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const page = new AscVisio.Page_Type();
page.fromPPTY(pReader);
this.page.push(page);
return true;
}
return false;
};
/**
* Read attributes from stream for Page_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Page_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.name = stream.GetString2();
break;
case 2:
this.nameU = stream.GetString2();
break;
case 3:
this.isCustomName = stream.GetBool();
break;
case 4:
this.isCustomNameU = stream.GetBool();
break;
case 5:
this.background = stream.GetBool();
break;
case 6:
this.backPage = stream.GetULong();
break;
case 7:
this.viewScale = stream.GetDouble();
break;
case 8:
this.viewCenterX = stream.GetDouble();
break;
case 9:
this.viewCenterY = stream.GetDouble();
break;
case 10:
this.reviewerID = stream.GetULong();
break;
case 11:
this.associatedPage = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Page_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Page_Type.prototype.readChild = function(elementType, pReader) {
switch (elementType) {
case 0: {
this.pageSheet = new AscVisio.PageSheet_Type();
this.pageSheet.fromPPTY(pReader);
break;
}
case 1: {
const pageContents = new AscVisio.CPageContents();
pageContents.fromPPTY(pReader);
this.content = pageContents;
break;
}
default:
return false;
}
return true;
};
/**
* Read attributes from stream for PageSheet_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.PageSheet_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.uniqueID = stream.GetString2();
break;
case 1:
this.lineStyle = stream.GetULong();
break;
case 2:
this.fillStyle = stream.GetULong();
break;
case 3:
this.textStyle = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for PageSheet_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.PageSheet_Type.prototype.readChild = function(elementType, pReader) {
switch (elementType) {
case 0: {
const cell = new AscVisio.Cell_Type();
cell.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(cell);
this.elements[key] = cell;
break;
}
case 1: {
const trigger = new AscVisio.Trigger_Type();
trigger.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(trigger);
this.elements[key] = trigger;
break;
}
case 2: {
const section = new AscVisio.Section_Type();
section.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(section);
this.elements[key] = section;
break;
}
default:
return false;
}
return true;
};
// /**
// * Read attributes from stream for Comment_Type
// *
// * @param {number} attrType - The type of attribute
// * @param {BinaryVSDYLoader} pReader - The binary reader
// * @returns {boolean} - True if attribute was handled, false otherwise
// */
// AscVisio.Comment_Type.prototype.readAttribute = function(attrType, pReader) {
// const stream = pReader.stream;
// switch (attrType) {
// case 0:
// this.id = stream.GetULong();
// break;
// case 1:
// this.authorName = stream.GetString2();
// break;
// case 2:
// this.authorInitials = stream.GetString2();
// break;
// case 3:
// this.text = stream.GetString2();
// break;
// case 4:
// this.date = stream.GetString2();
// break;
// case 5:
// this.reviewerID = stream.GetULong();
// break;
// case 6:
// this.shapeId = stream.GetULong();
// break;
// case 7:
// this.pageId = stream.GetULong();
// break;
// default:
// return false;
// }
//
// return true;
// };
// /**
// * Read attributes from stream for Recordset_Type
// *
// * @param {number} attrType - The type of attribute
// * @param {BinaryVSDYLoader} pReader - The binary reader
// * @returns {boolean} - True if attribute was handled, false otherwise
// */
// AscVisio.Recordset_Type.prototype.readAttribute = function(attrType, pReader) {
// const stream = pReader.stream;
// switch (attrType) {
// case 0:
// this.id = stream.GetULong();
// break;
// case 1:
// this.name = stream.GetString2();
// break;
// case 2:
// this.dataSource = stream.GetString2();
// break;
// case 3:
// this.command = stream.GetString2();
// break;
// case 4:
// this.options = stream.GetULong();
// break;
// case 5:
// this.timeRefreshed = stream.GetString2();
// break;
// case 6:
// this.nextRowID = stream.GetULong();
// break;
// default:
// return false;
// }
//
// return true;
// };
/**
* Read attributes from stream for CComments
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.CComments.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.showCommentTags = pReader.stream.GetBool();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read child elements from stream for CComments
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CComments.prototype.readChild = function(elementType, pReader)
{
let handled = true;
let t = this;
switch (elementType)
{
case 0:
// Read author list elements
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const authorEntry = new AscVisio.AuthorEntry_Type();
authorEntry.fromPPTY(pReader);
t.authorList.push(authorEntry);
return true;
}
return false;
}
}, pReader);
break;
case 1:
// Read comment list elements
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const commentEntry = new AscVisio.CommentEntry_Type();
commentEntry.fromPPTY(pReader);
t.commentList.push(commentEntry);
return true;
}
return false;
}
}, pReader);
break;
default:
handled = false;
break;
}
return handled;
};
AscVisio.CSolutions.prototype.readAttribute = undefined;
/**
* Read child elements from stream for CSolutions
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CSolutions.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const solution = new AscVisio.Solution_Type();
solution.fromPPTY(pReader);
this.solution.push(solution);
return true;
}
return false;
};
/**
* Read attributes from stream for Solution_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Solution_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.name = stream.GetString2();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Solution_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Solution_Type.prototype.readChild = function(elementType, pReader) {
let res = true;
let t = this;
switch (elementType) {
case 0: {
pReader.stream.Skip2(4);//len
pReader.stream.Skip2(1);//type
const len = pReader.stream.GetULong();
this.content = pReader.stream.GetBufferUint8(len);
break;
}
default: {
res = false;
break;
}
}
return res;
}
AscVisio.CValidation.prototype.readAttribute = undefined;
/**
* Read child elements from stream for CValidation
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CValidation.prototype.readChild = function(elementType, pReader) {
let res = true;
let t = this;
switch (elementType) {
case 0: {
this.validationProperties = new AscVisio.ValidationProperties_Type();
this.validationProperties.fromPPTY(pReader);
break;
}
case 1: {
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
let elem = new AscVisio.RuleSet_Type();
elem.fromPPTY(pReader);
t.ruleSets.push(elem);
return true;
}
return false;
}
}, pReader);
break;
}
case 2: {
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
let elem = new AscVisio.Issue_Type();
elem.fromPPTY(pReader);
t.issues.push(elem);
return true;
}
return false;
}
}, pReader);
break;
}
default: {
res = false;
break;
}
}
return res;
};
/**
* Read attributes from stream for CWindows
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.CWindows.prototype.readAttribute = function(attrType, pReader) {
let stream = pReader.stream;
switch (attrType) {
case 0:
this.clientWidth = stream.GetULong();
return true;
case 1:
this.clientHeight = stream.GetULong();
return true;
}
return false;
};
/**
* Read child elements from stream for CWindows
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CWindows.prototype.readChild = function(elementType, pReader) {
let stream = pReader.stream;
if (elementType === 0) {
let window = new AscVisio.Window_Type();
window.fromPPTY(pReader);
this.window.push(window);
return true;
}
return false;
};
/**
* Read attributes from stream for Window_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Window_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
return true;
case 1:
this.windowType = stream.GetUChar();
return true;
case 2:
this.windowState = stream.GetULong();
return true;
case 3:
this.windowLeft = stream.GetLong();
return true;
case 4:
this.windowTop = stream.GetLong();
return true;
case 5:
this.windowWidth = stream.GetULong();
return true;
case 6:
this.windowHeight = stream.GetULong();
return true;
case 7:
this.containerType = stream.GetUChar();
return true;
case 8:
this.container = stream.GetULong();
return true;
case 9:
this.page = stream.GetULong();
return true;
case 10:
this.sheet = stream.GetULong();
return true;
case 11:
this.viewScale = stream.GetDouble();
return true;
case 12:
this.viewCenterX = stream.GetDouble();
return true;
case 13:
this.viewCenterY = stream.GetDouble();
return true;
case 14:
this.document = stream.GetString2();
return true;
case 15:
this.parentWindow = stream.GetULong();
return true;
case 16:
this.readOnly = stream.GetBool();
return true;
case 17:
this.showRulers = stream.GetBool();
return true;
case 18:
this.showGrid = stream.GetBool();
return true;
case 19:
this.showPageBreaks = stream.GetBool();
return true;
case 20:
this.showGuides = stream.GetBool();
return true;
case 21:
this.showConnectionPoints = stream.GetBool();
return true;
case 22:
this.glueSettings = stream.GetULong();
return true;
case 23:
this.snapSettings = stream.GetULong();
return true;
case 24:
this.snapExtensions = stream.GetULong();
return true;
case 26:
this.dynamicGridEnabled = stream.GetBool();
return true;
case 27:
this.tabSplitterPos = stream.GetDouble();
return true;
case 28:
this.stencilGroup = stream.GetULong();
return true;
case 29:
this.stencilGroupPos = stream.GetULong();
return true;
}
return false;
};
/**
* Read children from stream for DocumentSettings_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Window_Type.prototype.readChild = function(elementType, pReader) {
const t = this;
switch (elementType) {
case 0:
// Read Shape_Type
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
if (elementType === 0) {
const snapAngle = new AscVisio.SnapAngle_Type();
snapAngle.fromPPTY(pReader);
t.snapAngles.push(snapAngle);
return true;
}
return false;
}
}, pReader);
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Window_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.SnapAngle_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.value = stream.GetDouble();
return true;
}
return false;
};
/**
* Read attributes from stream for DocumentSheet_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DocumentSheet_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.uniqueID = stream.GetString2();
break;
case 1:
this.nameU = stream.GetString2();
break;
case 2:
this.name = stream.GetString2();
break;
case 3:
this.isCustomName = stream.GetBool();
break;
case 4:
this.isCustomNameU = stream.GetBool();
break;
case 5:
this.lineStyle = stream.GetULong();
break;
case 6:
this.fillStyle = stream.GetULong();
break;
case 7:
this.textStyle = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for DocumentSheet_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.DocumentSheet_Type.prototype.readChild = function(elementType, pReader) {
const stream = pReader.stream;
switch (elementType) {
case 0: {
const cell = new AscVisio.Cell_Type();
cell.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(cell);
this.elements[key] = cell;
break;
}
case 1: {
const trigger = new AscVisio.Trigger_Type();
trigger.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(trigger);
this.elements[key] = trigger;
break;
}
case 2: {
const selection = new AscVisio.Section_Type();
selection.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(selection);
this.elements[key] = selection;
break;
}
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Trigger_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Trigger_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.n = stream.GetString2Utf8();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Trigger_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Trigger_Type.prototype.readChild = function(elementType, pReader) {
if (elementType === 0) {
const refBy = new AscVisio.RefBy_Type();
refBy.fromPPTY(pReader);
this.refBy.push(refBy);
return true;
}
return false;
};
/**
* Read attributes from stream for Section_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Section_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.ix = stream.GetULong();
break;
case 1:
this.n = stream.GetString2Utf8();
break;
case 2:
this.del = stream.GetBool();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Section_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Section_Type.prototype.readChild = function(elementType, pReader) {
switch (elementType) {
case 0: {
const cell = new AscVisio.Cell_Type();
cell.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(cell);
this.elements[key] = cell;
break;
}
case 1: {
const trigger = new AscVisio.Trigger_Type();
trigger.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(trigger);
this.elements[key] = trigger;
break;
}
case 6: {
const row = new AscVisio.Row_Type();
row.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(row);
this.elements[key] = row;
break;
}
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Row_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Row_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.ix = stream.GetULong();
break;
case 1:
this.n = stream.GetString2Utf8();
break;
case 2:
this.localName = stream.GetString2();
break;
case 3:
this.t = stream.GetString2Utf8();
break;
case 4:
this.del = stream.GetBool();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Row_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Row_Type.prototype.readChild = function(elementType, pReader) {
switch (elementType) {
case 0: {
const cell = new AscVisio.Cell_Type();
cell.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(cell);
this.elements[key] = cell;
break;
}
case 1: {
const trigger = new AscVisio.Trigger_Type();
trigger.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(trigger);
this.elements[key] = trigger;
break;
}
default:
return false;
}
return true;
};
AscVisio.CPageContents.prototype.readAttribute = undefined;
/**
* Read child elements from stream for CPageContents
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CPageContents.prototype.readChild = function(elementType, pReader) {
let t = this;
switch (elementType) {
case 0: {
// Read Shapes
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
const stream = pReader.stream;
if (elementType === 0) {
const shape = new AscVisio.Shape_Type();
shape.fromPPTY(pReader);
t.shapes.push(shape);
return true;
}
return false;
}
}, pReader);
break;
}
case 1: {
// Read Connects
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
if (elementType === 0) {
const connect = new AscVisio.Connect_Type();
connect.fromPPTY(pReader);
t.connects.push(connect);
return true;
}
return false;
}
}, pReader);
break;
}
// case 2: {
// // Handle Master relationships
// const stream = pReader.stream;
// const endPos = stream.GetPos() + stream.GetULong() + 4;
//
// // Skip start attributes byte
// stream.Skip2(1);
//
// let id = null;
// let uniqueID = null;
//
// // Read attributes
// while (true) {
// const attrType = stream.GetUChar();
// if (attrType === AscVisio.g_nodeAttributeEnd)
// break;
//
// switch (attrType) {
// case 0:
// id = stream.GetULong();
// break;
// case 1:
// uniqueID = stream.GetString2();
// break;
// }
// }
//
// // Store master relationship info
// if (id !== null || uniqueID !== null) {
// if (!this.masterRels) {
// this.masterRels = [];
// }
// this.masterRels.push({ id: id, uniqueID: uniqueID });
// }
//
// // Seek to end of record
// stream.Seek2(endPos);
// break;
// }
// case 3: {
// // Handle Page relationships
// const stream = pReader.stream;
// const endPos = stream.GetPos() + stream.GetULong() + 4;
//
// // Skip start attributes byte
// stream.Skip2(1);
//
// let id = null;
//
// // Read attributes
// while (true) {
// const attrType = stream.GetUChar();
// if (attrType === AscVisio.g_nodeAttributeEnd)
// break;
//
// switch (attrType) {
// case 0:
// id = stream.GetULong();
// break;
// }
// }
//
// // Store page relationship info
// if (id !== null) {
// if (!this.pageRels) {
// this.pageRels = [];
// }
// this.pageRels.push(id);
// }
//
// // Seek to end of record
// stream.Seek2(endPos);
// break;
// }
default:
return false;
}
return true;
};
/**
* Loads a Visio document from a binary stream
*
* @param {BinaryVSDYLoader} pReader - The binary reader
*/
AscVisio.Shape_Type.prototype.fromPPTY = function(pReader) {
AscVisio.SheetStorageAndStyles.prototype.fromPPTY.call(this, pReader);
//todo make common with xml
if (this.type === AscVisio.SHAPE_TYPES_FOREIGN) {
let foreignDataObject = this.getForeignDataObject();
if (foreignDataObject && foreignDataObject.mediaFilename) {
// if image init image
// imitate presentation parse workflow
// CBlipFill stores data about blib fill (stretch, effects, rasterImageId) and calls CBlip.fromXml
// CBlip has this.blipFill and this.link
// CBlip.prototype.readAttrXml reads image rId and calls
// fReadXmlRasterImageId which inits reader.context.imageMap, imageMap stores blipFills array.
// CBlipFill is part of CUniFill which is part of CImageShape
// pic tag read
let oSp = new AscFormat.CImageShape();
// nvPicPr tag read
let prop = new AscFormat.UniNvPr();
oSp.setNvPicPr(prop);
oSp.setLocks(prop.getLocks());
// blipFill tag read
let uni_fill = new AscFormat.CUniFill();
uni_fill.fill = new AscFormat.CBlipFill();
if (uni_fill.fill) {
let oImageShape = oSp;
var sReadPath = foreignDataObject.mediaFilename;
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);
//todo common function
const allowExt = ["png","jpg", "jpeg", "jpe"];
var ext = AscCommon.GetFileExtension(sReadPath);
if (ext === "emf" || ext === "wmf") {
sReadPath = AscCommon.changeFileExtention(sReadPath, "svg");
uni_fill.fill.setRasterImageId(sReadPath);
} else if (allowExt.indexOf(ext) === -1) {
var images = AscCommon.g_oDocumentUrls.getImagesWithOtherExtension(sReadPath);
if (images.length > 0) {
for (var i = 0; i < images.length; i++) {
var image = images[i];
var ext = AscCommon.GetFileExtension(image);
if (allowExt.indexOf(ext) !== -1) {
sReadPath = image;
uni_fill.fill.setRasterImageId(sReadPath);
break;
}
}
}
}
// ----------------------------
if (this.IsThemeLoader)
{
sReadPath = "theme" + (this.Api.ThemeLoader.CurrentLoadThemeIndex + 1) + "/media/" + sReadPath;
uni_fill.fill.setRasterImageId(sReadPath);
}
if (pReader.ImageMapChecker != null)
{
let bAddToMap = true;
if(oImageShape && oImageShape instanceof AscFormat.COleObject)
{
if(sReadPath.indexOf(".") === -1)
{
bAddToMap = false;
}
}
if(bAddToMap)
{
if (!pReader.document.ImageMap) {
pReader.document.ImageMap = {};
}
pReader.document.ImageMap[Object.keys(pReader.document.ImageMap).length] = sReadPath;
}
}
if (this.IsUseFullUrl) {
//this.RebuildImages.push(new CBuilderImages(uni_fill.fill, sReadPath, oImageShape, oSpPr, oLn, undefined, undefined, undefined, oParagraph, oBullet));
}
if (uni_fill.checkTransparent) {
uni_fill.checkTransparent();
}
}
oSp.setBlipFill(uni_fill.fill);
this.cImageShape = oSp;
}
}
}
/**
* Read attributes from stream for Shape_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Shape_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.type = stream.GetUChar();
break;
case 2:
this.originalID = stream.GetULong();
break;
case 3:
this.del = stream.GetBool();
break;
case 4:
this.masterShape = stream.GetULong();
break;
case 5:
this.uniqueID = stream.GetString2();
break;
case 6:
this.nameU = stream.GetString2();
break;
case 7:
this.name = stream.GetString2();
break;
case 8:
this.isCustomName = stream.GetBool();
break;
case 9:
this.isCustomNameU = stream.GetBool();
break;
case 10:
this.master = stream.GetULong();
break;
case 11:
this.lineStyle = stream.GetULong();
break;
case 12:
this.fillStyle = stream.GetULong();
break;
case 13:
this.textStyle = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Shape_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Shape_Type.prototype.readChild = function(elementType, pReader) {
let t = this;
switch (elementType) {
case 0: {
const cell = new AscVisio.Cell_Type();
cell.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(cell);
this.elements[key] = cell;
break;
}
case 1: {
const trigger = new AscVisio.Trigger_Type();
trigger.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(trigger);
this.elements[key] = trigger;
break;
}
case 2: {
const section = new AscVisio.Section_Type();
section.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(section);
this.elements[key] = section;
break;
}
case 3: {
const text = new AscVisio.Text_Type();
text.fromPPTY(pReader);
const key = AscVisio.createKeyFromSheetObject(text);
this.elements[key] = text;
break;
}
case 4: {
const foreignData = new AscVisio.ForeignData_Type();
foreignData.fromPPTY(pReader);
let key = AscVisio.createKeyFromSheetObject(foreignData);
this.elements[key] = foreignData;
break;
}
case 5: {
// Read Shapes
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readChild: function(elementType, pReader) {
if (elementType === 0) {
const shape = new AscVisio.Shape_Type();
shape.fromPPTY(pReader);
t.shapes.push(shape);
return true;
}
return false;
}
}, pReader);
break;
}
default:
return false;
}
return true;
};
AscVisio.Text_Type.prototype.readAttribute = undefined;
/**
* Read child elements from stream for Text_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Text_Type.prototype.readChild = function(elementType, pReader) {
let t = this;
switch (elementType) {
case 0: {
// Text_cp (Character properties)
const textCp = new AscVisio.cp_Type();
textCp.fromPPTY(pReader);
this.elements.push(textCp);
break;
}
case 1: {
// Text_pp (Paragraph properties)
const textPp = new AscVisio.pp_Type();
textPp.fromPPTY(pReader);
this.elements.push(textPp);
break;
}
case 2: {
// Text_tp (Tab properties)
const textTp = new AscVisio.tp_Type();
textTp.fromPPTY(pReader);
this.elements.push(textTp);
break;
}
case 3: {
// Text_fld (Field)
const textFld = new AscVisio.fld_Type();
textFld.fromPPTY(pReader);
this.elements.push(textFld);
break;
}
case 4: {
// Text_text (Text content)
// Read Shapes
AscFormat.CBaseFormatNoIdObject.prototype.fromPPTY.call({
readChildren: AscFormat.CBaseFormatNoIdObject.prototype.readChildren,
readAttributes: AscFormat.CBaseFormatNoIdObject.prototype.readAttributes,
readAttribute: function(attrType, pReader) {
if (attrType === 0) {
t.elements.push(pReader.stream.GetString2());
return true;
}
return false;
}
}, pReader);
break;
}
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Text_fld_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.fld_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.ix = stream.GetULong();
break;
case 1:
this.value = stream.GetString2();
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Text_tp_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.tp_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.ix = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Text_pp_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.pp_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.ix = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for Text_cp_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.cp_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.ix = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for CDataConnections
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.CDataConnections.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.nextID = pReader.stream.GetULong();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read child elements from stream for CDataConnections
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CDataConnections.prototype.readChild = function(elementType, pReader)
{
let handled = true;
switch (elementType)
{
case 0:
let dataConnection = new AscVisio.DataConnection_Type();
dataConnection.fromPPTY(pReader);
this.dataConnection.push(dataConnection);
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for CDataRecordSets
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.CDataRecordSets.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.nextID = pReader.stream.GetULong();
break;
case 1:
this.activeRecordsetID = pReader.stream.GetULong();
break;
case 2:
this.dataWindowOrder = pReader.stream.GetString2();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read child elements from stream for CDataRecordSets
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.CDataRecordSets.prototype.readChild = function(elementType, pReader)
{
let handled = true;
switch (elementType)
{
case 0:
let dataRecordSet = new AscVisio.DataRecordSet_Type();
dataRecordSet.fromPPTY(pReader);
this.dataRecordSet.push(dataRecordSet);
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for CommentEntry_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.CommentEntry_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.authorID = pReader.stream.GetULong();
break;
case 1:
this.pageID = pReader.stream.GetULong();
break;
case 2:
this.shapeID = pReader.stream.GetULong();
break;
case 3:
this.date = pReader.stream.GetString2();
break;
case 4:
this.editDate = pReader.stream.GetString2();
break;
case 5:
this.commentID = pReader.stream.GetULong();
break;
case 6:
this.autoCommentType = pReader.stream.GetULong();
break;
case 7:
this.value = pReader.stream.GetString2(); // Called 'content' in C++
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for AuthorEntry_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.AuthorEntry_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.id = pReader.stream.GetULong();
break;
case 1:
this.name = pReader.stream.GetString2();
break;
case 2:
this.initials = pReader.stream.GetString2();
break;
case 3:
this.resolutionID = pReader.stream.GetString2();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for RuleTest_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.RuleTest_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.value = pReader.stream.GetString2(); // Formula in C++
break;
default:
handled = false;
break;
}
return handled;
};
AscVisio.RuleFilter_Type.prototype.readAttribute = AscVisio.RuleTest_Type.prototype.readAttribute
/**
* Read attributes from stream for RowKeyValue_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.RowKeyValue_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.rowID = pReader.stream.GetULong();
break;
case 1:
this.value = pReader.stream.GetString2();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for DataColumn_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DataColumn_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.columnNameID = pReader.stream.GetString2();
break;
case 1:
this.name = pReader.stream.GetString2();
break;
case 2:
this.label = pReader.stream.GetString2();
break;
case 3:
this.origLabel = pReader.stream.GetString2();
break;
case 4:
//todo int or string
pReader.stream.GetString2();
//this.langID ;
break;
case 5:
this.calendar = pReader.stream.GetULong();
break;
case 6:
this.dataType = pReader.stream.GetULong();
break;
case 7:
this.unitType = pReader.stream.GetString2();
break;
case 8:
this.currency = pReader.stream.GetULong();
break;
case 9:
this.degree = pReader.stream.GetULong();
break;
case 10:
this.displayWidth = pReader.stream.GetULong();
break;
case 11:
this.displayOrder = pReader.stream.GetULong();
break;
case 12:
this.mapped = pReader.stream.GetBool();
break;
case 13:
this.hyperlink = pReader.stream.GetBool();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for RuleInfo_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.RuleInfo_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.ruleID = pReader.stream.GetULong();
break;
case 1:
this.ruleSetID = pReader.stream.GetULong();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for IssueTarget_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.IssueTarget_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.pageID = pReader.stream.GetULong();
break;
case 1:
this.shapeID = pReader.stream.GetULong();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for Rule_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Rule_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.id = pReader.stream.GetULong();
break;
case 1:
this.category = pReader.stream.GetString2();
break;
case 2:
this.nameU = pReader.stream.GetString2();
break;
case 3:
this.ignored = pReader.stream.GetBool();
break;
case 4:
this.description = pReader.stream.GetString2();
break;
case 5:
this.ruleTarget = pReader.stream.GetLong();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read child elements from stream for Rule_Type
*
* @param {number} recType - The type of record
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if child was handled, false otherwise
*/
AscVisio.Rule_Type.prototype.readChild = function(recType, pReader)
{
let handled = true;
switch (recType)
{
case 0:
this.ruleFilter = new AscVisio.RuleFilter_Type();
this.ruleFilter.fromPPTY(pReader);
break;
case 1:
this.ruleTest = new AscVisio.RuleTest_Type();
this.ruleTest.fromPPTY(pReader);
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for RuleSetFlags_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.RuleSetFlags_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.hidden = pReader.stream.GetBool();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for RowMap_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.RowMap_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.rowID = pReader.stream.GetULong();
break;
case 1:
this.pageID = pReader.stream.GetULong();
break;
case 2:
this.shapeID = pReader.stream.GetULong();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for PrimaryKey_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.PrimaryKey_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.columnNameID = pReader.stream.GetString2();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read child elements from stream for PrimaryKey_Type
*
* @param {number} recType - The type of record
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if child was handled, false otherwise
*/
AscVisio.PrimaryKey_Type.prototype.readChild = function(recType, pReader)
{
let handled = true;
switch (recType)
{
case 0:
const rowKeyValue = new AscVisio.RowKeyValue_Type();
rowKeyValue.fromPPTY(pReader);
this.rowKeyValue.push(rowKeyValue);
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for DataColumns_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DataColumns_Type.prototype.readAttribute = function(attrType, pReader)
{
let handled = true;
switch (attrType)
{
case 0:
this.sortColumn = pReader.stream.GetString2();
break;
case 1:
this.sortAsc = pReader.stream.GetBool();
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read child elements from stream for DataColumns_Type
*
* @param {number} recType - The type of record
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if child was handled, false otherwise
*/
AscVisio.DataColumns_Type.prototype.readChild = function(recType, pReader)
{
let handled = true;
switch (recType)
{
case 0:
const dataColumn = new AscVisio.DataColumn_Type();
dataColumn.fromPPTY(pReader);
this.dataColumn.push(dataColumn);
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for ForeignData_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.ForeignData_Type.prototype.readAttribute = function(attrType, pReader) {
let res = true;
switch (attrType) {
case 0:
this.foreignType = pReader.stream.GetUChar();
break;
case 1:
this.objectType = pReader.stream.GetULong();
break;
case 2:
this.showAsIcon = pReader.stream.GetBool();
break;
case 3:
this.objectWidth = pReader.stream.GetDouble();
break;
case 4:
this.objectHeight = pReader.stream.GetDouble();
break;
case 5:
this.extentX = pReader.stream.GetDouble();
break;
case 6:
this.extentY = pReader.stream.GetDouble();
break;
case 7:
this.compressionType = pReader.stream.GetUChar();
break;
case 8:
this.compressionLevel = pReader.stream.GetDouble();
break;
default:
res = false;
break;
}
return res;
};
/**
* Read child elements from stream for ForeignData_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.ForeignData_Type.prototype.readChild = function(elementType, pReader) {
let res = true;
switch (elementType) {
case 1:
pReader.stream.Skip2(4);//len
// media filename
this.mediaFilename = pReader.stream.GetString2();
break;
case 2:
pReader.stream.Skip2(4);//len
// ole filename
this.oleFilename = pReader.stream.GetString2();
break;
default:
res = false;
break;
}
return res;
};
/**
* Read attributes from stream for DocumentSheet_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DocumentSheet_Type.prototype.readAttribute = function(attrType, pReader) {
let res = true;
switch (attrType) {
case 0:
this.uniqueID = pReader.stream.GetString2();
break;
case 1:
this.nameU = pReader.stream.GetString2();
break;
case 2:
this.name = pReader.stream.GetString2();
break;
case 3:
this.isCustomName = pReader.stream.GetBool();
break;
case 4:
this.isCustomNameU = pReader.stream.GetBool();
break;
case 5:
this.lineStyle = pReader.stream.GetULong();
break;
case 6:
this.fillStyle = pReader.stream.GetULong();
break;
case 7:
this.textStyle = pReader.stream.GetULong();
break;
default:
res = false;
break;
}
return res;
};
/**
* Read child elements from stream for DocumentSheet_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.DocumentSheet_Type.prototype.readChild = function(elementType, pReader) {
let res = true;
let element, key;
switch (elementType) {
case 0:
element = new AscVisio.Cell_Type();
element.fromPPTY(pReader);
key = AscVisio.createKeyFromSheetObject(element);
this.elements[key] = element;
break;
case 1:
element = new AscVisio.Trigger_Type();
element.fromPPTY(pReader);
key = AscVisio.createKeyFromSheetObject(element);
this.elements[key] = element;
break;
case 2:
element = new AscVisio.Section_Type();
element.fromPPTY(pReader);
key = AscVisio.createKeyFromSheetObject(element);
this.elements[key] = element;
break;
default:
res = false;
break;
}
return res;
};
/**
* Read attributes from stream for RefBy_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.RefBy_Type.prototype.readAttribute = function(attrType, pReader) {
let res = true;
switch (attrType) {
case 0:
this.id = pReader.stream.GetULong();
break;
case 1:
this.t = pReader.stream.GetString2();
break;
default:
res = false;
break;
}
return res;
};
/**
* Read from binary stream for Icon_Type
*
* @param {BinaryVSDYLoader} pReader - The binary reader
*/
AscVisio.Icon_Type.prototype.fromPPTY = function(pReader) {
const _end_rec = pReader.stream.cur + pReader.stream.GetULong() + 4;
this.value = pReader.stream.GetString2();
pReader.stream.Seek2(_end_rec);
};
/**
* Read attributes from stream for Issue_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.Issue_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.ignored = stream.GetBool();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for Issue_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.Issue_Type.prototype.readChild = function(elementType, pReader) {
let handled = true;
switch (elementType) {
case 0:
this.issueTarget = new AscVisio.IssueTarget_Type();
this.issueTarget.fromPPTY(pReader);
break;
case 1:
this.ruleInfo = new AscVisio.RuleInfo_Type();
this.ruleInfo.fromPPTY(pReader);
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for RuleSet_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.RuleSet_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.nameU = stream.GetString2();
break;
case 2:
this.name = stream.GetString2();
break;
case 3:
this.description = stream.GetString2();
break;
case 4:
this.enabled = stream.GetBool();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for RuleSet_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.RuleSet_Type.prototype.readChild = function(elementType, pReader) {
let handled = true;
switch (elementType) {
case 0:
this.ruleSetFlags = new AscVisio.RuleSetFlags_Type();
this.ruleSetFlags.fromPPTY(pReader);
break;
case 1:
let rule = new AscVisio.Rule_Type();
rule.fromPPTY(pReader);
this.rule.push(rule);
break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for ValidationProperties_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.ValidationProperties_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.showIgnored = stream.GetBool();
break;
case 1:
this.lastValidated = stream.GetString2();
break;
default:
return false;
}
return true;
};
/**
* Read attributes from stream for DataRecordSet_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DataRecordSet_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.connectionID = stream.GetULong();
break;
case 2:
this.command = stream.GetString2();
break;
case 3:
this.options = stream.GetULong();
break;
case 4:
this.timeRefreshed = stream.GetString2();
break;
case 5:
this.nextRowID = stream.GetULong();
break;
case 6:
this.name = stream.GetString2();
break;
case 7:
this.rowOrder = stream.GetString2();
break;
case 8:
this.refreshOverwriteAll = stream.GetBool();
break;
case 9:
this.refreshNoReconciliationUI = stream.GetBool();
break;
case 10:
this.refreshInterval = stream.GetULong();
break;
case 11:
this.replaceLinks = stream.GetBool();
break;
case 12:
this.checksum = stream.GetULong();
break;
default:
return false;
}
return true;
};
/**
* Read child elements from stream for DataRecordSet_Type
*
* @param {number} elementType - The type of child element
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if element was handled, false otherwise
*/
AscVisio.DataRecordSet_Type.prototype.readChild = function(elementType, pReader) {
let handled = true;
switch (elementType) {
//todo
// case 0:
// this.aDOData = new AscVisio.ADOData_Type();
// this.aDOData.fromPPTY(pReader);
// break;
case 0:
this.dataColumns = new AscVisio.DataColumns_Type();
this.dataColumns.fromPPTY(pReader);
break;
case 1:
let primaryKey = new AscVisio.PrimaryKey_Type();
primaryKey.fromPPTY(pReader);
this.primaryKey.push(primaryKey);
break;
case 2:
let rowMap = new AscVisio.RowMap_Type();
rowMap.fromPPTY(pReader);
this.rowMap.push(rowMap);
break;
case 5:
pReader.stream.Skip2(4);//len
pReader.stream.Skip2(1);//type
const len = pReader.stream.GetULong();
this.content = pReader.stream.GetBufferUint8(len);
break;
//todo
// case 5:
// let refreshConflict = new AscVisio.RefreshConflict_Type();
// refreshConflict.fromPPTY(pReader);
// this.refreshConflict.push(refreshConflict);
// break;
// case 6:
// let autoLinkComparison = new AscVisio.AutoLinkComparison_Type();
// autoLinkComparison.fromPPTY(pReader);
// this.autoLinkComparison.push(autoLinkComparison);
// break;
default:
handled = false;
break;
}
return handled;
};
/**
* Read attributes from stream for DataConnection_Type
*
* @param {number} attrType - The type of attribute
* @param {BinaryVSDYLoader} pReader - The binary reader
* @returns {boolean} - True if attribute was handled, false otherwise
*/
AscVisio.DataConnection_Type.prototype.readAttribute = function(attrType, pReader) {
const stream = pReader.stream;
switch (attrType) {
case 0:
this.id = stream.GetULong();
break;
case 1:
this.fileName = stream.GetString2();
break;
case 2:
this.connectionString = stream.GetString2();
break;
case 3:
this.command = stream.GetString2();
break;
case 4:
this.friendlyName = stream.GetString2();
break;
case 5:
this.timeout = stream.GetULong();
break;
case 6:
this.alwaysUseConnectionFile = stream.GetBool();
break;
default:
return false;
}
return true;
};
window['AscVisio'] = window['AscVisio'] || {};
window['AscVisio'].BinaryVSDYLoader = BinaryVSDYLoader;
})(window, window.document);
Reference in New Issue View Git Blame Copy Permalink