1331 lines
37 KiB
JavaScript
1331 lines
37 KiB
JavaScript
/*
|
||
* (c) Copyright Ascensio System SIA 2010-2024
|
||
*
|
||
* This program is a free software product. You can redistribute it and/or
|
||
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
||
* version 3 as published by the Free Software Foundation. In accordance with
|
||
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
||
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
||
* of any third-party rights.
|
||
*
|
||
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
||
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
||
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
||
*
|
||
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
||
* street, Riga, Latvia, EU, LV-1050.
|
||
*
|
||
* The interactive user interfaces in modified source and object code versions
|
||
* of the Program must display Appropriate Legal Notices, as required under
|
||
* Section 5 of the GNU AGPL version 3.
|
||
*
|
||
* Pursuant to Section 7(b) of the License you must retain the original Product
|
||
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
||
* grant you any rights under trademark law for use of our trademarks.
|
||
*
|
||
* All the Product's GUI elements, including illustrations and icon sets, as
|
||
* well as technical writing content are licensed under the terms of the
|
||
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
||
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
||
*
|
||
*/
|
||
|
||
"use strict";
|
||
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
// Класс CTableRow
|
||
//----------------------------------------------------------------------------------------------------------------------
|
||
function CTableRow(Table, Cols, TableGrid)
|
||
{
|
||
this.Id = AscCommon.g_oIdCounter.Get_NewId();
|
||
|
||
this.Table = Table; // Родительский класс таблицы
|
||
|
||
this.Next = null;
|
||
this.Prev = null;
|
||
|
||
this.Content = [];
|
||
for ( var Index = 0; Index < Cols; Index++ )
|
||
{
|
||
var ColW = ( undefined != TableGrid && undefined != TableGrid[Index] ? TableGrid[Index] : undefined );
|
||
this.Content[Index] = new CTableCell( this, ColW );
|
||
}
|
||
|
||
this.Internal_ReIndexing();
|
||
|
||
// Информация о рассчитанных метриках ячеек
|
||
this.CellsInfo = [];
|
||
|
||
// Метрика строки
|
||
this.Metrics =
|
||
{
|
||
X_min : 0,
|
||
X_max : 0
|
||
};
|
||
|
||
// Информация о spacing до и после текущей строки
|
||
this.SpacingInfo = { Top : false, Bottom : false };
|
||
|
||
this.CompiledPr =
|
||
{
|
||
Pr : null,
|
||
NeedRecalc : true
|
||
};
|
||
|
||
this.Pr = new CTableRowPr();
|
||
|
||
// Данные два параметра нужны для контроля кардинальности изменений, которые
|
||
// происходят внутри ячеек данной строки.
|
||
this.Height = 0;
|
||
this.PagesCount = 1;
|
||
|
||
// Добавляем данный класс в список DocumentContent'ов
|
||
if (typeof AscCommon.CollaborativeEditing !== "undefined")
|
||
AscCommon.CollaborativeEditing.Add_NewDC(this);
|
||
this.m_oContentChanges = new AscCommon.CContentChanges(); // список изменений(добавление/удаление элементов)
|
||
|
||
this.Index = 0;
|
||
|
||
this.ReviewType = reviewtype_Common;
|
||
this.ReviewInfo = new AscWord.ReviewInfo();
|
||
|
||
if (editor
|
||
&& !editor.isPresentationEditor
|
||
&& editor.WordControl
|
||
&& editor.WordControl.m_oLogicDocument
|
||
&& true === editor.WordControl.m_oLogicDocument.IsTrackRevisions()
|
||
&& !editor.WordControl.m_oLogicDocument.RecalcTableHeader)
|
||
{
|
||
this.ReviewType = reviewtype_Add;
|
||
this.ReviewInfo.Update();
|
||
}
|
||
|
||
// Добавляем данный класс в таблицу Id (обязательно в конце конструктора)
|
||
AscCommon.g_oTableId.Add( this, this.Id );
|
||
}
|
||
|
||
CTableRow.prototype =
|
||
{
|
||
Get_Id : function()
|
||
{
|
||
return this.Id;
|
||
},
|
||
|
||
GetId : function()
|
||
{
|
||
return this.Id;
|
||
},
|
||
|
||
// Создаем копию данного объекта
|
||
Copy : function(Table, oPr)
|
||
{
|
||
var Row = new CTableRow(Table, 0);
|
||
|
||
// Копируем настройки строки
|
||
Row.Set_Pr(this.Pr.Copy());
|
||
|
||
// Копируем ячейки
|
||
var CellsCount = this.Content.length;
|
||
for (var Index = 0; Index < CellsCount; Index++)
|
||
{
|
||
Row.Content[Index] = this.Content[Index].Copy(Row, oPr);
|
||
Row.Content[Index].Recalc_CompiledPr();
|
||
AscCommon.History.Add(new CChangesTableRowAddCell(Row, Index, [Row.Content[Index]]));
|
||
}
|
||
|
||
Row.Internal_ReIndexing();
|
||
Row.private_UpdateTableGrid();
|
||
if(oPr && oPr.Comparison)
|
||
{
|
||
oPr.Comparison.checkReviewInfoOfCopiedElements(Row, this);
|
||
}
|
||
return Row;
|
||
},
|
||
|
||
IsUseInDocument : function(Id)
|
||
{
|
||
var bUse = false;
|
||
if ( null != Id )
|
||
{
|
||
var Count = this.Content.length;
|
||
for ( var Index = 0; Index < Count; Index++ )
|
||
{
|
||
if ( Id === this.Content[Index].Get_Id() )
|
||
{
|
||
bUse = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
bUse = true;
|
||
|
||
if ( true === bUse && null != this.Table )
|
||
return this.Table.IsUseInDocument(this.Get_Id());
|
||
|
||
return false;
|
||
},
|
||
|
||
Set_Metrics_X : function(x_min, x_max)
|
||
{
|
||
this.Metrics.X_min = x_min;
|
||
this.Metrics.X_max = x_max;
|
||
},
|
||
|
||
GetEndInfo : function()
|
||
{
|
||
var CellsCount = this.Content.length;
|
||
if ( CellsCount > 0 )
|
||
return this.Content[CellsCount - 1].GetEndInfo();
|
||
else
|
||
return null;
|
||
},
|
||
|
||
GetPrevElementEndInfo : function(CellIndex)
|
||
{
|
||
if (-1 === CellIndex || !this.Table || !this.Content[CellIndex])
|
||
return null;
|
||
|
||
if (0 === CellIndex)
|
||
return this.Table.GetPrevElementEndInfo(this.Index);
|
||
else
|
||
return this.Content[CellIndex - 1].GetEndInfo();
|
||
},
|
||
|
||
SaveRecalculateObject : function()
|
||
{
|
||
var RecalcObj = new CTableRowRecalculateObject();
|
||
RecalcObj.Save(this);
|
||
return RecalcObj;
|
||
},
|
||
|
||
LoadRecalculateObject : function(RecalcObj)
|
||
{
|
||
RecalcObj.Load(this);
|
||
},
|
||
|
||
PrepareRecalculateObject : function()
|
||
{
|
||
this.CellsInfo = [];
|
||
this.Metrics = {X_min : 0, X_max : 0};
|
||
this.SpacingInfo = {Top : false, Bottom : false};
|
||
|
||
var Count = this.Content.length;
|
||
for (var Index = 0; Index < Count; Index++)
|
||
{
|
||
this.Content[Index].PrepareRecalculateObject();
|
||
}
|
||
},
|
||
|
||
PreDelete : function()
|
||
{
|
||
for (let iCell = 0, cellCount = this.GetCellsCount(); iCell < cellCount; ++iCell)
|
||
{
|
||
this.GetCell(iCell).PreDelete();
|
||
}
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Работаем с стилем строки
|
||
//-----------------------------------------------------------------------------------
|
||
Recalc_CompiledPr : function()
|
||
{
|
||
this.CompiledPr.NeedRecalc = true;
|
||
|
||
var oTable = this.GetTable();
|
||
if (oTable)
|
||
oTable.RecalcInfo.RecalcBorders();
|
||
},
|
||
|
||
// Формируем конечные свойства параграфа на основе стиля и прямых настроек.
|
||
Get_CompiledPr : function(bCopy)
|
||
{
|
||
let forceCompile = false;
|
||
if (true === AscCommon.g_oIdCounter.m_bLoad || true === AscCommon.g_oIdCounter.m_bRead)
|
||
{
|
||
let logicDocument = this.GetLogicDocument();
|
||
if (logicDocument
|
||
&& logicDocument.IsDocumentEditor()
|
||
&& logicDocument.CompileStyleOnLoad)
|
||
forceCompile = true;
|
||
}
|
||
|
||
if ( true === this.CompiledPr.NeedRecalc )
|
||
{
|
||
if (!forceCompile && (true === AscCommon.g_oIdCounter.m_bLoad || true === AscCommon.g_oIdCounter.m_bRead))
|
||
{
|
||
this.CompiledPr.Pr = g_oDocumentDefaultTableRowPr;
|
||
this.CompiledPr.NeedRecalc = true;
|
||
}
|
||
else
|
||
{
|
||
this.CompiledPr.Pr = this.Internal_Compile_Pr();
|
||
this.CompiledPr.NeedRecalc = forceCompile;
|
||
}
|
||
}
|
||
|
||
if ( false === bCopy )
|
||
return this.CompiledPr.Pr;
|
||
else
|
||
return this.CompiledPr.Pr.Copy(); // Отдаем копию объекта, чтобы никто не поменял извне настройки стиля
|
||
},
|
||
|
||
Internal_Compile_Pr : function()
|
||
{
|
||
var TablePr = this.Table.Get_CompiledPr(false);
|
||
var TableLook = this.Table.Get_TableLook();
|
||
var CurIndex = this.Index;
|
||
|
||
// Сначала возьмем настройки по умолчанию для строки
|
||
var RowPr = TablePr.TableRowPr.Copy();
|
||
if (undefined !== TablePr.TablePr.TableCellSpacing)
|
||
RowPr.TableCellSpacing = TablePr.TablePr.TableCellSpacing;
|
||
|
||
// Совместим настройки с настройками для групп строк
|
||
if ( true === TableLook.IsBandHor() )
|
||
{
|
||
var RowBandSize = TablePr.TablePr.TableStyleRowBandSize;
|
||
var _CurIndex = ( true != TableLook.IsFirstRow() ? CurIndex : CurIndex - 1 );
|
||
var GroupIndex = ( 1 != RowBandSize ? Math.floor( _CurIndex / RowBandSize ) : _CurIndex );
|
||
if ( 0 === GroupIndex % 2 )
|
||
RowPr.Merge(TablePr.TableBand1Horz.TableRowPr);
|
||
else
|
||
RowPr.Merge(TablePr.TableBand2Horz.TableRowPr);
|
||
}
|
||
|
||
// Совместим настройки с настройками для последней строки
|
||
if ( true === TableLook.IsLastRow() && this.Table.Content.length - 1 === CurIndex )
|
||
{
|
||
RowPr.Merge(TablePr.TableLastRow.TableRowPr);
|
||
}
|
||
|
||
// Совместим настройки с настройками для первой строки
|
||
if ( true === TableLook.IsFirstRow() && ( 0 === CurIndex || true === this.Pr.TableHeader ) )
|
||
{
|
||
RowPr.Merge(TablePr.TableFirstRow.TableRowPr);
|
||
}
|
||
|
||
// Полученные настройки совместим с прямыми настройками
|
||
RowPr.Merge(this.Pr);
|
||
|
||
return RowPr;
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Работаем с настройками строки
|
||
//-----------------------------------------------------------------------------------
|
||
Clear_DirectFormatting : function(bClearMerge)
|
||
{
|
||
// Очищаем все строки и всех ее ячеек
|
||
if (true === bClearMerge)
|
||
{
|
||
this.Set_After(undefined, undefined);
|
||
this.Set_Before(undefined, undefined);
|
||
this.Set_Height(undefined, undefined);
|
||
}
|
||
|
||
this.Set_CellSpacing(undefined);
|
||
|
||
var Count = this.Content.length;
|
||
for ( var Index = 0; Index < Count; Index++ )
|
||
{
|
||
this.Content[Index].Clear_DirectFormatting(bClearMerge);
|
||
}
|
||
},
|
||
|
||
Set_Pr : function(RowPr)
|
||
{
|
||
let isHavePrChange = this.HavePrChange();
|
||
|
||
this.private_AddPrChange();
|
||
AscCommon.History.Add(new CChangesTableRowPr(this, this.Pr, RowPr));
|
||
this.Pr = RowPr;
|
||
this.Recalc_CompiledPr();
|
||
this.private_UpdateTableGrid();
|
||
|
||
if (isHavePrChange || this.HavePrChange())
|
||
this.updateTrackRevisions();
|
||
},
|
||
|
||
Get_Before : function()
|
||
{
|
||
var RowPr = this.Get_CompiledPr( false );
|
||
|
||
var Before = {
|
||
WBefore : RowPr.WBefore.Copy(),
|
||
GridBefore : RowPr.GridBefore
|
||
};
|
||
|
||
return Before;
|
||
},
|
||
|
||
Set_Before : function(GridBefore, WBefore)
|
||
{
|
||
// Если парметр WBefore === false, значит значение WBefore мы не меняем
|
||
if (this.Pr.GridBefore !== GridBefore || this.Pr.WBefore !== WBefore)
|
||
{
|
||
var OldBefore = {
|
||
GridBefore : this.Pr.GridBefore,
|
||
WBefore : this.Pr.WBefore
|
||
};
|
||
|
||
var NewBefore = {
|
||
GridBefore : GridBefore,
|
||
WBefore : WBefore
|
||
};
|
||
|
||
if (false === WBefore)
|
||
{
|
||
NewBefore.WBefore = OldBefore.WBefore;
|
||
}
|
||
else if (undefined != WBefore)
|
||
{
|
||
NewBefore.WBefore = new CTableMeasurement(tblwidth_Auto, 0);
|
||
NewBefore.WBefore.Set_FromObject(WBefore);
|
||
}
|
||
|
||
this.private_AddPrChange();
|
||
AscCommon.History.Add(new CChangesTableRowBefore(this, OldBefore, NewBefore));
|
||
|
||
this.Pr.GridBefore = GridBefore;
|
||
this.Pr.WBefore = NewBefore.WBefore;
|
||
this.Recalc_CompiledPr();
|
||
this.private_UpdateTableGrid();
|
||
}
|
||
},
|
||
|
||
Get_After : function()
|
||
{
|
||
var RowPr = this.Get_CompiledPr( false );
|
||
|
||
var After = {
|
||
WAfter : RowPr.WAfter.Copy(),
|
||
GridAfter : RowPr.GridAfter
|
||
};
|
||
|
||
return After;
|
||
},
|
||
|
||
Set_After : function(GridAfter, WAfter)
|
||
{
|
||
// Если парметр WAfter === false, значит значение WAfter мы не меняем
|
||
if (this.Pr.GridAfter !== GridAfter || this.Pr.WAfter !== WAfter)
|
||
{
|
||
var OldAfter = {
|
||
GridAfter : this.Pr.GridAfter,
|
||
WAfter : this.Pr.WAfter
|
||
};
|
||
|
||
var NewAfter = {
|
||
GridAfter : GridAfter,
|
||
WAfter : WAfter
|
||
};
|
||
|
||
if (false === WAfter)
|
||
{
|
||
NewAfter.WAfter = OldAfter.WAfter;
|
||
}
|
||
else if (undefined != WAfter)
|
||
{
|
||
NewAfter.WAfter = new CTableMeasurement(tblwidth_Auto, 0);
|
||
NewAfter.WAfter.Set_FromObject(WAfter);
|
||
}
|
||
|
||
this.private_AddPrChange();
|
||
AscCommon.History.Add(new CChangesTableRowAfter(this, OldAfter, NewAfter));
|
||
|
||
this.Pr.GridAfter = GridAfter;
|
||
this.Pr.WAfter = NewAfter.WAfter;
|
||
this.Recalc_CompiledPr();
|
||
this.private_UpdateTableGrid();
|
||
}
|
||
},
|
||
|
||
Get_CellSpacing : function()
|
||
{
|
||
return this.Get_CompiledPr(false).TableCellSpacing;
|
||
},
|
||
|
||
Set_CellSpacing : function(Value)
|
||
{
|
||
if (this.Pr.TableCellSpacing === Value)
|
||
return;
|
||
|
||
this.private_AddPrChange();
|
||
AscCommon.History.Add(new CChangesTableRowCellSpacing(this, this.Pr.TableCellSpacing, Value));
|
||
this.Pr.TableCellSpacing = Value;
|
||
|
||
this.Recalc_CompiledPr();
|
||
this.private_UpdateTableGrid();
|
||
},
|
||
|
||
Get_Height : function()
|
||
{
|
||
var RowPr = this.Get_CompiledPr( false );
|
||
return RowPr.Height;
|
||
},
|
||
|
||
Set_Height : function(Value, HRule)
|
||
{
|
||
if ((undefined === this.Pr.Height && undefined === Value) || (undefined != this.Pr.Height && HRule === this.Pr.Height.HRule && Math.abs(Value - this.Pr.Height.Value) < 0.001))
|
||
return;
|
||
|
||
var OldHeight = this.Pr.Height;
|
||
var NewHeight = undefined != Value ? new CTableRowHeight(Value, HRule) : undefined;
|
||
|
||
this.private_AddPrChange();
|
||
AscCommon.History.Add(new CChangesTableRowHeight(this, OldHeight, NewHeight));
|
||
this.Pr.Height = NewHeight;
|
||
this.Recalc_CompiledPr();
|
||
},
|
||
|
||
Copy_Pr : function(OtherPr)
|
||
{
|
||
// Before
|
||
if ( undefined === OtherPr.WBefore )
|
||
this.Set_Before( OtherPr.GridBefore, undefined );
|
||
else
|
||
this.Set_Before( OtherPr.GridBefore, { W : OtherPr.WBefore.W, Type : OtherPr.WBefore.Type } );
|
||
|
||
// After
|
||
if ( undefined === OtherPr.WAfter )
|
||
this.Set_After( OtherPr.GridAfter, undefined );
|
||
else
|
||
this.Set_After( OtherPr.GridAfter, { W : OtherPr.WAfter.W, Type : OtherPr.WAfter.Type } );
|
||
|
||
// Height
|
||
if ( undefined === OtherPr.Height )
|
||
this.Set_Height( undefined, undefined );
|
||
else
|
||
this.Set_Height( OtherPr.Height.Value, OtherPr.Height.HRule );
|
||
|
||
// CellSpacing
|
||
if ( undefined != OtherPr.TableCellSpacing )
|
||
this.Set_CellSpacing( OtherPr.TableCellSpacing );
|
||
else
|
||
this.Set_CellSpacing( undefined );
|
||
|
||
// TableHeader
|
||
if ( undefined != OtherPr.TableHeader )
|
||
this.SetHeader( OtherPr.TableHeader );
|
||
else
|
||
this.SetHeader( undefined );
|
||
},
|
||
|
||
Set_SpacingInfo : function(bSpacingTop, bSpacingBot)
|
||
{
|
||
this.SpacingInfo =
|
||
{
|
||
Top : bSpacingTop,
|
||
Bottom : bSpacingBot
|
||
};
|
||
},
|
||
|
||
Get_SpacingInfo : function()
|
||
{
|
||
return this.SpacingInfo;
|
||
},
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
// Работаем с ячейками строки
|
||
//-----------------------------------------------------------------------------------
|
||
Get_Cell : function(Index)
|
||
{
|
||
if ( Index < 0 || Index >= this.Content.length )
|
||
return null;
|
||
|
||
return this.Content[Index];
|
||
},
|
||
|
||
Get_CellsCount : function()
|
||
{
|
||
return this.Content.length;
|
||
},
|
||
|
||
Set_CellInfo : function(Index, StartGridCol, X_grid_start, X_grid_end, X_cell_start, X_cell_end, X_content_start, X_content_end)
|
||
{
|
||
this.CellsInfo[Index] =
|
||
{
|
||
StartGridCol : StartGridCol,
|
||
X_grid_start : X_grid_start,
|
||
X_grid_end : X_grid_end,
|
||
X_cell_start : X_cell_start,
|
||
X_cell_end : X_cell_end,
|
||
X_content_start : X_content_start,
|
||
X_content_end : X_content_end
|
||
};
|
||
},
|
||
|
||
Update_CellInfo : function(Index)
|
||
{
|
||
var Cell = this.Content[Index];
|
||
|
||
var StartGridCol = Cell.Metrics.StartGridCol;
|
||
var X_grid_start = Cell.Metrics.X_grid_start;
|
||
var X_grid_end = Cell.Metrics.X_grid_end;
|
||
var X_cell_start = Cell.Metrics.X_cell_start;
|
||
var X_cell_end = Cell.Metrics.X_cell_end;
|
||
var X_content_start = Cell.Metrics.X_content_start;
|
||
var X_content_end = Cell.Metrics.X_content_end;
|
||
|
||
this.Set_CellInfo(Index, StartGridCol, X_grid_start, X_grid_end, X_cell_start, X_cell_end, X_content_start, X_content_end);
|
||
},
|
||
|
||
Get_CellInfo : function(Index)
|
||
{
|
||
if (!this.CellsInfo[Index] || undefined === this.CellsInfo[Index].StartGridCol)
|
||
this.GetTable().private_RecalculateGridCols();
|
||
|
||
return this.CellsInfo[Index];
|
||
},
|
||
|
||
Get_StartGridCol : function(Index)
|
||
{
|
||
var Max = Math.min( this.Content.length - 1, Index - 1);
|
||
var CurGridCol = this.Get_Before().GridBefore;
|
||
for ( var CurCell = 0; CurCell <= Max; CurCell++ )
|
||
{
|
||
var Cell = this.Get_Cell( CurCell );
|
||
var GridSpan = Cell.Get_GridSpan();
|
||
|
||
CurGridCol += GridSpan;
|
||
}
|
||
|
||
return CurGridCol;
|
||
},
|
||
|
||
Remove_Cell : function(Index)
|
||
{
|
||
this.Content[Index].PreDelete();
|
||
|
||
AscCommon.History.Add(new CChangesTableRowRemoveCell(this, Index, [this.Content[Index]]));
|
||
|
||
this.Content.splice(Index, 1);
|
||
this.CellsInfo.splice(Index, 1);
|
||
|
||
this.Internal_ReIndexing(Index);
|
||
|
||
this.private_CheckCurCell();
|
||
this.private_UpdateTableGrid();
|
||
this.OnContentChange();
|
||
},
|
||
|
||
Add_Cell : function(Index, Row, Cell, bReIndexing)
|
||
{
|
||
if ("undefined" === typeof(Cell) || null === Cell)
|
||
Cell = new CTableCell(Row);
|
||
|
||
AscCommon.History.Add(new CChangesTableRowAddCell(this, Index, [Cell]));
|
||
|
||
this.Content.splice(Index, 0, Cell);
|
||
this.CellsInfo.splice(Index, 0, {});
|
||
|
||
if (true === bReIndexing)
|
||
{
|
||
this.Internal_ReIndexing(Index);
|
||
}
|
||
else
|
||
{
|
||
if (Index > 0)
|
||
{
|
||
this.Content[Index - 1].Next = Cell;
|
||
Cell.Prev = this.Content[Index - 1];
|
||
}
|
||
else
|
||
Cell.Prev = null;
|
||
|
||
if (Index < this.Content.length - 1)
|
||
{
|
||
this.Content[Index + 1].Prev = Cell;
|
||
Cell.Next = this.Content[Index + 1];
|
||
}
|
||
else
|
||
Cell.Next = null;
|
||
}
|
||
|
||
this.private_CheckCurCell();
|
||
this.private_UpdateTableGrid();
|
||
this.OnContentChange();
|
||
|
||
return Cell;
|
||
},
|
||
|
||
Clear_ContentChanges : function()
|
||
{
|
||
this.m_oContentChanges.Clear();
|
||
},
|
||
|
||
Add_ContentChanges : function(Changes)
|
||
{
|
||
this.m_oContentChanges.Add( Changes );
|
||
},
|
||
|
||
Refresh_ContentChanges : function()
|
||
{
|
||
this.m_oContentChanges.Refresh();
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Внутренние функции
|
||
//-----------------------------------------------------------------------------------
|
||
Internal_ReIndexing : function(StartIndex)
|
||
{
|
||
if ( "undefined" === typeof(StartIndex) )
|
||
StartIndex = 0;
|
||
|
||
for ( var Ind = StartIndex; Ind < this.Content.length; Ind++ )
|
||
{
|
||
this.Content[Ind].SetIndex( Ind );
|
||
this.Content[Ind].Prev = ( Ind > 0 ? this.Content[Ind - 1] : null );
|
||
this.Content[Ind].Next = ( Ind < this.Content.length - 1 ? this.Content[Ind + 1] : null );
|
||
this.Content[Ind].Row = this;
|
||
}
|
||
},
|
||
|
||
//-----------------------------------------------------------------------------------
|
||
// Undo/Redo функции
|
||
//-----------------------------------------------------------------------------------
|
||
Get_ParentObject_or_DocumentPos : function()
|
||
{
|
||
return this.Table.Get_ParentObject_or_DocumentPos(this.Table.Index);
|
||
},
|
||
|
||
Refresh_RecalcData : function(Data)
|
||
{
|
||
let oTable = this.GetTable();
|
||
if (!oTable)
|
||
return;
|
||
|
||
let isNeedRecalc = false;
|
||
switch (Data.Type)
|
||
{
|
||
case AscDFH.historyitem_TableRow_Before:
|
||
case AscDFH.historyitem_TableRow_After:
|
||
case AscDFH.historyitem_TableRow_CellSpacing:
|
||
case AscDFH.historyitem_TableRow_Height:
|
||
case AscDFH.historyitem_TableRow_AddCell:
|
||
case AscDFH.historyitem_TableRow_RemoveCell:
|
||
case AscDFH.historyitem_TableRow_TableHeader:
|
||
case AscDFH.historyitem_TableRow_Pr:
|
||
{
|
||
isNeedRecalc = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
for (let nCurCell = 0, nCellsCount = this.GetCellsCount(); nCurCell < nCellsCount; ++nCurCell)
|
||
{
|
||
oTable.RecalcInfo.Add_Cell(this.GetCell(nCurCell));
|
||
}
|
||
|
||
oTable.RecalcInfo.RecalcBorders();
|
||
|
||
if (isNeedRecalc)
|
||
this.Refresh_RecalcData2(0, 0);
|
||
},
|
||
|
||
Refresh_RecalcData2 : function(CellIndex, Page_rel)
|
||
{
|
||
this.Table.Refresh_RecalcData2( this.Index, Page_rel );
|
||
},
|
||
//-----------------------------------------------------------------------------------
|
||
// Функции для работы с совместным редактирования
|
||
//-----------------------------------------------------------------------------------
|
||
Write_ToBinary2 : function(Writer)
|
||
{
|
||
Writer.WriteLong(AscDFH.historyitem_type_TableRow);
|
||
|
||
// String : Id строки
|
||
// Variable : свойства строки
|
||
// Long : количество ячеек
|
||
// Array strings : Id ячеек
|
||
// Long : ReviewType
|
||
// AscWord.ReviewInfo : ReviewType
|
||
|
||
Writer.WriteString2(this.Id);
|
||
this.Pr.Write_ToBinary(Writer);
|
||
|
||
var Count = this.Content.length;
|
||
Writer.WriteLong(Count);
|
||
for (var Index = 0; Index < Count; Index++)
|
||
Writer.WriteString2(this.Content[Index].Get_Id());
|
||
|
||
if (!(this.ReviewInfo instanceof AscWord.ReviewInfo))
|
||
this.ReviewInfo = new AscWord.ReviewInfo();
|
||
|
||
Writer.WriteLong(this.ReviewType);
|
||
this.ReviewInfo.WriteToBinary(Writer);
|
||
},
|
||
|
||
Read_FromBinary2 : function(Reader)
|
||
{
|
||
// String : Id строки
|
||
// Variable : свойства строки
|
||
// Long : количество ячеек
|
||
// Array variables : сами ячейки
|
||
// Long : ReviewType
|
||
// AscWord.ReviewInfo : ReviewType
|
||
|
||
this.Id = Reader.GetString2();
|
||
this.Pr = new CTableRowPr();
|
||
this.Pr.Read_FromBinary(Reader);
|
||
this.Recalc_CompiledPr();
|
||
|
||
var Count = Reader.GetLong();
|
||
this.Content = [];
|
||
for (var Index = 0; Index < Count; Index++)
|
||
{
|
||
var Cell = AscCommon.g_oTableId.Get_ById(Reader.GetString2());
|
||
this.Content.push(Cell);
|
||
}
|
||
|
||
this.ReviewType = Reader.GetLong();
|
||
this.ReviewInfo = new AscWord.ReviewInfo();
|
||
this.ReviewInfo.ReadFromBinary(Reader);
|
||
|
||
this.Internal_ReIndexing();
|
||
}
|
||
};
|
||
CTableRow.prototype.constructor = CTableRow;
|
||
/**
|
||
* Доступ к родительской таблице
|
||
* @returns {null | CTable}
|
||
*/
|
||
CTableRow.prototype.GetTable = function()
|
||
{
|
||
return this.Table;
|
||
};
|
||
/**
|
||
* Доступ к главному классу документа
|
||
* @returns {CDocument|null}
|
||
*/
|
||
CTableRow.prototype.GetLogicDocument = function()
|
||
{
|
||
let table = this.GetTable();
|
||
if (table)
|
||
return table.GetLogicDocument();
|
||
|
||
return null;
|
||
};
|
||
/**
|
||
* Получаем номер данной строки в родительской таблице
|
||
* @returns {number}
|
||
*/
|
||
CTableRow.prototype.GetIndex = function()
|
||
{
|
||
return this.Index;
|
||
};
|
||
/**
|
||
* Выставляем номер данной строки в родительской таблице
|
||
* @param {number} nIndex
|
||
*/
|
||
CTableRow.prototype.SetIndex = function(nIndex)
|
||
{
|
||
if (nIndex != this.Index)
|
||
{
|
||
this.Index = nIndex;
|
||
this.Recalc_CompiledPr();
|
||
}
|
||
};
|
||
CTableRow.prototype.GetDocumentPositionFromObject = function(arrPos)
|
||
{
|
||
if (!arrPos)
|
||
arrPos = [];
|
||
|
||
var oTable = this.GetTable();
|
||
if (oTable)
|
||
{
|
||
if (arrPos.length > 0)
|
||
{
|
||
arrPos.splice(0, 0, {Class : oTable, Position : this.GetIndex()});
|
||
oTable.GetDocumentPositionFromObject(arrPos);
|
||
}
|
||
else
|
||
{
|
||
oTable.GetDocumentPositionFromObject(arrPos);
|
||
arrPos.push({Class : oTable, Position : this.GetIndex()});
|
||
}
|
||
}
|
||
|
||
return arrPos;
|
||
};
|
||
/**
|
||
* Получаем ячейку с заданным номером в строке
|
||
* @param nCellIndex
|
||
* @returns {CTableCell}
|
||
*/
|
||
CTableRow.prototype.GetCell = function(nCellIndex)
|
||
{
|
||
return this.Get_Cell(nCellIndex);
|
||
};
|
||
CTableRow.prototype.GetCellsCount = function()
|
||
{
|
||
return this.Get_CellsCount()
|
||
};
|
||
CTableRow.prototype.AddCell = function(nIndex, oRow, oCell, isReIndexing)
|
||
{
|
||
this.Add_Cell(nIndex, oRow, oCell, isReIndexing);
|
||
};
|
||
CTableRow.prototype.RemoveCell = function(nIndex)
|
||
{
|
||
this.Remove_Cell(nIndex);
|
||
};
|
||
CTableRow.prototype.GetCellInfo = function(nIndex)
|
||
{
|
||
return this.Get_CellInfo(nIndex);
|
||
};
|
||
CTableRow.prototype.GetCellSpacing = function()
|
||
{
|
||
return this.Get_CellSpacing();
|
||
};
|
||
/**
|
||
* Получаем высоту строки
|
||
* @returns {CTableRowHeight}
|
||
*/
|
||
CTableRow.prototype.GetHeight = function()
|
||
{
|
||
return this.Get_Height();
|
||
};
|
||
/**
|
||
* Устанавливаем высоту строки
|
||
* @param nValue
|
||
* @param nHRule
|
||
*/
|
||
CTableRow.prototype.SetHeight = function(nValue, nHRule)
|
||
{
|
||
return this.Set_Height(nValue, nHRule);
|
||
};
|
||
/**
|
||
* Получаем информацию о отступе сетки в начале строки
|
||
* @returns {{W, Grid}}
|
||
*/
|
||
CTableRow.prototype.GetBefore = function()
|
||
{
|
||
var oRowPr = this.Get_CompiledPr(false);
|
||
|
||
return {
|
||
W : oRowPr.WBefore.Copy(),
|
||
Grid : oRowPr.GridBefore
|
||
};
|
||
};
|
||
/**
|
||
* Задаем информацию об отступе сетки в начале строки
|
||
* @param {number} Grid - сколько колонок занимает отступ
|
||
* @param {CTableMeasurement | 'false'} W - желаемая ширина (если задано значение false, тогда не меняем ширину)
|
||
*/
|
||
CTableRow.prototype.SetBefore = function(Grid, W)
|
||
{
|
||
this.Set_Before(Grid, W);
|
||
};
|
||
/**
|
||
* Получаем информацию об отступе сетки в конце строки
|
||
* @returns {{W, Grid}}
|
||
*/
|
||
CTableRow.prototype.GetAfter = function()
|
||
{
|
||
var oRowPr = this.Get_CompiledPr(false);
|
||
|
||
return {
|
||
W : oRowPr.WAfter.Copy(),
|
||
Grid : oRowPr.GridAfter
|
||
};
|
||
};
|
||
/**
|
||
* Задаем информацию об отступе сетки в конце строки
|
||
* @param {number} Grid - сколько колонок занимает отступ
|
||
* @param {CTableMeasurement | 'false'} W - желаемая ширина (если задано значение false, тогда не меняем ширину)
|
||
*/
|
||
CTableRow.prototype.SetAfter = function(Grid, W)
|
||
{
|
||
this.Set_After(Grid, W);
|
||
};
|
||
/**
|
||
* Получаем общий отступ сверху у строки (максимальный отступ сверху среди всех ячеек)
|
||
* @returns {number}
|
||
*/
|
||
CTableRow.prototype.GetTopMargin = function()
|
||
{
|
||
var nTopMargin = 0;
|
||
|
||
for (var nCurCell = 0, nCellsCount = this.GetCellsCount(); nCurCell < nCellsCount; ++nCurCell)
|
||
{
|
||
var oCell = this.GetCell(nCurCell);
|
||
|
||
if (vmerge_Restart != oCell.GetVMerge())
|
||
continue;
|
||
|
||
var oMargins = oCell.GetMargins();
|
||
|
||
if (oMargins.Top.W > nTopMargin)
|
||
nTopMargin = oMargins.Top.W;
|
||
}
|
||
|
||
return nTopMargin;
|
||
};
|
||
/**
|
||
* Получаем общий отступ снизу у строки (максимальный отступ снизу среди всех ячеек)
|
||
* @returns {number}
|
||
*/
|
||
CTableRow.prototype.GetBottomMargin = function()
|
||
{
|
||
// Ячейки, участвующие в вертикальном объединении, не влияют на отступ снизу
|
||
|
||
var nBottomMargin = 0;
|
||
|
||
for (var nCurCell = 0, nCellsCount = this.GetCellsCount(); nCurCell < nCellsCount; ++nCurCell)
|
||
{
|
||
var oCell = this.GetCell(nCurCell);
|
||
|
||
if (vmerge_Restart != oCell.GetVMerge())
|
||
continue;
|
||
|
||
var nVMergeCount = this.Table.GetVMergeCount(nCurCell, this.Index);
|
||
if (nVMergeCount > 1)
|
||
continue;
|
||
|
||
var oMargins = oCell.GetMargins();
|
||
|
||
if (oMargins.Bottom.W > nBottomMargin)
|
||
nBottomMargin = oMargins.Bottom.W;
|
||
}
|
||
|
||
return nBottomMargin;
|
||
};
|
||
/**
|
||
* Проверяем является ли данная строка строкой заголовка таблицы
|
||
* @returns {boolean}
|
||
*/
|
||
CTableRow.prototype.IsHeader = function()
|
||
{
|
||
return this.Get_CompiledPr(false).TableHeader;
|
||
};
|
||
/**
|
||
* Устанавливаем является ли данная строка строкой заголовка таблицы
|
||
* @param isHeader {boolean}
|
||
*/
|
||
CTableRow.prototype.SetHeader = function(isHeader)
|
||
{
|
||
if (isHeader === this.Pr.TableHeader)
|
||
return;
|
||
|
||
this.private_AddPrChange();
|
||
AscCommon.History.Add(new CChangesTableRowTableHeader(this, this.Pr.TableHeader, isHeader));
|
||
this.Pr.TableHeader = isHeader;
|
||
this.Recalc_CompiledPr();
|
||
this.RecalcCopiledPrCells();
|
||
};
|
||
/**
|
||
* Пересчитываем рассчитанные настройки для ячеек
|
||
*/
|
||
CTableRow.prototype.RecalcCopiledPrCells = function()
|
||
{
|
||
for (var nCurCell = 0, nCellsCount = this.GetCellsCount(); nCurCell < nCellsCount; ++nCurCell)
|
||
{
|
||
this.GetCell(nCurCell).Recalc_CompiledPr();
|
||
}
|
||
};
|
||
/**
|
||
* Возвращаем тип рецензирования
|
||
* @returns {reviewtype_Common | reviewtype_Add | reviewtype_Remove}
|
||
*/
|
||
CTableRow.prototype.GetReviewType = function()
|
||
{
|
||
return this.ReviewType;
|
||
};
|
||
/**
|
||
* Возвращаем информацию о рецензенте
|
||
* @returns {AscWord.ReviewInfo}
|
||
*/
|
||
CTableRow.prototype.GetReviewInfo = function()
|
||
{
|
||
return this.ReviewInfo;
|
||
};
|
||
/**
|
||
* Меняем тип рецензирования для данного рана
|
||
* @param {number} nType
|
||
* @param {boolean} [isCheckDeleteAdded=false] - нужно ли проверять, что происходит удаление добавленного ранее
|
||
* @constructor
|
||
*/
|
||
CTableRow.prototype.SetReviewType = function(nType, isCheckDeleteAdded)
|
||
{
|
||
if (nType !== this.ReviewType)
|
||
{
|
||
var OldReviewType = this.ReviewType;
|
||
var OldReviewInfo = this.ReviewInfo.Copy();
|
||
|
||
if (reviewtype_Add === this.ReviewType && reviewtype_Remove === nType && true === isCheckDeleteAdded)
|
||
{
|
||
this.ReviewInfo.SavePrev(this.ReviewType);
|
||
}
|
||
|
||
this.ReviewType = nType;
|
||
this.ReviewInfo.Update();
|
||
|
||
AscCommon.History.Add(new CChangesTableRowReviewType(this, {
|
||
ReviewType : OldReviewType,
|
||
ReviewInfo : OldReviewInfo
|
||
}, {
|
||
ReviewType : this.ReviewType,
|
||
ReviewInfo : this.ReviewInfo.Copy()
|
||
}));
|
||
|
||
this.updateTrackRevisions();
|
||
}
|
||
};
|
||
/**
|
||
* Меняем тип рецензирования вместе с информацией о рецензента
|
||
* @param {number} nType
|
||
* @param {AscWord.ReviewInfo} oInfo
|
||
*/
|
||
CTableRow.prototype.SetReviewTypeWithInfo = function(nType, oInfo)
|
||
{
|
||
AscCommon.History.Add(new CChangesTableRowReviewType(this, {
|
||
ReviewType : this.ReviewType,
|
||
ReviewInfo : this.ReviewInfo ? this.ReviewInfo.Copy() : undefined
|
||
}, {
|
||
ReviewType : nType,
|
||
ReviewInfo : oInfo ? oInfo.Copy() : undefined
|
||
}));
|
||
|
||
this.ReviewType = nType;
|
||
this.ReviewInfo = oInfo;
|
||
|
||
this.updateTrackRevisions();
|
||
};
|
||
CTableRow.prototype.updateTrackRevisions = function()
|
||
{
|
||
var oTable = this.GetTable();
|
||
if (oTable)
|
||
oTable.updateTrackRevisions();
|
||
};
|
||
CTableRow.prototype.HavePrChange = function()
|
||
{
|
||
return this.Pr.HavePrChange();
|
||
};
|
||
CTableRow.prototype.AddPrChange = function()
|
||
{
|
||
if (false === this.HavePrChange())
|
||
{
|
||
this.Pr.AddPrChange();
|
||
AscCommon.History.Add(new CChangesTableRowPrChange(this, {
|
||
PrChange : undefined,
|
||
ReviewInfo : undefined
|
||
}, {
|
||
PrChange : this.Pr.PrChange,
|
||
ReviewInfo : this.Pr.ReviewInfo
|
||
}));
|
||
this.updateTrackRevisions();
|
||
}
|
||
};
|
||
CTableRow.prototype.RemovePrChange = function()
|
||
{
|
||
if (true === this.HavePrChange())
|
||
{
|
||
AscCommon.History.Add(new CChangesTableRowPrChange(this, {
|
||
PrChange : this.Pr.PrChange,
|
||
ReviewInfo : this.Pr.ReviewInfo
|
||
}, {
|
||
PrChange : undefined,
|
||
ReviewInfo : undefined
|
||
}));
|
||
this.Pr.RemovePrChange();
|
||
this.updateTrackRevisions();
|
||
}
|
||
};
|
||
CTableRow.prototype.private_AddPrChange = function()
|
||
{
|
||
var oTable = this.GetTable();
|
||
if (oTable
|
||
&& oTable.LogicDocument
|
||
&& true === oTable.LogicDocument.IsTrackRevisions()
|
||
&& true !== this.HavePrChange()
|
||
&& reviewtype_Common === this.GetReviewType())
|
||
{
|
||
this.AddPrChange();
|
||
oTable.AddPrChange();
|
||
}
|
||
};
|
||
CTableRow.prototype.AcceptPrChange = function()
|
||
{
|
||
this.RemovePrChange();
|
||
};
|
||
CTableRow.prototype.RejectPrChange = function()
|
||
{
|
||
if (this.HavePrChange())
|
||
{
|
||
this.Set_Pr(this.Pr.PrChange);
|
||
this.RemovePrChange();
|
||
}
|
||
};
|
||
CTableRow.prototype.HaveCellPrChange = function()
|
||
{
|
||
for (let iCell = 0, nCells = this.GetCellsCount(); iCell < nCells; ++iCell)
|
||
{
|
||
if (this.GetCell(iCell).HavePrChange())
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
CTableRow.prototype.GetFirstCellReviewInfo = function()
|
||
{
|
||
for (let iCell = 0, nCells = this.GetCellsCount(); iCell < nCells; ++iCell)
|
||
{
|
||
let reviewInfo = this.GetCell(iCell).Pr.ReviewInfo;
|
||
if (reviewInfo)
|
||
return reviewInfo;
|
||
}
|
||
return null;
|
||
};
|
||
CTableRow.prototype.private_CheckCurCell = function()
|
||
{
|
||
if (this.GetTable())
|
||
this.GetTable().private_CheckCurCell();
|
||
};
|
||
/**
|
||
* Запрашиваем пересчет сетки таблицы
|
||
*/
|
||
CTableRow.prototype.private_UpdateTableGrid = function()
|
||
{
|
||
var oTable = this.GetTable();
|
||
if (oTable)
|
||
oTable.private_UpdateTableGrid();
|
||
};
|
||
CTableRow.prototype.GetAllDrawingObjects = function(drawingObjects)
|
||
{
|
||
if (!drawingObjects)
|
||
drawingObjects = [];
|
||
|
||
for (let curCell = 0, cellCount = this.GetCellsCount(); curCell < cellCount; ++curCell)
|
||
{
|
||
this.GetCell(curCell).GetContent().GetAllDrawingObjects(drawingObjects);
|
||
}
|
||
|
||
return drawingObjects;
|
||
};
|
||
CTableRow.prototype.OnContentChange = function()
|
||
{
|
||
let table = this.GetTable();
|
||
if (table)
|
||
table.OnContentChange();
|
||
};
|
||
CTableRow.prototype.FindParagraph = function (fCondition, bBackward, nStartIdx)
|
||
{
|
||
var nSearchStartIdx, nIdx, oResult, oContent;
|
||
if(bBackward)
|
||
{
|
||
if(nStartIdx !== null)
|
||
{
|
||
nSearchStartIdx = Math.min(nStartIdx, this.Content.length - 1);
|
||
}
|
||
else
|
||
{
|
||
nSearchStartIdx = this.Content.length - 1;
|
||
}
|
||
for(nIdx = nSearchStartIdx; nIdx >= 0; --nIdx)
|
||
{
|
||
oContent = this.Content[nIdx].GetContent();
|
||
oResult = oContent.FindParagraph(fCondition, bBackward, null);
|
||
if(oResult)
|
||
{
|
||
return oResult
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(nStartIdx !== null)
|
||
{
|
||
nSearchStartIdx = Math.max(nStartIdx, 0);
|
||
}
|
||
else
|
||
{
|
||
nSearchStartIdx = 0;
|
||
}
|
||
for(nIdx = nSearchStartIdx; nIdx < this.Content.length; ++nIdx)
|
||
{
|
||
oContent = this.Content[nIdx].GetContent();
|
||
oResult = oContent.FindParagraph(fCondition, bBackward, null);
|
||
if(oResult)
|
||
{
|
||
return oResult
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
};
|
||
|
||
CTableRow.prototype.FindParaWithStyle = function (sStyleId, bBackward, nStartIdx)
|
||
{
|
||
let fCondition = function (oParagraph)
|
||
{
|
||
return oParagraph.GetParagraphStyle() === sStyleId;
|
||
};
|
||
return this.FindParagraph(fCondition, bBackward, nStartIdx);
|
||
};
|
||
|
||
CTableRow.prototype.FindParaWithOutlineLvl = function (nOutlineLvl, bBackward, nStartIdx)
|
||
{
|
||
let fCondition = function (oParagraph) {
|
||
return oParagraph.GetOutlineLvl() === nOutlineLvl;
|
||
};
|
||
return this.FindParagraph(fCondition, bBackward, nStartIdx);
|
||
};
|
||
|
||
function CTableRowRecalculateObject()
|
||
{
|
||
this.CellsInfo = [];
|
||
this.Metrics = {};
|
||
this.SpacingInfo = {};
|
||
|
||
this.Height = 0;
|
||
this.PagesCount = 0;
|
||
|
||
this.Content = [];
|
||
}
|
||
|
||
CTableRowRecalculateObject.prototype =
|
||
{
|
||
Save : function(Row)
|
||
{
|
||
this.CellsInfo = Row.CellsInfo;
|
||
this.Metrics = Row.Metrics;
|
||
this.SpacingInfo = Row.SpacingInfo;
|
||
|
||
this.Height = Row.Height;
|
||
this.PagesCount = Row.PagesCount;
|
||
|
||
var Count = Row.Content.length;
|
||
for ( var Index = 0; Index < Count; Index++ )
|
||
{
|
||
this.Content[Index] = Row.Content[Index].SaveRecalculateObject();
|
||
}
|
||
},
|
||
|
||
Load : function(Row)
|
||
{
|
||
Row.CellsInfo = this.CellsInfo;
|
||
Row.Metrics = this.Metrics;
|
||
Row.SpacingInfo = this.SpacingInfo;
|
||
|
||
Row.Height = this.Height;
|
||
Row.PagesCount = this.PagesCount;
|
||
|
||
var Count = Row.Content.length;
|
||
for ( var Index = 0; Index < Count; Index++ )
|
||
{
|
||
Row.Content[Index].LoadRecalculateObject( this.Content[Index] );
|
||
}
|
||
},
|
||
|
||
Get_DrawingFlowPos : function(FlowPos)
|
||
{
|
||
var Count = this.Content.length;
|
||
for ( var Index = 0; Index < Count; Index++ )
|
||
{
|
||
this.Content[Index].Get_DrawingFlowPos( FlowPos );
|
||
}
|
||
}
|
||
};
|
||
|
||
//--------------------------------------------------------export----------------------------------------------------
|
||
window['AscCommonWord'] = window['AscCommonWord'] || {};
|
||
window['AscCommonWord'].CTableRow = CTableRow;
|
||
window['AscWord'].TableRow = CTableRow;
|