TableRowChanges.js

/*
 * (c) Copyright Ascensio System SIA 2010-2024
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */

"use strict";

AscDFH.changesFactory[AscDFH.historyitem_TableRow_Before]      = CChangesTableRowBefore;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_After]       = CChangesTableRowAfter;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_CellSpacing] = CChangesTableRowCellSpacing;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_Height]      = CChangesTableRowHeight;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_AddCell]     = CChangesTableRowAddCell;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_RemoveCell]  = CChangesTableRowRemoveCell;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_TableHeader] = CChangesTableRowTableHeader;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_Pr]          = CChangesTableRowPr;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_PrChange]    = CChangesTableRowPrChange;
AscDFH.changesFactory[AscDFH.historyitem_TableRow_ReviewType]  = CChangesTableRowReviewType;
//----------------------------------------------------------------------------------------------------------------------
// Карта зависимости изменений
//----------------------------------------------------------------------------------------------------------------------
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_Before]      = [
	AscDFH.historyitem_TableRow_Before,
	AscDFH.historyitem_TableRow_Pr
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_After]       = [
	AscDFH.historyitem_TableRow_After,
	AscDFH.historyitem_TableRow_Pr
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_CellSpacing] = [
	AscDFH.historyitem_TableRow_CellSpacing,
	AscDFH.historyitem_TableRow_Pr
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_Height]      = [
	AscDFH.historyitem_TableRow_Height,
	AscDFH.historyitem_TableRow_Pr
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_AddCell]     = [
	AscDFH.historyitem_TableRow_AddCell,
	AscDFH.historyitem_TableRow_RemoveCell
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_RemoveCell]  = [
	AscDFH.historyitem_TableRow_AddCell,
	AscDFH.historyitem_TableRow_RemoveCell
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_TableHeader] = [
	AscDFH.historyitem_TableRow_TableHeader,
	AscDFH.historyitem_TableRow_Pr
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_Pr]          = [
	AscDFH.historyitem_TableRow_Before,
	AscDFH.historyitem_TableRow_After,
	AscDFH.historyitem_TableRow_CellSpacing,
	AscDFH.historyitem_TableRow_Height,
	AscDFH.historyitem_TableRow_TableHeader,
	AscDFH.historyitem_TableRow_Pr,
	AscDFH.historyitem_TableRow_PrChange
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_PrChange] = [
	AscDFH.historyitem_TableRow_PrChange,
	AscDFH.historyitem_TableRow_Pr
];
AscDFH.changesRelationMap[AscDFH.historyitem_TableRow_ReviewType] = [
	AscDFH.historyitem_TableRow_ReviewType
];
/**
 * Общая функция объединения изменений, которые зависят только от себя и AscDFH.historyitem_TableRow_Pr
 * @param oChange
 * @returns {boolean}
 */
function private_TableRowChangesOnMergePr(oChange)
{
	if (oChange.Class !== this.Class)
		return true;

	if (oChange.Type === this.Type || oChange.Type === AscDFH.historyitem_TableRow_Pr)
		return false;

	return true;
}
//----------------------------------------------------------------------------------------------------------------------

/**
 * @constructor
 * @extends {AscDFH.CChangesBaseProperty}
 */
