[bu][de] - Added method for creating ApiComplexForm objects.

Feature/oform

api.js

@@ -34,7 +34,6 @@
 (function(window, document) {
     window['Asc']['Addons'] = window['Asc']['Addons'] || {};
 	window['Asc']['Addons']['forms'] = true; // register addon
-	
 	window['Asc']['asc_docs_api'].prototype['asc_AddContentControlCheckBox'] = window['Asc']['asc_docs_api'].prototype.asc_AddContentControlCheckBox = function(oPr, oFormPr, oCommonPr)
 	{
 		var oLogicDocument = this.private_GetLogicDocument();
@@ -85,6 +84,7 @@
 			{
 				oCC.SetFormPr(oFormPr);
 				oCC.UpdatePlaceHolderTextPrForForm();
+				private_CheckFormKey(oCC, oLogicDocument);
 			}
 
 			if (oCommonPr)
@@ -180,27 +180,29 @@
 			{
 				oCC.SetFormPr(oFormPr);
 				oCC.UpdatePlaceHolderTextPrForForm();
+				private_CheckFormKey(oCC, oLogicDocument);
+
 				oFormParaDrawing = oCC.ConvertFormToFixed();
 				oCC.SetPictureFormPr(new AscCommon.CSdtPictureFormPr());
 				var aDrawings = oCC.GetAllDrawingObjects();
-				for(var nDrawing = 0; nDrawing < aDrawings.length; ++nDrawing) 
+				for(var nDrawing = 0; nDrawing < aDrawings.length; ++nDrawing)
 				{
 					var oDrawing = aDrawings[nDrawing];
 					var oGraphic = oDrawing.GraphicObj;
-					if(oGraphic && oGraphic.getObjectType() === AscDFH.historyitem_type_ImageShape) 
+					if(oGraphic && oGraphic.getObjectType() === AscDFH.historyitem_type_ImageShape)
 					{
 						var oSpPr = oGraphic.spPr;
-						if(oSpPr) 
+						if(oSpPr)
 						{
-							if(oSpPr.Fill) 
+							if(oSpPr.Fill)
 							{
 								oSpPr.setFill(null);
 							}
-							if(oSpPr.ln) 
+							if(oSpPr.ln)
 							{
 								oSpPr.setLn(null);
 							}
-							if(oSpPr.geometry) 
+							if(oSpPr.geometry)
 							{
 								oSpPr.setGeometry(null);
 							}
@@ -240,10 +242,10 @@
 
 			oLogicDocument.UpdateInterface();
 			oLogicDocument.Recalculate();
-			if(oFormParaDrawing) 
+			if(oFormParaDrawing)
 			{
 				let oFormShape = oFormParaDrawing.GraphicObj;
-				if(oFormShape) 
+				if(oFormShape)
 				{
 					oFormShape.Set_CurrentElement(true, null, true);
 				}
@@ -272,6 +274,7 @@
 			{
 				oCC.SetFormPr(oFormPr);
 				oCC.UpdatePlaceHolderTextPrForForm();
+				private_CheckFormKey(oCC, oLogicDocument);
 			}
 
 			if (oCC && oCommonPr)
@@ -304,21 +307,32 @@
 			oLogicDocument.FinalizeAction();
 		}
 	};
-	window['Asc']['asc_docs_api'].prototype['asc_AddContentControlTextForm'] = window['Asc']['asc_docs_api'].prototype.asc_AddContentControlTextForm = function(oPr, oFormPr)
+	window['Asc']['asc_docs_api'].prototype['asc_AddContentControlTextForm'] = window['Asc']['asc_docs_api'].prototype.asc_AddContentControlTextForm = function(contentControlPr)
 	{
 		var oLogicDocument = this.private_GetLogicDocument();
 		if (!oLogicDocument)
 			return;
 
+		let textFormPr      = contentControlPr ? contentControlPr.TextFormPr : null;
+		let formPr          = contentControlPr ? contentControlPr.FormPr : null;
+		let placeholderText = contentControlPr ? contentControlPr.PlaceholderText : "";
+
 		if (!oLogicDocument.IsSelectionLocked(AscCommon.changestype_Paragraph_Content))
 		{
 			oLogicDocument.StartAction(AscDFH.historydescription_Document_AddContentControlTextForm);
 
-			var oCC = oLogicDocument.AddContentControlTextForm(oPr);
-			if (oCC && oFormPr)
+			var oCC = oLogicDocument.AddContentControlTextForm(textFormPr);
+			if (oCC)
 			{
-				oCC.SetFormPr(oFormPr);
-				oCC.UpdatePlaceHolderTextPrForForm();
+				if (placeholderText)
+					oCC.SetPlaceholderText(placeholderText);
+
+				if (formPr)
+				{
+					oCC.SetFormPr(formPr);
+					oCC.UpdatePlaceHolderTextPrForForm();
+					private_CheckFormKey(oCC, oLogicDocument);
+				}
 			}
 
 			oLogicDocument.UpdateInterface();
@@ -334,12 +348,12 @@
 
 		function AddComplexForm()
 		{
-			logicDocument.RemoveTextSelection();
 			if (!logicDocument.IsSelectionLocked(AscCommon.changestype_Paragraph_Content))
 			{
 				logicDocument.StartAction(AscDFH.historydescription_Document_AddComplexForm);
 
 				let complexForm = logicDocument.AddComplexForm(new AscWord.CSdtComplexFormPr(), formPr);
+				private_CheckFormKey(complexForm, logicDocument);
 
 				if (json)
 					AscWord.JsonToForm(json, complexForm);
@@ -390,4 +404,25 @@
 		return AscWord.FormToJson(form);
 	};
 
+	function private_CheckFormKey(form, logicDocument)
+	{
+		if (!form || !form.IsForm() || !logicDocument)
+			return;
+
+		let key = form.GetFormKey();
+		if (key && "" !== key.trim())
+			return;
+
+		let formManager  = logicDocument.GetFormsManager();
+		let keyGenerator = formManager.GetKeyGenerator();
+
+		let formPr = form.GetFormPr().Copy();
+		if (!formPr)
+			return;
+
+		key = keyGenerator.GetNewKey(form);
+		formPr.SetKey(key);
+		form.SetFormPr(formPr);
+	}
+
 })(window, window.document);

apiBuilder.js

@@ -156,7 +156,7 @@
 		oPr.SetWidth((GetNumberParameter(oFormPr["cellWidth"], 0) * 72 * 20 / 25.4) | 0);
 
 		oCC.ApplyTextFormPr(oPr);
-
+		CheckFormKey(oCC);
 		return new AscBuilder.ApiTextForm(oCC);
 	};
 	/**
@@ -226,6 +226,7 @@
 			private_PerformAddCheckBox();
 		}
 
+		CheckFormKey(oCC);
 		return new AscBuilder.ApiCheckBoxForm(oCC);
 	};
 	/**
@@ -239,7 +240,7 @@
 		if (!oFormPr)
 			oFormPr = {};
 
-		var oPr = new CSdtComboBoxPr();
+		var oPr = new AscCommon.CSdtComboBoxPr();
 		oPr.AddItem(AscCommon.translateManager.getValue("Choose an item"), "");
 
 		var oCC = CreateCommonForm(oFormPr);
@@ -290,6 +291,7 @@
 			}
 		}
 
+		CheckFormKey(oCC);
 		return new AscBuilder.ApiComboBoxForm(oCC);
 	};
 	/**
@@ -328,8 +330,29 @@
 
 		oCC.SetPictureFormPr(oPr);
 
+		CheckFormKey(oCC);
 		return new AscBuilder.ApiPictureForm(oCC);
 	};
+
+	/**
+	 * Creates a complex form with the specified base form properties.
+	 * @memberof Api
+	 * @param {FormPrBase} oFormPr - base form property.
+	 * @returns {ApiComplexForm}
+	 */
+	Api.prototype.CreateComplexForm = function(oFormPr)
+	{
+		if (!oFormPr)
+			oFormPr = {};
+
+		let oCC = CreateCommonForm(oFormPr);
+		let oComplexPr = new AscWord.CSdtComplexFormPr();
+
+		oCC.SetComplexFormPr(oComplexPr);
+		CheckFormKey(oCC);
+		return new AscBuilder.ApiComplexForm(oCC);
+	};
+
 	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	// Private area
 	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -357,6 +380,27 @@
 
 		return oCC;
 	}
+	function CheckFormKey(form)
+	{
+		let logicDocument = editor && editor.WordControl && editor.WordControl.m_oLogicDocument;
+		if (!form || !form.IsForm() || !logicDocument)
+			return;
+
+		let key = form.GetFormKey();
+		if (key && "" !== key.trim())
+			return;
+
+		let formManager  = logicDocument.GetFormsManager();
+		let keyGenerator = formManager.GetKeyGenerator();
+
+		let formPr = form.GetFormPr().Copy();
+		if (!formPr)
+			return;
+
+		key = keyGenerator.GetNewKey(form);
+		formPr.SetKey(key);
+		form.SetFormPr(formPr);
+	}
 	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	// Export
 	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -364,5 +408,5 @@
 	Api.prototype["CreatePictureForm"]  = Api.prototype.CreatePictureForm;
 	Api.prototype["CreateCheckBoxForm"] = Api.prototype.CreateCheckBoxForm;	
 	Api.prototype["CreateComboBoxForm"] = Api.prototype.CreateComboBoxForm;	
-
+	Api.prototype["CreateComplexForm"]  = Api.prototype.CreateComplexForm;	
 }(window, null));

configs/word.json

@@ -5,7 +5,10 @@
 	  "apiPlugins.js"
 	],
     "common": [      
-	  "apiBuilder.js"
+	  "apiBuilder.js",
+	  "oform/Main.js",
+	  "oform/Field.js",
+	  "oform/User.js"
     ]
   }
 }

