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

2830 lines
84 KiB
JavaScript
Raw Blame History

/*
* (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";
// Import
var global_MatrixTransformer = AscCommon.global_MatrixTransformer;
//----------------------------------------------------------------------------------------------------------------------
// Класс CTableCell
//----------------------------------------------------------------------------------------------------------------------
function CTableCell(Row, ColW)
{
this.Id = AscCommon.g_oIdCounter.Get_NewId();
this.Row = Row;
this.Prev = null;
this.Next = null;
this.Content = new CDocumentContent(this, (undefined !== this.Row ? this.Row.Table.DrawingDocument : undefined), 0, 0, 0, 0, false, false, undefined !== this.Row ? this.Row.Table.bPresentation : undefined);
this.Content.Set_StartPage( ( Row ? this.Row.Table.PageNum : 0 ) );
this.CompiledPr =
{
Pr : null, // настройки ячейки
TextPr : null, // настройки текста
ParaPr : null, // настройки параграфа
NeedRecalc : true
};
this.Pr = new CTableCellPr();
if ( undefined != ColW )
this.Pr.TableCellW = new CTableMeasurement(tblwidth_Mm, ColW);
// Массивы с рассчитанными стилями для границ данной ячейки.
// В каждом элементе лежит массив стилей.
this.BorderInfo = {
Top : null,
Left : null,
Right : null,
Bottom : null, // Используется для последней строки таблицы,
TopHeader : null, // Используется для первой строки таблицы с заголовком на странице
Bottom_BeforeCount : -1, // когда Spacing = null(у последней строки) или когда в следущей строке
Bottom_AfterCount : -1, // GridBefore и/или GridAfter отлично от 0.
MaxLeft : 0,
MaxRight : 0
};
// Метрики данной ячейки(они все относительные, а не абсолютные). Абсолютные хранятся в строке
this.Metrics =
{
StartGridCol : 0,
X_grid_start : 0,
X_grid_end : 0,
X_cell_start : 0,
X_cell_end : 0,
X_content_start : 0,
X_content_end : 0
};
this.Temp =
{
Y : 0,
CurPage : 0,
X_start : 0,
Y_start : 0,
X_end : 0,
Y_end : 0,
X_cell_start : 0,
X_cell_end : 0,
Y_cell_start : 0,
Y_cell_end : 0,
UseClip : false,
ClipTop : 0,
ClipBottom : 0,
Y_VAlign_offset : [] // Сдвиг, который нужно сделать из-за VAlign (массив по страницам)
};
this.CachedMinMax = {
RecalcId : -1,
MinMax : null
};
this.Index = 0;
// Добавляем данный класс в таблицу Id (обязательно в конце конструктора)
AscCommon.g_oTableId.Add( this, this.Id );
}
CTableCell.prototype =
{
Get_Id : function()
{
return this.Id;
},
GetId : function()
{
return this.Id;
},
Get_Theme : function()
{
return this.Row.Table.Get_Theme();
},
Get_ColorMap: function()
{
return this.Row.Table.Get_ColorMap();
},
Copy : function(Row, oPr)
{
var Cell = new CTableCell(Row);
// Копируем настройки ячейки
Cell.Copy_Pr( this.Pr.Copy(), false );
// Копируем содержимое ячейки
Cell.Content.Copy2(this.Content, oPr);
// Скопируем BorderInfo и метрики, чтобы при копировании строки целиком не надо было их пересчитывать
Cell.BorderInfo.Top = this.BorderInfo.Top;
Cell.BorderInfo.Left = this.BorderInfo.Left;
Cell.BorderInfo.Right = this.BorderInfo.Right;
Cell.BorderInfo.Bottom = this.BorderInfo.Bottom;
Cell.BorderInfo.Bottom_BeforeCount = this.BorderInfo.Bottom_BeforeCount;
Cell.BorderInfo.Bottom_AfterCount = this.BorderInfo.Bottom_AfterCount;
Cell.BorderInfo.MaxLeft = this.BorderInfo.MaxLeft;
Cell.BorderInfo.MaxRight = this.BorderInfo.MaxRight;
Cell.Metrics.StartGridCol = this.Metrics.StartGridCol;
Cell.Metrics.X_grid_start = this.Metrics.X_grid_start;
Cell.Metrics.X_grid_end = this.Metrics.X_grid_end;
Cell.Metrics.X_cell_start = this.Metrics.X_cell_start;
Cell.Metrics.X_cell_end = this.Metrics.X_cell_end;
Cell.Metrics.X_content_start = this.Metrics.X_content_start;
Cell.Metrics.X_content_end = this.Metrics.X_content_end;
return Cell;
},
Set_Metrics : function(StartGridCol, X_grid_start, X_grid_end, X_cell_start, X_cell_end, X_content_start, X_content_end )
{
this.Metrics.StartGridCol = StartGridCol;
this.Metrics.X_grid_start = X_grid_start;
this.Metrics.X_grid_end = X_grid_end;
this.Metrics.X_cell_start = X_cell_start;
this.Metrics.X_cell_end = X_cell_end;
this.Metrics.X_content_start = X_content_start;
this.Metrics.X_content_end = X_content_end;
},
GetEndInfo : function()
{
return this.Content.GetEndInfo();
},
GetPrevElementEndInfo : function(CurElement)
{
return this.Row.GetPrevElementEndInfo( this.Index );
},
SaveRecalculateObject : function()
{
var RecalcObj = new CTableCellRecalculateObject();
RecalcObj.Save( this );
return RecalcObj;
},
LoadRecalculateObject : function(RecalcObj)
{
RecalcObj.Load(this);
},
PrepareRecalculateObject : function()
{
this.BorderInfo =
{
Top : null,
Left : null,
Right : null,
Bottom : null, // Используется для последней строки таблицы,
Bottom_BeforeCount : -1, // когда Spacing = null(у последней строки) или когда в следущей строке
Bottom_AfterCount : -1, // GridBefore и/или GridAfter отлично от 0.
MaxLeft : 0,
MaxRight : 0
};
// Метрики данной ячейки(они все относительные, а не абсолютные). Абсолютные хранятся в строке
this.Metrics =
{
StartGridCol : 0,
X_grid_start : 0,
X_grid_end : 0,
X_cell_start : 0,
X_cell_end : 0,
X_content_start : 0,
X_content_end : 0
};
this.Temp =
{
Y : 0,
CurPage : 0,
Y_VAlign_offset : [] // Сдвиг, который нужно сделать из-за VAlign (массив по страницам)
};
this.Content.PrepareRecalculateObject();
},
//-----------------------------------------------------------------------------------
// Работаем с стилем ячейки
//-----------------------------------------------------------------------------------
Recalc_CompiledPr : function()
{
this.CompiledPr.NeedRecalc = true;
this.Content.Recalc_AllParagraphs_CompiledPr();
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_oDocumentDefaultTableCellPr;
this.CompiledPr.ParaPr = g_oDocumentDefaultParaPr;
this.CompiledPr.TextPr = g_oDocumentDefaultTextPr;
this.CompiledPr.NeedRecalc = true;
}
else
{
// TODO: Возможно стоит разделить рассчет стиля для ячейки и для текста
var FullPr = this.Internal_Compile_Pr();
this.CompiledPr.Pr = FullPr.CellPr;
this.CompiledPr.ParaPr = FullPr.ParaPr;
this.CompiledPr.TextPr = FullPr.TextPr;
this.CompiledPr.NeedRecalc = forceCompile;
}
}
if ( false === bCopy )
return this.CompiledPr.Pr;
else
return this.CompiledPr.Pr.Copy(); // Отдаем копию объекта, чтобы никто не поменял извне настройки стиля
},
Internal_Compile_Pr : function()
{
var Table = this.Row.Table;
var TablePr = Table.Get_CompiledPr(false);
var TableLook = Table.Get_TableLook();
var CellIndex = this.Index;
var RowIndex = this.Row.Index;
// Сначала возьмем настройки по умолчанию для всей таблицы
var CellPr = TablePr.TableCellPr.Copy();
var ParaPr = TablePr.ParaPr.Copy();
var TextPr;
if(!Table.bPresentation)
{
TextPr = TablePr.TextPr.Copy();
}
else
{
TextPr = TablePr.TableWholeTable.TextPr.Copy();
}
// Совместим настройки с настройками для групп строк. Сначала группы строк, потом группы колонок.
if ( true === TableLook.IsBandHor() )
{
var RowBandSize = TablePr.TablePr.TableStyleRowBandSize;
var __RowIndex = ( true != TableLook.IsFirstRow() ? RowIndex : RowIndex - 1 );
var _RowIndex = ( 1 != RowBandSize ? Math.floor( __RowIndex / RowBandSize ) : __RowIndex );
var TableBandStyle = null;
if ( 0 === _RowIndex % 2 )
TableBandStyle = TablePr.TableBand1Horz;
else
TableBandStyle = TablePr.TableBand2Horz;
CellPr.Merge( TableBandStyle.TableCellPr );
TextPr.Merge( TableBandStyle.TextPr );
ParaPr.Merge( TableBandStyle.ParaPr );
}
// Совместим с настройками для групп колонок
// Согласно спецификации DOCX, совмещать надо всегда. Word проверяет наличие первой колонки не только
// через флаг TableLook.IsFirstCol(), но и самим наличием непустого стиля для первой колонки.
if (true === TableLook.IsBandVer())
{
var bFirstCol = false;
if (true === TableLook.IsFirstCol())
{
var oStyles = this.Get_Styles();
var oTableStyle = oStyles && oStyles.Get(this.Row.Table.Get_TableStyle());
if (oTableStyle && styletype_Table === oTableStyle.Get_Type() && oTableStyle.TableFirstCol)
{
var oCondStyle = oTableStyle.TableFirstCol;
if (true !== oCondStyle.TableCellPr.Is_Empty()
|| true !== oCondStyle.ParaPr.Is_Empty()
|| true !== oCondStyle.TextPr.Is_Empty())
{
bFirstCol = true;
}
}
}
var ColBandSize = TablePr.TablePr.TableStyleColBandSize;
var _ColIndex = ( true != bFirstCol ? CellIndex : CellIndex - 1 );
var ColIndex = ( 1 != ColBandSize ? Math.floor(_ColIndex / ColBandSize) : _ColIndex );
var TableBandStyle = null;
if (0 === ColIndex % 2)
TableBandStyle = TablePr.TableBand1Vert;
else
TableBandStyle = TablePr.TableBand2Vert;
CellPr.Merge(TableBandStyle.TableCellPr);
TextPr.Merge(TableBandStyle.TextPr);
ParaPr.Merge(TableBandStyle.ParaPr);
}
// Совместим настройки с настройками для последней колонки
if ( true === TableLook.IsLastCol() && this.Row.Get_CellsCount() - 1 === CellIndex )
{
CellPr.Merge( TablePr.TableLastCol.TableCellPr );
TextPr.Merge( TablePr.TableLastCol.TextPr );
ParaPr.Merge( TablePr.TableLastCol.ParaPr );
}
// Совместим настройки с настройками для первой колонки
if ( true === TableLook.IsFirstCol() && 0 === CellIndex )
{
CellPr.Merge( TablePr.TableFirstCol.TableCellPr );
TextPr.Merge( TablePr.TableFirstCol.TextPr );
ParaPr.Merge( TablePr.TableFirstCol.ParaPr );
}
// Совместим настройки с настройками для последней строки
if ( true === TableLook.IsLastRow() && Table.Content.length - 1 === RowIndex )
{
CellPr.Merge( TablePr.TableLastRow.TableCellPr );
TextPr.Merge( TablePr.TableLastRow.TextPr );
ParaPr.Merge( TablePr.TableLastRow.ParaPr );
}
// Совместим настройки с настройками для первой строки
if ( true === TableLook.IsFirstRow() && ( 0 === RowIndex || true === this.Row.Pr.TableHeader ) )
{
CellPr.Merge( TablePr.TableFirstRow.TableCellPr );
TextPr.Merge( TablePr.TableFirstRow.TextPr );
ParaPr.Merge( TablePr.TableFirstRow.ParaPr );
}
// Совместим настройки с настройками для правой нижней ячейки
if ( this.Row.Get_CellsCount() - 1 === CellIndex && Table.Content.length - 1 === RowIndex && (!Table.bPresentation || true === TableLook.IsLastRow() && true === TableLook.IsLastCol()))
{
CellPr.Merge( TablePr.TableBRCell.TableCellPr );
TextPr.Merge( TablePr.TableBRCell.TextPr );
ParaPr.Merge( TablePr.TableBRCell.ParaPr );
}
// Совместим настройки с настройками для левой нижней ячейки
if ( 0 === CellIndex && Table.Content.length - 1 === RowIndex && (!Table.bPresentation || true === TableLook.IsLastRow() && true === TableLook.IsFirstCol()))
{
CellPr.Merge( TablePr.TableBLCell.TableCellPr );
TextPr.Merge( TablePr.TableBLCell.TextPr );
ParaPr.Merge( TablePr.TableBLCell.ParaPr );
}
// Совместим настройки с настройками для правой верхней ячейки
if ( this.Row.Get_CellsCount() - 1 === CellIndex && 0 === RowIndex && (!Table.bPresentation || true === TableLook.IsFirstRow() && true === TableLook.IsLastCol()) )
{
CellPr.Merge( TablePr.TableTRCell.TableCellPr );
TextPr.Merge( TablePr.TableTRCell.TextPr );
ParaPr.Merge( TablePr.TableTRCell.ParaPr );
}
// Совместим настройки с настройками для левой верхней ячейки
if ( 0 === CellIndex && 0 === RowIndex && (!Table.bPresentation || true === TableLook.IsFirstRow() && true === TableLook.IsFirstCol()))
{
CellPr.Merge( TablePr.TableTLCell.TableCellPr );
TextPr.Merge( TablePr.TableTLCell.TextPr );
ParaPr.Merge( TablePr.TableTLCell.ParaPr );
}
if ( null === CellPr.TableCellMar && undefined != this.Pr.TableCellMar && null != this.Pr.TableCellMar )
CellPr.TableCellMar = {};
// Полученные настройки совместим с прямыми настройками ячейки
CellPr.Merge( this.Pr );
if(Table.bPresentation)
{
CellPr.Check_PresentationPr(Table.Get_Theme())
}
return { CellPr : CellPr, ParaPr : ParaPr, TextPr : TextPr };
},
//-----------------------------------------------------------------------------------
// Функции, к которым идет обращение из контента
//-----------------------------------------------------------------------------------
OnContentReDraw : function(StartPage, EndPage)
{
this.Row.Table.Parent.OnContentReDraw( StartPage, EndPage );
},
Get_Styles : function(Lvl)
{
return this.Row.Table.Get_Styles(Lvl);
},
Get_TableStyleForPara : function()
{
this.Get_CompiledPr(false);
var TextPr = this.CompiledPr.TextPr.Copy();
var ParaPr = this.CompiledPr.ParaPr.Copy();
return { TextPr : TextPr, ParaPr : ParaPr };
},
Get_ShapeStyleForPara: function()
{
var oTable = this.GetTable();
return oTable ? oTable.Get_ShapeStyleForPara() : null;
},
Get_TextBackGroundColor : function()
{
// Сначала проверим заливку данной ячейки, если ее нет, тогда спрашиваем у таблицы
var Shd = this.Get_Shd();
if (Shd && !Shd.IsNil())
return Shd.GetSimpleColor(this.Get_Theme(), this.Get_ColorMap());
var oTable = this.GetTable();
return oTable ? oTable.Get_TextBackGroundColor() : null;
},
Get_Numbering : function()
{
var oTable = this.GetTable();
return oTable ? oTable.Get_Numbering() : null;
},
IsCell : function(isReturnCell)
{
if (true === isReturnCell)
return this;
return true;
},
IsTableFirstRowOnNewPage : function()
{
var oTable = this.GetTable();
if (!oTable)
return false;
return oTable.IsTableFirstRowOnNewPage(this.GetRow().GetIndex());
},
Check_AutoFit : function()
{
return false;
},
Is_DrawingShape : function(bRetShape)
{
var oTableParent = this.GetTableParent();
if (!oTableParent)
return (bRetShape ? null : false);
return oTableParent.Is_DrawingShape(bRetShape);
},
IsHdrFtr : function(bReturnHdrFtr)
{
var oTableParent = this.GetTableParent();
if (!oTableParent)
return (bReturnHdrFtr ? null : false);
return oTableParent.IsHdrFtr(bReturnHdrFtr);
},
IsFootnote : function(bReturnFootnote)
{
var oTableParent = this.GetTableParent();
if (!oTableParent)
return (bReturnFootnote ? null : false);
return oTableParent.IsFootnote(bReturnFootnote);
},
Is_TopDocument : function(bReturnTopDocument)
{
if (true === bReturnTopDocument)
{
var oTableParent = this.GetTableParent();
if (!oTableParent)
return (bReturnTopDocument ? null : false);
return oTableParent.Is_TopDocument(bReturnTopDocument);
}
return false;
},
IsInTable : function(bReturnTopTable)
{
if (true === bReturnTopTable)
{
var oTable = this.GetTable();
if (!oTable)
return null;
var oTopTable = oTable.Parent ? oTable.Parent.IsInTable(true) : null;
if (oTopTable)
return oTopTable;
else
return oTable;
}
return true;
},
IsUseInDocument : function(Id)
{
if (!this.Row)
return false;
return this.Row.IsUseInDocument(this.GetId());
},
GetPageContentFrame : function(page)
{
return this.Row.Table.GetCellPageContentFrame(page + this.Content.StartPage, this.Row.Index, this.Index);
},
Set_CurrentElement : function(bUpdateStates)
{
var Table = this.Row.Table;
// Делаем данную ячейку текущей в таблице
Table.Selection.Start = false;
Table.Selection.Type = table_Selection_Text;
Table.Selection.Use = this.Content.IsSelectionUse();
Table.Selection.StartPos.Pos = { Row : this.Row.Index, Cell : this.Index };
Table.Selection.EndPos.Pos = { Row : this.Row.Index, Cell : this.Index };
Table.Markup.Internal.RowIndex = 0;
Table.Markup.Internal.CellIndex = 0;
Table.Markup.Internal.PageNum = 0;
Table.CurCell = this;
// Делаем таблицу текущим элементом в документе
Table.Document_SetThisElementCurrent(bUpdateStates);
},
IsThisElementCurrent : function()
{
var Table = this.Row.Table;
if ( false === Table.Selection.Use && this === Table.CurCell )
{
var Parent = Table.Parent;
if ((Parent instanceof AscFormat.CGraphicFrame) || docpostype_Content === Parent.GetDocPosType() && false === Parent.Selection.Use && this.Index === Parent.CurPos.ContentPos )
return Table.Parent.IsThisElementCurrent();
}
return false;
},
CheckTableCoincidence : function(Table)
{
var CurTable = this.Row.Table;
if (Table === CurTable)
return true;
else
return CurTable.Parent.CheckTableCoincidence(Table);
},
//-----------------------------------------------------------------------------------
// Функции для работы с номерами страниц
//-----------------------------------------------------------------------------------
GetAbsoluteStartPage : function()
{
return this.Row.Table.GetAbsoluteStartPage();
},
GetRelativeStartPage : function()
{
return this.Row.Table.GetRelativeStartPage();
},
/**
* Получаем абсолютный номер страницы по относительному номеру страницы (относительно таблицы, а не ячейки!)
* @param CurPage
* @returns {number}
*/
GetAbsolutePage : function(CurPage)
{
return this.Row.Table.GetAbsolutePage(CurPage);
},
/**
* Получаем абсолютный номер колонки по относительному номеру страницы (относительно таблицы, а не ячейки!)
* @param CurPage
* @returns {number}
*/
GetAbsoluteColumn : function(CurPage)
{
return this.Row.Table.GetAbsoluteColumn(CurPage);
},
GetAbsoluteSection : function(curPage)
{
return this.Row.Table.GetAbsoluteSection(curPage);
},
//-----------------------------------------------------------------------------------
// Работаем с содержимым ячейки
//-----------------------------------------------------------------------------------
Get_ParentTextTransform: function()
{
var oParentTransform = this.Row.Table.Get_ParentTextTransform();
var oOwnTransform = this.private_GetTextDirectionTransform();
if(oOwnTransform && oParentTransform)
{
global_MatrixTransformer.MultiplyAppend(oOwnTransform, oParentTransform);
return oOwnTransform;
}
return oParentTransform || oOwnTransform;
},
Content_Reset : function(X, Y, XLimit, YLimit)
{
this.Content.Reset( X, Y, XLimit, YLimit );
this.Content.SetCurPosXY( X, Y );
},
Content_Get_PageBounds : function(PageIndex)
{
return this.Content.Get_PageBounds(PageIndex);
},
Content_Get_PagesCount : function()
{
return this.Content.Get_PagesCount();
},
Content_Draw_Line : function (pGraphics)
{
const oParagraph = this.Content.Get_FirstParagraph();
if (oParagraph)
{
const nLineWidth = oParagraph.XLimit - oParagraph.X;
const nOffset = nLineWidth * 0.2;
const nLeftOffset = oParagraph.X + nOffset;
const nRightOffset = oParagraph.XLimit - nOffset;
const oTextPr = oParagraph.Get_FirstTextPr();
if (oTextPr.Unifill)
{
const oColor = oTextPr.Unifill.getRGBAColor();
pGraphics.p_color(oColor.R, oColor.G, oColor.B, 255);
}
else if (oTextPr.Color)
{
const oColor = oTextPr.Color;
pGraphics.p_color(oColor.r, oColor.g, oColor.b, 255);
}
else
{
pGraphics.p_color(0, 0, 0, 255);
}
pGraphics.drawHorLine(AscCommon.c_oAscLineDrawingRule.Center, oParagraph.Y + (this.Row.Height / 2), nLeftOffset, nRightOffset, 4 * AscCommon.g_dKoef_pix_to_mm);
}
},
Content_Draw : function(PageIndex, pGraphics)
{
var TextDirection = this.Get_TextDirection();
var bNeedRestore = false;
var _transform = undefined;
if (textdirection_BTLR === TextDirection || textdirection_TBRL === TextDirection)
{
bNeedRestore = true;
pGraphics.SaveGrState();
pGraphics.AddClipRect(this.Temp.X_cell_start, this.Temp.Y_cell_start, this.Temp.X_cell_end - this.Temp.X_cell_start, this.Temp.Y_cell_end - this.Temp.Y_cell_start);
_transform = this.Get_ParentTextTransform();
if (pGraphics.CheckUseFonts2 !== undefined)
pGraphics.CheckUseFonts2(_transform);
pGraphics.transform3(_transform);
}
if (pGraphics.bIsDrawCellTextLines)
{
this.Content_Draw_Line(pGraphics);
}
else
{
this.Content.Draw(PageIndex, pGraphics);
}
if (bNeedRestore)
{
pGraphics.RestoreGrState();
if (pGraphics.UncheckUseFonts2 !== undefined && _transform)
pGraphics.UncheckUseFonts2(_transform);
}
},
Content_Selection_SetStart : function(X, Y, CurPage, MouseEvent)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
this.Content.Selection_SetStart(_X, _Y, CurPage, MouseEvent);
},
Content_Selection_SetEnd : function(X, Y, CurPage, MouseEvent)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
this.Content.Selection_SetEnd(_X, _Y, CurPage, MouseEvent);
},
Content_Selection_Stop : function()
{
return this.Content.Selection_Stop();
},
Content_CheckPosInSelection : function(X, Y, CurPage, NearPos)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.CheckPosInSelection(_X, _Y, CurPage, NearPos);
},
Content_MoveCursorToXY : function(X, Y, bLine, bDontChangeRealPos, CurPage)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
this.Content.MoveCursorToXY(_X, _Y, bLine, bDontChangeRealPos, CurPage);
},
Content_UpdateCursorType : function(X, Y, CurPage)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.UpdateCursorType(_X, _Y, CurPage);
},
Content_DrawSelectionOnPage : function(CurPage)
{
var Transform = this.private_GetTextDirectionTransform();
var DrawingDocument = this.Row.Table.DrawingDocument;
if (null !== Transform && DrawingDocument)
DrawingDocument.MultiplyTargetTransform(Transform);
this.Content.DrawSelectionOnPage(CurPage);
},
Content_RecalculateCurPos : function(bUpdateX, bUpdateY, isUpdateTarget)
{
var Transform = this.private_GetTextDirectionTransform();
var DrawingDocument = this.Row.Table.DrawingDocument;
if (null !== Transform && DrawingDocument)
DrawingDocument.MultiplyTargetTransform(Transform);
return this.Content.RecalculateCurPos(bUpdateX, bUpdateY, isUpdateTarget);
},
Content_Get_NearestPos : function(CurPage, X, Y, bAnchor, Drawing)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.Get_NearestPos(CurPage, _X, _Y, bAnchor, Drawing);
},
Content_Is_TableBorder : function(X, Y, CurPage)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.IsTableBorder(_X, _Y, CurPage);
},
Content_Is_InText : function(X, Y, CurPage)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.IsInText(_X, _Y, CurPage);
},
Content_Is_InDrawing : function(X, Y, CurPage)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.IsInDrawing(_X, _Y, CurPage);
},
Content_GetCurPosXY : function()
{
return this.Content.GetCurPosXY();
},
Content_SetCurPosXY : function(X, Y)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.SetCurPosXY(_X, _Y);
},
Content_MoveCursorUpToLastRow : function(X, Y, AddToSelect)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.MoveCursorUpToLastRow(_X, _Y, AddToSelect);
},
Content_MoveCursorDownToFirstRow : function(X, Y, AddToSelect)
{
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return this.Content.MoveCursorDownToFirstRow(_X, _Y, AddToSelect);
},
RecalculateMinMaxContentWidth : function(isRotated, nPctWidth)
{
var oLogicDocument = this.GetLogicDocument();
if (undefined === isRotated)
isRotated = false;
if (true === this.IsVerticalText())
isRotated = true !== isRotated;
let layoutCoeff = this.GetTable().getLayoutScaleCoefficient();
var oResult;
if (oLogicDocument && oLogicDocument.GetRecalcId() === this.CachedMinMax.RecalcId)
{
oResult = this.CachedMinMax.MinMax;
}
else
{
oResult = this.Content.RecalculateMinMaxContentWidth(isRotated);
// В MSWord у ячейки минимальная ширина 0.1мм
if (oResult.Min < 0.1)
oResult.Min = 0.1;
var oMargins = this.GetMargins();
var oRow = this.GetRow();
var nAdd = 0;
if (oRow)
{
var nCellSpacing = oRow.GetCellSpacing();
var oBorders = this.GetBorders();
if (nCellSpacing)
{
nAdd = oMargins.Left.W + oMargins.Right.W;
if (border_Single === oBorders.Left.Value)
{
nAdd += oBorders.Left.Size;
}
if (border_Single === oBorders.Right.Value)
{
nAdd += oBorders.Right.Size;
}
}
else
{
if (border_Single === oBorders.Left.Value && oBorders.Left.Size / 2 > oMargins.Left.W)
{
nAdd += oBorders.Left.Size / 2;
}
else
{
nAdd += oMargins.Left.W;
}
if (border_Single === oBorders.Right.Value && oBorders.Right.Size / 2 > oMargins.Right.W)
{
nAdd += oBorders.Right.Size / 2;
}
else
{
nAdd += oMargins.Right.W;
}
}
}
else
{
nAdd = oMargins.Left.W + oMargins.Right.W;
}
nAdd *= layoutCoeff;
oResult.Min += nAdd;
oResult.Max += nAdd;
oResult.ContentMin = oResult.Min;
oResult.ContentMax = oResult.Max;
var oPrefW = this.GetW();
if (tblwidth_Mm === oPrefW.Type)
{
if (oResult.Min < oPrefW.W * layoutCoeff)
oResult.Min = oPrefW.W * layoutCoeff;
if (oResult.Max < oPrefW.W * layoutCoeff)
oResult.Max = oPrefW.W * layoutCoeff;
}
else if (tblwidth_Pct === oPrefW.Type && nPctWidth)
{
var nPrefW = nPctWidth * oPrefW.W / 100;
if (oResult.Min < nPrefW)
oResult.Min = nPrefW;
if (oResult.Max < nPrefW)
oResult.Max = nPrefW;
}
if (true !== isRotated && this.GetNoWrap())
{
if (this.GetW().IsMM())
{
oResult.ContentMin = Math.max(oResult.ContentMin, oResult.Min);
}
else
{
oResult.ContentMin = Math.max(oResult.ContentMin, oResult.ContentMax);
oResult.Min = Math.max(oResult.Min, oResult.Max);
oResult.Max = oResult.Min;
}
}
if (oLogicDocument)
{
this.CachedMinMax.RecalcId = oLogicDocument.GetRecalcId();
this.CachedMinMax.MinMax = oResult;
}
}
return oResult;
},
ShiftCell : function(CurPage, dX, dY)
{
// TODO: По логике нужно тут двигать this.Temp.ClipTop/ClipBottom, но при пересчете мы их проставляем заново,
// возможно сделать через флаг
if (true === this.IsVerticalText())
{
this.Temp.X_start += dX;
this.Temp.Y_start += dY;
this.Temp.X_end += dX;
this.Temp.Y_end += dY;
this.Temp.X_cell_start += dX;
this.Temp.Y_cell_start += dY;
this.Temp.X_cell_end += dX;
this.Temp.Y_cell_end += dY;
this.Temp.Y += dY;
}
else
{
this.ShiftCellContent(CurPage, dX, dY);
}
},
ShiftCellContent : function(nCurPage, nShiftX, nShiftY, keepClip)
{
this.Content.Shift(nCurPage, nShiftX, nShiftY, keepClip);
var arrDrawings = this.Content.GetAllDrawingObjects();
for (var nIndex = 0, nCount = arrDrawings.length; nIndex < nCount; ++nIndex)
{
var _nShiftX = 0, _nShiftY = 0;
var oDrawing = arrDrawings[nIndex];
if (!oDrawing.IsInline() && oDrawing.IsLayoutInCell())
{
if (!oDrawing.IsMoveWithTextHorizontally())
_nShiftX = nShiftX;
if (!oDrawing.IsMoveWithTextVertically())
_nShiftY = nShiftY;
oDrawing.Shift(_nShiftX, _nShiftY);
}
}
},
private_GetTextDirectionTransform : function()
{
var Transform = null;
var TextDirection = this.Get_TextDirection();
if (textdirection_BTLR === TextDirection)
{
Transform = new AscCommon.CMatrix();
global_MatrixTransformer.RotateRadAppend(Transform, 0.5 * Math.PI);
global_MatrixTransformer.TranslateAppend(Transform, this.Temp.X_start, this.Temp.Y_end);
}
else if (textdirection_TBRL === TextDirection)
{
var Transform = new AscCommon.CMatrix();
global_MatrixTransformer.RotateRadAppend(Transform, -0.5 * Math.PI);
global_MatrixTransformer.TranslateAppend(Transform, this.Temp.X_end, this.Temp.Y_start);
}
return Transform;
},
Recalculate : function()
{
this.Content.Recalculate();
},
Content_Merge : function(OtherContent)
{
this.Content.Add_Content( OtherContent );
},
Content_Is_ContentOnFirstPage : function()
{
return this.Content.IsContentOnFirstPage();
},
Content_Set_StartPage : function(PageNum)
{
this.Content.Set_StartPage(PageNum);
},
Content_Document_CreateFontMap : function(FontMap)
{
this.Content.Document_CreateFontMap( FontMap );
},
Content_MoveCursorToStartPos : function()
{
this.Content.MoveCursorToStartPos();
},
Content_MoveCursorToEndPos : function()
{
this.Content.MoveCursorToEndPos();
},
//-----------------------------------------------------------------------------------
// Работаем с настройками ячейки
//-----------------------------------------------------------------------------------
Clear_DirectFormatting : function(bClearMerge)
{
// Очищаем все строки и всех ее ячеек
this.Set_Shd( undefined );
this.Set_Margins( undefined );
this.Set_Border( undefined, 0 );
this.Set_Border( undefined, 1 );
this.Set_Border( undefined, 2 );
this.Set_Border( undefined, 3 );
if ( true === bClearMerge )
{
this.Set_GridSpan( undefined );
this.SetVMerge( undefined );
}
},
Set_Pr : function(CellPr)
{
let isHavePrChange = this.HavePrChange();
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellPr(this, this.Pr, CellPr));
this.Pr = CellPr;
this.Recalc_CompiledPr();
this.private_UpdateTableGrid();
if (isHavePrChange || this.HavePrChange())
this.updateTrackRevisions();
},
Copy_Pr : function(OtherPr, bCopyOnlyVisualProps)
{
if ( true != bCopyOnlyVisualProps )
{
// GridSpan
if ( undefined === OtherPr.GridSpan )
this.Set_GridSpan( undefined );
else
this.Set_GridSpan( OtherPr.GridSpan );
}
// Shd
if (undefined === OtherPr.Shd)
{
this.Set_Shd(undefined);
}
else
{
// TODO: переделать здесь на нармальное выставление настроек
this.Set_Shd({
Value : OtherPr.Shd.Value,
Color : OtherPr.Shd.Color ? {r : OtherPr.Shd.Color.r, g : OtherPr.Shd.Color.g, b : OtherPr.Shd.Color.b} : undefined,
Fill : OtherPr.Shd.Fill ? {r : OtherPr.Shd.Fill.r, g : OtherPr.Shd.Fill.g, b : OtherPr.Shd.Fill.b} : undefined,
Unifill : OtherPr.Shd.Unifill ? OtherPr.Shd.Unifill.createDuplicate() : undefined,
ThemeFill: OtherPr.Shd.ThemeFill ? OtherPr.Shd.ThemeFill.createDuplicate() : undefined
});
}
if ( true != bCopyOnlyVisualProps )
{
// VMerge
this.SetVMerge(OtherPr.VMerge);
}
// Border Top
if ( undefined === OtherPr.TableCellBorders.Top )
this.Set_Border( undefined, 0 );
else
{
var Border_top_new = ( null === OtherPr.TableCellBorders.Top ? null : OtherPr.TableCellBorders.Top.Copy() );
this.Set_Border( Border_top_new, 0 );
}
// Border bottom
if ( undefined === OtherPr.TableCellBorders.Bottom )
this.Set_Border( undefined, 2 );
else
{
var Border_bottom_new = ( null === OtherPr.TableCellBorders.Bottom ? null : OtherPr.TableCellBorders.Bottom.Copy() );
this.Set_Border( Border_bottom_new, 2 );
}
// Border left
if ( undefined === OtherPr.TableCellBorders.Left )
this.Set_Border( undefined, 3 );
else
{
var Border_left_new = ( null === OtherPr.TableCellBorders.Left ? null : OtherPr.TableCellBorders.Left.Copy() );
this.Set_Border( Border_left_new, 3 );
}
// Border right
if ( undefined === OtherPr.TableCellBorders.Right )
this.Set_Border( undefined, 1 );
else
{
var Border_right_new = ( null === OtherPr.TableCellBorders.Right ? null : OtherPr.TableCellBorders.Right.Copy() );
this.Set_Border( Border_right_new, 1 );
}
// Margins
if (!OtherPr.TableCellMar)
{
this.Set_Margins(undefined);
}
else
{
var oMarginsNew = {};
if (OtherPr.TableCellMar.Top)
{
oMarginsNew.Top = {
W : OtherPr.TableCellMar.Top.W,
Type : OtherPr.TableCellMar.Top.Type
};
}
if (OtherPr.TableCellMar.Left)
{
oMarginsNew.Left = {
W : OtherPr.TableCellMar.Left.W,
Type : OtherPr.TableCellMar.Left.Type
};
}
if (OtherPr.TableCellMar.Bottom)
{
oMarginsNew.Bottom = {
W : OtherPr.TableCellMar.Bottom.W,
Type : OtherPr.TableCellMar.Bottom.Type
};
}
if (OtherPr.TableCellMar.Right)
{
oMarginsNew.Right = {
W : OtherPr.TableCellMar.Right.W,
Type : OtherPr.TableCellMar.Right.Type
};
}
this.Set_Margins(oMarginsNew, -1);
}
// W
if ( undefined === OtherPr.TableCellW )
this.Set_W( undefined );
else
this.Set_W( OtherPr.TableCellW.Copy() );
// VAlign
this.Set_VAlign(OtherPr.VAlign);
// TextDirection
this.Set_TextDirection(OtherPr.TextDirection);
// NoWrap
this.SetNoWrap(OtherPr.NoWrap);
},
Get_W : function()
{
var W = this.Get_CompiledPr(false).TableCellW;
return W.Copy();
},
Set_W : function(CellW)
{
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellW(this, this.Pr.TableCellW, CellW));
this.Pr.TableCellW = CellW;
this.Recalc_CompiledPr();
this.private_UpdateTableGrid();
},
Get_GridSpan : function()
{
var GridSpan = this.Get_CompiledPr(false).GridSpan;
return GridSpan;
},
Set_GridSpan : function(Value)
{
if (this.Pr.GridSpan === Value)
return;
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellGridSpan(this, this.Pr.GridSpan, Value));
this.Pr.GridSpan = Value;
this.Recalc_CompiledPr();
this.private_UpdateTableGrid();
},
GetMargins : function(isDirectTop)
{
var oCellMargins = this.Get_CompiledPr(false).TableCellMar;
var oDefaultMargins = this.Row.Table.Get_TableCellMar();
var nT = oDefaultMargins.Top;
var nB = oDefaultMargins.Bottom;
var nL = oDefaultMargins.Left;
var nR = oDefaultMargins.Right;
if (oCellMargins)
{
if (oCellMargins.Top)
nT = oCellMargins.Top;
if (oCellMargins.Bottom)
nB = oCellMargins.Bottom;
if (oCellMargins.Left)
nL = oCellMargins.Left;
if (oCellMargins.Right)
nR = oCellMargins.Right;
}
// Делаем как MSWord, верхний отступ считаем общим для всей строки
if (true !== isDirectTop && !this.Row.Table.bPresentation)
nT = new CTableMeasurement(tblwidth_Mm, this.private_GetRowTopMargin());
return {
Top : nT,
Bottom : nB,
Left : nL,
Right : nR
};
},
Is_TableMargins : function()
{
var TableCellMar = this.Get_CompiledPr(false).TableCellMar;
if ( null === TableCellMar )
return true;
else
return false;
},
Set_Margins : function(Margin, Type)
{
var OldValue = ( undefined === this.Pr.TableCellMar ? undefined : this.Pr.TableCellMar );
if (undefined === Margin || null === Margin)
{
if (Margin !== this.Pr.TableCellMar)
{
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellMargins(this, OldValue, Margin));
this.Pr.TableCellMar = undefined;
this.Recalc_CompiledPr();
this.private_UpdateTableGrid();
}
return;
}
var Margins_new;
var bNeedChange = false;
var TableMargins = this.Row.Table.Get_TableCellMar();
if (!this.Pr.TableCellMar)
{
Margins_new = {
Left : TableMargins.Left.Copy(),
Right : TableMargins.Right.Copy(),
Top : TableMargins.Top.Copy(),
Bottom : TableMargins.Bottom.Copy()
};
bNeedChange = true;
}
else
{
Margins_new = {
Left : this.Pr.TableCellMar.Left ? this.Pr.TableCellMar.Left.Copy() : TableMargins.Left.Copy(),
Right : this.Pr.TableCellMar.Right ? this.Pr.TableCellMar.Right.Copy() : TableMargins.Right.Copy(),
Bottom : this.Pr.TableCellMar.Bottom ? this.Pr.TableCellMar.Bottom.Copy() : TableMargins.Bottom.Copy(),
Top : this.Pr.TableCellMar.Top ? this.Pr.TableCellMar.Top.Copy() : TableMargins.Top.Copy()
};
}
switch (Type)
{
case -1 :
{
bNeedChange = true;
if (Margin.Top)
{
Margins_new.Top.W = Margin.Top.W;
Margins_new.Top.Type = Margin.Top.Type;
}
if (Margin.Right)
{
Margins_new.Right.W = Margin.Right.W;
Margins_new.Right.Type = Margin.Right.Type;
}
if (Margin.Bottom)
{
Margins_new.Bottom.W = Margin.Bottom.W;
Margins_new.Bottom.Type = Margin.Bottom.Type;
}
if (Margin.Left)
{
Margins_new.Left.W = Margin.Left.W;
Margins_new.Left.Type = Margin.Left.Type;
}
break;
}
case 0:
{
if (true != bNeedChange && Margins_new.Top.W != Margin.W || Margins_new.Top.Type != Margin.Type)
bNeedChange = true;
Margins_new.Top.W = Margin.W;
Margins_new.Top.Type = Margin.Type;
break;
}
case 1:
{
if (true != bNeedChange && Margins_new.Right.W != Margin.W || Margins_new.Right.Type != Margin.Type)
bNeedChange = true;
Margins_new.Right.W = Margin.W;
Margins_new.Right.Type = Margin.Type;
break;
}
case 2:
{
if (true != bNeedChange && Margins_new.Bottom.W != Margin.W || Margins_new.Bottom.Type != Margin.Type)
bNeedChange = true;
Margins_new.Bottom.W = Margin.W;
Margins_new.Bottom.Type = Margin.Type;
break;
}
case 3:
{
if (true != bNeedChange && Margins_new.Left.W != Margin.W || Margins_new.Left.Type != Margin.Type)
bNeedChange = true;
Margins_new.Left.W = Margin.W;
Margins_new.Left.Type = Margin.Type;
break;
}
}
if (true === bNeedChange)
{
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellMargins(this, OldValue, Margins_new));
this.Pr.TableCellMar = Margins_new;
this.Recalc_CompiledPr();
this.private_UpdateTableGrid();
}
},
Get_Shd : function()
{
var Shd = this.Get_CompiledPr(false).Shd;
return Shd;
},
Set_Shd : function(Shd)
{
if (undefined === Shd && undefined === this.Pr.Shd)
return;
if (undefined === Shd)
{
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellShd(this, this.Pr.Shd, undefined));
this.Pr.Shd = undefined;
this.Recalc_CompiledPr();
}
else if (undefined === this.Pr.Shd || false === this.Pr.Shd.Compare(Shd))
{
this.private_AddPrChange();
var _Shd = new CDocumentShd();
_Shd.Set_FromObject(Shd);
AscCommon.History.Add(new CChangesTableCellShd(this, this.Pr.Shd, _Shd));
this.Pr.Shd = _Shd;
this.Recalc_CompiledPr();
}
},
Get_VAlign : function()
{
var VAlign = this.Get_CompiledPr(false).VAlign;
return VAlign;
},
Set_VAlign : function(Value)
{
if (Value === this.Pr.VAlign)
return;
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellVAlign(this, this.Pr.VAlign, Value));
this.Pr.VAlign = Value;
this.Recalc_CompiledPr();
},
GetNoWrap : function()
{
return this.Get_CompiledPr(false).NoWrap;
},
SetNoWrap : function(Value)
{
if (this.Pr.NoWrap !== Value)
{
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellNoWrap(this, this.Pr.NoWrap, Value));
this.Pr.NoWrap = Value;
this.Recalc_CompiledPr();
}
},
IsVerticalText : function()
{
var TextDirection = this.Get_TextDirection();
return (textdirection_BTLR === TextDirection || textdirection_TBRL === TextDirection);
},
Get_TextDirection : function()
{
return this.Get_CompiledPr(false).TextDirection;
},
Set_TextDirection : function(Value)
{
if (Value !== this.Pr.TextDirection)
{
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellTextDirection(this, this.Pr.TextDirection, Value));
this.Pr.TextDirection = Value;
this.Recalc_CompiledPr();
}
},
Set_TextDirectionFromApi : function(TextDirection)
{
var isVerticalText = (textdirection_BTLR === TextDirection || textdirection_TBRL === TextDirection) ? true : false;
// Во время изменения направления текста меняем высоту строки, если надо и отступы и параграфов внутри ячейки.
var OldTextDirection = this.Get_TextDirection();
this.Set_TextDirection(TextDirection);
if (OldTextDirection !== TextDirection)
{
if (true === isVerticalText)
{
var Row = this.Row;
var RowH = this.Row.Get_Height();
if (Asc.linerule_Auto === RowH.HRule)
Row.Set_Height(20, Asc.linerule_AtLeast);
else if (RowH.Value < 20)
Row.Set_Height(20, RowH.HRule);
}
this.Content.Set_ParaPropsForVerticalTextInCell(isVerticalText);
}
},
Get_Borders : function()
{
return this.GetBorders();
},
// 0 - Top, 1 - Right, 2- Bottom, 3- Left
Get_Border : function(Type)
{
var TableBorders = this.Row.Table.Get_TableBorders();
var Borders = this.Get_CompiledPr(false).TableCellBorders;
var Border = null;
switch (Type)
{
case 0 :
{
if ( null != Borders.Top )
Border = Borders.Top;
else
{
if ( 0 != this.Row.Index || null != this.Row.Get_CellSpacing() )
Border = TableBorders.InsideH;
else
Border = TableBorders.Top;
}
break;
}
case 1 :
{
if ( null != Borders.Right )
Border = Borders.Right;
else
{
if ( this.Row.Content.length - 1 != this.Index || null != this.Row.Get_CellSpacing() )
Border = TableBorders.InsideV;
else
Border = TableBorders.Right;
}
break;
}
case 2 :
{
if ( null != Borders.Bottom )
Border = Borders.Bottom;
else
{
if ( this.Row.Table.Content.length - 1 != this.Row.Index || null != this.Row.Get_CellSpacing() )
Border = TableBorders.InsideH;
else
Border = TableBorders.Bottom;
}
break;
}
case 3 :
{
if ( null != Borders.Left )
Border = Borders.Left;
else
{
if ( 0 != this.Index || null != this.Row.Get_CellSpacing() )
Border = TableBorders.InsideV;
else
Border = TableBorders.Left;
}
break;
}
}
return Border;
},
// 0 - Top, 1 - Right, 2- Bottom, 3- Left
Set_Border : function(Border, Type)
{
var DstBorder = this.Pr.TableCellBorders.Top;
switch (Type)
{
case 0 :
DstBorder = this.Pr.TableCellBorders.Top;
break;
case 1 :
DstBorder = this.Pr.TableCellBorders.Right;
break;
case 2 :
DstBorder = this.Pr.TableCellBorders.Bottom;
break;
case 3 :
DstBorder = this.Pr.TableCellBorders.Left;
break;
}
if (undefined === Border || null === Border)
{
if (Border === DstBorder)
return;
this.private_AddPrChange();
switch (Type)
{
case 0:
{
AscCommon.History.Add(new CChangesTableCellBorderTop(this, this.Pr.TableCellBorders.Top, Border));
this.Pr.TableCellBorders.Top = undefined;
break;
}
case 1 :
{
AscCommon.History.Add(new CChangesTableCellBorderRight(this, this.Pr.TableCellBorders.Right, Border));
this.Pr.TableCellBorders.Right = undefined;
break;
}
case 2 :
{
AscCommon.History.Add(new CChangesTableCellBorderBottom(this, this.Pr.TableCellBorders.Bottom, Border));
this.Pr.TableCellBorders.Bottom = undefined;
break;
}
case 3 :
{
AscCommon.History.Add(new CChangesTableCellBorderLeft(this, this.Pr.TableCellBorders.Left, Border));
this.Pr.TableCellBorders.Left = undefined;
break;
}
}
this.Recalc_CompiledPr();
}
else if (null === DstBorder)
{
var NewBorder = this.Get_Border(Type).Copy();
NewBorder.Value = null != Border.Value ? Border.Value : NewBorder.Value;
NewBorder.Size = null != Border.Size ? Border.Size : NewBorder.Size;
NewBorder.Color.r = null != Border.Color ? Border.Color.r : NewBorder.Color.r;
NewBorder.Color.g = null != Border.Color ? Border.Color.g : NewBorder.Color.g;
NewBorder.Color.b = null != Border.Color ? Border.Color.b : NewBorder.Color.b;
NewBorder.Unifill = null != Border.Unifill ? Border.Unifill : NewBorder.Unifill;
this.private_AddPrChange();
switch (Type)
{
case 0:
{
AscCommon.History.Add(new CChangesTableCellBorderTop(this, this.Pr.TableCellBorders.Top, NewBorder));
this.Pr.TableCellBorders.Top = NewBorder;
break;
}
case 1 :
{
AscCommon.History.Add(new CChangesTableCellBorderRight(this, this.Pr.TableCellBorders.Right, NewBorder));
this.Pr.TableCellBorders.Right = NewBorder;
break;
}
case 2 :
{
AscCommon.History.Add(new CChangesTableCellBorderBottom(this, this.Pr.TableCellBorders.Bottom, NewBorder));
this.Pr.TableCellBorders.Bottom = NewBorder;
break;
}
case 3 :
{
AscCommon.History.Add(new CChangesTableCellBorderLeft(this, this.Pr.TableCellBorders.Left, NewBorder));
this.Pr.TableCellBorders.Left = NewBorder;
break;
}
}
this.Recalc_CompiledPr();
}
else
{
var NewBorder = new CDocumentBorder();
var DefBorder = DstBorder;
if (undefined === DefBorder)
DefBorder = new CDocumentBorder();
NewBorder.Value = null != Border.Value ? Border.Value : DefBorder.Value;
NewBorder.Size = null != Border.Size ? Border.Size : DefBorder.Size;
NewBorder.Color.r = null != Border.Color ? Border.Color.r : DefBorder.Color.r;
NewBorder.Color.g = null != Border.Color ? Border.Color.g : DefBorder.Color.g;
NewBorder.Color.b = null != Border.Color ? Border.Color.b : DefBorder.Color.b;
NewBorder.Unifill = null != Border.Unifill ? Border.Unifill : DefBorder.Unifill;
this.private_AddPrChange();
switch (Type)
{
case 0:
{
AscCommon.History.Add(new CChangesTableCellBorderTop(this, this.Pr.TableCellBorders.Top, NewBorder));
this.Pr.TableCellBorders.Top = NewBorder;
break;
}
case 1 :
{
AscCommon.History.Add(new CChangesTableCellBorderRight(this, this.Pr.TableCellBorders.Right, NewBorder));
this.Pr.TableCellBorders.Right = NewBorder;
break;
}
case 2 :
{
AscCommon.History.Add(new CChangesTableCellBorderBottom(this, this.Pr.TableCellBorders.Bottom, NewBorder));
this.Pr.TableCellBorders.Bottom = NewBorder;
break;
}
case 3 :
{
AscCommon.History.Add(new CChangesTableCellBorderLeft(this, this.Pr.TableCellBorders.Left, NewBorder));
this.Pr.TableCellBorders.Left = NewBorder;
break;
}
}
this.Recalc_CompiledPr();
}
},
SetBorderInfoTop : function(oTopInfo)
{
this.BorderInfo.Top = oTopInfo;
},
SetBorderInfoTopHeader : function(oTopInfo)
{
this.BorderInfo.TopHeader = oTopInfo;
},
Set_BorderInfo_Bottom : function(BottomInfo, BeforeCount, AfterCount)
{
this.BorderInfo.Bottom = BottomInfo;
this.BorderInfo.Bottom_BeforeCount = BeforeCount;
this.BorderInfo.Bottom_AfterCount = AfterCount;
},
Set_BorderInfo_Left : function(LeftInfo, Max)
{
this.BorderInfo.Left = LeftInfo;
this.BorderInfo.MaxLeft = Max;
},
Set_BorderInfo_Right : function(RightInfo, Max)
{
this.BorderInfo.Right = RightInfo;
this.BorderInfo.MaxRight = Max;
},
GetBorderInfo : function()
{
return this.BorderInfo;
},
GetBorderInfoLeft : function()
{
return this.BorderInfo.Left;
},
GetBorderInfoRight : function()
{
return this.BorderInfo.Right;
},
//-----------------------------------------------------------------------------------
// Undo/Redo функции
//-----------------------------------------------------------------------------------
Get_ParentObject_or_DocumentPos : function()
{
return this.Row.Table.Get_ParentObject_or_DocumentPos(this.Row.Table.Index);
},
Refresh_RecalcData : function(Data)
{
let oTable = this.GetTable();
if (!oTable)
return;
var bNeedRecalc = false;
var Type = Data.Type;
switch ( Type )
{
case AscDFH.historyitem_TableCell_GridSpan:
case AscDFH.historyitem_TableCell_Margins:
case AscDFH.historyitem_TableCell_VMerge:
case AscDFH.historyitem_TableCell_Border_Left:
case AscDFH.historyitem_TableCell_Border_Right:
case AscDFH.historyitem_TableCell_Border_Top:
case AscDFH.historyitem_TableCell_Border_Bottom:
case AscDFH.historyitem_TableCell_VAlign:
case AscDFH.historyitem_TableCell_W:
case AscDFH.historyitem_TableCell_Pr:
case AscDFH.historyitem_TableCell_TextDirection:
case AscDFH.historyitem_TableCell_NoWrap:
{
bNeedRecalc = true;
break;
}
case AscDFH.historyitem_TableCell_Shd:
{
// Пересчитывать этот элемент не надо при таких изменениях
break;
}
}
oTable.RecalcInfo.RecalcBorders();
this.Refresh_RecalcData2( 0, 0 );
},
Refresh_RecalcData2 : function(Page_Rel)
{
var oRow = this.GetRow();
var oTable = this.GetTable();
if (!oRow || !oTable)
return;
oTable.RecalcInfo.Add_Cell(this);
// Изменения в текущей ячейке могут вызвать изменения в следующей или предыдущей ячейках.
// Например, когда у нас сквозная есть нумерация внутри ячеек
var nCurCell = this.GetIndex();
var nCellsCount = oRow.GetCellsCount();
if (nCurCell > 0 && nCellsCount > 0)
{
var oPrevCell = oRow.GetCell(nCurCell <= nCellsCount ? nCurCell - 1 : nCellsCount - 1);
if (oPrevCell)
oTable.RecalcInfo.Add_Cell(oPrevCell);
}
if (nCurCell < nCellsCount - 1 && nCurCell >= 0 && nCellsCount > 0)
{
var oNextCell = oRow.GetCell(nCurCell + 1);
if (oNextCell)
oTable.RecalcInfo.Add_Cell(oRow.GetCell(nCurCell + 1));
}
var TablePr = oTable.Get_CompiledPr(false).TablePr;
if (tbllayout_AutoFit === TablePr.TableLayout)
{
if (oTable.Parent && oTable.Parent.Pages.length > 0)
{
// Если изменение внутри ячейки влечет за собой изменение сетки таблицы, тогда
// пересчитывать таблицу надо с самого начала.
AscCommon.History.Add_RecalcTableGrid(oTable.Get_Id());
}
else
{
return oTable.Refresh_RecalcData2(0, 0);
}
}
oRow.Refresh_RecalcData2(nCurCell, Page_Rel);
},
//-----------------------------------------------------------------------------------
// Функции для работы с совместным редактирования
//-----------------------------------------------------------------------------------
Write_ToBinary2 : function(Writer)
{
Writer.WriteLong( AscDFH.historyitem_type_TableCell );
// String : Id ячейки
// Variable : TableCell.Pr
// String : Id DocumentContent
Writer.WriteString2( this.Id );
this.Pr.Write_ToBinary( Writer );
Writer.WriteString2( this.Content.Get_Id() );
},
Read_FromBinary2 : function(Reader)
{
// String : Id ячейки
// Variable : TableCell.Pr
// String : Id DocumentContent
this.Id = Reader.GetString2();
this.Pr = new CTableCellPr();
this.Pr.Read_FromBinary(Reader);
this.Recalc_CompiledPr();
this.Content = AscCommon.g_oTableId.Get_ById(Reader.GetString2());
if (this.Content)
this.Content.SetParent(this);
}
};
CTableCell.prototype.constructor = CTableCell;
/**
* Доступ к содержимому ячейки
* @returns {CDocumentContent}
*/
CTableCell.prototype.GetContent = function()
{
return this.Content;
};
/**
* Функция для выставления класса содержимого ячейки (используется в совместке)
* @param {CDocumentContent} oDocumentContent
*/
CTableCell.prototype.SetDocumentContent = function(oDocumentContent)
{
this.Content = oDocumentContent;
oDocumentContent.SetParent(this);
};
/**
* Доступ к родительской строке
* @returns {null | CTableRow}
*/
CTableCell.prototype.GetRow = function()
{
return this.Row;
};
/**
* Доступ к родительской таблице
* @returns {null | CTable}
*/
CTableCell.prototype.GetTable = function()
{
var oRow = this.GetRow();
if (!oRow)
return null;
return oRow.GetTable();
};
/**
* Доступ к главному классу документа
* @returns {CDocument|null}
*/
CTableCell.prototype.GetLogicDocument = function()
{
let table = this.GetTable();
if (table)
return table.GetLogicDocument();
return null;
};
/**
* Доступ к родительскому классу для родительской таблицы
* @returns {null|*}
*/
CTableCell.prototype.GetTableParent = function()
{
var oTable = this.GetTable();
if (!oTable)
return null;
return oTable.GetParent();
};
/**
* Получаем номер данной ячейки в родительской строке
* @returns {number}
*/
CTableCell.prototype.GetIndex = function()
{
return this.Index;
};
/**
* Выставляем номер данной ячейки в родительской строке
* @param {number} nIndex
*/
CTableCell.prototype.SetIndex = function(nIndex)
{
if (nIndex != this.Index)
{
this.Index = nIndex;
this.Recalc_CompiledPr();
}
};
CTableCell.prototype.private_TransformXY = function(X, Y)
{
// TODO: Везде, где идет такой код заменить на данную функцию
var _X = X, _Y = Y;
var Transform = this.private_GetTextDirectionTransform();
if (null !== Transform)
{
Transform = global_MatrixTransformer.Invert(Transform);
_X = Transform.TransformPointX(X, Y);
_Y = Transform.TransformPointY(X, Y);
}
return {X : _X, Y : _Y};
};
CTableCell.prototype.GetTopElement = function()
{
if (this.Row && this.Row.Table)
return this.Row.Table.GetTopElement();
return null;
};
CTableCell.prototype.Is_EmptyFirstPage = function()
{
if (!this.Row || !this.Row.Table || !this.Row.Table.RowsInfo[this.Row.Index] || true === this.Row.Table.RowsInfo[this.Row.Index].FirstPage)
return true;
return false;
};
CTableCell.prototype.Get_SectPr = function()
{
if (this.Row && this.Row.Table && this.Row.Table)
return this.Row.Table.Get_SectPr();
return null;
};
CTableCell.prototype.GetDocumentPositionFromObject = function(arrPos)
{
if (!arrPos)
arrPos = [];
var oRow = this.GetRow();
if (oRow)
{
if (arrPos.length > 0)
{
arrPos.splice(0, 0, {Class : oRow, Position : this.GetIndex()});
oRow.GetDocumentPositionFromObject(arrPos);
}
else
{
oRow.GetDocumentPositionFromObject(arrPos);
arrPos.push({Class : oRow, Position : this.GetIndex()});
}
}
return arrPos;
};
CTableCell.prototype.Get_Table = function()
{
var Row = this.Row;
if (!Row)
return null;
var Table = Row.Table;
if (!Table)
return null;
return Table;
};
CTableCell.prototype.GetTopDocumentContent = function(isOneLevel)
{
if (this.Row && this.Row.Table && this.Row.Table.Parent)
return this.Row.Table.Parent.GetTopDocumentContent(isOneLevel);
return null;
};
/**
* Специальная вставка таблицы в таблицу. Данная функция вызывается из CDocumentContent
* @param oTable
*/
CTableCell.prototype.InsertTableContent = function(oTable)
{
if (!this.Row || !this.Row.Table)
return;
this.Row.Table.InsertTableContent(this.Index, this.Row.Index, oTable);
};
/**
* Получаем ширину ячейки исходя из таблицы TableGrid
* @returns {number}
*/
CTableCell.prototype.GetCalculatedW = function()
{
var oRow = this.Row,
oTable = oRow.Table;
var nCurGridStart = oRow.GetCellInfo(this.Index).StartGridCol;
var nCurGridEnd = nCurGridStart + this.Get_GridSpan() - 1;
if (oTable.TableSumGrid.length > nCurGridEnd)
return oTable.TableSumGrid[nCurGridEnd] - oTable.TableSumGrid[nCurGridStart - 1];
return 3.8; // 1.9 + 1.9 стандартные отступы справа и слева
};
/**
* Получаем количество промежутков, которое занимает данная ячейка
* @returns {number}
*/
CTableCell.prototype.GetGridSpan = function()
{
return this.Get_GridSpan();
};
/**
* Выставляем количество промежутков, которое занимает данная ячейка
* @param nGridSpan
*/
CTableCell.prototype.SetGridSpan = function(nGridSpan)
{
return this.Set_GridSpan(nGridSpan);
};
/**
* Получаем информацию о границе ячейки
* @param {number} nType - 0 - Top, 1 - Right, 2- Bottom, 3- Left
*/
CTableCell.prototype.GetBorder = function(nType)
{
return this.Get_Border(nType);
};
/**
* Выставляем заданную границу
* @poram {CDocumentBorder} oBorder
* @param {number} nType - 0 - Top, 1 - Right, 2- Bottom, 3- Left
*/
CTableCell.prototype.SetBorder = function(oBorder, nType)
{
return this.Set_Border(oBorder, nType);
};
/**
* Проверяем, является ли данная ячейка последней в строке
* @returns {boolean}
*/
CTableCell.prototype.IsLastTableCellInRow = function(isSelection)
{
if (true !== isSelection)
return !!(this.Row && this.Row.GetCellsCount() - 1 === this.Index);
if (!this.Row || !this.Row.Table)
return false;
var nCurCell = this.Index;
var nCurRow = this.Row.Index;
var oTable = this.Row.Table;
var arrSelectionArray = oTable.GetSelectionArray();
for (var nIndex = 0, nCount = arrSelectionArray.length; nIndex < nCount; ++nIndex)
{
var nRow = arrSelectionArray[nIndex].Row;
var nCell = arrSelectionArray[nIndex].Cell;
if (nRow === nCurRow && nCell > nCurCell)
return false;
}
return true;
};
/**
* Проверяем пустая ли заданная граница, если надо удаляем ее
* @param {number} nType - 0 - Top, 1 - Right, 2- Bottom, 3- Left
*/
CTableCell.prototype.CheckEmptyBorder = function(nType)
{
var oBorderNone = new CDocumentBorder();
if (nType === 0)
{
if (border_None !== this.GetBorder(nType).Value)
this.SetBorder(oBorderNone, nType);
}
else if (nType === 1 || nType === 3)
{
// Удаляем границы для всех ячеейк, учавствующих в вертикальном объединении
var oTable = this.GetTable();
var oRow = this.GetRow();
var nVMergeCount = oTable.GetVMergeCount(this.GetIndex(), oRow.GetIndex());
var nCurGridStart = oRow.GetCellInfo(this.Index).StartGridCol;
if (this.Get_Border(nType).Value != 0)
this.Set_Border(oBorderNone, nType);
if (nVMergeCount > 1)
{
for (var nIndex = oRow.GetIndex() + 1; nIndex < oRow.GetIndex() + nVMergeCount; ++nIndex)
{
var oCellInVertUnion = oTable.GetCellByStartGridCol(nIndex, nCurGridStart);
if (oCellInVertUnion && border_None !== oCellInVertUnion.GetBorder(nType).Value)
oCellInVertUnion.SetBorder(oBorderNone, nType);
}
}
}
else if (nType === 2)
{
var oTable = this.GetTable();
var oRow = this.GetRow();
var nCurGridStart = oRow.GetCellInfo(this.Index).StartGridCol;
var nVMergeCount = oTable.GetVMergeCount(this.GetIndex(), this.GetRow().GetIndex());
var oLastCellInVertUnion = oTable.GetCellByStartGridCol(oRow.GetIndex() + nVMergeCount - 1, nCurGridStart);
if (oLastCellInVertUnion && border_None !== oLastCellInVertUnion.GetBorder(nType).Value)
oLastCellInVertUnion.SetBorder(oBorderNone, nType);
}
};
/**
* Проверяем заданную границу, и если надо делаем ее не пустой
* @param {number} nType - 0 - Top, 1 - Right, 2- Bottom, 3- Left
*/
CTableCell.prototype.CheckNonEmptyBorder = function(nType)
{
var oBorder = new CDocumentBorder();
oBorder.Value = border_Single;
if (nType === 0 || nType === 2)
{
if (border_None === this.GetBorder(nType).Value)
this.SetBorder(oBorder, nType);
}
else if (nType === 1 || nType === 3)
{
var oTable = this.GetTable();
var oRow = this.GetRow();
var nVMergeCount = oTable.GetVMergeCount(this.GetIndex(), oRow.GetIndex());
var nCurGridStart = oRow.GetCellInfo(this.Index).StartGridCol;
if (this.Get_Border(nType).Value === 0)
this.Set_Border(oBorder, nType);
if (nVMergeCount > 1)
{
for (var nIndex = oRow.GetIndex() + 1; nIndex < oRow.GetIndex() + nVMergeCount; ++nIndex)
{
var oCellInVertUnion = oTable.GetCellByStartGridCol(nIndex, nCurGridStart);
if (oCellInVertUnion && border_None === oCellInVertUnion.GetBorder(nType).Value)
oCellInVertUnion.SetBorder(oBorder, nType);
}
}
}
};
/**
* Получаем скомпилированную настройку ширины ячейки
* @returns {?CTableMeasurement}
*/
CTableCell.prototype.GetW = function()
{
return this.Get_W();
};
/**
* Задаем предпочитаемую ширину ячейки
* @param {CTableMeasurement} oCellW
*/
CTableCell.prototype.SetW = function(oCellW)
{
return this.Set_W(oCellW);
};
/**
* Участвует ли в вертикальном объединении данная ячейка
* @returns {vmerge_Restart | vmerge_Continue}
*/
CTableCell.prototype.GetVMerge = function()
{
return this.Get_CompiledPr(false).VMerge;
};
/**
* Задаем настройку участия данной ячейки в вертикальном объединении
* @param {vmerge_Restart | vmerge_Continue} nType
*/
CTableCell.prototype.SetVMerge = function(nType)
{
if (nType === this.Pr.VMerge)
return;
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellVMerge(this, this.Pr.VMerge, nType));
this.Pr.VMerge = nType;
this.Recalc_CompiledPr();
};
/**
* Проверяем находится ли данная ячейка в заголовке таблицы
* @param {boolean} [isDeep=false] Если данная ячейка не в заголовке своей таблицы, то смотрим ли у родительского класса таблицы
* @returns {boolean}
*/
CTableCell.prototype.IsInHeader = function(isDeep)
{
var isInHeader = this.Row.Table.IsInHeader(this.Row.GetIndex());
if (isInHeader)
return true;
if (true === isDeep && this.Row.Table.Parent && this.Row.Table.Parent.IsTableHeader)
return this.Row.Table.Parent.IsTableHeader();
return false;
};
/**
* Получаем последний элемент в предыдущей ячейке данной строки
* @returns {?CDocumentContentElementBase}
*/
CTableCell.prototype.GetLastElementInPrevCell = function()
{
var nCurCell = this.GetIndex();
var oRow = this.GetRow();
if (!oRow)
return null;
// TODO: Разобраться, что делать в данном случае
if (0 === nCurCell)
{
var oTable = this.GetTable();
if (0 === oRow.GetIndex() && oTable)
return oTable.Get_DocumentPrev();
return null;
}
var oPrevCell = oRow.GetCell(nCurCell - 1);
var oCellContent = oPrevCell.GetContent();
var nCount = oCellContent.GetElementsCount();
if (nCount <= 0)
return null;
return oCellContent.GetElement(nCount - 1);
};
/**
* Получаем первый элемент в следующей ячейке
* @returns {?CDocumentContentElementBase}
*/
CTableCell.prototype.GetFirstElementInNextCell = function()
{
var nCurCell = this.GetIndex();
var oRow = this.GetRow();
if (!oRow)
return null;
// TODO: Разобраться, что делать в данном случае
if (nCurCell >= oRow.GetCellsCount() - 1)
return null;
var oCellContent = oRow.GetCell(nCurCell + 1).GetContent();
var nCount = oCellContent.GetElementsCount();
if (nCount <= 0)
return null;
return oCellContent.GetElement(0);
};
/**
* Получаем предыдущий параграф
* @returns {?Paragraph}
*/
CTableCell.prototype.GetPrevParagraph = function()
{
var oTable = this.GetTable();
var oRow = this.GetRow();
var nCellIndex = this.GetIndex();
if (0 === nCellIndex)
{
var nRowIndex = oRow.GetIndex();
if (0 === nRowIndex)
{
return oTable.GetPrevParagraph();
}
else
{
var oPrevRow = oTable.GetRow(nRowIndex - 1);
var oPrevCell = oPrevRow.GetCell(oPrevRow.GetCellsCount() - 1);
if (!oPrevCell)
return null;
return oPrevCell.GetContent().GetLastParagraph();
}
}
else
{
var oPrevCell = oRow.GetCell(nCellIndex - 1);
if (!oPrevCell)
return null;
return oPrevCell.GetContent().GetLastParagraph();
}
};
/**
* Участвует ли в вертикальном объединении данная ячейка
* @returns {vmerge_Restart | vmerge_Continue}
*/
CTableCell.prototype.GetHMerge = function()
{
return this.Get_CompiledPr(false).HMerge;
};
/**
* Задаем настройку участия данной ячейки в вертикальном объединении
* @param {vmerge_Restart | vmerge_Continue} nType
*/
CTableCell.prototype.SetHMerge = function(nType)
{
if (nType === this.Pr.HMerge)
return;
this.private_AddPrChange();
AscCommon.History.Add(new CChangesTableCellHMerge(this, this.Pr.HMerge, nType));
this.Pr.HMerge = nType;
this.Recalc_CompiledPr();
};
/**
* По заданной абсолютной странице получаем массив относительных страниц (относительно таблицы)
* @param nPageAbs
* @returns {Array}
*/
CTableCell.prototype.GetCurPageByAbsolutePage = function(nPageAbs)
{
var arrPages = [];
var oRow = this.GetRow();
var oTable = this.GetTable();
if (!oRow || !oTable || !oTable.RowsInfo[oRow.GetIndex()])
return arrPages;
var nStartPage = oTable.RowsInfo[oRow.GetIndex()].StartPage;
var nPagesCount = this.Content.Pages.length;
for (var nCurPage = 0; nCurPage < nPagesCount; ++nCurPage)
{
if (nPageAbs === this.GetAbsolutePage(nStartPage + nCurPage))
{
arrPages.push(nStartPage + nCurPage);
}
}
return arrPages;
};
/**
* Получаем границы ячейки
* @param nCurPage Номер страницы относительно таблицы
* @returns {CDocumentBounds}
*/
CTableCell.prototype.GetPageBounds = function(nCurPage)
{
var oTable = this.GetTable();
var oRow = this.GetRow();
if (!oRow || !oTable || !oTable.Pages[nCurPage])
return new CDocumentBounds(0, 0, 0, 0);
var nCurRow = oRow.GetIndex();
if (!oTable.RowsInfo[nCurRow] || !oTable.RowsInfo[nCurRow].Y[nCurPage] || !oTable.RowsInfo[nCurRow].H[nCurPage])
return new CDocumentBounds(0, 0, 0, 0);
var oPage = oTable.Pages[nCurPage];
var oCellInfo = oRow.GetCellInfo(this.GetIndex());
var nVMergeCountOnPage = oTable.private_GetVertMergeCountOnPage(nCurPage, oRow.GetIndex(), oCellInfo.StartGridCol, this.GetGridSpan());
if (nVMergeCountOnPage <= 0)
return new CDocumentBounds(0, 0, 0, 0);
var nL = oPage.X + oCellInfo.X_cell_start;
var nR = oPage.X + oCellInfo.X_cell_end;
var nT = oTable.RowsInfo[nCurRow].Y[nCurPage];
var nB = oTable.RowsInfo[nCurRow + nVMergeCountOnPage - 1].Y[nCurPage] + oTable.RowsInfo[nCurRow + nVMergeCountOnPage - 1].H[nCurPage];
return new CDocumentBounds(nL, nT, nR, nB);
};
/**
* Получаем колонку в виде массива ячеек
* @returns {[CTableCell]}
*/
CTableCell.prototype.GetColumn = function()
{
var oTable = this.GetTable();
if (!oTable)
return [this];
return oTable.GetColumn(this.GetIndex(), this.GetRow().GetIndex());
};
CTableCell.prototype.updateTrackRevisions = function()
{
var oTable = this.GetTable();
if (oTable)
oTable.updateTrackRevisions();
};
CTableCell.prototype.HavePrChange = function()
{
return this.Pr.HavePrChange();
};
CTableCell.prototype.AddPrChange = function()
{
if (false === this.HavePrChange())
{
this.Pr.AddPrChange();
AscCommon.History.Add(new CChangesTableCellPrChange(this, {
PrChange : undefined,
ReviewInfo : undefined
}, {
PrChange : this.Pr.PrChange,
ReviewInfo : this.Pr.ReviewInfo
}));
this.updateTrackRevisions();
}
};
CTableCell.prototype.RemovePrChange = function()
{
if (true === this.HavePrChange())
{
AscCommon.History.Add(new CChangesTableCellPrChange(this, {
PrChange : this.Pr.PrChange,
ReviewInfo : this.Pr.ReviewInfo
}, {
PrChange : undefined,
ReviewInfo : undefined
}));
this.Pr.RemovePrChange();
this.updateTrackRevisions();
}
};
CTableCell.prototype.private_AddPrChange = function()
{
var oTable = this.GetTable();
var oRow = this.GetRow();
if (oTable
&& oRow
&& oTable.LogicDocument
&& true === oTable.LogicDocument.IsTrackRevisions()
&& true !== this.HavePrChange()
&& reviewtype_Common === oRow.GetReviewType())
{
this.AddPrChange();
oTable.AddPrChange();
}
};
CTableCell.prototype.AcceptPrChange = function()
{
this.RemovePrChange();
};
CTableCell.prototype.RejectPrChange = function()
{
if (this.HavePrChange())
{
this.Set_Pr(this.Pr.PrChange);
this.RemovePrChange();
}
};
/**
* Проверяем является ли данная ячейка частью смерженной ячейки
* @returns {boolean}
*/
CTableCell.prototype.IsMergedCell = function()
{
var oTable = this.GetTable();
var nVMerge = this.GetVMerge();
if (nVMerge === vmerge_Continue && oTable)
return (oTable.GetStartMergedCell(this.GetIndex(), this.GetRow().GetIndex()) !== this);
return false;
};
/**
* Получаем границы данной ячейки
* @returns {{Top: *, Right: *, Bottom: *, Left: *}}
*/
CTableCell.prototype.GetBorders = function()
{
return {
Top : this.GetBorder(0),
Right : this.GetBorder(1),
Bottom : this.GetBorder(2),
Left : this.GetBorder(3)
};
};
CTableCell.prototype.CheckContentControlEditingLock = function()
{
if (this.Row && this.Row.Table && this.Row.Table.Parent && this.Row.Table.Parent.CheckContentControlEditingLock)
this.Row.Table.Parent.CheckContentControlEditingLock();
};
/**
* @returns {AscWord.CBorder}
*/
CTableCell.prototype.GetBottomBorder = function()
{
return this.GetBorder(2);
};
/**
* Запрашиваем пересчет сетки таблицы
*/
CTableCell.prototype.private_UpdateTableGrid = function()
{
var oTable = this.GetTable();
if (oTable)
oTable.private_UpdateTableGrid();
};
/**
* Копируем настройки текста и параграфа из заданной ячейки
* @param {CTableCell} oCell
*/
CTableCell.prototype.CopyParaPrAndTextPr = function(oCell)
{
// Копируем также текстовые настройки и настройки параграфа
var oFirstPara = oCell.GetContent().GetFirstParagraph();
if (oFirstPara)
{
var oCellContent = this.GetContent();
var arrAllParagraphs = oCellContent.GetAllParagraphs({All : true});
for (var nParaIndex = 0, nParasCount = arrAllParagraphs.length; nParaIndex < nParasCount; ++nParaIndex)
{
var oTempPara = arrAllParagraphs[nParaIndex];
oTempPara.SetDirectParaPr(oFirstPara.GetDirectParaPr(true));
oTempPara.SetDirectTextPr(oFirstPara.GetFirstRunPr(), false);
}
}
};
CTableCell.prototype.private_GetRowTopMargin = function()
{
var oRow = this.GetRow();
if (!oRow)
return 0;
var nTop = null;
for (var nCurCell = 0, nCellsCount = oRow.GetCellsCount(); nCurCell < nCellsCount; ++nCurCell)
{
var oCell = oRow.GetCell(nCurCell);
var oMargins = oCell.GetMargins(true);
if (null === nTop || nTop < oMargins.Top.W)
nTop = oMargins.Top.W;
}
return nTop;
};
CTableCell.prototype.OnContentChange = function()
{
let table = this.GetTable();
if (table)
table.OnContentChange();
};
CTableCell.prototype.PreDelete = function()
{
this.Content.PreDelete();
};
function CTableCellRecalculateObject()
{
this.BorderInfo = null;
this.Metrics = null;
this.Temp = null;
this.Content = null;
}
CTableCellRecalculateObject.prototype =
{
Save : function(Cell)
{
this.BorderInfo = Cell.BorderInfo;
this.Metrics = Cell.Metrics;
this.Temp = Cell.Temp;
this.Content = Cell.Content.SaveRecalculateObject();
},
Load : function(Cell)
{
Cell.BorderInfo = this.BorderInfo;
Cell.Metrics = this.Metrics;
Cell.Temp = this.Temp;
Cell.Content.LoadRecalculateObject( this.Content );
},
Get_DrawingFlowPos : function(FlowPos)
{
this.Content.Get_DrawingFlowPos( FlowPos );
}
};
//--------------------------------------------------------export----------------------------------------------------
window['AscCommonWord'] = window['AscCommonWord'] || {};
window['AscCommonWord'].CTableCell = CTableCell;
window['AscWord'].CTableCell = CTableCell;
window['AscWord'].TableCell = CTableCell;
Reference in New Issue View Git Blame Copy Permalink