function CChangesTableRowBefore(Class, Old, New, Color)
{
	AscDFH.CChangesBaseProperty.call(this, Class, Old, New, Color);
}
CChangesTableRowBefore.prototype = Object.create(AscDFH.CChangesBaseProperty.prototype);
CChangesTableRowBefore.prototype.constructor = CChangesTableRowBefore;
CChangesTableRowBefore.prototype.Type = AscDFH.historyitem_TableRow_Before;
CChangesTableRowBefore.prototype.WriteToBinary = function(Writer)
{
	// Long : Flags
	// 1-bit : is New.GridBefore undefined?
	// 2-bit : is New.WBefore undefined?
	// 3-bit : is Old.GridBefore undefined?
	// 4-bit : is Old.WBefore undefined?
	// Long : New.GridBefore
	// CTableMeasurement : New.WBefore
	// Long : Old.GridBefore
	// CTableMeasurement : Old.WBefore

	var nFlags = 0;
	if (undefined === this.New.GridBefore)
		nFlags |= 1;
	if (undefined === this.New.WBefore)
		nFlags |= 2;
	if (undefined === this.Old.GridBefore)
		nFlags |= 4;
	if (undefined === this.Old.WBefore)
		nFlags |= 8;

	Writer.WriteLong(nFlags);

	if (undefined !== this.New.GridBefore)
		Writer.WriteLong(this.New.GridBefore);
	if (undefined !== this.New.WBefore)
		this.New.WBefore.Write_ToBinary(Writer);
	if (undefined !== this.Old.GridBefore)
		Writer.WriteLong(this.Old.GridBefore);
	if (undefined !== this.Old.WBefore)
		this.Old.WBefore.Write_ToBinary(Writer);
};
CChangesTableRowBefore.prototype.ReadFromBinary = function(Reader)
{
	// Long : Flags
	// 1-bit : is New.GridBefore undefined?
	// 2-bit : is New.WBefore undefined?
	// 3-bit : is Old.GridBefore undefined?
	// 4-bit : is Old.WBefore undefined?
	// Long : New.GridBefore
	// CTableMeasurement : New.WBefore
	// Long : Old.GridBefore
	// CTableMeasurement : Old.WBefore

	var nFlags = Reader.GetLong();

	this.New = {
		GridBefore : undefined,
		WBefore    : undefined
	};

	this.Old = {
		GridBefore : undefined,
		WBefore    : undefined
	};

	if (nFlags & 1)
		this.New.GridBefore = undefined;
	else
		this.New.GridBefore = Reader.GetLong();

	if (nFlags & 2)
	{
		this.New.WBefore = undefined;
	}
	else
	{
		this.New.WBefore = new CTableMeasurement(tblwidth_Auto, 0);
		this.New.WBefore.Read_FromBinary(Reader);
	}

	if (nFlags & 4)
		this.Old.GridBefore = undefined;
	else
		this.Old.GridBefore = Reader.GetLong();

	if (nFlags & 8)
	{
		this.Old.WBefore = undefined;
	}
	else
	{
		this.Old.WBefore = new CTableMeasurement(tblwidth_Auto, 0);
		this.Old.WBefore.Read_FromBinary(Reader);
	}
};
CChangesTableRowBefore.prototype.private_SetValue = function(Value)
{
	var oTableRow = this.Class;

	oTableRow.Pr.GridBefore = Value.GridBefore;
	oTableRow.Pr.WBefore    = Value.WBefore;
	oTableRow.Recalc_CompiledPr();
	oTableRow.private_UpdateTableGrid();
};
CChangesTableRowBefore.prototype.Merge = private_TableRowChangesOnMergePr;
CChangesTableRowBefore.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseProperty}
 */