oform/Field.js

@@ -0,0 +1,416 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * 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-12 Ernesta Birznieka-Upisha
+ * 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) {
+
+	const CBaseFormatObject = AscFormat.CBaseFormatObject;
+	const InitClass = AscFormat.InitClass;
+	const CChangesString = AscDFH.CChangesDrawingsString;
+	const CChangesObject = AscDFH.CChangesDrawingsObject;
+	const CChangesContent = AscDFH.CChangesDrawingsContent;
+
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_FieldId] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_User] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_Field] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_FormFieldMaster_SignRequest] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_FormField_Content] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_FormField_EncryptedData] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_FormField_FieldMaster] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_SignRequest_User] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_EncryptedData_Method] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_EncryptedData_Value] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_EncryptedData_KeyInfo] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_KeyInfo_User] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_KeyInfo_Value] = CChangesObject;
+
+
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormFieldMaster_FieldId] = function(oClass, value) {oClass.FieldId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormFieldMaster_Field] = function(oClass, value) {oClass.Field = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormFieldMaster_SignRequest] = function(oClass, value) {oClass.SignRequest = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormField_Content] = function(oClass, value) {oClass.FieldContent = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormField_FieldMaster] = function(oClass, value) {oClass.FieldMaster = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_EncryptedData_Method] = function(oClass, value) {oClass.EncryptedMethod = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_EncryptedData_Value] = function(oClass, value) {oClass.EncryptedValue = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_EncryptedData_KeyInfo] = function(oClass, value) {oClass.KeyInfo = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_KeyInfo_User] = function(oClass, value) {oClass.FieldId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_KeyInfo_Value] = function(oClass, value) {oClass.FieldId = value;};
+
+
+	AscDFH.drawingContentChanges[AscDFH.historyitem_FormFieldMaster_User] = function (oClass) {return oClass.Users;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_SignRequest_User] = function (oClass) {return oClass.Users;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_FormField_EncryptedData] = function (oClass) {return oClass.EndcriptedData;};
+
+
+	function CFieldMaster() {
+		CBaseFormatObject.call(this);
+		this.FieldId = null;
+		this.Users = [];
+		this.Field = null;
+		this.SignRequest = null;
+	}
+	InitClass(CFieldMaster, CBaseFormatObject, AscDFH.historyitem_type_FormFieldMaster);
+	CFieldMaster.prototype.setFieldId = function(sFieldId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormFieldMaster_FieldId, this.FieldId, sFieldId));
+		this.FieldId = sFieldId;
+	};
+	CFieldMaster.prototype.addUser = function(oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_FormFieldMaster_User, this.Users.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CFieldMaster.prototype.setField = function(oField) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_FormFieldMaster_Field, this.Field, oField));
+		this.Field = oField;
+		if(oField) {
+			oField.setFieldMaster(this);
+		}
+	};
+	CFieldMaster.prototype.setSignRequest = function(oSignRequest) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_FormFieldMaster_SignRequest, this.SignRequest, oSignRequest));
+		this.SignRequest = oSignRequest;
+	};
+	CFieldMaster.prototype.readAttrXml = function(name, reader) {
+		switch (name) {
+			case "id": {
+				this.setFieldId(reader.GetValue());
+				break;
+			}
+		}
+	};
+	CFieldMaster.prototype.readChildXml = function (name, reader) {
+		let oThis = this;
+		switch (name) {
+			case "Users": {
+				let oUsersNode = new CT_XmlNode(function (reader, name){
+					if(name === "User") {
+						let oUserNode = new CT_XmlNode();
+						oUserNode.fromXml(reader);
+						let sId = oUserNode.attributes["id"];
+						let oRel = reader.rels.getRelationshipById(sId);
+						reader.context.addFieldMasterRelation(oThis, oRel.targetFullName)
+					}
+					return true;
+				});
+				oUsersNode.fromXml(reader);
+				break;
+			}
+			case "SignRequest": {
+				let oSignRequest = new CSignRequest();
+				oSignRequest.fromXml(reader);
+				this.setSignRequest(oSignRequest);
+				break;
+			}
+		}
+	};
+	CFieldMaster.prototype.toXml = function (writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("FieldMaster");
+		writer.WriteXmlAttributeString("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");
+		writer.WriteXmlNullableAttributeString("id", this.FieldId);
+		writer.WriteXmlAttributesEnd();
+
+		writer.WriteXmlNodeStart("Users");
+		writer.WriteXmlAttributesEnd();
+		let oContext = writer.context;
+		let oUserMasterPartMap = oContext.userMasterPartMap;
+		let oUsersIdMap = {};
+		for(let nUser = 0; nUser < this.Users.length; ++nUser) {
+			let oUser = this.Users[nUser];
+			let oPart = oUserMasterPartMap[oUser.Id];
+			if(!oPart) {
+				oPart = writer.context.part.addPart(AscCommon.openXml.Types.userMaster);
+				let oUserMemory = new AscCommon.CMemory();
+				oUserMemory.context = writer.context;
+				oPart.part.setDataXml(oUser, oUserMemory);
+				oUserMasterPartMap[oUser.Id] = oPart;
+			}
+			let oNode = new CT_XmlNode();
+			let sRId = oContext.part.addRelationship(AscCommon.openXml.Types.userMaster.relationType, oPart.uri);
+			oNode.attributes["r:id"] = sRId
+			oUsersIdMap[oUser.Id] = sRId;
+			oNode.toXml(writer, "User");
+
+		}
+		writer.WriteXmlNodeEnd("Users");
+		if(this.SignRequest) {
+			this.SignRequest.toXml(writer, oUsersIdMap);
+		}
+		writer.WriteXmlNodeEnd("FieldMaster");
+		if(writer.context.fileType === Asc.c_oAscFileType.OFORM) {
+			if(this.Field) {
+				let oPart = writer.context.docPart.part.addPartWithoutRels(AscCommon.openXml.Types.field);
+				let oMemory = new AscCommon.CMemory();
+				oMemory.context = writer.context;
+				oPart.setDataXml(this.Field, oMemory);
+				oMemory.Seek(0);
+				oPart.addRelationship(AscCommon.openXml.Types.fieldMaster.relationType, oContext.part.uri)
+			}
+		}
+	};
+
+	function CSignRequest() {
+		CBaseFormatObject.call(this);
+		this.Users = [];
+	}
+	InitClass(CSignRequest, CBaseFormatObject, AscDFH.historyitem_type_SignRequest);
+	CSignRequest.prototype.addUser = function(oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_SignRequest_User, this.Users.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CSignRequest.prototype.readChildXml = function (name, reader) {
+		CFieldMaster.prototype.readChildXml.call(this, name, reader);
+	};
+	CSignRequest.prototype.toXml = function (writer, oUsersIdMap) {
+		writer.WriteXmlNodeStart("SignRequest");
+		writer.WriteXmlAttributesEnd();
+
+		writer.WriteXmlNodeStart("Users");
+		writer.WriteXmlAttributesEnd();
+		for(let nUser = 0; nUser < this.Users.length; ++nUser) {
+			let oUser = this.Users[nUser];
+			let oNode = new CT_XmlNode();
+			let sRId = oUsersIdMap[oUser.Id];
+			if(sRId) {
+				oNode.attributes["r:id"] = sRId
+				oUsersIdMap[oUser.Id] = sRId;
+				oNode.toXml(writer, "User");
+			}
+
+		}
+		writer.WriteXmlNodeEnd("Users");
+		writer.WriteXmlNodeEnd("SignRequest");
+	};
+
+	function CFieldContent() {
+		CParagraphContentWithParagraphLikeContent.call(this);
+	}
+	InitClass(CFieldContent, CParagraphContentWithParagraphLikeContent, 0);
+	CFieldContent.prototype.Add_ToContent = function(Pos, Item, UpdatePosition)
+	{
+		AscCommon.History.Add(new CChangesFormFieldAddItem(this, Pos, [Item]));
+		CParagraphContentWithParagraphLikeContent.prototype.Add_ToContent.apply(this, arguments);
+	};
+
+	CFieldContent.prototype.Remove_FromContent = function(Pos, Count, UpdatePosition)
+	{
+		let DeletedItems = this.Content.slice( Pos, Pos + Count );
+		AscCommon.History.Add(new CChangesFormFieldRemoveItem(this, Pos, DeletedItems));
+		CParagraphContentWithParagraphLikeContent.prototype.Remove_FromContent.apply(this, arguments);
+	};
+	CFieldContent.prototype.fromXml = function (reader) {
+		CParagraphContentWithParagraphLikeContent.prototype.fromXml.call(this, reader);
+	};
+	CFieldContent.prototype.toXml = function (writer) {
+		writer.WriteXmlNodeStart("w:sdtContent");
+		writer.WriteXmlAttributesEnd();
+		CParagraphContentWithParagraphLikeContent.prototype.toXml.call(this, writer);
+		writer.WriteXmlNodeEnd("w:sdtContent");
+	};
+
+	function CField() {
+		CBaseFormatObject.call(this);
+		this.EndcriptedData = [];
+		this.FieldContent = null;
+	}
+	InitClass(CField, CBaseFormatObject, AscDFH.historyitem_type_FormField);
+	CField.prototype.setFieldContent = function(oFieldContent) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormField_Content, this.FieldContent, oFieldContent));
+		this.FieldContent = oFieldContent;
+	};
+	CField.prototype.addEncryptedData = function(oEncryptedData) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_FormField_EncryptedData, this.EndcriptedData.length, [oEncryptedData], true));
+		this.EndcriptedData.push(oEncryptedData);
+	};
+	CField.prototype.setFieldMaster = function(oFieldMaster) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_FormField_FieldMaster, this.FieldMaster, oFieldMaster));
+		this.FieldMaster = oFieldMaster;
+	};
+	CField.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "EncryptedData": {
+				let oEncryptedData = new CEncryptedData();
+				oEncryptedData.fromXml(reader);
+				this.addEncryptedData(oEncryptedData);
+				break;
+			}
+			case "Body": {
+				let oFieldContent = null;
+				let oNode = new CT_XmlNode(function (reader, name) {
+					if(name === "sdtContent") {
+						oFieldContent = new CFieldContent();
+						oFieldContent.fromXml(reader);
+						return oFieldContent;
+					}
+					return null;
+				});
+				oNode.fromXml(reader);
+				if(oFieldContent) {
+					this.setFieldContent(oFieldContent);
+				}
+				break;
+			}
+		}
+	};
+	CField.prototype.toXml = function(writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("Field");
+		writer.WriteXmlAttributesEnd();
+		if(this.FieldContent) {
+			writer.WriteXmlNodeStart("Body");
+			writer.WriteXmlString(AscCommonWord.g_sXmlDocumentNamespaces);
+			writer.WriteXmlAttributesEnd();
+			this.FieldContent.toXml(writer);
+			writer.WriteXmlNodeEnd("Body");
+		}
+		for(let nData = 0; nData < this.EndcriptedData.length; ++nData) {
+			this.EndcriptedData[nData].toXml(writer);
+		}
+		writer.WriteXmlNodeEnd("Field");
+	};
+
+	function CEncryptedData() {
+		CBaseFormatObject.call(this);
+		this.EncryptedMethod = null;
+		this.EncryptedValue = null;
+		this.KeyInfo = null;
+	}
+	InitClass(CEncryptedData, CBaseFormatObject, AscDFH.historyitem_type_EncryptedData);
+	CEncryptedData.prototype.setEncryptedMethod = function (sEncryptedMethod) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_EncryptedData_Method, this.EncryptedMethod, sEncryptedMethod));
+		this.EncryptedMethod = sEncryptedMethod;
+	};
+	CEncryptedData.prototype.setEncryptedValue = function (sEncryptedValue) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_EncryptedData_Value, this.EncryptedValue, sEncryptedValue));
+		this.EncryptedValue = sEncryptedValue;
+	};
+	CEncryptedData.prototype.setKeyInfo = function (oKeyInfo) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_EncryptedData_KeyInfo, this.KeyInfo, oKeyInfo));
+		this.KeyInfo = oKeyInfo;
+	};
+	CEncryptedData.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "EncryptedMethod": {
+				let oMethod =  new CT_XmlNode();
+				oMethod.fromXml(reader);
+				let sAlgorithm = oMethod.attributes["Algorithm"];
+				if(sAlgorithm) {
+					this.setEncryptedMethod(sAlgorithm)
+				}
+				break;
+			}
+			case "EncryptedValue": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setEncryptedValue(oNode.text);
+				break;
+			}
+			case "KeyInfo": {
+				let oKeyInfo = new CKeyInfo();
+				oKeyInfo.fromXml(reader);
+				this.setKeyInfo(oKeyInfo)
+				break;
+			}
+		}
+	};
+	CEncryptedData.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("EncryptedData");
+		writer.WriteXmlAttributesEnd();
+		if(this.EncryptedMethod) {
+			let oMethod =  new CT_XmlNode();
+			oMethod.attributes["Algorithm"] = this.EncryptedMethod;
+			oMethod.toXml(writer, "EncryptedMethod");
+		}
+		if(this.EncryptedValue) {
+			let oValue =  new CT_XmlNode();
+			oValue.text = this.EncryptedValue;
+			oValue.toXml(writer, "EncryptedValue");
+		}
+		if(this.KeyInfo) {
+			this.KeyInfo.toXml(writer);
+		}
+		writer.WriteXmlNodeEnd("EncryptedData");
+	};
+
+	function CKeyInfo() {
+		CBaseFormatObject.call(this);
+		this.UserId = null;
+		this.Value = null;
+	}
+	InitClass(CKeyInfo, CBaseFormatObject, AscDFH.historyitem_type_KeyInfo);
+	CKeyInfo.prototype.setUserId = function (sUserId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_KeyInfo_User, this.UserId, sUserId));
+		this.UserId = sUserId;
+	};
+	CKeyInfo.prototype.setValue = function (sValue) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_KeyInfo_Value, this.Value, sValue));
+		this.Value = sValue;
+	};
+	CKeyInfo.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "User": {
+				let oNode =  new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setUserId(oNode.attributes["id"]);
+				break;
+			}
+			case "Value": {
+				let oNode =  new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setValue(oNode.text);
+				break;
+			}
+		}
+	};
+	CKeyInfo.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("KeyInfo");
+		writer.WriteXmlAttributesEnd();
+		if(this.UserId) {
+			let oNode = new CT_XmlNode();
+			oNode.attributes["id"] = this.UserId;
+			oNode.toXml(writer, "User");
+		}
+		if(this.Value) {
+			let oValue =  new CT_XmlNode();
+			oValue.text = this.Value;
+			oValue.toXml(writer, "Value");
+		}
+		writer.WriteXmlNodeEnd("KeyInfo");
+	};
+
+	AscWord.CFieldContent = CFieldContent;
+	AscWord.CFieldMaster = CFieldMaster;
+	AscWord.CField = CField;
+	AscWord.CEncryptedData = CEncryptedData;
+	AscWord.CKeyInfo = CKeyInfo;
+	AscWord.CSignRequest = CSignRequest;
+})(window);

