39 #include <osl/diagnose.h>
71 #define NETSCAPE_DFLT_BORDER 1
72 #define NETSCAPE_DFLT_CELLSPACING 2
74 using ::editeng::SvxBorderLine;
89 struct HTMLTableOptions
94 sal_uInt16 nCellPadding;
95 sal_uInt16 nCellSpacing;
105 bool bPercentWidth : 1;
106 bool bTableAdjust : 1;
112 OUString aBGImage, aStyle,
aId, aClass, aDir;
117 class HTMLTableContext
123 std::unique_ptr<SwPosition> m_pPos;
125 size_t m_nContextStAttrMin;
126 size_t m_nContextStMin;
128 bool m_bRestartPRE : 1;
129 bool m_bRestartXMP : 1;
130 bool m_bRestartListing : 1;
132 HTMLTableContext(
const HTMLTableContext&) =
delete;
133 HTMLTableContext& operator=(
const HTMLTableContext&) =
delete;
137 std::shared_ptr<HTMLAttrTable> m_xAttrTab;
139 HTMLTableContext(
SwPosition *pPs,
size_t nCntxtStMin,
140 size_t nCntxtStAttrMin ) :
141 m_pTableNd( nullptr ),
142 m_pFrameFormat( nullptr ),
144 m_nContextStAttrMin( nCntxtStAttrMin ),
145 m_nContextStMin( nCntxtStMin ),
146 m_bRestartPRE(
false ),
147 m_bRestartXMP(
false ),
148 m_bRestartListing(
false ),
160 SwPosition *GetPos()
const {
return m_pPos.get(); }
162 void SetTableNode(
SwTableNode *pNd ) { m_pTableNd = pNd; }
163 SwTableNode *GetTableNode()
const {
return m_pTableNd; }
165 void SetFrameFormat(
SwFrameFormat *pFormat ) { m_pFrameFormat = pFormat; }
166 SwFrameFormat *GetFrameFormat()
const {
return m_pFrameFormat; }
168 size_t GetContextStMin()
const {
return m_nContextStMin; }
169 size_t GetContextStAttrMin()
const {
return m_nContextStAttrMin; }
194 explicit HTMLTableCnts(
const std::shared_ptr<HTMLTable>& rTab);
204 void Add( std::unique_ptr<HTMLTableCnts> pNewCnts );
222 std::shared_ptr<HTMLTableCnts> m_xContents;
223 std::shared_ptr<SvxBrushItem> m_xBGBrush;
224 std::shared_ptr<SvxBoxItem> m_xBoxItem;
227 sal_uInt32 m_nNumFormat;
228 sal_uInt16 m_nRowSpan;
229 sal_uInt16 m_nColSpan;
231 sal_Int16 m_eVertOrient;
232 bool m_bProtected : 1;
233 bool m_bRelWidth : 1;
234 bool m_bHasNumFormat : 1;
235 bool m_bHasValue : 1;
244 void Set( std::shared_ptr<HTMLTableCnts>
const& rCnts, sal_uInt16 nRSpan, sal_uInt16 nCSpan,
245 sal_Int16 eVertOri, std::shared_ptr<SvxBrushItem>
const& rBGBrush,
246 std::shared_ptr<SvxBoxItem>
const& rBoxItem,
247 bool bHasNumFormat, sal_uInt32 nNumFormat,
248 bool bHasValue,
double nValue,
bool bNoWrap,
bool bCovered );
254 void SetContents(std::shared_ptr<HTMLTableCnts>
const& rCnts) { m_xContents = rCnts; }
255 const std::shared_ptr<HTMLTableCnts>& GetContents()
const {
return m_xContents; }
258 void SetRowSpan( sal_uInt16 nRSpan ) { m_nRowSpan = nRSpan; }
259 sal_uInt16 GetRowSpan()
const {
return m_nRowSpan; }
261 void SetColSpan( sal_uInt16 nCSpan ) { m_nColSpan = nCSpan; }
262 sal_uInt16 GetColSpan()
const {
return m_nColSpan; }
264 inline void SetWidth( sal_uInt16 nWidth,
bool bRelWidth );
266 const std::shared_ptr<SvxBrushItem>& GetBGBrush()
const {
return m_xBGBrush; }
267 const std::shared_ptr<SvxBoxItem>& GetBoxItem()
const {
return m_xBoxItem; }
269 inline bool GetNumFormat( sal_uInt32& rNumFormat )
const;
270 inline bool GetValue(
double& rValue )
const;
272 sal_Int16 GetVertOri()
const {
return m_eVertOrient; }
275 bool IsUsed()
const {
return m_xContents || m_bProtected; }
277 std::unique_ptr<SwHTMLTableLayoutCell> CreateLayoutInfo();
279 bool IsCovered()
const {
return mbCovered; }
290 std::vector<HTMLTableCell> m_aCells;
291 std::unique_ptr<SvxBrushItem> m_xBGBrush;
294 sal_uInt16 m_nHeight;
295 sal_uInt16 m_nEmptyRows;
296 sal_Int16 m_eVertOri;
297 bool m_bIsEndOfGroup : 1;
298 bool m_bBottomBorder : 1;
302 explicit HTMLTableRow( sal_uInt16 nCells );
304 void SetBottomBorder(
bool bIn) { m_bBottomBorder = bIn; }
305 bool GetBottomBorder()
const {
return m_bBottomBorder; }
307 inline void SetHeight( sal_uInt16 nHeight );
308 sal_uInt16 GetHeight()
const {
return m_nHeight; }
310 const HTMLTableCell& GetCell(sal_uInt16 nCell)
const;
311 HTMLTableCell& GetCell(sal_uInt16 nCell)
313 return const_cast<HTMLTableCell&
>(
const_cast<const HTMLTableRow&
>(*this).GetCell(nCell));
316 void SetAdjust(
SvxAdjust eAdj ) { m_eAdjust = eAdj; }
317 SvxAdjust GetAdjust()
const {
return m_eAdjust; }
319 void SetVertOri( sal_Int16 eV) { m_eVertOri = eV; }
320 sal_Int16 GetVertOri()
const {
return m_eVertOri; }
322 void SetBGBrush(std::unique_ptr<SvxBrushItem>& rBrush ) { m_xBGBrush = std::move(rBrush); }
323 const std::unique_ptr<SvxBrushItem>& GetBGBrush()
const {
return m_xBGBrush; }
325 void SetEndOfGroup() { m_bIsEndOfGroup =
true; }
326 bool IsEndOfGroup()
const {
return m_bIsEndOfGroup; }
328 void IncEmptyRows() { m_nEmptyRows++; }
329 sal_uInt16 GetEmptyRows()
const {
return m_nEmptyRows; }
332 void Expand( sal_uInt16 nCells,
bool bOneCell=
false );
335 void Shrink( sal_uInt16 nCells );
339 class HTMLTableColumn
341 bool m_bIsEndOfGroup;
347 sal_Int16 m_eVertOri;
351 static inline sal_uInt16 GetFrameFormatIdx(
bool bBorderLine,
352 sal_Int16 eVertOri );
360 inline void SetWidth( sal_uInt16 nWidth,
bool bRelWidth);
362 void SetAdjust(
SvxAdjust eAdj ) { m_eAdjust = eAdj; }
363 SvxAdjust GetAdjust()
const {
return m_eAdjust; }
365 void SetVertOri( sal_Int16 eV) { m_eVertOri = eV; }
366 sal_Int16 GetVertOri()
const {
return m_eVertOri; }
368 void SetEndOfGroup() { m_bIsEndOfGroup =
true; }
369 bool IsEndOfGroup()
const {
return m_bIsEndOfGroup; }
371 inline void SetFrameFormat(
SwFrameFormat *pFormat,
bool bBorderLine,
372 sal_Int16 eVertOri );
374 sal_Int16 eVertOri )
const;
376 std::unique_ptr<SwHTMLTableLayoutColumn> CreateLayoutInfo();
469 void InitCtor(
const HTMLTableOptions& rOptions);
475 void ProtectRowSpan( sal_uInt16 nRow, sal_uInt16 nCol, sal_uInt16 nRowSpan );
486 sal_uInt16 nRowSpan, sal_uInt16 nColSpan,
487 bool bFirstPara=
true,
bool bLastPara=
true )
const;
499 sal_uInt16 nTopRow, sal_uInt16 nLeftCol,
500 sal_uInt16 nBottomRow, sal_uInt16 nRightCol );
505 sal_uInt16 nTopRow, sal_uInt16 nLeftCol,
506 sal_uInt16 nBootomRow, sal_uInt16 nRightCol );
512 sal_uInt16 nRow, sal_uInt16 nCol,
514 bool bFirstPara,
bool bLastPara );
518 sal_uInt16 nCol, sal_uInt16 nColSpan );
530 bool bWithDistance=
false )
const;
539 bool bParHead,
bool bHasParentSec,
541 const HTMLTableOptions& rOptions);
546 const HTMLTableCell&
GetCell(sal_uInt16 nRow, sal_uInt16 nCell)
const;
547 HTMLTableCell&
GetCell(sal_uInt16 nRow, sal_uInt16 nCell)
549 return const_cast<HTMLTableCell&
>(
const_cast<const HTMLTable&
>(*this).
GetCell(nRow, nCell));
559 return (m_bTableAdjustOfTag || bAny) ? m_eTableAdjust : SvxAdjust::End;
570 void InsertCell( std::shared_ptr<HTMLTableCnts>
const& rCnts, sal_uInt16 nRowSpan, sal_uInt16 nColSpan,
571 sal_uInt16 nWidth,
bool bRelWidth, sal_uInt16 nHeight,
572 sal_Int16 eVertOri, std::shared_ptr<SvxBrushItem>
const& rBGBrushItem,
573 std::shared_ptr<SvxBoxItem>
const& rBoxItem,
574 bool bHasNumFormat, sal_uInt32 nNumFormat,
575 bool bHasValue,
double nValue,
bool bNoWrap );
578 void OpenRow(
SvxAdjust eAdjust, sal_Int16 eVertOri, std::unique_ptr<SvxBrushItem>& rBGBrush);
585 inline void CloseColGroup( sal_uInt16 nSpan, sal_uInt16 nWidth,
bool bRelWidth,
589 void InsertCol( sal_uInt16 nSpan, sal_uInt16 nWidth,
bool bRelWidth,
597 sal_uInt16 nRelAvail=0, sal_uInt16 nAbsLeftSpace=0,
598 sal_uInt16 nAbsRightSpace=0, sal_uInt16 nInhAbsSpace=0 );
600 bool IsNewDoc()
const {
return m_pParser->IsNewDoc(); }
605 void SetParentContents(std::unique_ptr<HTMLTableCnts> pCnts) { m_xParentContents = std::move(pCnts); }
613 sal_uInt16 nLeft, sal_uInt16 nRight,
614 const SwTable *pSwTab=
nullptr,
bool bFrcFrame=
false );
616 HTMLTableContext *
GetContext()
const {
return m_pContext.get(); }
647 : m_pStartNode(pStNd)
653 : m_pStartNode(nullptr)
672 pCnts->
m_pNext = std::move(pNewCnts);
686 std::shared_ptr<SwHTMLTableLayoutCnts> xNextInfo;
688 xNextInfo =
m_pNext->CreateLayoutInfo();
689 std::shared_ptr<SwHTMLTableLayout> xTableInfo;
691 xTableInfo =
m_xTable->CreateLayoutInfo();
698 HTMLTableCell::HTMLTableCell():
704 m_eVertOrient(
text::VertOrientation::
NONE ),
706 m_bRelWidth(
false ),
707 m_bHasNumFormat(
false),
713 void HTMLTableCell::Set( std::shared_ptr<HTMLTableCnts>
const& rCnts, sal_uInt16 nRSpan, sal_uInt16 nCSpan,
714 sal_Int16 eVert, std::shared_ptr<SvxBrushItem>
const& rBrush,
715 std::shared_ptr<SvxBoxItem>
const& rBoxItem,
716 bool bHasNF, sal_uInt32 nNF,
bool bHasV,
double nVal,
717 bool bNWrap,
bool bCovered )
722 m_bProtected =
false;
723 m_eVertOrient = eVert;
725 m_xBoxItem = rBoxItem;
727 m_bHasNumFormat = bHasNF;
733 mbCovered = bCovered;
736 inline void HTMLTableCell::SetWidth( sal_uInt16 nWdth,
bool bRelWdth )
739 m_bRelWidth = bRelWdth;
742 void HTMLTableCell::SetProtected()
751 m_xBGBrush = std::make_shared<SvxBrushItem>(*m_xBGBrush);
758 inline bool HTMLTableCell::GetNumFormat( sal_uInt32& rNumFormat )
const
760 rNumFormat = m_nNumFormat;
761 return m_bHasNumFormat;
764 inline bool HTMLTableCell::GetValue(
double& rValue )
const
770 std::unique_ptr<SwHTMLTableLayoutCell> HTMLTableCell::CreateLayoutInfo()
772 std::shared_ptr<SwHTMLTableLayoutCnts> xCntInfo;
774 xCntInfo = m_xContents->CreateLayoutInfo();
775 return std::unique_ptr<SwHTMLTableLayoutCell>(
new SwHTMLTableLayoutCell(xCntInfo, m_nRowSpan, m_nColSpan, m_nWidth,
776 m_bRelWidth, m_bNoWrap));
779 HTMLTableRow::HTMLTableRow(sal_uInt16
const nCells)
784 , m_eVertOri(
text::VertOrientation::
TOP)
785 , m_bIsEndOfGroup(
false)
786 , m_bBottomBorder(
false)
788 assert(nCells == m_aCells.size() &&
789 "wrong Cell count in new HTML table row");
792 inline void HTMLTableRow::SetHeight( sal_uInt16 nHght )
794 if( nHght > m_nHeight )
798 const HTMLTableCell& HTMLTableRow::GetCell(sal_uInt16 nCell)
const
800 OSL_ENSURE( nCell < m_aCells.size(),
801 "invalid cell index in HTML table row" );
802 return m_aCells.at(nCell);
805 void HTMLTableRow::Expand( sal_uInt16 nCells,
bool bOneCell )
810 sal_uInt16 nColSpan = nCells - m_aCells.size();
811 for (sal_uInt16 i = m_aCells.size();
i < nCells; ++
i)
813 m_aCells.emplace_back();
815 m_aCells.back().SetColSpan(nColSpan);
819 OSL_ENSURE(nCells == m_aCells.size(),
820 "wrong Cell count in expanded HTML table row");
823 void HTMLTableRow::Shrink( sal_uInt16 nCells )
825 OSL_ENSURE(nCells < m_aCells.size(),
"number of cells too large");
827 #if OSL_DEBUG_LEVEL > 0
828 sal_uInt16
const nEnd = m_aCells.size();
835 HTMLTableCell& rCell = m_aCells[--i];
836 if (!rCell.GetContents())
838 #if OSL_DEBUG_LEVEL > 0
839 OSL_ENSURE( rCell.GetColSpan() == nEnd - i,
840 "invalid col span for empty cell at row end" );
842 rCell.SetColSpan( nCells-i);
847 #if OSL_DEBUG_LEVEL > 0
848 for( i=nCells; i<nEnd; i++ )
850 HTMLTableCell& rCell = m_aCells[i];
851 OSL_ENSURE( rCell.GetRowSpan() == 1,
852 "RowSpan of to be deleted cell is wrong" );
853 OSL_ENSURE( rCell.GetColSpan() == nEnd - i,
854 "ColSpan of to be deleted cell is wrong" );
855 OSL_ENSURE( !rCell.GetContents(),
"To be deleted cell has content" );
859 m_aCells.erase(m_aCells.begin() + nCells, m_aCells.end());
862 HTMLTableColumn::HTMLTableColumn():
863 m_bIsEndOfGroup(
false),
864 m_nWidth(0), m_bRelWidth(
false),
872 inline void HTMLTableColumn::SetWidth( sal_uInt16 nWdth,
bool bRelWdth )
874 if( m_bRelWidth==bRelWdth )
876 if( nWdth > m_nWidth )
881 m_bRelWidth = bRelWdth;
884 inline std::unique_ptr<SwHTMLTableLayoutColumn> HTMLTableColumn::CreateLayoutInfo()
886 return std::unique_ptr<SwHTMLTableLayoutColumn>(
new SwHTMLTableLayoutColumn( m_nWidth, m_bRelWidth, m_bLeftBorder ));
889 inline sal_uInt16 HTMLTableColumn::GetFrameFormatIdx(
bool bBorderLine,
890 sal_Int16 eVertOrient )
892 OSL_ENSURE( text::VertOrientation::TOP != eVertOrient,
"Top is not allowed" );
893 sal_uInt16
n = bBorderLine ? 3 : 0;
894 switch( eVertOrient )
896 case text::VertOrientation::CENTER: n+=1;
break;
897 case text::VertOrientation::BOTTOM: n+=2;
break;
904 inline void HTMLTableColumn::SetFrameFormat(
SwFrameFormat *pFormat,
bool bBorderLine,
905 sal_Int16 eVertOrient )
907 m_aFrameFormats[GetFrameFormatIdx(bBorderLine,eVertOrient)] = pFormat;
910 inline SwFrameFormat *HTMLTableColumn::GetFrameFormat(
bool bBorderLine,
911 sal_Int16 eVertOrient )
const
913 return m_aFrameFormats[GetFrameFormatIdx(bBorderLine,eVertOrient)];
939 const Color& rBorderColor = rOptions.aBorderColor;
944 tools::Long nPHeight = nBorderOpt==USHRT_MAX ? 0 : nBorderOpt;
950 m_nBorder = o3tl::narrowing<sal_uInt16>(nPWidth);
951 if( nBorderOpt==USHRT_MAX )
954 if ( rOptions.nCellSpacing != 0 )
962 if( nPWidth == nPHeight )
968 if ( rOptions.nCellSpacing != 0 )
977 if( rOptions.nCellSpacing != 0 )
978 m_aBorderLine.SetBorderLineStyle(SvxBorderLineStyle::DOUBLE);
1000 nPWidth = rOptions.nHSpace;
1001 nPHeight = rOptions.nVSpace;
1003 m_nHSpace = o3tl::narrowing<sal_uInt16>(nPWidth);
1004 m_nVSpace = o3tl::narrowing<sal_uInt16>(nPHeight);
1009 rOptions.bBGColor ? &(rOptions.aBGColor) :
nullptr,
1010 rOptions.aBGImage, OUString(), OUString(), OUString()));
1015 m_aId = rOptions.aId;
1023 bool bHasParentSec,
bool bHasToFlw,
1024 const HTMLTableOptions& rOptions) :
1025 m_aColumns(rOptions.nCols),
1026 m_nCols(rOptions.nCols),
1027 m_nFilledColumns( 0 ),
1028 m_nCellPadding(rOptions.nCellPadding),
1029 m_nCellSpacing(rOptions.nCellSpacing),
1031 m_pCaptionStartNode( nullptr ),
1032 m_bTableAdjustOfTag( rOptions.bTableAdjust ),
1033 m_bIsParentHead( bParHead ),
1034 m_bHasParentSection( bHasParentSec ),
1035 m_bHasToFly( bHasToFlw ),
1036 m_bFixedCols( rOptions.nCols>0 ),
1037 m_bPercentWidth( rOptions.bPercentWidth ),
1039 m_nWidth( rOptions.nWidth ),
1040 m_nHeight( rOptions.nHeight ),
1041 m_eTableAdjust( rOptions.eAdjust ),
1042 m_eVertOrientation( rOptions.eVertOri ),
1043 m_eFrame( rOptions.eFrame ),
1044 m_eRules( rOptions.eRules ),
1045 m_bTopCaption(
false ),
1088 for (
size_t i = 0; i < nCount; ++i)
1090 SdrObject *pObj = (*m_xResizeDrawObjects)[i];
1108 sal_uInt16 nLeftBorderWidth =
1110 sal_uInt16 nRightBorderWidth =
1119 nBorderWidth, nLeftBorderWidth, nRightBorderWidth);
1121 bool bExportable =
true;
1125 HTMLTableRow& rRow =
m_aRows[i];
1126 for( sal_uInt16 j=0; j<
m_nCols; j++ )
1128 m_xLayoutInfo->SetCell(rRow.GetCell(j).CreateLayoutInfo(), i, j);
1133 const std::shared_ptr<SwHTMLTableLayoutCnts>& rLayoutCnts =
1135 bExportable = !rLayoutCnts ||
1136 (rLayoutCnts->GetStartNode() && !rLayoutCnts->GetNext());
1158 sal_uInt16 nRowSpan=1;
1161 HTMLTableCell& rCell =
GetCell(nRow, nCol);
1162 if (rCell.GetContents().get() != pCnts)
1164 rCell.SetRowSpan(nRowSpan);
1175 for( sal_uInt16 i=0; i<nRowSpan; i++ )
1177 GetCell(nRow+i,nCol).SetProtected();
1192 pPrevCnts =
GetCell(0, nCol - 1).GetContents().get();
1196 else if( USHRT_MAX==nRow && USHRT_MAX==nCol )
1202 const HTMLTableRow& rPrevRow =
m_aRows[nRow-1];
1209 if( 1 == rPrevRow.GetCell(i).GetRowSpan() )
1211 pPrevCnts =
GetCell(nRow, i).GetContents().get();
1220 while( !pPrevCnts && i )
1223 pPrevCnts = rPrevRow.GetCell(i).GetContents().get();
1227 OSL_ENSURE( pPrevCnts,
"No previous filled cell found" );
1230 pPrevCnts =
GetCell(0, 0).GetContents().get();
1235 while( pPrevCnts->
Next() )
1236 pPrevCnts = pPrevCnts->
Next();
1263 if( nRow+nRowSpan ==
m_nRows )
1272 sal_uInt16 nRow, sal_uInt16 nCol,
1273 sal_uInt16 nRowSpan, sal_uInt16 nColSpan,
1274 bool bFirstPara,
bool bLastPara )
const
1279 std::shared_ptr<SvxBoxItem> pBoxItem;
1280 bool bTopLine =
false, bBottomLine =
false, bLastBottomLine =
false;
1281 bool bReUsable =
false;
1282 sal_uInt16 nEmptyRows = 0;
1283 bool bHasNumFormat =
false;
1284 bool bHasValue =
false;
1285 sal_uInt32 nNumFormat = 0;
1288 const HTMLTableColumn& rColumn =
m_aColumns[nCol];
1293 const HTMLTableCell& rCell =
GetCell(nRow, nCol);
1294 pBoxItem = rCell.GetBoxItem();
1295 pBGBrushItem = rCell.GetBGBrush().get();
1301 pBGBrushItem =
m_aRows[nRow].GetBGBrush().get();
1306 if (
m_aRows[nRow+nRowSpan-1].GetBottomBorder() && bLastPara)
1308 nEmptyRows =
m_aRows[nRow+nRowSpan-1].GetEmptyRows();
1309 if( nRow+nRowSpan ==
m_nRows )
1310 bLastBottomLine =
true;
1315 eVOri = rCell.GetVertOri();
1316 bHasNumFormat = rCell.GetNumFormat( nNumFormat );
1318 bHasValue = rCell.GetValue( nValue );
1320 if( nColSpan==1 && !bTopLine && !bLastBottomLine && !nEmptyRows &&
1321 !pBGBrushItem && !bHasNumFormat && !pBoxItem)
1323 pFrameFormat = rColumn.GetFrameFormat( bBottomLine, eVOri );
1324 bReUsable = !pFrameFormat;
1334 ->GetRelColWidth());
1335 for( sal_uInt16 i=1; i<nColSpan; i++ )
1336 nFrameWidth += static_cast<SwTwips>(
m_xLayoutInfo->GetColumn(nCol+i)
1337 ->GetRelColWidth());
1354 if( bLastBottomLine )
1359 else if( bBottomLine )
1367 nBorderWidth *= (nEmptyRows + 1);
1368 aThickBorderLine.SetBorderLineStyle(SvxBorderLineStyle::SOLID);
1369 aThickBorderLine.SetWidth( nBorderWidth );
1370 aBoxItem.
SetLine( &aThickBorderLine, SvxBoxItemLine::BOTTOM );
1380 const SvxBorderLine& rBorderLine =
1382 aBoxItem.
SetLine( &rBorderLine, SvxBoxItemLine::LEFT );
1400 sal_uInt16 nBDist =
static_cast< sal_uInt16
>(
1402 : (nInnerFrameWidth / 2) );
1419 if( bHasNumFormat && (bHasValue || pBox->
IsEmpty()) )
1449 else if( pCNd && SvxAdjust::End != eAdjust )
1458 OSL_ENSURE( eVOri != text::VertOrientation::TOP,
"text::VertOrientation::TOP is not allowed!" );
1467 const_cast<HTMLTableColumn&
>(rColumn).SetFrameFormat(pFrameFormat, bBottomLine, eVOri);
1489 const_cast<SfxItemSet&>(static_cast<SfxItemSet const&>(
1501 "Box without content has vertical orientation" );
1502 pBox->
ChgFrameFormat( static_cast<SwTableBoxFormat*>(pFrameFormat) );
1530 "Cell has vertical orientation" );
1535 sal_uInt16 nTopRow, sal_uInt16 nLeftCol,
1536 sal_uInt16 nBottomRow, sal_uInt16 nRightCol )
1539 if (!pUpper && 0 == nTopRow)
1546 const HTMLTableRow& rTopRow =
m_aRows[nTopRow];
1547 sal_uInt16 nRowHeight = rTopRow.GetHeight();
1549 if (nTopRow > 0 || nBottomRow <
m_nRows)
1553 pBGBrushItem = rTopRow.GetBGBrush().get();
1555 if( nTopRow==nBottomRow-1 && (nRowHeight || pBGBrushItem) )
1586 sal_uInt16 nStartCol = nLeftCol;
1587 while( nStartCol<nRightCol )
1589 sal_uInt16 nCol = nStartCol;
1590 sal_uInt16 nSplitCol = nRightCol;
1591 bool bSplitted =
false;
1594 OSL_ENSURE( nCol < nRightCol,
"Gone too far" );
1596 HTMLTableCell& rCell =
GetCell(nTopRow,nCol);
1597 const bool bSplit = 1 == rCell.GetColSpan();
1599 OSL_ENSURE((nCol != nRightCol-1) || bSplit,
"Split-Flag wrong");
1603 HTMLTableCell& rCell2 =
GetCell(nTopRow, nStartCol);
1604 if (rCell2.GetColSpan() == (nCol+1-nStartCol))
1607 nSplitCol = nCol + 1;
1609 sal_Int32 nBoxRowSpan = rCell2.GetRowSpan();
1610 if (!rCell2.GetContents() || rCell2.IsCovered())
1612 if (rCell2.IsCovered())
1613 nBoxRowSpan = -1 * nBoxRowSpan;
1617 auto xCnts = std::make_shared<HTMLTableCnts>(
1619 const std::shared_ptr<SwHTMLTableLayoutCnts> xCntsLayoutInfo =
1620 xCnts->CreateLayoutInfo();
1622 rCell2.SetContents(xCnts);
1625 if( nBoxRowSpan < 0 )
1629 for( sal_uInt16 j=nStartCol+1; j<nSplitCol; j++ )
1631 GetCell(nTopRow, j).SetContents(xCnts);
1633 ->SetContents(xCntsLayoutInfo);
1639 nBottomRow, nSplitCol);
1641 if (1 != nBoxRowSpan && pBox)
1647 OSL_ENSURE( pBox,
"Colspan trouble" );
1650 rBoxes.push_back( pBox );
1654 nStartCol = nSplitCol;
1662 sal_uInt16 nTopRow, sal_uInt16 nLeftCol,
1663 sal_uInt16 nBottomRow, sal_uInt16 nRightCol )
1666 sal_uInt16 nColSpan = nRightCol - nLeftCol;
1667 sal_uInt16 nRowSpan = nBottomRow - nTopRow;
1669 if( !pCnts->
Next() )
1680 pTable->InheritVertBorders(
this, nLeftCol,
1681 nRightCol-nLeftCol );
1685 sal_uInt16 nAbs, nRel;
1687 sal_uInt16 nLSpace =
m_xLayoutInfo->GetLeftCellSpace( nLeftCol, nColSpan );
1688 sal_uInt16 nRSpace =
m_xLayoutInfo->GetRightCellSpace( nLeftCol, nColSpan );
1689 sal_uInt16 nInhSpace =
m_xLayoutInfo->GetInhCellSpace( nLeftCol, nColSpan );
1690 pCnts->
GetTable()->MakeTable( pBox, nAbs, nRel, nLSpace, nRSpace,
1703 bool bFirstPara =
true;
1725 bFirstPara,
nullptr==pCnts->
Next() );
1732 pCnts->
GetTable()->InheritVertBorders(
this, nLeftCol,
1733 nRightCol-nLeftCol );
1735 sal_uInt16 nAbs, nRel;
1737 sal_uInt16 nLSpace =
m_xLayoutInfo->GetLeftCellSpace( nLeftCol,
1739 sal_uInt16 nRSpace =
m_xLayoutInfo->GetRightCellSpace( nLeftCol,
1741 sal_uInt16 nInhSpace =
m_xLayoutInfo->GetInhCellSpace( nLeftCol, nColSpan );
1742 pCnts->
GetTable()->MakeTable( pBox, nAbs, nRel, nLSpace,
1743 nRSpace, nInhSpace );
1746 pCnts = pCnts->
Next();
1757 sal_uInt16 nRow, sal_uInt16 nCol,
1758 sal_uInt16 nRowSpan,
1759 bool bFirstPara,
bool bLastPara )
1762 "Was CloseTable not called?" );
1775 if (pParent->
m_aRows[nRow+nRowSpan-1].GetBottomBorder() && bLastPara)
1787 (0==nRow || !pParent->
m_aRows[nRow-1].GetBottomBorder())) );
1791 if( !pInhBG && pParent !=
this &&
1796 pInhBG = pParent->
m_aRows[nRow].GetBGBrush().get();
1807 sal_uInt16 nCol, sal_uInt16 nColSpan )
1809 sal_uInt16 nInhLeftBorderWidth = 0;
1810 sal_uInt16 nInhRightBorderWidth = 0;
1816 nInhRightBorderWidth =
1825 nInhLeftBorderWidth =
1834 nInhRightBorderWidth );
1837 (nCol+nColSpan==pParent->
m_nCols ||
1838 !pParent->
m_aColumns[nCol+nColSpan].m_bLeftBorder) );
1857 m_aRows[i].SetBottomBorder(
true);
1866 m_aRows[m_nRows-1].SetBottomBorder(
true);
1878 HTMLTableRow& rRow =
m_aRows[i];
1879 for (sal_uInt16 j=0; j<
m_nCols; ++j)
1881 HTMLTableCell& rCell = rRow.GetCell(j);
1882 if (rCell.GetContents())
1885 bool bFirstPara =
true;
1894 nullptr==pCnts->
Next());
1898 pCnts = pCnts->
Next();
1908 bool bWithDistance )
const
1915 else if( nBorderWidth )
1919 return nBorderWidth;
1924 OSL_ENSURE(nRow <
m_aRows.size(),
"invalid row index in HTML table");
1925 return m_aRows[nRow].GetCell(nCell);
1932 if( SvxAdjust::End==eAdjust )
1944 if( text::VertOrientation::TOP==eVOri )
1947 OSL_ENSURE(
m_eVertOrientation != text::VertOrientation::TOP,
"text::VertOrientation::TOP is not allowed!" );
1952 sal_uInt16 nRowSpan, sal_uInt16 nColSpan,
1953 sal_uInt16 nCellWidth,
bool bRelWidth, sal_uInt16 nCellHeight,
1954 sal_Int16 eVertOrient, std::shared_ptr<SvxBrushItem>
const& rBGBrushItem,
1955 std::shared_ptr<SvxBoxItem>
const& rBoxItem,
1956 bool bHasNumFormat, sal_uInt32 nNumFormat,
1957 bool bHasValue,
double nValue,
bool bNoWrap )
1959 if( !nRowSpan || static_cast<sal_uInt32>(
m_nCurrentRow) + nRowSpan > USHRT_MAX )
1962 if( !nColSpan || static_cast<sal_uInt32>(
m_nCurrentColumn) + nColSpan > USHRT_MAX )
1977 "wrong number of columns after expanding");
1985 for( i=
m_nRows; i<nRowsReq; i++ )
1988 OSL_ENSURE(
m_nRows ==
m_aRows.size(),
"wrong number of rows in Insert");
1992 sal_uInt16 nSpanedCols = 0;
1998 HTMLTableCell& rCell = rCurRow.GetCell(i);
1999 if (rCell.GetContents())
2004 nSpanedCols = i + rCell.GetColSpan();
2006 if (rCell.GetRowSpan() > nRowSpan)
2008 rCell.GetRowSpan()-nRowSpan );
2011 for( i=nColsReq; i<nSpanedCols; i++ )
2014 HTMLTableCell& rCell = rCurRow.GetCell(i);
2021 for( i=nColSpan; i>0; i-- )
2023 for( j=nRowSpan; j>0; j-- )
2025 const bool bCovered = i != nColSpan || j != nRowSpan;
2026 GetCell( nRowsReq-j, nColsReq-i )
2027 .Set( rCnts, j, i, eVertOrient, rBGBrushItem, rBoxItem,
2028 bHasNumFormat, nNumFormat, bHasValue, nValue, bNoWrap, bCovered );
2032 Size aTwipSz( bRelWidth ? 0 : nCellWidth, nCellHeight );
2042 sal_uInt16 nTmp = bRelWidth ? nCellWidth : o3tl::narrowing<sal_uInt16>(aTwipSz.
Width());
2047 if( nCellHeight && 1==nRowSpan )
2073 std::unique_ptr<SvxBrushItem>& rBGBrushItem)
2080 for( sal_uInt16 i=
m_nRows; i<nRowsReq; i++ )
2084 "Row number in OpenRow is wrong" );
2088 rCurRow.SetAdjust(eAdjust);
2089 rCurRow.SetVertOri(eVertOrient);
2120 HTMLTableCell& rCell = rRow.GetCell(--i);
2121 if (!rCell.GetContents())
2123 sal_uInt16 nColSpan =
m_nCols-i;
2125 rCell.SetColSpan(nColSpan);
2136 sal_Int16 eVertOrient )
2139 InsertCol( nSpan, _nWidth, bRelWidth, eAdjust, eVertOrient );
2147 SvxAdjust eAdjust, sal_Int16 eVertOrient )
2166 Size aTwipSz( bRelWidth ? 0 : nColWidth, 0 );
2176 sal_uInt16 nTmp = bRelWidth ? nColWidth : o3tl::narrowing<sal_uInt16>(aTwipSz.
Width());
2177 rCol.SetWidth( nTmp, bRelWidth );
2178 rCol.SetAdjust( eAdjust );
2179 rCol.SetVertOri( eVertOrient );
2199 HTMLTableCell& rCell = rPrevRow.GetCell(i);
2200 if (rCell.GetRowSpan() > 1)
2243 for( sal_uInt16 i=0; i<
m_nRows; i++ )
2282 sal_uInt16 nRelAvail, sal_uInt16 nAbsLeftSpace,
2283 sal_uInt16 nAbsRightSpace, sal_uInt16 nInhAbsSpace )
2286 "Was CloseTable not called?" );
2288 OSL_ENSURE(
m_xLayoutInfo ==
nullptr,
"Table already has layout info");
2306 m_xLayoutInfo->AutoLayoutPass2( nAbsAvail, nRelAvail, nAbsLeftSpace,
2307 nAbsRightSpace, nInhAbsSpace );
2316 eHoriOri =
m_bPercentWidth ? text::HoriOrientation::FULL : text::HoriOrientation::LEFT;
2323 case SvxAdjust::Right:
2325 eHoriOri = text::HoriOrientation::RIGHT;
2327 case SvxAdjust::Center:
2329 eHoriOri = text::HoriOrientation::CENTER;
2331 case SvxAdjust::Left:
2334 eHoriOri =
m_nLeftMargin ? text::HoriOrientation::LEFT_AND_WIDTH : text::HoriOrientation::LEFT;
2347 if (text::HoriOrientation::LEFT_AND_WIDTH == eHoriOri)
2350 "There are still leftovers from relative margins" );
2405 if (eAdjust != SvxAdjust::Left &&
2406 eAdjust != SvxAdjust::Right)
2411 OSL_ENSURE(
HasToFly(),
"Why is the table in a frame?" );
2413 if( nMin > USHRT_MAX )
2417 m_pContext->GetFrameFormat()->SetFormatAttr( aFlyFrameSize );
2418 bIsInFlyFrame =
false;
2425 if(
m_pContext->GetFrameFormat()->GetAnchor().GetContentAnchor()
2426 ->nNode.GetNode().FindTableNode() )
2429 if( nMax > USHRT_MAX )
2432 m_pContext->GetFrameFormat()->SetFormatAttr( aFlyFrameSize );
2433 bIsInFlyFrame =
false;
2449 SAL_WARN(
"sw.html",
"no table box");
2457 for( sal_uInt16 i=0; i<nCount; i++ )
2459 SdrObject *pObj = (*m_xResizeDrawObjects)[i];
2460 sal_uInt16 nRow = (*m_xDrawObjectPercentWidths)[3*i];
2461 sal_uInt16 nCol = (*m_xDrawObjectPercentWidths)[3*i+1];
2462 sal_uInt8 nPercentWidth =
static_cast<sal_uInt8>((*m_xDrawObjectPercentWidths)[3*i+2]);
2466 sal_uInt16 nColSpan = pLayoutCell->
GetColSpan();
2468 sal_uInt16 nWidth2, nDummy;
2470 nWidth2 =
static_cast< sal_uInt16
>((
static_cast<tools::Long>(
m_nWidth) * nPercentWidth) / 100);
2478 sal_uInt16 nLeft, sal_uInt16 nRight,
2479 const SwTable *pSwTab,
bool bFrcFrame )
2516 void HTMLTableContext::SavePREListingXMP(
SwHTMLParser& rParser )
2518 m_bRestartPRE = rParser.IsReadPRE();
2519 m_bRestartXMP = rParser.IsReadXMP();
2520 m_bRestartListing = rParser.IsReadListing();
2521 rParser.FinishPREListingXMP();
2524 void HTMLTableContext::RestorePREListingXMP(
SwHTMLParser& rParser )
2526 rParser.FinishPREListingXMP();
2534 if( m_bRestartListing )
2535 rParser.StartListing();
2541 OSL_ENSURE( pPrevStNd,
"Start-Node is NULL" );
2543 m_pCSS1Parser->SetTDTagStyles();
2547 if (m_xTable->m_bFirstCell )
2549 SwNode *
const pNd = & m_pPam->GetPoint()->nNode.GetNode();
2552 m_xTable->m_bFirstCell =
false;
2564 m_xTable->IncBoxCount();
2568 eState = SvParserState::Error;
2577 pCNd->
SetAttr( aFontHeightCJK );
2579 pCNd->
SetAttr( aFontHeightCTL );
2605 eState = SvParserState::Error;
2617 eState = SvParserState::Error;
2625 pTableNd = pOutTable;
2641 eState = SvParserState::Error;
2651 rIdx =
m_xDoc->GetNodes().GetEndOfExtras();
2663 sal_Int32 nStripped = 0;
2678 sal_Int32
nPos = nLen;
2679 sal_Int32 nLFCount = 0;
2680 while (nPos && (
'\x0a' == pTextNd->
GetText()[--nPos]))
2696 nPos = nLen - nLFCount;
2697 SwIndex nIdx( pTextNd, nPos );
2699 nStripped = nLFCount;
2708 const OUString& rImageURL,
2709 const OUString& rStyle,
2710 const OUString& rId,
2711 const OUString& rClass )
2715 if( !rStyle.isEmpty() || !rId.isEmpty() || !rClass.isEmpty() )
2720 if( !rClass.isEmpty() )
2722 OUString aClass( rClass );
2729 if( !rId.isEmpty() )
2736 m_pCSS1Parser->ParseStyleOption( rStyle, aItemSet, aPropInfo );
2743 if( !pBrushItem && (pColor || !rImageURL.isEmpty()) )
2750 if( !rImageURL.isEmpty() )
2773 #if OSL_DEBUG_LEVEL > 0
2780 m_nBaseFontStMinSave(rParser.m_nBaseFontStMin),
2781 m_nFontStMinSave(rParser.m_nFontStMin),
2782 m_nFontStHeadStartSave(rParser.m_nFontStHeadStart),
2783 m_nDefListDeepSave(rParser.m_nDefListDeep),
2784 m_nContextStMinSave(rParser.m_nContextStMin),
2785 m_nContextStAttrMinSave(rParser.m_nContextStAttrMin)
2818 "The Context Stack was not cleaned up" );
2865 void AddContents( std::unique_ptr<HTMLTableCnts> pNewCnts );
2881 bool bHd,
bool bReadOpt ) :
2883 m_pCurrCnts( nullptr ),
2890 m_nNoBreakEndContentPos( 0 ),
2891 m_eVertOri( pCurTable->GetInheritedVertOri() ),
2893 m_bPercentWidth(
false ),
2894 m_bHasNumFormat(
false ),
2895 m_bHasValue(
false ),
2896 m_bBGColor(
false ),
2900 OUString aNumFormat, aValue, aDir, aLang;
2905 const HTMLOptions& rOptions = rParser.GetOptions();
2906 for (
size_t i = rOptions.size(); i; )
2911 case HtmlOptionId::ID:
2914 case HtmlOptionId::COLSPAN:
2922 case HtmlOptionId::ROWSPAN:
2930 case HtmlOptionId::ALIGN:
2933 case HtmlOptionId::VALIGN:
2936 case HtmlOptionId::WIDTH:
2939 if( m_bPercentWidth &&
m_nWidth>100 )
2942 case HtmlOptionId::HEIGHT:
2944 if( rOption.
GetString().indexOf(
'%') != -1)
2947 case HtmlOptionId::BGCOLOR:
2956 case HtmlOptionId::BACKGROUND:
2959 case HtmlOptionId::STYLE:
2962 case HtmlOptionId::CLASS:
2965 case HtmlOptionId::LANG:
2968 case HtmlOptionId::DIR:
2971 case HtmlOptionId::SDNUM:
2975 case HtmlOptionId::SDVAL:
2979 case HtmlOptionId::NOWRAP:
2986 if( !
m_aId.isEmpty() )
2995 *rParser.
m_xDoc->GetNumberFormatter() );
3004 nToken = HtmlTokenId::TABLEHEADER_ON;
3009 nToken = HtmlTokenId::TABLEDATA_ON;
3012 std::unique_ptr<HTMLAttrContext> xCntxt(
new HTMLAttrContext(nToken, nColl, OUString(),
true));
3013 if( SvxAdjust::End != eAdjust )
3024 aPropInfo, &aLang, &aDir ) )
3031 rParser.
InsertAttrs(aItemSet, aPropInfo, xCntxt.get());
3045 m_xCnts->Add( std::move(pNewCnts) );
3047 m_xCnts = std::move(pNewCnts);
3053 #if OSL_DEBUG_LEVEL > 0
3074 OSL_ENSURE( !*pTable,
"The attribute table isn't empty" );
3080 std::shared_ptr<SvxBrushItem> xBrushItem(
3095 m_xCnts->GetStartNode()->GetIndex() + 1 ==
3137 if(
' '==cLast ||
'\x0a'==cLast )
3167 HTMLAttr** pHTMLAttributes =
reinterpret_cast<HTMLAttr**
>(m_xAttrTab.get());
3170 HTMLAttr *pAttr = *pHTMLAttributes;
3173 OSL_ENSURE( !pAttr->
GetPrev(),
"Attribute has previous list" );
3183 return std::make_unique<HTMLTableCnts>( pStNd );
3204 std::unique_ptr<CellSaveStruct> xSaveStruct;
3207 bool bPending =
false;
3210 xSaveStruct.reset(static_cast<CellSaveStruct*>(
m_vPendingStack.back().pData.release()));
3214 bPending = SvParserState::Error == eState && !
m_vPendingStack.empty();
3216 SaveState( nToken );
3223 SaveState( HtmlTokenId::NONE );
3229 bool bTopTable =
m_xTable.get() == pCurTable;
3242 > aItemSet(
m_xDoc->GetAttrPool() );
3248 aItemSet, aPropInfo,
3253 RES_BACKGROUND,
false ) )
3256 aItemSet.ClearItem( RES_BACKGROUND );
3259 RES_PARATR_SPLIT,
false ) )
3263 aItemSet.ClearItem( RES_PARATR_SPLIT );
3267 sal_uInt16 nLeftSpace = 0;
3268 sal_uInt16 nRightSpace = 0;
3274 bool bForceFrame =
false;
3275 bool bAppended =
false;
3276 bool bParentLFStripped =
false;
3283 bForceFrame = eTableAdjust == SvxAdjust::Left ||
3284 eTableAdjust == SvxAdjust::Right ||
3291 "table in frame has no parent!" );
3293 bool bAppend =
false;
3370 std::unique_ptr<HTMLTableContext> pTCntxt(
3371 new HTMLTableContext( pSavePos, m_nContextStMin,
3372 m_nContextStAttrMin ) );
3375 std::optional<std::deque<std::unique_ptr<HTMLAttr>>> pPostIts;
3384 if( (bTopTable && !bAppended) ||
3385 (!bTopTable && !bParentLFStripped &&
3388 SetAttr( bTopTable, bTopTable, pPostIts ? &*pPostIts :
nullptr );
3393 if( bTopTable && !bAppended )
3396 SetAttr(
true,
true, &*pPostIts );
3404 pTCntxt->SavePREListingXMP( *
this );
3413 aFrameSet(
m_xDoc->GetAttrPool() );
3417 css::text::WrapTextMode eSurround = css::text::WrapTextMode_NONE;
3422 case SvxAdjust::Right:
3423 eHori = text::HoriOrientation::RIGHT;
3424 eSurround = css::text::WrapTextMode_LEFT;
3426 case SvxAdjust::Center:
3427 eHori = text::HoriOrientation::CENTER;
3429 case SvxAdjust::Left:
3430 eSurround = css::text::WrapTextMode_RIGHT;
3433 eHori = text::HoriOrientation::LEFT;
3444 aFrameSet.Put( aFrameSize );
3446 sal_uInt16 nSpace = pCurTable->
GetHSpace();
3459 pTCntxt->SetFrameFormat( pFrameFormat );
3472 "The paragraph after the table is not empty!" );
3476 SwFrameFormat *pFrameFormat = pSwTable ? pSwTable->GetFrameFormat() :
nullptr;
3482 m_xDoc->GetNodes().Delete( aDstIdx );
3486 if (bStyleParsed && pFrameFormat)
3495 SwTextNode *
const pOldTextNd = (!bAppended && !bForceFrame) ?
3498 if (pFrameFormat && pOldTextNd)
3502 if( pPageDescItem && pPageDescItem->
GetPageDesc() )
3511 switch( pBreakItem->GetBreak() )
3513 case SvxBreak::PageBefore:
3514 case SvxBreak::PageAfter:
3515 case SvxBreak::PageBoth:
3525 if( !bAppended && pPostIts )
3532 pTCntxt->SetTableNode( const_cast<SwTableNode *>(pNd->
FindTableNode()) );
3534 auto pTableNode = pTCntxt->GetTableNode();
3535 pCurTable->
SetTable( pTableNode, std::move(pTCntxt),
3536 nLeftSpace, nRightSpace,
3537 pSwTable, bForceFrame );
3539 OSL_ENSURE( !pPostIts,
"unused PostIts" );
3545 bParentLFStripped =
false;
3551 if( !bParentLFStripped )
3566 pCurTable->
SetTable( pStNd, std::move(pTCntxt), nLeftSpace, nRightSpace );
3576 xSaveStruct.reset(
new CellSaveStruct(*
this, pCurTable, bHead, bReadOptions));
3579 SaveState( HtmlTokenId::NONE );
3582 if( nToken == HtmlTokenId::NONE )
3583 nToken = GetNextToken();
3586 while( (IsParserWorking() && !bDone) || bPending )
3588 SaveState( nToken );
3590 nToken = FilterToken( nToken );
3593 "Where is the section??" );
3599 else switch( nToken )
3601 case HtmlTokenId::TABLEHEADER_ON:
3602 case HtmlTokenId::TABLEDATA_ON:
3603 case HtmlTokenId::TABLEROW_ON:
3604 case HtmlTokenId::TABLEROW_OFF:
3605 case HtmlTokenId::THEAD_ON:
3606 case HtmlTokenId::THEAD_OFF:
3607 case HtmlTokenId::TFOOT_ON:
3608 case HtmlTokenId::TFOOT_OFF:
3609 case HtmlTokenId::TBODY_ON:
3610 case HtmlTokenId::TBODY_OFF:
3611 case HtmlTokenId::TABLE_OFF:
3614 case HtmlTokenId::TABLEHEADER_OFF:
3615 case HtmlTokenId::TABLEDATA_OFF:
3618 case HtmlTokenId::TABLE_ON:
3620 bool bHasToFly =
false;
3629 if( !xSaveStruct->IsInSection() )
3633 bool bNeedsSection =
false;
3635 for (
const auto & rOption : rHTMLOptions)
3637 if( HtmlOptionId::ALIGN==rOption.GetToken() )
3640 bNeedsSection = SvxAdjust::Left == eAdjust ||
3641 SvxAdjust::Right == eAdjust;
3647 xSaveStruct->AddContents(
3659 eTabAdjust = m_xAttrTab->pAdjust
3660 ?
static_cast<const SvxAdjustItem&
>(m_xAttrTab->pAdjust->GetItem()).
3665 std::shared_ptr<HTMLTable> xSubTable =
BuildTable(eTabAdjust,
3667 xSaveStruct->IsInSection(),
3669 if( SvParserState::Pending != GetStatus() )
3674 OSL_ENSURE( xSubTable->GetTableAdjust(
false)!= SvxAdjust::Left &&
3675 xSubTable->GetTableAdjust(
false)!= SvxAdjust::Right,
3676 "left or right aligned tables belong in frames" );
3678 auto& rParentContents = xSubTable->GetParentContents();
3679 if (rParentContents)
3681 OSL_ENSURE( !xSaveStruct->IsInSection(),
3682 "Where is the section" );
3685 xSaveStruct->AddContents(std::move(rParentContents));
3689 xSubTable->GetCaptionStartNode();
3691 if (xSubTable->GetContext())
3693 OSL_ENSURE( !xSubTable->GetContext()->GetFrameFormat(),
3696 if( pCapStNd && xSubTable->IsTopCaption() )
3698 xSaveStruct->AddContents(
3699 std::make_unique<HTMLTableCnts>(pCapStNd) );
3702 xSaveStruct->AddContents(
3703 std::make_unique<HTMLTableCnts>(xSubTable) );
3705 if( pCapStNd && !xSubTable->IsTopCaption() )
3707 xSaveStruct->AddContents(
3708 std::make_unique<HTMLTableCnts>(pCapStNd) );
3712 xSaveStruct->ClearIsInSection();
3718 xSaveStruct->AddContents(
3719 std::make_unique<HTMLTableCnts>(pCapStNd) );
3722 xSaveStruct->ClearIsInSection();
3731 case HtmlTokenId::NOBR_ON:
3736 case HtmlTokenId::NOBR_OFF:
3740 case HtmlTokenId::COMMENT:
3746 case HtmlTokenId::MARQUEE_ON:
3747 if( !xSaveStruct->IsInSection() )
3750 xSaveStruct->AddContents(
3757 case HtmlTokenId::TEXTTOKEN:
3759 if( !xSaveStruct->IsInSection() && 1==aToken.getLength() &&
3764 if( !xSaveStruct->IsInSection() )
3767 xSaveStruct->AddContents(
3771 if( IsParserWorking() || bPending )
3777 "SwHTMLParser::BuildTableCell: There is a PendStack again" );
3779 if( IsParserWorking() )
3780 SaveState( HtmlTokenId::NONE );
3783 nToken = GetNextToken();
3786 if( SvParserState::Pending == GetStatus() )
3789 : HtmlTokenId::TABLEDATA_ON );
3799 if( !xSaveStruct->HasFirstContents() ||
3800 (!xSaveStruct->IsInSection() && !pCurTable->
HasColTags()) )
3802 OSL_ENSURE( xSaveStruct->HasFirstContents() ||
3803 !xSaveStruct->IsInSection(),
3804 "Section or not, that is the question here" );
3811 eState = SvParserState::Error;
3817 eState = SvParserState::Error;
3824 pCNd->
SetAttr( aFontHeightCJK );
3826 pCNd->
SetAttr( aFontHeightCTL );
3830 xSaveStruct->AddContents( std::make_unique<HTMLTableCnts>(pStNd) );
3831 xSaveStruct->ClearIsInSection();
3834 if( xSaveStruct->IsInSection() )
3840 while(
m_aContexts.size() > m_nContextStAttrMin+1 )
3842 std::unique_ptr<HTMLAttrContext> xCntxt(
PopContext());
3849 HTMLTableContext* pTableContext =
m_xTable ?
m_xTable->GetContext() :
nullptr;
3850 SwPosition* pSavedPos = pTableContext ? pTableContext->GetPos() :
nullptr;
3857 std::unique_ptr<HTMLAttrContext> xCntxt(
PopContext());
3866 std::unique_ptr<HTMLAttrContext> xCntxt(
PopContext());
3878 xSaveStruct->InsertCell( *
this, pCurTable );
3881 xSaveStruct.reset();
3902 sal_Int16 eGrpVertOri )
3910 std::unique_ptr<RowSaveStruct> xSaveStruct;
3912 bool bPending =
false;
3915 xSaveStruct.reset(static_cast<RowSaveStruct*>(
m_vPendingStack.back().pData.release()));
3919 bPending = SvParserState::Error == eState && !
m_vPendingStack.empty();
3921 SaveState( nToken );
3926 sal_Int16 eVertOri = eGrpVertOri;
3928 OUString aBGImage, aStyle,
aId, aClass;
3929 bool bBGColor =
false;
3930 xSaveStruct.reset(
new RowSaveStruct);
3935 for (
size_t i = rHTMLOptions.size(); i; )
3937 const HTMLOption& rOption = rHTMLOptions[--i];
3940 case HtmlOptionId::ID:
3943 case HtmlOptionId::ALIGN:
3946 case HtmlOptionId::VALIGN:
3947 eVertOri = rOption.
GetEnum( aHTMLTableVAlignTable, eVertOri );
3949 case HtmlOptionId::BGCOLOR:
3958 case HtmlOptionId::BACKGROUND:
3961 case HtmlOptionId::STYLE:
3964 case HtmlOptionId::CLASS:
3972 if( !aId.isEmpty() )
3975 std::unique_ptr<SvxBrushItem> xBrushItem(
3978 pCurTable->
OpenRow(eAdjust, eVertOri, xBrushItem);
3980 SaveState( HtmlTokenId::NONE );
3983 if( nToken == HtmlTokenId::NONE )
3984 nToken = GetNextToken();
3987 while( (IsParserWorking() && !bDone) || bPending )
3989 SaveState( nToken );
3991 nToken = FilterToken( nToken );
3995 "Where is the section??" );
4002 else switch( nToken )
4004 case HtmlTokenId::TABLE_ON:
4012 case HtmlTokenId::TABLEROW_ON:
4013 case HtmlTokenId::THEAD_ON:
4014 case HtmlTokenId::THEAD_OFF:
4015 case HtmlTokenId::TBODY_ON:
4016 case HtmlTokenId::TBODY_OFF:
4017 case HtmlTokenId::TFOOT_ON:
4018 case HtmlTokenId::TFOOT_OFF:
4019 case HtmlTokenId::TABLE_OFF:
4022 case HtmlTokenId::TABLEROW_OFF:
4025 case HtmlTokenId::TABLEHEADER_ON:
4026 case HtmlTokenId::TABLEDATA_ON:
4027 BuildTableCell( pCurTable,
true, HtmlTokenId::TABLEHEADER_ON==nToken );
4028 if( SvParserState::Pending != GetStatus() )
4030 xSaveStruct->bHasCells =
true;
4034 case HtmlTokenId::CAPTION_ON:
4038 case HtmlTokenId::CAPTION_OFF:
4039 case HtmlTokenId::TABLEHEADER_OFF:
4040 case HtmlTokenId::TABLEDATA_OFF:
4041 case HtmlTokenId::COLGROUP_ON:
4042 case HtmlTokenId::COLGROUP_OFF:
4043 case HtmlTokenId::COL_ON:
4044 case HtmlTokenId::COL_OFF:
4048 case HtmlTokenId::MULTICOL_ON:
4051 case HtmlTokenId::FORM_ON:
4054 case HtmlTokenId::FORM_OFF:
4057 case HtmlTokenId::COMMENT:
4060 case HtmlTokenId::MAP_ON:
4064 case HtmlTokenId::TEXTTOKEN:
4067 1==aToken.getLength() &&
' '==aToken[0] )
4077 "SwHTMLParser::BuildTableRow: There is a PendStack again" );
4079 if( IsParserWorking() )
4080 SaveState( HtmlTokenId::NONE );
4083 nToken = GetNextToken();
4086 if( SvParserState::Pending == GetStatus() )
4093 pCurTable->
CloseRow(!xSaveStruct->bHasCells);
4094 xSaveStruct.reset();
4109 bool bPending =
false;
4110 std::unique_ptr<RowSaveStruct> xSaveStruct;
4114 xSaveStruct.reset(static_cast<RowSaveStruct*>(
m_vPendingStack.back().pData.release()));
4118 bPending = SvParserState::Error == eState && !
m_vPendingStack.empty();
4120 SaveState( nToken );
4124 xSaveStruct.reset(
new RowSaveStruct);
4129 for (
size_t i = rHTMLOptions.size(); i; )
4131 const HTMLOption& rOption = rHTMLOptions[--i];
4134 case HtmlOptionId::ID:
4137 case HtmlOptionId::ALIGN:
4138 xSaveStruct->eAdjust =
4141 case HtmlOptionId::VALIGN:
4142 xSaveStruct->eVertOri =
4143 rOption.
GetEnum( aHTMLTableVAlignTable,
4144 xSaveStruct->eVertOri );
4152 SaveState( HtmlTokenId::NONE );
4155 if( nToken == HtmlTokenId::NONE )
4156 nToken = GetNextToken();
4159 while( (IsParserWorking() && !bDone) || bPending )
4161 SaveState( nToken );
4163 nToken = FilterToken( nToken );
4167 "Where is the section?" );
4174 else switch( nToken )
4176 case HtmlTokenId::TABLE_ON:
4184 case HtmlTokenId::THEAD_ON:
4185 case HtmlTokenId::TFOOT_ON:
4186 case HtmlTokenId::TBODY_ON:
4187 case HtmlTokenId::TABLE_OFF:
4190 case HtmlTokenId::THEAD_OFF:
4191 case HtmlTokenId::TBODY_OFF:
4192 case HtmlTokenId::TFOOT_OFF:
4195 case HtmlTokenId::CAPTION_ON:
4199 case HtmlTokenId::CAPTION_OFF:
4201 case HtmlTokenId::TABLEHEADER_ON:
4202 case HtmlTokenId::TABLEDATA_ON:
4205 xSaveStruct->eVertOri );
4208 case HtmlTokenId::TABLEROW_ON:
4210 xSaveStruct->eVertOri );
4213 case HtmlTokenId::MULTICOL_ON:
4216 case HtmlTokenId::FORM_ON:
4219 case HtmlTokenId::FORM_OFF:
4222 case HtmlTokenId::TEXTTOKEN:
4226 1==aToken.getLength() &&
' ' == aToken[0] )
4235 "SwHTMLParser::BuildTableSection: There is a PendStack again" );
4237 if( IsParserWorking() )
4238 SaveState( HtmlTokenId::NONE );
4241 nToken = GetNextToken();
4244 if( SvParserState::Pending == GetStatus() )
4247 : HtmlTokenId::TBODY_ON );
4253 xSaveStruct.reset();
4263 sal_uInt16 nColGrpSpan;
4264 sal_uInt16 nColGrpWidth;
4265 bool bRelColGrpWidth;
4267 sal_Int16 eColGrpVertOri;
4269 inline TableColGrpSaveStruct();
4271 inline void CloseColGroup(
HTMLTable *pTable );
4276 inline TableColGrpSaveStruct::TableColGrpSaveStruct() :
4277 nColGrpSpan( 1 ), nColGrpWidth( 0 ),
4279 eColGrpVertOri(
text::VertOrientation::
TOP )
4282 inline void TableColGrpSaveStruct::CloseColGroup(
HTMLTable *pTable )
4285 bRelColGrpWidth, eColGrpAdjust, eColGrpVertOri );
4297 bool bPending =
false;
4298 std::unique_ptr<TableColGrpSaveStruct> pSaveStruct;
4302 pSaveStruct.reset(static_cast<TableColGrpSaveStruct*>(
m_vPendingStack.back().pData.release()));
4307 bPending = SvParserState::Error == eState && !
m_vPendingStack.empty();
4309 SaveState( nToken );
4314 pSaveStruct.reset(
new TableColGrpSaveStruct);
4318 for (
size_t i = rColGrpOptions.size(); i; )
4320 const HTMLOption& rOption = rColGrpOptions[--i];
4323 case HtmlOptionId::ID:
4326 case HtmlOptionId::SPAN:
4327 pSaveStruct->nColGrpSpan = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4328 if (pSaveStruct->nColGrpSpan > 256)
4330 SAL_INFO(
"sw.html",
"ignoring huge SPAN " << pSaveStruct->nColGrpSpan);
4331 pSaveStruct->nColGrpSpan = 1;
4334 case HtmlOptionId::WIDTH:
4335 pSaveStruct->nColGrpWidth = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4336 pSaveStruct->bRelColGrpWidth =
4337 (rOption.
GetString().indexOf(
'*') != -1);
4339 case HtmlOptionId::ALIGN:
4340 pSaveStruct->eColGrpAdjust =
4343 case HtmlOptionId::VALIGN:
4344 pSaveStruct->eColGrpVertOri =
4345 rOption.
GetEnum( aHTMLTableVAlignTable,
4346 pSaveStruct->eColGrpVertOri );
4353 SaveState( HtmlTokenId::NONE );
4356 if( nToken == HtmlTokenId::NONE )
4357 nToken = GetNextToken();
4360 while( (IsParserWorking() && !bDone) || bPending )
4362 SaveState( nToken );
4364 nToken = FilterToken( nToken );
4368 "Where is the section?" );
4375 else switch( nToken )
4377 case HtmlTokenId::TABLE_ON:
4385 case HtmlTokenId::COLGROUP_ON:
4386 case HtmlTokenId::THEAD_ON:
4387 case HtmlTokenId::TFOOT_ON:
4388 case HtmlTokenId::TBODY_ON:
4389 case HtmlTokenId::TABLEROW_ON:
4390 case HtmlTokenId::TABLE_OFF:
4393 case HtmlTokenId::COLGROUP_OFF:
4396 case HtmlTokenId::COL_ON:
4398 sal_uInt16 nColSpan = 1;
4399 sal_uInt16 nColWidth = pSaveStruct->nColGrpWidth;
4400 bool bRelColWidth = pSaveStruct->bRelColGrpWidth;
4401 SvxAdjust eColAdjust = pSaveStruct->eColGrpAdjust;
4402 sal_Int16 eColVertOri = pSaveStruct->eColGrpVertOri;
4405 for (
size_t i = rColOptions.size(); i; )
4407 const HTMLOption& rOption = rColOptions[--i];
4410 case HtmlOptionId::ID:
4413 case HtmlOptionId::SPAN:
4414 nColSpan = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4417 SAL_INFO(
"sw.html",
"ignoring huge SPAN " << nColSpan);
4421 case HtmlOptionId::WIDTH:
4422 nColWidth = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4424 (rOption.
GetString().indexOf(
'*') != -1);
4426 case HtmlOptionId::ALIGN:
4429 case HtmlOptionId::VALIGN:
4431 rOption.
GetEnum( aHTMLTableVAlignTable, eColVertOri );
4436 pCurTable->
InsertCol( nColSpan, nColWidth, bRelColWidth,
4437 eColAdjust, eColVertOri );
4440 pSaveStruct->nColGrpSpan = 0;
4443 case HtmlTokenId::COL_OFF:
4445 case HtmlTokenId::MULTICOL_ON:
4448 case HtmlTokenId::TEXTTOKEN:
4451 1==aToken.getLength() &&
' '==aToken[0] )
4460 "SwHTMLParser::BuildTableColGrp: There is a PendStack again" );
4462 if( IsParserWorking() )
4463 SaveState( HtmlTokenId::NONE );
4466 nToken = GetNextToken();
4469 if( SvParserState::Pending == GetStatus() )
4476 pSaveStruct->CloseColGroup( pCurTable );
4523 std::unique_ptr<CaptionSaveStruct> xSaveStruct;
4527 xSaveStruct.reset(static_cast<CaptionSaveStruct*>(
m_vPendingStack.back().pData.release()));
4531 OSL_ENSURE(
m_vPendingStack.empty(),
"Where does a PendStack coming from?" );
4533 SaveState( nToken );
4539 SaveState( HtmlTokenId::NONE );
4545 for (
size_t i = rHTMLOptions.size(); i; )
4547 const HTMLOption& rOption = rHTMLOptions[--i];
4548 if( HtmlOptionId::ALIGN == rOption.
GetToken() )
4550 if (rOption.
GetString().equalsIgnoreAsciiCase(
4569 std::unique_ptr<HTMLAttrContext> xCntxt(
new HTMLAttrContext(HtmlTokenId::CAPTION_ON));
4575 rAttrs.push_back( m_xAttrTab->pAdjust );
4583 SaveState( HtmlTokenId::NONE );
4586 if( nToken == HtmlTokenId::NONE )
4587 nToken = GetNextToken();
4591 while( IsParserWorking() && !bDone )
4593 SaveState( nToken );
4595 nToken = FilterToken( nToken );
4599 case HtmlTokenId::TABLE_ON:
4603 bool bHasToFly = xSaveStruct->m_xTable.get() != pCurTable;
4605 false,
true, bHasToFly );
4611 if( SvParserState::Pending != GetStatus() )
4616 case HtmlTokenId::TABLE_OFF:
4617 case HtmlTokenId::COLGROUP_ON:
4618 case HtmlTokenId::THEAD_ON:
4619 case HtmlTokenId::TFOOT_ON:
4620 case HtmlTokenId::TBODY_ON:
4621 case HtmlTokenId::TABLEROW_ON:
4626 case HtmlTokenId::CAPTION_OFF:
4636 if( IsParserWorking() )
4641 if( IsParserWorking() )
4642 SaveState( HtmlTokenId::NONE );
4645 nToken = GetNextToken();
4648 if( SvParserState::Pending==GetStatus() )
4656 while(
m_aContexts.size() > m_nContextStAttrMin+1 )
4658 std::unique_ptr<HTMLAttrContext> xCntxt(
PopContext());
4679 std::unique_ptr<HTMLAttrContext> xCntxt(
PopContext());
4689 xSaveStruct->RestoreAll(*
this);
4700 std::shared_ptr<HTMLTable> m_xCurrentTable;
4702 explicit TableSaveStruct(
const std::shared_ptr<HTMLTable>& rCurTable)
4703 : m_xCurrentTable(rCurTable)
4714 void TableSaveStruct::MakeTable( sal_uInt16 nWidth,
SwPosition& rPos,
SwDoc *pDoc )
4716 m_xCurrentTable->MakeTable(
nullptr, nWidth);
4718 HTMLTableContext *pTCntxt = m_xCurrentTable->GetContext();
4719 OSL_ENSURE( pTCntxt,
"Where is the table context" );
4722 OSL_ENSURE( pTableNd,
"Where is the table node" );
4728 if( pTCntxt->GetFrameFormat() )
4730 pTCntxt->GetFrameFormat()->DelFrames();
4732 pTCntxt->GetFrameFormat()->MakeFrames();
4738 OSL_ENSURE( aIdx.GetIndex() <= pTCntxt->GetPos()->nNode.GetIndex(),
4739 "unexpected node for table layout" );
4744 rPos = *pTCntxt->GetPos();
4747 HTMLTableOptions::HTMLTableOptions(
const HTMLOptions& rOptions,
4750 nWidth( 0 ), nHeight( 0 ),
4751 nCellPadding( USHRT_MAX ), nCellSpacing( USHRT_MAX ),
4753 nHSpace( 0 ), nVSpace( 0 ),
4754 eAdjust( eParentAdjust ), eVertOri(
text::VertOrientation::
CENTER ),
4756 bPercentWidth(
false ),
4757 bTableAdjust(
false ),
4761 bool bBorderColor =
false;
4762 bool bHasFrame =
false, bHasRules =
false;
4764 for (
size_t i = rOptions.size(); i; )
4769 case HtmlOptionId::ID:
4772 case HtmlOptionId::COLS:
4773 nCols = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4775 case HtmlOptionId::WIDTH:
4776 nWidth = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4777 bPercentWidth = (rOption.
GetString().indexOf(
'%') != -1);
4778 if( bPercentWidth && nWidth>100 )
4781 case HtmlOptionId::HEIGHT:
4782 nHeight = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4783 if( rOption.
GetString().indexOf(
'%') != -1 )
4786 case HtmlOptionId::CELLPADDING:
4787 nCellPadding = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4789 case HtmlOptionId::CELLSPACING:
4790 nCellSpacing = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4792 case HtmlOptionId::ALIGN:
4796 bTableAdjust =
true;
4800 case HtmlOptionId::VALIGN:
4801 eVertOri = rOption.
GetEnum( aHTMLTableVAlignTable, eVertOri );
4803 case HtmlOptionId::BORDER:
4806 !rOption.
GetString().equalsIgnoreAsciiCase(
4807 OOO_STRING_SVTOOLS_HTML_O_border))
4815 eFrame = (
nBorder ? HTMLTableFrame::Box : HTMLTableFrame::Void );
4817 eRules = (
nBorder ? HTMLTableRules::All : HTMLTableRules::NONE );
4819 case HtmlOptionId::FRAME:
4823 case HtmlOptionId::RULES:
4827 case HtmlOptionId::BGCOLOR:
4836 case HtmlOptionId::BACKGROUND:
4839 case HtmlOptionId::BORDERCOLOR:
4841 bBorderColor =
true;
4843 case HtmlOptionId::BORDERCOLORDARK:
4847 case HtmlOptionId::STYLE:
4850 case HtmlOptionId::CLASS:
4853 case HtmlOptionId::DIR:
4856 case HtmlOptionId::HSPACE:
4857 nHSpace = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4859 case HtmlOptionId::VSPACE:
4860 nVSpace = o3tl::narrowing<sal_uInt16>(rOption.
GetNumber());
4866 if( nCols && !nWidth )
4869 bPercentWidth =
true;
4873 if( 0==nBorder || USHRT_MAX==nBorder )
4875 eFrame = HTMLTableFrame::Void;
4876 eRules = HTMLTableRules::NONE;
4896 return aTextIdx >= maStart && aTextIdx <= maEnd;
4924 for (
auto i = rTable.
size(); i; )
4930 ((rAnch.
GetAnchorId() == RndStdIds::FLY_AT_PARA) ||
4931 (rAnch.
GetAnchorId() == RndStdIds::FLY_AT_CHAR)) &&
4932 ( rMkNdIdx < pAPos->
nNode && pAPos->
nNode <= rPtNdIdx ))
4934 if( rPtNdIdx != pAPos->
nNode )
4960 m_xDoc->getIDocumentContentOperations().DeleteSection(pSttNd);
4973 bool bHasParentSection,
4978 eState = SvParserState::Error;
4981 return std::shared_ptr<HTMLTable>();
4985 bool bPending =
false;
4986 std::unique_ptr<TableSaveStruct> xSaveStruct;
4990 xSaveStruct.reset(static_cast<TableSaveStruct*>(
m_vPendingStack.back().pData.release()));
4994 bPending = SvParserState::Error == eState && !
m_vPendingStack.empty();
4996 SaveState( nToken );
5001 HTMLTableOptions aTableOptions(GetOptions(), eParentAdjust);
5003 if (!aTableOptions.aId.isEmpty())
5006 std::shared_ptr<HTMLTable> xCurTable(std::make_shared<HTMLTable>(
this,
5013 xSaveStruct.reset(
new TableSaveStruct(xCurTable));
5016 SaveState( HtmlTokenId::NONE );
5019 std::shared_ptr<HTMLTable> xCurTable = xSaveStruct->m_xCurrentTable;
5022 if( nToken == HtmlTokenId::NONE )
5023 nToken = GetNextToken();
5026 while( (IsParserWorking() && !bDone) || bPending )
5028 SaveState( nToken );
5030 nToken = FilterToken( nToken );
5033 xCurTable->GetContext() || xCurTable->HasParentSection(),
5034 "Where is the section?" );
5036 (xCurTable->GetContext() || xCurTable->HasParentSection()) )
5041 else switch( nToken )
5043 case HtmlTokenId::TABLE_ON:
5044 if( !xCurTable->GetContext() )
5052 case HtmlTokenId::TABLE_OFF:
5055 case HtmlTokenId::CAPTION_ON:
5059 case HtmlTokenId::COL_ON:
5063 case HtmlTokenId::COLGROUP_ON:
5066 case HtmlTokenId::TABLEROW_ON:
5067 case HtmlTokenId::TABLEHEADER_ON:
5068 case HtmlTokenId::TABLEDATA_ON:
5073 case HtmlTokenId::THEAD_ON:
5074 case HtmlTokenId::TFOOT_ON:
5075 case HtmlTokenId::TBODY_ON:
5079 case HtmlTokenId::MULTICOL_ON:
5082 case HtmlTokenId::FORM_ON:
5085 case HtmlTokenId::FORM_OFF:
5088 case HtmlTokenId::TEXTTOKEN:
5090 if( (xCurTable->GetContext() ||
5091 !xCurTable->HasParentSection()) &&
5092 1==aToken.getLength() &&
' '==aToken[0] )
5096 xCurTable->MakeParentContents();
5102 "SwHTMLParser::BuildTable: There is a PendStack again" );
5104 if( IsParserWorking() )
5105 SaveState( HtmlTokenId::NONE );
5108 nToken = GetNextToken();
5111 if( SvParserState::Pending == GetStatus() )
5115 return std::shared_ptr<HTMLTable>();
5118 HTMLTableContext *pTCntxt = xCurTable->GetContext();
5123 xCurTable->CloseTable();
5129 std::unique_ptr<HTMLAttrContext> xCntxt(
PopContext());
5135 m_nContextStMin = pTCntxt->GetContextStMin();
5136 m_nContextStAttrMin = pTCntxt->GetContextStAttrMin();
5153 bool bTop =
m_xTable->IsTopCaption();
5154 SwStartNode *pTableStNd = pTCntxt->GetTableNode();
5156 OSL_ENSURE( pTableStNd,
"Where is the table node" );
5158 "Are we in the wrong table?" );
5167 m_xDoc->getIDocumentContentOperations().MoveNodeRange( aSrcRg, aDstIdx,
5185 m_xTable->SetCaption(
nullptr,
false );
5194 pTCntxt->RestorePREListingXMP( *
this );
5203 SwTableNode* pTableNode = pTCntxt->GetTableNode();
5220 if( !
m_nParaCnt && SvParserState::Working == GetStatus() )
5229 const SwStartNode *pCapStNd = xCurTable->GetCaptionStartNode();
5235 xCurTable->SetCaption(
nullptr,
false );
5241 xSaveStruct->m_xCurrentTable.reset();
5245 std::shared_ptr<HTMLTable> xRetTable = xSaveStruct->m_xCurrentTable;
5246 xSaveStruct.reset();
sal_uInt16 IncGrfsThatResizeTable()
void SetNodeNum(sal_uInt8 nLevel)
std::vector< SwPending > m_vPendingStack
const SwEndNode * EndOfSectionNode() const
const SwStartNode * m_pStartNode
sal_uInt8 GetLevel() const
Starts a section of nodes in the document model.
SwNodeOffset min(const SwNodeOffset &a, const SwNodeOffset &b)
SvxAdjust GetInheritedAdjust() const
const std::unique_ptr< SvxBrushItem > & GetBGBrush() const
constexpr TypedWhichId< SvxFrameDirectionItem > RES_FRAMEDIR(120)
constexpr TypedWhichId< SwFormatPageDesc > RES_PAGEDESC(93)
std::optional< SdrObjects > m_xResizeDrawObjects
void SetAnchorAndAdjustment(sal_Int16 eVertOri, sal_Int16 eHoriOri, const SvxCSS1PropertyInfo &rPropInfo, SfxItemSet &rFrameSet)
SwNode & GetNode(bool bPoint=true) const
std::shared_ptr< SwHTMLTableLayout > m_xLayoutInfo
SwTableLine * MakeTableLine(SwTableBox *pUpper, sal_uInt16 nTopRow, sal_uInt16 nLeftCol, sal_uInt16 nBottomRow, sal_uInt16 nRightCol)
EnumT GetEnum(const HTMLOptionEnum< EnumT > *pOptEnums, EnumT nDflt=static_cast< EnumT >(0)) const
void SplitPREListingXMP(HTMLAttrContext *pCntxt)
constexpr SwTwips MIN_BORDER_DIST
void AddContents(std::unique_ptr< HTMLTableCnts > pNewCnts)
void DeleteSection(SwStartNode *pSttNd)
std::unique_ptr< HTMLTableCnts > m_pNext
HtmlOptionId GetToken() const
static Css1ScriptFlags GetScriptFromClass(OUString &rClass, bool bSubClassOnly=true)
SwNodeOffset EndOfSectionIndex() const
Represents the style of a paragraph.
void InsertCol(sal_uInt16 nSpan, sal_uInt16 nWidth, bool bRelWidth, SvxAdjust eAdjust, sal_Int16 eVertOri)
#define OOO_STRING_SVTOOLS_HTML_VA_bottom
const T * GetItemIfSet(TypedWhichId< T > nWhich, bool bSrchInParent=true) const
Marks a position in the document model.
void SetAttr(bool bChkEnd=true, bool bBeforeTable=false, std::deque< std::unique_ptr< HTMLAttr >> *pPostIts=nullptr)
void EndForm(bool bAppend=true)
Pagedescriptor Client of SwPageDesc that is "described" by the attribute.
SvxBorderLine m_aLeftBorderLine
std::vector< sal_uInt16 > m_aBaseFontStack
SvxAdjust GetAdjust() const
void DelFrames(SwRootFrame const *pLayout=nullptr)
Method deletes all views of document for the node.
SwPageDesc * GetPageDesc()
constexpr TypedWhichId< SwTableBoxNumFormat > RES_BOXATR_FORMAT(RES_BOXATR_BEGIN)
void SetParentContents(std::unique_ptr< HTMLTableCnts > pCnts)
const OUString & GetText() const
std::vector< sal_uInt16 > m_aFontStack
SwStartNode * InsertTempTableCaptionSection()
SvxBorderLine m_aBottomBorderLine
SvNumberFormatter * GetNumberFormatter(bool bCreate=true)
bool IsHeaderCell() const
void RemoveObjectUser(sdr::ObjectUser &rOldUser)
std::shared_ptr< HTMLTable > BuildTable(SvxAdjust eCellAdjust, bool bIsParentHead=false, bool bHasParentSection=true, bool bHasToFlow=false)
constexpr TypedWhichId< SvxFormatKeepItem > RES_KEEP(110)
constexpr TypedWhichId< SwFormatFrameSize > RES_FRM_SIZE(89)
std::unique_ptr< SwHTMLFootEndNote_Impl > m_pFootEndNoteImpl
const std::shared_ptr< SwHTMLTableLayout > & CreateLayoutInfo()
void SaveAttrTab(std::shared_ptr< HTMLAttrTable > const &rNewAttrTab)
void ProtectRowSpan(sal_uInt16 nRow, sal_uInt16 nCol, sal_uInt16 nRowSpan)
void InsertBookmark(const OUString &rName)
#define NETSCAPE_DFLT_BORDER
std::shared_ptr< HTMLTable > & GetTable()
void Set(const SwHTMLNumRuleInfo &rInf)
void InsertCell(std::shared_ptr< HTMLTableCnts > const &rCnts, sal_uInt16 nRowSpan, sal_uInt16 nColSpan, sal_uInt16 nWidth, bool bRelWidth, sal_uInt16 nHeight, sal_Int16 eVertOri, std::shared_ptr< SvxBrushItem > const &rBGBrushItem, std::shared_ptr< SvxBoxItem > const &rBoxItem, bool bHasNumFormat, sal_uInt32 nNumFormat, bool bHasValue, double nValue, bool bNoWrap)
const OUString & GetStyle() const
void SetHasParentSection(bool bSet)
sal_uInt16 GetVSpace() const
constexpr TypedWhichId< SvxFontHeightItem > RES_CHRATR_FONTSIZE(8)
HTMLAttr * GetNext() const
const SwStartNode * InsertTableSection(const SwStartNode *pPrevStNd)
constexpr Point convert(const Point &rPoint, o3tl::Length eFrom, o3tl::Length eTo)
void NewAttr(const std::shared_ptr< HTMLAttrTable > &rAttrTab, HTMLAttr **ppAttr, const SfxPoolItem &rItem)
Provides access to the marks of a document.
const OUString & GetString() const
sal_uInt16 m_nBaseFontStMin
virtual void ObjectInDestruction(const SdrObject &rObject) override
constexpr sal_uInt16 RES_FRMATR_END(133)
sal_uInt16 m_nDefListDeepSave
SwFrameFormat * ClaimFrameFormat()
std::unique_ptr< HTMLTableCnts > InsertTableContents(bool bHead)
bool IsOverflowing() const
const OUString & GetClass() const
bool IsTopCaption() const
HTMLAttrContexts m_aContexts
const std::shared_ptr< HTMLTable > & GetTable() const
void FixFrameFormat(SwTableBox *pBox, sal_uInt16 nRow, sal_uInt16 nCol, sal_uInt16 nRowSpan, sal_uInt16 nColSpan, bool bFirstPara=true, bool bLastPara=true) const
constexpr TypedWhichId< SvxFormatBreakItem > RES_BREAK(94)
void push_back(SwTableLine *pLine)
SwTableLine is one table row in the document model.
SvxBorderLine m_aTopBorderLine
sal_uInt16 m_nBaseFontStMinSave
Content, content of frame (header, footer, fly).
void SetBGBrush(const SvxBrushItem &rBrush)
SvxBorderLine m_aBorderLine
std::shared_ptr< SwHTMLTableLayoutCnts > m_xLayoutInfo
sal_Int32 StripTrailingLF()
std::shared_ptr< HTMLAttrTable > m_xAttrTab
void NewForm(bool bAppend=true)
std::shared_ptr< T > make_shared(Args &&...args)
void SetTable(const SwStartNode *pStNd, std::unique_ptr< HTMLTableContext > pCntxt, sal_uInt16 nLeft, sal_uInt16 nRight, const SwTable *pSwTab=nullptr, bool bFrcFrame=false)
const SwStartNode * m_pCaptionStartNode
void SplitAttrTab(const SwPosition &rNewPos)
static void PixelToTwip(tools::Long &nWidth, tools::Long &nHeight)
bool m_isInTableStructure
friend class CellSaveStruct
static void RegisterDrawObjectToTable(HTMLTable *pCurTable, SdrObject *pObj, sal_uInt8 nWidth)
SwTableFormat * GetFrameFormat()
Value in Var-direction gives minimum (can be exceeded but not be less).
std::shared_ptr< HTMLTable > m_xTable
std::unique_ptr< SvxBrushItem > m_xInheritedBackgroundBrush
constexpr TypedWhichId< SwFlyFrameFormat > RES_FLYFRMFMT(156)
constexpr TypedWhichId< SwFormatLayoutSplit > RES_LAYOUT_SPLIT(113)
void AddObjectUser(sdr::ObjectUser &rNewUser)
const HTMLTableCnts * Next() const
SvxBorderLine m_aRightBorderLine
HTMLTableCell & GetCell(sal_uInt16 nRow, sal_uInt16 nCell)
static OutputDevice * GetDefaultDevice()
constexpr tools::Long Width() const
constexpr TypedWhichId< SwFormatVertOrient > RES_VERT_ORIENT(102)
bool m_bFillerBottomBorder
static void ResetFrameFormatAttrs(SfxItemSet &rFrameSet)