function CChangesTableRowAfter(Class, Old, New, Color)
{
	AscDFH.CChangesBaseProperty.call(this, Class, Old, New, Color);
}
CChangesTableRowAfter.prototype = Object.create(AscDFH.CChangesBaseProperty.prototype);
CChangesTableRowAfter.prototype.constructor = CChangesTableRowAfter;
CChangesTableRowAfter.prototype.Type = AscDFH.historyitem_TableRow_After;
CChangesTableRowAfter.prototype.WriteToBinary = function(Writer)
{
	// Long : Flags
	// 1-bit : is New.GridAfter undefined?
	// 2-bit : is New.WAfter undefined?
	// 3-bit : is Old.GridAfter undefined?
	// 4-bit : is Old.WAfter undefined?
	// Long : New.GridBefore
	// CTableMeasurement : New.WBefore
	// Long : Old.GridBefore
	// CTableMeasurement : Old.WBefore

	var nFlags = 0;
	if (undefined === this.New.GridAfter)
		nFlags |= 1;
	if (undefined === this.New.WAfter)
		nFlags |= 2;
	if (undefined === this.Old.GridAfter)
		nFlags |= 4;
	if (undefined === this.Old.WAfter)
		nFlags |= 8;

	Writer.WriteLong(nFlags);

	if (undefined !== this.New.GridAfter)
		Writer.WriteLong(this.New.GridAfter);
	if (undefined !== this.New.WAfter)
		this.New.WAfter.Write_ToBinary(Writer);
	if (undefined !== this.Old.GridAfter)
		Writer.WriteLong(this.Old.GridAfter);
	if (undefined !== this.Old.WAfter)
		this.Old.WAfter.Write_ToBinary(Writer);
};
CChangesTableRowAfter.prototype.ReadFromBinary = function(Reader)
{
	// Long : Flags
	// 1-bit : is New.GridAfter undefined?
	// 2-bit : is New.WAfter undefined?
	// 3-bit : is Old.GridAfter undefined?
	// 4-bit : is Old.WAfter undefined?
	// Long : New.GridAfter
	// CTableMeasurement : New.WAfter
	// Long : Old.GridAfter
	// CTableMeasurement : Old.WAfter

	var nFlags = Reader.GetLong();

	this.New = {
		GridAfter : undefined,
		WAfter    : undefined
	};

	this.Old = {
		GridAfter : undefined,
		WAfter    : undefined
	};

	if (nFlags & 1)
		this.New.GridAfter = undefined;
	else
		this.New.GridAfter = Reader.GetLong();

	if (nFlags & 2)
	{
		this.New.WAfter = undefined;
	}
	else
	{
		this.New.WAfter = new CTableMeasurement(tblwidth_Auto, 0);
		this.New.WAfter.Read_FromBinary(Reader);
	}

	if (nFlags & 4)
		this.Old.GridAfter = undefined;
	else
		this.Old.GridAfter = Reader.GetLong();

	if (nFlags & 8)
	{
		this.Old.WAfter = undefined;
	}
	else
	{
		this.Old.WAfter = new CTableMeasurement(tblwidth_Auto, 0);
		this.Old.WAfter.Read_FromBinary(Reader);
	}
};
CChangesTableRowAfter.prototype.private_SetValue = function(Value)
{
	var oTableRow = this.Class;

	oTableRow.Pr.GridAfter = Value.GridAfter;
	oTableRow.Pr.WAfter    = Value.WAfter;
	oTableRow.Recalc_CompiledPr();
	oTableRow.private_UpdateTableGrid();
};
CChangesTableRowAfter.prototype.Merge = private_TableRowChangesOnMergePr;
CChangesTableRowAfter.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseProperty}
 */
function CChangesTableRowCellSpacing(Class, Old, New, Color)
{
	AscDFH.CChangesBaseProperty.call(this, Class, Old, New, Color);
}
CChangesTableRowCellSpacing.prototype = Object.create(AscDFH.CChangesBaseProperty.prototype);
CChangesTableRowCellSpacing.prototype.constructor = CChangesTableRowCellSpacing;
CChangesTableRowCellSpacing.prototype.Type = AscDFH.historyitem_TableRow_CellSpacing;
CChangesTableRowCellSpacing.prototype.WriteToBinary = function(Writer)
{
	// Long : Flags
	// 1-bit : is New undefined?
	// 2-bit : is New null?
	// 3-bit : is Old undefined?
	// 4-bit : is Old null?
	// Double : New (1,2 bits are clear)
	// Double : Old (3,4 bits are clear)

	var nFlags = 0;
	if (undefined === this.New)
		nFlags |= 1;
	else if (null === this.New)
		nFlags |= 2;

	if (undefined === this.Old)
		nFlags |= 4;
	else if (null === this.Old)
		nFlags |= 8;

	Writer.WriteLong(nFlags);

	if (undefined !== this.New && null !== this.New)
		Writer.WriteDouble(this.New);
	if (undefined !== this.Old && null !== this.Old)
		Writer.WriteDouble(this.Old);
};
CChangesTableRowCellSpacing.prototype.ReadFromBinary = function(Reader)
{
	// Long : Flags
	// 1-bit : is New undefined?
	// 2-bit : is New null?
	// 3-bit : is Old undefined?
	// 4-bit : is Old null?
	// Double : New (1,2 bits are clear)
	// Double : Old (3,4 bits are clear)

	var nFlags = Reader.GetLong();

	if (nFlags & 1)
		this.New = undefined;
	else if (nFlags & 2)
		this.New = null;
	else
		this.New = Reader.GetDouble();

	if (nFlags & 4)
		this.Old = undefined;
	else if (nFlags & 8)
		this.Old = null;
	else
		this.Old = Reader.GetDouble();
};
CChangesTableRowCellSpacing.prototype.private_SetValue = function(Value)
{
	var oTableRow = this.Class;
	oTableRow.Pr.TableCellSpacing = Value;
	oTableRow.Recalc_CompiledPr();
	oTableRow.private_UpdateTableGrid();
};
CChangesTableRowCellSpacing.prototype.Merge = private_TableRowChangesOnMergePr;
CChangesTableRowCellSpacing.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseObjectProperty}
 */