oform/Main.js

@@ -0,0 +1,316 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * 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-12 Ernesta Birznieka-Upisha
+ * 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) {
+
+	const CBaseFormatObject = AscFormat.CBaseFormatObject;
+	const InitClass = AscFormat.InitClass;
+	const CChangesString = AscDFH.CChangesDrawingsString;
+	const CChangesObject = AscDFH.CChangesDrawingsObject;
+	const CChangesContent = AscDFH.CChangesDrawingsContent;
+	const CChangesLong = AscDFH.CChangesDrawingsLong;
+
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Author] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Date] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Description] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Type] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_Application] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_DocumentId] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_FieldsGroups] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_MainDocument_User] = CChangesContent;
+	AscDFH.changesFactory[AscDFH.historyitem_FormDate_Format] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FormDate_Value] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FieldsGroup_Id] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_FieldsGroup_Weight] = CChangesLong;
+	AscDFH.changesFactory[AscDFH.historyitem_FieldsGroup_Field] = CChangesContent;
+
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Author] = function (oClass, value) {oClass.Author = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Date] = function (oClass, value) {oClass.Date = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Description] = function (oClass, value) {oClass.Description = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Type] = function (oClass, value) {oClass.Type = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_Application] = function (oClass, value) {oClass.Application = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_MainDocument_DocumentId] = function (oClass, value) {oClass.DocumentId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormDate_Format] = function (oClass, value) {oClass.Format = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FormDate_Value] = function (oClass, value) {oClass.Value = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FieldsGroup_Id] = function (oClass, value) {oClass.GroupId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_FieldsGroup_Weight] = function (oClass, value) {oClass.Weight = value;};
+
+	AscDFH.drawingContentChanges[AscDFH.historyitem_MainDocument_FieldsGroups] = function (oClass) {return oClass.FieldsGroups;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_MainDocument_User] = function (oClass) {return oClass.Users;};
+	AscDFH.drawingContentChanges[AscDFH.historyitem_FieldsGroup_Field] = function (oClass) {return oClass.Fields;};
+
+
+	function CMainDocument() {
+		CBaseFormatObject.call(this);
+		this.Author = null;
+		this.Date = null;
+		this.Description = null;
+		this.Type = null;
+		this.Application = null;
+		this.DocumentId = null;
+		this.FieldsGroups = [];
+
+		this.Users = [];
+	}
+	InitClass(CMainDocument, CBaseFormatObject, AscDFH.historyitem_type_MainDocument);
+	CMainDocument.prototype.setAuthor = function (sAuthor) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Author, this.Author, sAuthor));
+		this.Author = sAuthor;
+	};
+	CMainDocument.prototype.setDate = function (oDate) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_MainDocument_Date, this.Date, oDate));
+		this.Date = oDate;
+	};
+	CMainDocument.prototype.setDescription = function (sDescription) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Description, this.Description, sDescription));
+		this.Description = sDescription;
+	};
+	CMainDocument.prototype.setType = function (sType) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Type, this.Type, sType));
+		this.Type = sType;
+	};
+	CMainDocument.prototype.setApplication = function (sApplication) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_Application, this.Application, sApplication));
+		this.Application = sApplication;
+	};
+	CMainDocument.prototype.setDocumentId = function (sDocumentId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_MainDocument_DocumentId, this.DocumentId, sDocumentId));
+		this.DocumentId = sDocumentId;
+	};
+	CMainDocument.prototype.addFieldsGroups = function(oFieldsGroup) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_MainDocument_FieldsGroups, this.FieldsGroups.length, [oFieldsGroup], true));
+		this.FieldsGroups.push(oFieldsGroup);
+	};
+	CMainDocument.prototype.addUser = function(oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_MainDocument_User, this.FieldsGroups.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CMainDocument.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "Author": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				let sAuthor = oNode.attributes["id"];
+				if(sAuthor) {
+					this.setAuthor(sAuthor);
+				}
+				break;
+			}
+			case "Date": {
+				let oDate = new CFormDate();
+				oDate.fromXml(reader);
+				this.setDate(oDate);
+				break;
+			}
+			case "Description": {
+
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setDescription(oNode.text);
+				break;
+			}
+			case "Type": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setType(oNode.text);
+				break;
+			}
+			case "Application": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setApplication(oNode.text);
+				break;
+			}
+			case "Id": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setDocumentId(oNode.text);
+				break;
+			}
+			case "FieldsGroup": {
+				let oFieldsGroup = new CFieldsGroup();
+				oFieldsGroup.fromXml(reader);
+				this.addFieldsGroups(oFieldsGroup);
+				break;
+			}
+		}
+	};
+	CMainDocument.prototype.toXml = function(writer) {
+
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("Document");
+		writer.WriteXmlAttributeString("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships");
+		writer.WriteXmlAttributesEnd();
+		if(this.Author) {
+			let oNode = new CT_XmlNode();
+			oNode.attributes["id"] = this.Author;
+			oNode.toXml(writer, "Author");
+		}
+		if(this.Date) {
+			this.Date.toXml(writer);
+		}
+		let oDescriptionNode = new CT_XmlNode();
+		oDescriptionNode.text = this.Description;
+		oDescriptionNode.toXml(writer, "Description");
+
+		let oTypeNode = new CT_XmlNode();
+		oTypeNode.text = this.Type;
+		oTypeNode.toXml(writer, "Type");
+
+		let oAppNode = new CT_XmlNode();
+		oAppNode.text = this.Application;
+		oAppNode.toXml(writer, "Application");
+
+		let oIdNode = new CT_XmlNode();
+		oIdNode.text = this.DocumentId;
+		oIdNode.toXml(writer, "Id");
+		for(let nFG = 0; nFG < this.FieldsGroups.length; ++nFG) {
+			this.FieldsGroups[nFG].toXml(writer);
+		}
+		writer.WriteXmlNodeEnd("Document");
+	};
+
+	function CFormDate() {
+		CBaseFormatObject.call(this);
+		this.Format = null;
+		this.Value = null;
+	}
+	InitClass(CFormDate, CBaseFormatObject, AscDFH.historyitem_type_FormDate);
+	CFormDate.prototype.setFormat = function(sFormat) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormDate_Format, this.Format, sFormat));
+		this.Format = sFormat;
+	};
+	CFormDate.prototype.setValue = function(sValue) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FormDate_Value, this.Value, sValue));
+		this.Value = sValue;
+	};
+	CFormDate.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "Format": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setFormat(oNode.text);
+				break;
+			}
+			case "Value": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setValue(oNode.text);
+				break;
+			}
+		}
+	};
+	CFormDate.prototype.toXml = function (writer) {
+		writer.WriteXmlNodeStart("Date");
+		writer.WriteXmlAttributesEnd();
+
+		let oFormatNode = new CT_XmlNode();
+		oFormatNode.text = this.Format;
+		oFormatNode.toXml(writer, "Format");
+
+		let oValueNode = new CT_XmlNode();
+		oValueNode.text = this.Value;
+		oValueNode.toXml(writer, "Value");
+
+		writer.WriteXmlNodeEnd("Date");
+	};
+
+	function CFieldsGroup() {
+		CBaseFormatObject.call(this);
+		this.GroupId = null;
+		this.Weight = null;
+		this.Fields = [];
+	}
+	InitClass(CFieldsGroup, CBaseFormatObject, AscDFH.historyitem_type_FieldsGroup);
+	CFieldsGroup.prototype.setGroupId = function (sGroupId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_FieldsGroup_Id, this.GroupId, sGroupId));
+		this.GroupId = sGroupId;
+	};
+	CFieldsGroup.prototype.setWeight = function (nWeight) {
+		AscCommon.History.Add(new CChangesLong(this, AscDFH.historyitem_FieldsGroup_Weight, this.Weight, nWeight));
+		this.Weight = nWeight;
+	};
+	CFieldsGroup.prototype.addField = function (oField) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_FieldsGroup_Field, this.Fields.length, [oField], true));
+		this.Fields.push(oField);
+	};
+	CFieldsGroup.prototype.readAttrXml = function(name, reader) {
+		switch (name) {
+			case "id": {
+				this.setGroupId(reader.GetValue());
+				break;
+			}
+			case "weight": {
+				this.setWeight(reader.GetValueInt());
+				break;
+			}
+		}
+	};
+	CFieldsGroup.prototype.readChildXml = function(name, reader) {
+		switch (name) {
+			case "Field": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				let sId = oNode.attributes["id"];
+				let oRel = reader.rels.getRelationshipById(sId);
+				reader.context.addFieldGroupRelation(this, oRel.targetFullName);
+				break;
+			}
+		}
+	};
+	CFieldsGroup.prototype.toXml = function (writer) {
+		writer.WriteXmlNodeStart("FieldsGroup");
+		writer.WriteXmlNullableAttributeString("id", this.GroupId);
+		writer.WriteXmlNullableAttributeInt("weight", this.Weight);
+		writer.WriteXmlAttributesEnd();
+
+		let oContext = writer.context;
+		let oFldMasterPartMap = oContext.fieldMastersPartMap;
+		for(let nFldMaster = 0; nFldMaster < this.Fields.length; ++nFldMaster) {
+			let oFieldMaster = this.Fields[nFldMaster];
+			let oPart = oFldMasterPartMap[oFieldMaster.Id];
+			if(oPart) {
+				let oNode = new CT_XmlNode();
+				oNode.attributes["r:id"] = oContext.part.addRelationship(AscCommon.openXml.Types.fieldMaster.relationType, oPart.part.uri);
+				oNode.toXml(writer, "Field");
+			}
+		}
+
+		writer.WriteXmlNodeEnd("FieldsGroup");
+	};
+
+	AscWord.CMainDocument = CMainDocument;
+	AscWord.CFieldsGroup = CFieldsGroup;
+	AscWord.CFormDate = CFormDate;
+})(window);