function CChangesTableRowHeight(Class, Old, New, Color)
{
	AscDFH.CChangesBaseObjectProperty.call(this, Class, Old, New, Color);
}
CChangesTableRowHeight.prototype = Object.create(AscDFH.CChangesBaseObjectProperty.prototype);
CChangesTableRowHeight.prototype.constructor = CChangesTableRowHeight;
CChangesTableRowHeight.prototype.Type = AscDFH.historyitem_TableRow_Height;
CChangesTableRowHeight.prototype.private_CreateObject = function()
{
	return new CTableRowHeight(0, Asc.linerule_Auto);
};
CChangesTableRowHeight.prototype.private_SetValue = function(Value)
{
	var oTable = this.Class;
	oTable.Pr.Height = Value;
	oTable.Recalc_CompiledPr();
};
CChangesTableRowHeight.prototype.Merge = private_TableRowChangesOnMergePr;
CChangesTableRowHeight.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseContentChange}
 */
function CChangesTableRowAddCell(Class, Pos, Cells)
{
	AscDFH.CChangesBaseContentChange.call(this, Class, Pos, Cells, true);
}
CChangesTableRowAddCell.prototype = Object.create(AscDFH.CChangesBaseContentChange.prototype);
CChangesTableRowAddCell.prototype.constructor = CChangesTableRowAddCell;
CChangesTableRowAddCell.prototype.Type = AscDFH.historyitem_TableRow_AddCell;
CChangesTableRowAddCell.prototype.Undo = function()
{
	if (this.Items.length <= 0)
		return;

	var oRow = this.Class;
	oRow.Content[this.Pos].SetIndex(-1);
	oRow.Content.splice(this.Pos, 1);
	oRow.CellsInfo.splice(this.Pos, 1);
	oRow.Internal_ReIndexing(this.Pos);
	oRow.private_CheckCurCell();
	oRow.private_UpdateTableGrid();
};
CChangesTableRowAddCell.prototype.Redo = function()
{
	if (this.Items.length <= 0)
		return;

	var oRow = this.Class;
	oRow.Content.splice(this.Pos, 0, this.Items[0]);
	oRow.CellsInfo.splice(this.Pos, 0, {});
	oRow.Internal_ReIndexing(this.Pos);
	oRow.private_CheckCurCell();
	oRow.private_UpdateTableGrid();
};
CChangesTableRowAddCell.prototype.private_WriteItem = function(Writer, Item)
{
	Writer.WriteString2(Item.Get_Id());
};
CChangesTableRowAddCell.prototype.private_ReadItem = function(Reader)
{
	return AscCommon.g_oTableId.Get_ById(Reader.GetString2());
};
CChangesTableRowAddCell.prototype.Load = function(Color)
{
	if (this.Items.length <= 0 || this.PosArray.length <= 0)
		return;

	var oRow = this.Class;

	var Pos     = oRow.m_oContentChanges.Check(AscCommon.contentchanges_Add, this.PosArray[0]);
	var Element = this.Items[0];

	if (null != Element)
	{
		oRow.Content.splice(Pos, 0, Element);
		AscCommon.CollaborativeEditing.Update_DocumentPositionsOnAdd(oRow, Pos);
	}

	oRow.Internal_ReIndexing();
	oRow.private_CheckCurCell();
	oRow.private_UpdateTableGrid();
};
CChangesTableRowAddCell.prototype.IsRelated = function(oChanges)
{
	if (this.Class === oChanges.Class && (AscDFH.historyitem_TableRow_AddCell === oChanges.Type || AscDFH.historyitem_TableRow_RemoveCell === oChanges.Type))
		return true;

	return false;
};
CChangesTableRowAddCell.prototype.CreateReverseChange = function()
{
	return this.private_CreateReverseChange(CChangesTableRowRemoveCell);
};
CChangesTableRowAddCell.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseContentChange}
 */
function CChangesTableRowRemoveCell(Class, Pos, Cells)
{
	AscDFH.CChangesBaseContentChange.call(this, Class, Pos, Cells, false);
}
CChangesTableRowRemoveCell.prototype = Object.create(AscDFH.CChangesBaseContentChange.prototype);
CChangesTableRowRemoveCell.prototype.constructor = CChangesTableRowRemoveCell;
CChangesTableRowRemoveCell.prototype.Type = AscDFH.historyitem_TableRow_RemoveCell;
CChangesTableRowRemoveCell.prototype.Undo = function()
{
	if (this.Items.length <= 0)
		return;

	var oRow = this.Class;
	oRow.Content.splice(this.Pos, 0, this.Items[0]);
	oRow.CellsInfo.splice(this.Pos, 0, {});
	oRow.Internal_ReIndexing(this.Pos);
	oRow.private_CheckCurCell();
	oRow.private_UpdateTableGrid();
};
CChangesTableRowRemoveCell.prototype.Redo = function()
{
	if (this.Items.length <= 0)
		return;

	var oRow = this.Class;
	oRow.Content[this.Pos].SetIndex(-1);
	oRow.Content.splice(this.Pos, 1);
	oRow.CellsInfo.splice(this.Pos, 1);
	oRow.Internal_ReIndexing(this.Pos);
	oRow.private_CheckCurCell();
	oRow.private_UpdateTableGrid();
};
CChangesTableRowRemoveCell.prototype.private_WriteItem = function(Writer, Item)
{
	Writer.WriteString2(Item.Get_Id());
};
CChangesTableRowRemoveCell.prototype.private_ReadItem = function(Reader)
{
	return AscCommon.g_oTableId.Get_ById(Reader.GetString2());
};
CChangesTableRowRemoveCell.prototype.Load = function(Color)
{
	if (this.Items.length <= 0 || this.PosArray.length <= 0)
		return;

	var oRow = this.Class;

	var Pos = oRow.m_oContentChanges.Check(AscCommon.contentchanges_Remove, this.PosArray[0]);
	if (false === Pos)
		return;

	oRow.Content[Pos].SetIndex(-1);
	oRow.Content.splice(Pos, 1);
	AscCommon.CollaborativeEditing.Update_DocumentPositionsOnRemove(oRow, Pos, 1);

	oRow.Internal_ReIndexing();
	oRow.private_CheckCurCell();
	oRow.private_UpdateTableGrid();
};
CChangesTableRowRemoveCell.prototype.IsRelated = function(oChanges)
{
	if (this.Class === oChanges.Class && (AscDFH.historyitem_TableRow_AddCell === oChanges.Type || AscDFH.historyitem_TableRow_RemoveCell === oChanges.Type))
		return true;

	return false;
};
CChangesTableRowRemoveCell.prototype.CreateReverseChange = function()
{
	return this.private_CreateReverseChange(CChangesTableRowAddCell);
};
CChangesTableRowRemoveCell.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseBoolProperty}
 */
function CChangesTableRowTableHeader(Class, Old, New, Color)
{
	AscDFH.CChangesBaseBoolProperty.call(this, Class, Old, New, Color);
}
CChangesTableRowTableHeader.prototype = Object.create(AscDFH.CChangesBaseBoolProperty.prototype);
CChangesTableRowTableHeader.prototype.constructor = CChangesTableRowTableHeader;
CChangesTableRowTableHeader.prototype.Type = AscDFH.historyitem_TableRow_TableHeader;
CChangesTableRowTableHeader.prototype.private_SetValue = function(Value)
{
	var oRow = this.Class;
	oRow.Pr.TableHeader = Value;
	oRow.Recalc_CompiledPr();
	oRow.RecalcCopiledPrCells();
};
CChangesTableRowTableHeader.prototype.Merge = private_TableRowChangesOnMergePr;
CChangesTableRowTableHeader.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseObjectValue}
 */