oform/User.js

@@ -0,0 +1,306 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * 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-12 Ernesta Birznieka-Upisha
+ * 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) {
+	const CBaseFormatObject = AscFormat.CBaseFormatObject;
+	const InitClass = AscFormat.InitClass;
+	const CChangesString = AscDFH.CChangesDrawingsString;
+	const CChangesObject = AscDFH.CChangesDrawingsObject;
+	const CChangesContent = AscDFH.CChangesDrawingsContent;
+
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterUserId] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterSignInfo] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterCipherInfo] = CChangesObject;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterRole] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserEmail] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserTelephone] = CChangesString;
+	AscDFH.changesFactory[AscDFH.historyitem_UserMasterUser] = CChangesContent;
+
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterUserId] = function(oClass, value) {oClass.UserId = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterSignInfo] = function(oClass, value) {oClass.SignInfo = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterCipherInfo] = function(oClass, value) {oClass.CipherInfo = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserMasterRole] = function(oClass, value) {oClass.Role = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserEmail] = function(oClass, value) {oClass.Email = value;};
+	AscDFH.drawingsChangesMap[AscDFH.historyitem_UserTelephone] = function(oClass, value) {oClass.Telephone = value;};
+
+	AscDFH.drawingContentChanges[AscDFH.historyitem_UserMasterUser] = function(oClass) {return oClass.Users;};
+
+
+
+	function CUserMaster() {
+		CBaseFormatObject.call(this);
+		this.UserId = null;
+		this.SignInfo = null;
+		this.CipherInfo = null;
+		this.Role = null;
+
+		this.Users = [];
+	}
+	InitClass(CUserMaster, CBaseFormatObject, AscDFH.historyitem_type_UserMaster);
+	CUserMaster.prototype.setUserId = function (sUserId) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserMasterUserId, this.UserId, sUserId));
+		this.UserId = sUserId;
+	};
+	CUserMaster.prototype.setSignInfo = function (oSignInfo) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_UserMasterSignInfo, this.SignInfo, oSignInfo));
+		this.SignInfo = oSignInfo;
+
+	};
+	CUserMaster.prototype.setCipherInfo = function (oCipherInfo) {
+		AscCommon.History.Add(new CChangesObject(this, AscDFH.historyitem_UserMasterCipherInfo, this.CipherInfo, oCipherInfo));
+		this.CipherInfo = oCipherInfo;
+	};
+	CUserMaster.prototype.setRole = function (sRole) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserMasterRole, this.Role, sRole));
+		this.Role = sRole;
+	};
+	CUserMaster.prototype.addUser = function (oUser) {
+		AscCommon.History.Add(new CChangesContent(this, AscDFH.historyitem_UserMasterUser, this.Users.length, [oUser], true));
+		this.Users.push(oUser);
+	};
+	CUserMaster.prototype.readChildXml = function (name, reader) {
+		let bRead = false;
+		switch (name) {
+			case "Id": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setUserId(oNode.text);
+				bRead = true;
+				break;
+			}
+			case "SignInfo": {
+				let oSignInfo = new CSignInfo();
+				oSignInfo.fromXml(reader);
+				this.setSignInfo(oSignInfo);
+				bRead = true;
+				break;
+			}
+			case "CipherInfo": {
+				let oCipherInfo = new CCipherInfo();
+				oCipherInfo.fromXml(reader);
+				this.setCipherInfo(oCipherInfo);
+				bRead = true;
+				break;
+			}
+			case "Role": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setRole(oNode.text);
+				bRead = true;
+				break;
+			}
+		}
+		return bRead;
+	};
+	CUserMaster.prototype.writeChildren = function(writer) {
+		let oIdNode = new CT_XmlNode();
+		oIdNode.text = this.UserId;
+		oIdNode.toXml(writer, "Id");
+		if(this.SignInfo) {
+			this.SignInfo.toXml(writer);
+		}
+		if(this.CipherInfo) {
+			this.CipherInfo.toXml(writer);
+		}
+		let oRoleNode = new CT_XmlNode();
+		oRoleNode.text = this.Role;
+		oRoleNode.toXml(writer, "Role");
+	}
+	CUserMaster.prototype.toXml = function (writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("UserMaster");
+		writer.WriteXmlAttributesEnd();
+		this.writeChildren(writer);
+		writer.WriteXmlNodeEnd("UserMaster");
+	};
+
+	function CUser() {
+		CUserMaster.call(this);
+		this.Email = null;
+		this.Telephone = null;
+	}
+	InitClass(CUser, CUserMaster, AscDFH.historyitem_type_User);
+	CUser.prototype.setEmail = function (sEmail) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserEmail, this.Email, sEmail));
+		this.Email = sEmail;
+	};
+	CUser.prototype.setTelephone = function (sTelephone) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_UserTelephone, this.Telephone, sTelephone));
+		this.Telephone = sTelephone;
+	};
+	CUser.prototype.readChildXml = function (name, reader) {
+		if(CUserMaster.prototype.readChildXml.call(this, name, reader)) {
+			return true;
+		}
+		let bRead = false;
+		switch (name) {
+			case "Email": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setEmail(oNode.text);
+				bRead = true;
+				break;
+			}
+			case "Telephone": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setTelephone(oNode.text);
+				bRead = true;
+				break;
+			}
+		}
+		return bRead;
+	};
+	CUser.prototype.toXml = function (writer) {
+		writer.WriteXmlString(AscCommonWord.g_sXmlHeader);
+		writer.WriteXmlNodeStart("User");
+		writer.WriteXmlAttributesEnd();
+		let oEmailNode = new CT_XmlNode();
+		oEmailNode.text = this.Email;
+		oEmailNode.toXml(writer, "Email");
+
+		let oTelephoneNode = new CT_XmlNode();
+		oTelephoneNode.text = this.Telephone;
+		oTelephoneNode.toXml(writer, "Telephone");
+		this.writeChildren(writer);
+		writer.WriteXmlNodeEnd("User");
+	};
+
+	function CSignInfo() {
+		CBaseFormatObject.call(this);
+		this.PublicKey = null;
+		this.X509 = null;
+		this.ImageValid = null;
+		this.ImageInvalid = null;
+	}
+	InitClass(CSignInfo, CBaseFormatObject, AscDFH.historyitem_type_SignInfo);
+	CSignInfo.prototype.setPublicKey = function (sPublicKey) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_PublicKey, this.PublicKey, sPublicKey));
+		this.PublicKey = sPublicKey;
+	};
+	CSignInfo.prototype.setX509 = function (sX509) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_X509, this.X509, sX509));
+		this.X509 = sX509;
+	};
+	CSignInfo.prototype.setImageValid = function (sImageValid) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_ImageValid, this.ImageValid, sImageValid));
+		this.ImageValid = sImageValid;
+	};
+	CSignInfo.prototype.setImageInvalid = function (sImageInvalid) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_SignInfo_ImageInvalid, this.ImageInvalid, sImageInvalid));
+		this.ImageInvalid = sImageInvalid;
+	};
+	CSignInfo.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "PublicKey": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setPublicKey(oNode.text);
+				break;
+			}
+			case "X509": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setX509(oNode.text);
+				break;
+			}
+			case "ImageValid": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setImageValid(oNode.text);
+				break;
+			}
+			case "ImageInvalid": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setImageInvalid(oNode.text);
+				break;
+			}
+		}
+	};
+	CSignInfo.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("SignInfo");
+		writer.WriteXmlAttributesEnd();
+		let oPublicKeyNode = new CT_XmlNode();
+		oPublicKeyNode.text = this.PublicKey;
+		oPublicKeyNode.toXml(writer, "PublicKey");
+
+		let oX509Node = new CT_XmlNode();
+		oX509Node.text = this.X509;
+		oX509Node.toXml(writer, "X509");
+
+		let oImageValidNode = new CT_XmlNode();
+		oImageValidNode.text = this.ImageValid;
+		oImageValidNode.toXml(writer, "ImageValid");
+
+		let oImageInvalidNode = new CT_XmlNode();
+		oImageInvalidNode.text = this.ImageInvalid;
+		oImageInvalidNode.toXml(writer, "ImageInvalid");
+
+		writer.WriteXmlNodeEnd("SignInfo");
+	};
+
+	function CCipherInfo() {
+		CBaseFormatObject.call(this);
+		this.PublicKey = null;
+	}
+	InitClass(CCipherInfo, CBaseFormatObject, AscDFH.historyitem_type_CipherInfo);
+	CCipherInfo.prototype.setPublicKey = function (sPublicKey) {
+		AscCommon.History.Add(new CChangesString(this, AscDFH.historyitem_CipherInfo_PublicKey, this.PublicKey, sPublicKey));
+		this.PublicKey = sPublicKey;
+	};
+	CCipherInfo.prototype.readChildXml = function (name, reader) {
+		switch (name) {
+			case "PublicKey": {
+				let oNode = new CT_XmlNode();
+				oNode.fromXml(reader);
+				this.setPublicKey(oNode.text);
+				break;
+			}
+		}
+	};
+	CCipherInfo.prototype.toXml = function(writer) {
+		writer.WriteXmlNodeStart("CipherInfo");
+		writer.WriteXmlAttributesEnd();
+		let oPublicKeyNode = new CT_XmlNode();
+		oPublicKeyNode.text = this.PublicKey;
+		oPublicKeyNode.toXml(writer, "PublicKey");
+		writer.WriteXmlNodeEnd("CipherInfo");
+	};
+
+	AscWord.CUserMaster = CUserMaster;
+	AscWord.CUser = CUser;
+	AscWord.CSignInfo = CSignInfo;
+	AscWord.CCipherInfo = CCipherInfo;
+})(window);