function CChangesTableRowPr(Class, Old, New, Color)
{
	AscDFH.CChangesBaseObjectValue.call(this, Class, Old, New, Color);
}
CChangesTableRowPr.prototype = Object.create(AscDFH.CChangesBaseObjectValue.prototype);
CChangesTableRowPr.prototype.constructor = CChangesTableRowPr;
CChangesTableRowPr.prototype.Type = AscDFH.historyitem_TableRow_Pr;
CChangesTableRowPr.prototype.private_CreateObject = function()
{
	return new CTableRowPr()
};
CChangesTableRowPr.prototype.private_SetValue = function(Value)
{
	let row = this.Class;

	let trackRevisions = !!(row.Pr.PrChange || Value.PrChange);
	
	row.Pr = Value;
	row.Recalc_CompiledPr();
	row.private_UpdateTableGrid();
	
	if (trackRevisions)
		row.updateTrackRevisions();
};
CChangesTableRowPr.prototype.Merge = function(oChange)
{
	if (this.Class !== oChange.Class)
		return true;

	if (this.Type === oChange.Type)
		return false;

	if (!this.New)
		this.New = new CTableRowPr();

	switch (oChange.Type)
	{
		case AscDFH.historyitem_TableRow_Before:
		{
			this.New.GridBefore = oChange.New.GridBefore;
			this.New.WBefore    = oChange.New.WBefore;
			break;
		}
		case AscDFH.historyitem_TableRow_After:
		{
			this.New.GridAfter = oChange.New.GridAfter;
			this.New.WAfter    = oChange.New.WAfter;
			break;
		}
		case AscDFH.historyitem_TableRow_CellSpacing:
		{
			this.New.TableCellSpacing = oChange.New;
			break;
		}
		case AscDFH.historyitem_TableRow_Height:
		{
			this.New.Height = oChange.New;
			break;
		}
		case AscDFH.historyitem_TableRow_TableHeader:
		{
			this.New.TableHeader = oChange.New;
			break;
		}
	}

	return true;
};
CChangesTableRowPr.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBase}
 */
function CChangesTableRowPrChange(Class, Old, New)
{
	AscDFH.CChangesBase.call(this, Class);

	this.Old = Old;
	this.New = New;
}
CChangesTableRowPrChange.prototype = Object.create(AscDFH.CChangesBase.prototype);
CChangesTableRowPrChange.prototype.constructor = CChangesTableRowPrChange;
CChangesTableRowPrChange.prototype.Type = AscDFH.historyitem_TableRow_PrChange;
CChangesTableRowPrChange.prototype.Undo = function()
{
	var oTableRow = this.Class;
	oTableRow.Pr.PrChange   = this.Old.PrChange;
	oTableRow.Pr.ReviewInfo = this.Old.ReviewInfo;
	oTableRow.updateTrackRevisions();
};
CChangesTableRowPrChange.prototype.Redo = function()
{
	var oTableRow = this.Class;
	oTableRow.Pr.PrChange   = this.New.PrChange;
	oTableRow.Pr.ReviewInfo = this.New.ReviewInfo;
	oTableRow.updateTrackRevisions();
};
CChangesTableRowPrChange.prototype.WriteToBinary = function(oWriter)
{
	// Long : Flags
	// 1-bit : is New.PrChange undefined ?
	// 2-bit : is New.ReviewInfo undefined ?
	// 3-bit : is Old.PrChange undefined ?
	// 4-bit : is Old.ReviewInfo undefined ?
	// Variable(CTableRowPr) : New.PrChange   (1bit = 0)
	// Variable(AscWord.ReviewInfo) : New.ReviewInfo (2bit = 0)
	// Variable(CTableRowPr) : Old.PrChange   (3bit = 0)
	// Variable(AscWord.ReviewInfo) : Old.ReviewInfo (4bit = 0)

	var nFlags = 0;
	if (undefined === this.New.PrChange)
		nFlags |= 1;

	if (undefined === this.New.ReviewInfo)
		nFlags |= 2;

	if (undefined === this.Old.PrChange)
		nFlags |= 4;

	if (undefined === this.Old.ReviewInfo)
		nFlags |= 8;

	oWriter.WriteLong(nFlags);

	if (undefined !== this.New.PrChange)
		this.New.PrChange.WriteToBinary(oWriter);

	if (undefined !== this.New.ReviewInfo)
		this.New.ReviewInfo.WriteToBinary(oWriter);

	if (undefined !== this.Old.PrChange)
		this.Old.PrChange.WriteToBinary(oWriter);

	if (undefined !== this.Old.ReviewInfo)
		this.Old.ReviewInfo.WriteToBinary(oWriter);
};
CChangesTableRowPrChange.prototype.ReadFromBinary = function(oReader)
{
	// Long : Flags
	// 1-bit : is New.PrChange undefined ?
	// 2-bit : is New.ReviewInfo undefined ?
	// 3-bit : is Old.PrChange undefined ?
	// 4-bit : is Old.ReviewInfo undefined ?
	// Variable(CTableRowPr) : New.PrChange   (1bit = 0)
	// Variable(AscWord.ReviewInfo) : New.ReviewInfo (2bit = 0)
	// Variable(CTableRowPr) : Old.PrChange   (3bit = 0)
	// Variable(AscWord.ReviewInfo) : Old.ReviewInfo (4bit = 0)

	var nFlags = oReader.GetLong();

	this.New = {
		PrChange   : undefined,
		ReviewInfo : undefined
	};

	this.Old = {
		PrChange   : undefined,
		ReviewInfo : undefined
	};

	if (nFlags & 1)
	{
		this.New.PrChange = undefined;
	}
	else
	{
		this.New.PrChange = new CTableRowPr();
		this.New.PrChange.ReadFromBinary(oReader);
	}

	if (nFlags & 2)
	{
		this.New.ReviewInfo = undefined;
	}
	else
	{
		this.New.ReviewInfo = new AscWord.ReviewInfo();
		this.New.ReviewInfo.ReadFromBinary(oReader);
	}

	if (nFlags & 4)
	{
		this.Old.PrChange = undefined;
	}
	else
	{
		this.Old.PrChange = new CTableRowPr();
		this.Old.PrChange.ReadFromBinary(oReader);
	}

	if (nFlags & 8)
	{
		this.Old.ReviewInfo = undefined;
	}
	else
	{
		this.Old.ReviewInfo = new AscWord.ReviewInfo();
		this.Old.ReviewInfo.ReadFromBinary(oReader);
	}
};
CChangesTableRowPrChange.prototype.CreateReverseChange = function()
{
	return new CChangesTableRowPrChange(this.Class, this.New, this.Old);
};
CChangesTableRowPrChange.prototype.Merge = function(oChange)
{
	if (this.Class !== oChange.Class)
		return true;

	if (oChange.Type === this.Type || AscDFH.historyitem_TableRow_Pr === oChange.Type)
		return false;

	return true;
};
CChangesTableRowPrChange.prototype.CheckLock = private_TableChangesCheckLock;
/**
 * @constructor
 * @extends {AscDFH.CChangesBaseProperty}
 */
function CChangesTableRowReviewType(Class, Old, New, Color)
{
	AscDFH.CChangesBaseProperty.call(this, Class, Old, New, Color);
}
CChangesTableRowReviewType.prototype = Object.create(AscDFH.CChangesBaseProperty.prototype);
CChangesTableRowReviewType.prototype.constructor = CChangesTableRowReviewType;
CChangesTableRowReviewType.prototype.Type = AscDFH.historyitem_TableRow_ReviewType;
CChangesTableRowReviewType.prototype.WriteToBinary = function(oWriter)
{
	// Long        : New ReviewType
	// AscWord.ReviewInfo : New ReviewInfo
	// Long        : Old ReviewType
	// AscWord.ReviewInfo : Old ReviewInfo
	oWriter.WriteLong(this.New.ReviewType);
	this.New.ReviewInfo.WriteToBinary(oWriter);
	oWriter.WriteLong(this.Old.ReviewType);
	this.Old.ReviewInfo.WriteToBinary(oWriter);
};
CChangesTableRowReviewType.prototype.ReadFromBinary = function(oReader)
{
	// Long        : New ReviewType
	// AscWord.ReviewInfo : New ReviewInfo
	// Long        : Old ReviewType
	// AscWord.ReviewInfo : Old ReviewInfo

	this.New = {
		ReviewType : reviewtype_Common,
		ReviewInfo : new AscWord.ReviewInfo()
	};

	this.Old = {
		ReviewType : reviewtype_Common,
		ReviewInfo : new AscWord.ReviewInfo()
	};

	this.New.ReviewType = oReader.GetLong();
	this.New.ReviewInfo.ReadFromBinary(oReader);
	this.Old.ReviewType = oReader.GetLong();
	this.Old.ReviewInfo.ReadFromBinary(oReader);
};
CChangesTableRowReviewType.prototype.private_SetValue = function(Value)
{
	var oTableRow = this.Class;

	oTableRow.ReviewType = Value.ReviewType;
	oTableRow.ReviewInfo = Value.ReviewInfo;
	oTableRow.updateTrackRevisions();
};
CChangesTableRowReviewType.prototype.CheckLock = private_TableChangesCheckLock;