/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <libxml/xmlwriter.h>
#include <hintids.hxx>
#include <hints.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/shaditem.hxx>
#include <editeng/adjustitem.hxx>
#include <editeng/colritem.hxx>
#include <osl/diagnose.h>
#include <sfx2/linkmgr.hxx>
#include <fmtfsize.hxx>
#include <fmtornt.hxx>
#include <fmtpdsc.hxx>
#include <fldbas.hxx>
#include <fmtfld.hxx>
#include <frmatr.hxx>
#include <doc.hxx>
#include <IDocumentLinksAdministration.hxx>
#include <IDocumentRedlineAccess.hxx>
#include <IDocumentFieldsAccess.hxx>
#include <docary.hxx>
#include <frame.hxx>
#include <swtable.hxx>
#include <ndtxt.hxx>
#include <tabcol.hxx>
#include <tabfrm.hxx>
#include <cellfrm.hxx>
#include <rowfrm.hxx>
#include <swserv.hxx>
#include <expfld.hxx>
#include <mdiexp.hxx>
#include <cellatr.hxx>
#include <txatbase.hxx>
#include <htmltbl.hxx>
#include <swtblfmt.hxx>
#include <ndindex.hxx>
#include <tblrwcl.hxx>
#include <shellres.hxx>
#include <viewsh.hxx>
#include <redline.hxx>
#include <vector>
#include <calbck.hxx>
#include <o3tl/string_view.hxx>
#include <o3tl/untaint.hxx>
#include <svl/numformat.hxx>
#include <txtfld.hxx>
#include <rolbck.hxx>
#ifdef DBG_UTIL
#define CHECK_TABLE(t) (t).CheckConsistency();
#else
#define CHECK_TABLE(t)
#endif
using namespace com::sun::star;
#define COLFUZZY 20
static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
bool bChgAlign, SwNodeOffset nNdPos );
void SwTableBox::setRowSpan( sal_Int32 nNewRowSpan )
{
mnRowSpan = nNewRowSpan;
}
bool SwTableBox::getDummyFlag() const
{
return mbDummyFlag;
}
void SwTableBox::setDummyFlag( bool bDummy )
{
mbDummyFlag = bDummy;
}
//JP 15.09.98: Bug 55741 - Keep tabs (front and rear)
static void lcl_TabToBlankAtSttEnd( OUString& rText )
{
sal_Unicode c;
sal_Int32 n;
for( n = 0; n < rText.getLength() && ' ' >= ( c = rText[n] ); ++n )
if( '\x9' == c )
rText = rText.replaceAt( n, 1, u" " );
for( n = rText.getLength(); n && ' ' >= ( c = rText[--n] ); )
if( '\x9' == c )
rText = rText.replaceAt( n, 1, u" " );
}
static void lcl_DelTabsAtSttEnd( OUString& rText )
{
sal_Unicode c;
sal_Int32 n;
OUStringBuffer sBuff(rText);
for( n = 0; n < sBuff.getLength() && ' ' >= ( c = sBuff[ n ]); ++n )
{
if( '\x9' == c )
sBuff.remove( n--, 1 );
}
for( n = sBuff.getLength(); n && ' ' >= ( c = sBuff[ --n ]); )
{
if( '\x9' == c )
sBuff.remove( n, 1 );
}
rText = sBuff.makeStringAndClear();
}
void InsTableBox( SwDoc& rDoc, SwTableNode* pTableNd,
SwTableLine* pLine, SwTableBoxFormat* pBoxFrameFormat,
SwTableBox* pBox,
sal_uInt16 nInsPos, sal_uInt16 nCnt )
{
OSL_ENSURE( pBox->GetSttNd(), "Box with no start node" );
SwNodeIndex aIdx( *pBox->GetSttNd(), +1 );
SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
if( !pCNd )
pCNd = SwNodes::GoNext(&aIdx);
assert(pCNd && "Box with no content node");
if( pCNd->IsTextNode() )
{
if( pCNd->GetpSwAttrSet() )
{
SwAttrSet aAttrSet( *pCNd->GetpSwAttrSet() );
if(pCNd->GetSwAttrSet().HasItem(RES_PARATR_LIST_AUTOFMT))
{
SwFormatAutoFormat format = aAttrSet.Get(RES_PARATR_LIST_AUTOFMT);
const std::shared_ptr<SfxItemSet>& handle = format.GetStyleHandle();
aAttrSet.Put(*handle);
}
if( pBox->GetSaveNumFormatColor() )
{
if( pBox->GetSaveUserColor() )
aAttrSet.Put( SvxColorItem( *pBox->GetSaveUserColor(), RES_CHRATR_COLOR ));
else
aAttrSet.ClearItem( RES_CHRATR_COLOR );
}
rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
static_cast<SwTextNode*>(pCNd)->GetTextColl(),
&aAttrSet, nInsPos, nCnt );
}
else
rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
static_cast<SwTextNode*>(pCNd)->GetTextColl(),
pCNd->GetpSwAttrSet(), nInsPos, nCnt );
}
else
rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
rDoc.GetDfltTextFormatColl(), nullptr,
nInsPos, nCnt );
sal_Int32 nRowSpan = pBox->getRowSpan();
if( nRowSpan != 1 )
{
SwTableBoxes& rTableBoxes = pLine->GetTabBoxes();
for( sal_uInt16 i = 0; i < nCnt; ++i )
{
pBox = rTableBoxes[ i + nInsPos ];
pBox->setRowSpan( nRowSpan );
}
}
}
SwTable::SwTable()
: SwClient( nullptr ),
m_pTableNode( nullptr ),
m_nGraphicsThatResize( 0 ),
m_nRowsToRepeat( 1 ),
m_bModifyLocked( false ),
m_bNewModel( true )
{
// default value set in the options
m_eTableChgMode = GetTableChgDefaultMode();
}
SwTable::SwTable( const SwTable& rTable )
: SwClient( rTable.GetFrameFormat() ),
m_pTableNode( nullptr ),
m_eTableChgMode( rTable.m_eTableChgMode ),
m_nGraphicsThatResize( 0 ),
m_nRowsToRepeat( rTable.GetRowsToRepeat() ),
maTableStyleName(rTable.maTableStyleName),
m_bModifyLocked( false ),
m_bNewModel( rTable.m_bNewModel )
{
}
void DelBoxNode( SwTableSortBoxes const & rSortCntBoxes )
{
for (size_t n = 0; n < rSortCntBoxes.size(); ++n)
{
rSortCntBoxes[ n ]->m_pStartNode = nullptr;
}
}
SwTable::~SwTable()
{
if( m_xRefObj.is() )
{
SwDoc& rDoc = GetFrameFormat()->GetDoc();
if( !rDoc.IsInDtor() ) // then remove from the list
rDoc.getIDocumentLinksAdministration().GetLinkManager().RemoveServer( m_xRefObj.get() );
m_xRefObj->Closed();
}
// the table can be deleted if it's the last client of the FrameFormat
SwTableFormat* pFormat = GetFrameFormat();
pFormat->Remove(*this); // remove
if( !pFormat->HasWriterListeners() )
pFormat->GetDoc().DelTableFrameFormat( pFormat ); // and delete
// Delete the pointers from the SortArray of the boxes. The objects
// are preserved and are deleted by the lines/boxes arrays dtor.
// Note: unfortunately not enough, pointers to the StartNode of the
// section need deletion.
DelBoxNode(m_TabSortContentBoxes);
m_TabSortContentBoxes.clear();
}
namespace
{
template<class T>
T lcl_MulDiv64(sal_uInt64 nA, sal_uInt64 nM, sal_uInt64 nD)
{
assert(nD != 0);
return nD == 0 ? static_cast<T>(nA*nM) : static_cast<T>((nA*nM)/nD);
}
}
static void FormatInArr( std::vector<SwFormat*>& rFormatArr, SwFormat* pBoxFormat )
{
std::vector<SwFormat*>::const_iterator it = std::find( rFormatArr.begin(), rFormatArr.end(), pBoxFormat );
if ( it == rFormatArr.end() )
rFormatArr.push_back( pBoxFormat );
}
static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const tools::Long nOld,
const tools::Long nNew, std::vector<SwFormat*>& rFormatArr );
static void lcl_ModifyLines( SwTableLines &rLines, const tools::Long nOld,
const tools::Long nNew, std::vector<SwFormat*>& rFormatArr, const bool bCheckSum )
{
for ( auto &rLine : rLines)
::lcl_ModifyBoxes( rLine->GetTabBoxes(), nOld, nNew, rFormatArr );
if( bCheckSum )
{
for(SwFormat* pFormat : rFormatArr)
{
const SwTwips nBox = lcl_MulDiv64<SwTwips>(pFormat->GetFrameSize().GetWidth(), nNew, nOld);
SwFormatFrameSize aNewBox( SwFrameSize::Variable, nBox, 0 );
pFormat->LockModify();
pFormat->SetFormatAttr( aNewBox );
pFormat->UnlockModify();
}
}
}
static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const tools::Long nOld,
const tools::Long nNew, std::vector<SwFormat*>& rFormatArr )
{
sal_uInt64 nSum = 0; // To avoid rounding errors we summarize all box widths
sal_uInt64 nOriginalSum = 0; // Sum of original widths
for ( size_t i = 0; i < rBoxes.size(); ++i )
{
SwTableBox &rBox = *rBoxes[i];
if ( !rBox.GetTabLines().empty() )
{
// For SubTables the rounding problem will not be solved :-(
::lcl_ModifyLines( rBox.GetTabLines(), nOld, nNew, rFormatArr, false );
}
// Adjust the box
SwFrameFormat *pFormat = rBox.GetFrameFormat();
sal_uInt64 nBox = pFormat->GetFrameSize().GetWidth();
nOriginalSum += nBox;
nBox = lcl_MulDiv64<sal_uInt64>(nBox, nNew, nOld);
const sal_uInt64 nWishedSum = lcl_MulDiv64<sal_uInt64>(nOriginalSum, nNew, nOld) - nSum;
if( nWishedSum > 0 )
{
if( nBox == nWishedSum )
FormatInArr( rFormatArr, pFormat );
else
{
nBox = nWishedSum;
pFormat = rBox.ClaimFrameFormat();
SwFormatFrameSize aNewBox( SwFrameSize::Variable, static_cast< SwTwips >(nBox), 0 );
pFormat->LockModify();
pFormat->SetFormatAttr( aNewBox );
pFormat->UnlockModify();
}
}
else {
OSL_FAIL( "Rounding error" );
}
nSum += nBox;
}
}
void SwTable::SwClientNotify(const SwModify&, const SfxHint& rHint)
{
if(rHint.GetId() == SfxHintId::SwAutoFormatUsedHint)
{
auto& rAutoFormatUsedHint = static_cast<const sw::AutoFormatUsedHint&>(rHint);
rAutoFormatUsedHint.CheckNode(GetTableNode());
}
else if (rHint.GetId() == SfxHintId::SwAttrSetChange)
{
auto pChangeHint = static_cast<const sw::AttrSetChangeHint*>(&rHint);
// catch SSize changes, to adjust the lines/boxes
const SwFormatFrameSize* pNewSize = nullptr, *pOldSize = nullptr;
if (pChangeHint->m_pOld && pChangeHint->m_pNew
&& (pNewSize = pChangeHint->m_pNew->GetChgSet()->GetItemIfSet(
RES_FRM_SIZE,
false)))
{
pOldSize = &pChangeHint->m_pOld->GetChgSet()->GetFrameSize();
}
if (pOldSize && pNewSize && !m_bModifyLocked)
AdjustWidths(pOldSize->GetWidth(), pNewSize->GetWidth());
}
else if (rHint.GetId() == SfxHintId::SwObjectDying)
{
auto pDyingHint = static_cast<const sw::ObjectDyingHint*>(&rHint);
CheckRegistration( *pDyingHint );
}
else if (rHint.GetId() == SfxHintId::SwLegacyModify)
{
auto pLegacy = static_cast<const sw::LegacyModifyHint*>(&rHint);
// catch SSize changes, to adjust the lines/boxes
const sal_uInt16 nWhich = pLegacy->GetWhich();
if (nWhich == RES_FRM_SIZE)
{
const SwFormatFrameSize* pNewSize = nullptr, *pOldSize = nullptr;
pOldSize = static_cast<const SwFormatFrameSize*>(pLegacy->m_pOld);
pNewSize = static_cast<const SwFormatFrameSize*>(pLegacy->m_pNew);
if (pOldSize && pNewSize && !m_bModifyLocked)
AdjustWidths(pOldSize->GetWidth(), pNewSize->GetWidth());
}
}
}
void SwTable::AdjustWidths( const tools::Long nOld, const tools::Long nNew )
{
std::vector<SwFormat*> aFormatArr;
aFormatArr.reserve( m_aLines[0]->GetTabBoxes().size() );
::lcl_ModifyLines( m_aLines, nOld, nNew, aFormatArr, true );
}
static void lcl_RefreshHidden( SwTabCols &rToFill, size_t nPos )
{
for ( size_t i = 0; i < rToFill.Count(); ++i )
{
if ( std::abs(static_cast<tools::Long>(nPos) - rToFill[i]) <= COLFUZZY )
{
rToFill.SetHidden( i, false );
break;
}
}
}
static void lcl_SortedTabColInsert( SwTabCols &rToFill, const SwTableBox *pBox,
const SwFrameFormat *pTabFormat, const bool bHidden,
const bool bRefreshHidden )
{
const tools::Long nWish = pTabFormat->GetFrameSize().GetWidth();
OSL_ENSURE(nWish, "weird <= 0 width frmfrm");
// The value for the left edge of the box is calculated from the
// widths of the previous boxes.
tools::Long nPos = 0;
tools::Long nLeftMin = 0;
tools::Long nRightMax = 0;
if (nWish != 0) //fdo#33012 0 width frmfmt
{
SwTwips nSum = 0;
const SwTableBox *pCur = pBox;
const SwTableLine *pLine = pBox->GetUpper();
const tools::Long nAct = rToFill.GetRight() - rToFill.GetLeft(); // +1 why?
while ( pLine )
{
const SwTableBoxes &rBoxes = pLine->GetTabBoxes();
for ( size_t i = 0; i < rBoxes.size(); ++i )
{
const SwTwips nWidth = rBoxes[i]->GetFrameFormat()->GetFrameSize().GetWidth();
nSum += nWidth;
const tools::Long nTmp = lcl_MulDiv64<tools::Long>(nSum, nAct, nWish);
if (rBoxes[i] != pCur)
{
if ( pLine == pBox->GetUpper() || 0 == nLeftMin )
nLeftMin = nTmp - nPos;
nPos = nTmp;
}
else
{
nSum -= nWidth;
if ( 0 == nRightMax )
nRightMax = nTmp - nPos;
break;
}
}
pCur = pLine->GetUpper();
pLine = pCur ? pCur->GetUpper() : nullptr;
}
}
bool bInsert = !bRefreshHidden;
for ( size_t j = 0; bInsert && (j < rToFill.Count()); ++j )
{
tools::Long nCmp = rToFill[j];
if ( (nPos >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
(nPos <= (nCmp + COLFUZZY)) )
{
bInsert = false; // Already has it.
}
else if ( nPos < nCmp )
{
bInsert = false;
rToFill.Insert( nPos, bHidden, j );
}
}
if ( bInsert )
rToFill.Insert( nPos, bHidden, rToFill.Count() );
else if ( bRefreshHidden )
::lcl_RefreshHidden( rToFill, nPos );
if ( !bHidden || bRefreshHidden )
return;
// calculate minimum/maximum values for the existing entries:
nLeftMin = nPos - nLeftMin;
nRightMax = nPos + nRightMax;
// check if nPos is entry:
bool bFoundPos = false;
bool bFoundMax = false;
for ( size_t j = 0; !(bFoundPos && bFoundMax ) && j < rToFill.Count(); ++j )
{
SwTabColsEntry& rEntry = rToFill.GetEntry( j );
tools::Long nCmp = rToFill[j];
if ( (nPos >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
(nPos <= (nCmp + COLFUZZY)) )
{
// check if nLeftMin is > old minimum for entry nPos:
const tools::Long nOldMin = rEntry.nMin;
if ( nLeftMin > nOldMin )
rEntry.nMin = nLeftMin;
// check if nRightMin is < old maximum for entry nPos:
const tools::Long nOldMax = rEntry.nMax;
if ( nRightMax < nOldMax )
rEntry.nMax = nRightMax;
bFoundPos = true;
}
else if ( (nRightMax >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
(nRightMax <= (nCmp + COLFUZZY)) )
{
// check if nPos is > old minimum for entry nRightMax:
const tools::Long nOldMin = rEntry.nMin;
if ( nPos > nOldMin )
rEntry.nMin = nPos;
bFoundMax = true;
}
}
}
static void lcl_ProcessBoxGet( const SwTableBox *pBox, SwTabCols &rToFill,
const SwFrameFormat *pTabFormat, bool bRefreshHidden )
{
if ( !pBox->GetTabLines().empty() )
{
const SwTableLines &rLines = pBox->GetTabLines();
for ( size_t i = 0; i < rLines.size(); ++i )
{
const SwTableBoxes &rBoxes = rLines[i]->GetTabBoxes();
for ( size_t j = 0; j < rBoxes.size(); ++j )
::lcl_ProcessBoxGet( rBoxes[j], rToFill, pTabFormat, bRefreshHidden);
}
}
else
::lcl_SortedTabColInsert( rToFill, pBox, pTabFormat, false, bRefreshHidden );
}
static void lcl_ProcessLineGet( const SwTableLine *pLine, SwTabCols &rToFill,
const SwFrameFormat *pTabFormat )
{
for ( size_t i = 0; i < pLine->GetTabBoxes().size(); ++i )
{
const SwTableBox *pBox = pLine->GetTabBoxes()[i];
if ( pBox->GetSttNd() )
::lcl_SortedTabColInsert( rToFill, pBox, pTabFormat, true, false );
else
for ( size_t j = 0; j < pBox->GetTabLines().size(); ++j )
::lcl_ProcessLineGet( pBox->GetTabLines()[j], rToFill, pTabFormat );
}
}
void SwTable::GetTabCols( SwTabCols &rToFill, const SwTableBox *pStart,
bool bRefreshHidden, bool bCurRowOnly ) const
{
// Optimization: if bHidden is set, we only update the Hidden Array.
if ( bRefreshHidden )
{
// remove corrections
for ( size_t i = 0; i < rToFill.Count(); ++i )
{
SwTabColsEntry& rEntry = rToFill.GetEntry( i );
rEntry.nPos -= rToFill.GetLeft();
rEntry.nMin -= rToFill.GetLeft();
rEntry.nMax -= rToFill.GetLeft();
}
// All are hidden, so add the visible ones.
for ( size_t i = 0; i < rToFill.Count(); ++i )
rToFill.SetHidden( i, true );
}
else
{
rToFill.Remove( 0, rToFill.Count() );
}
// Insertion cases:
// 1. All boxes which are inferior to Line which is superior to the Start,
// as well as their inferior boxes if present.
// 2. Starting from the Line, the superior box plus its neighbours; but no inferiors.
// 3. Apply 2. to the Line superior to the chain of boxes,
// until the Line's superior is not a box but the table.
// Only those boxes are inserted that don't contain further rows. The insertion
// function takes care to avoid duplicates. In order to achieve this, we work
// with some degree of fuzzyness (to avoid rounding errors).
// Only the left edge of the boxes are inserted.
// Finally, the first entry is removed again, because it's already
// covered by the border.
// 4. Scan the table again and insert _all_ boxes, this time as hidden.
const SwFrameFormat *pTabFormat = GetFrameFormat();
// 1.
const SwTableBoxes &rBoxes = pStart->GetUpper()->GetTabBoxes();
for ( size_t i = 0; i < rBoxes.size(); ++i )
::lcl_ProcessBoxGet( rBoxes[i], rToFill, pTabFormat, bRefreshHidden );
// 2. and 3.
const SwTableLine *pLine = pStart->GetUpper()->GetUpper() ?
pStart->GetUpper()->GetUpper()->GetUpper() : nullptr;
while ( pLine )
{
const SwTableBoxes &rBoxes2 = pLine->GetTabBoxes();
for ( size_t k = 0; k < rBoxes2.size(); ++k )
::lcl_SortedTabColInsert( rToFill, rBoxes2[k],
pTabFormat, false, bRefreshHidden );
pLine = pLine->GetUpper() ? pLine->GetUpper()->GetUpper() : nullptr;
}
if ( !bRefreshHidden )
{
// 4.
if ( !bCurRowOnly )
{
for ( size_t i = 0; i < m_aLines.size(); ++i )
::lcl_ProcessLineGet( m_aLines[i], rToFill, pTabFormat );
}
rToFill.Remove( 0 );
}
// Now the coordinates are relative to the left table border - i.e.
// relative to SwTabCols.nLeft. However, they are expected
// relative to the left document border, i.e. SwTabCols.nLeftMin.
// So all values need to be extended by nLeft.
for ( size_t i = 0; i < rToFill.Count(); ++i )
{
SwTabColsEntry& rEntry = rToFill.GetEntry( i );
rEntry.nPos += rToFill.GetLeft();
rEntry.nMin += rToFill.GetLeft();
rEntry.nMax += rToFill.GetLeft();
}
}
// Structure for parameter passing
struct Parm
{
const SwTabCols &rNew;
const SwTabCols &rOld;
tools::Long nNewWish,
nOldWish;
std::deque<SwTableBox*> aBoxArr;
SwShareBoxFormats aShareFormats;
Parm( const SwTabCols &rN, const SwTabCols &rO )
: rNew( rN ), rOld( rO ), nNewWish(0), nOldWish(0)
{}
};
static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm );
static void lcl_ProcessLine( SwTableLine *pLine, Parm &rParm )
{
SwTableBoxes &rBoxes = pLine->GetTabBoxes();
for ( size_t i = rBoxes.size(); i > 0; )
{
--i;
::lcl_ProcessBoxSet( rBoxes[i], rParm );
}
}
static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm )
{
if ( !pBox->GetTabLines().empty() )
{
SwTableLines &rLines = pBox->GetTabLines();
for ( size_t i = rLines.size(); i > 0; )
{
--i;
lcl_ProcessLine( rLines[i], rParm );
}
}
else
{
// Search the old TabCols for the current position (calculate from
// left and right edge). Adjust the box if the values differ from
// the new TabCols. If the adjusted edge has no neighbour we also
// adjust all superior boxes.
const tools::Long nOldAct = rParm.rOld.GetRight() -
rParm.rOld.GetLeft(); // +1 why?
// The value for the left edge of the box is calculated from the
// widths of the previous boxes plus the left edge.
tools::Long nLeft = rParm.rOld.GetLeft();
const SwTableBox *pCur = pBox;
const SwTableLine *pLine = pBox->GetUpper();
while ( pLine )
{
const SwTableBoxes &rBoxes = pLine->GetTabBoxes();
for ( size_t i = 0; (i < rBoxes.size()) && (rBoxes[i] != pCur); ++i)
{
nLeft += lcl_MulDiv64<tools::Long>(
rBoxes[i]->GetFrameFormat()->GetFrameSize().GetWidth(),
nOldAct, rParm.nOldWish);
}
pCur = pLine->GetUpper();
pLine = pCur ? pCur->GetUpper() : nullptr;
}
tools::Long nLeftDiff = 0;
tools::Long nRightDiff = 0;
if ( nLeft != rParm.rOld.GetLeft() ) // There are still boxes before this.
{
// Right edge is left edge plus width.
const tools::Long nWidth = lcl_MulDiv64<tools::Long>(
pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
nOldAct, rParm.nOldWish);
const tools::Long nRight = nLeft + nWidth;
size_t nLeftPos = 0;
size_t nRightPos = 0;
bool bFoundLeftPos = false;
bool bFoundRightPos = false;
for ( size_t i = 0; i < rParm.rOld.Count(); ++i )
{
if ( nLeft >= (rParm.rOld[i] - COLFUZZY) &&
nLeft <= (rParm.rOld[i] + COLFUZZY) )
{
nLeftPos = i;
bFoundLeftPos = true;
}
else if ( nRight >= (rParm.rOld[i] - COLFUZZY) &&
nRight <= (rParm.rOld[i] + COLFUZZY) )
{
nRightPos = i;
bFoundRightPos = true;
}
}
nLeftDiff = bFoundLeftPos ?
rParm.rOld[nLeftPos] - rParm.rNew[nLeftPos] : 0;
nRightDiff= bFoundRightPos ?
rParm.rNew[nRightPos] - rParm.rOld[nRightPos] : 0;
}
else // The first box.
{
nLeftDiff = rParm.rOld.GetLeft() - rParm.rNew.GetLeft();
if ( rParm.rOld.Count() )
{
// Calculate the difference to the edge touching the first box.
const tools::Long nWidth = lcl_MulDiv64<tools::Long>(
pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
nOldAct, rParm.nOldWish);
const tools::Long nTmp = nWidth + rParm.rOld.GetLeft();
for ( size_t i = 0; i < rParm.rOld.Count(); ++i )
{
if ( nTmp >= (rParm.rOld[i] - COLFUZZY) &&
nTmp <= (rParm.rOld[i] + COLFUZZY) )
{
nRightDiff = rParm.rNew[i] - rParm.rOld[i];
break;
}
}
}
}
if( pBox->getRowSpan() == 1 )
{
const sal_uInt16 nPos = pBox->GetUpper()->GetBoxPos( pBox );
SwTableBoxes& rTableBoxes = pBox->GetUpper()->GetTabBoxes();
if( nPos && rTableBoxes[ nPos - 1 ]->getRowSpan() != 1 )
nLeftDiff = 0;
if( nPos + 1 < o3tl::narrowing<sal_uInt16>(rTableBoxes.size()) &&
rTableBoxes[ nPos + 1 ]->getRowSpan() != 1 )
nRightDiff = 0;
}
else
nLeftDiff = nRightDiff = 0;
if ( nLeftDiff || nRightDiff )
{
// The difference is the actual difference amount. For stretched
// tables, it does not make sense to adjust the attributes of the
// boxes by this amount. The difference amount needs to be converted
// accordingly.
tools::Long nTmp = rParm.rNew.GetRight() - rParm.rNew.GetLeft(); // +1 why?
nLeftDiff *= rParm.nNewWish;
nLeftDiff /= nTmp;
nRightDiff *= rParm.nNewWish;
nRightDiff /= nTmp;
tools::Long nDiff = nLeftDiff + nRightDiff;
// Adjust the box and all superiors by the difference amount.
while ( pBox )
{
SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
aFormatFrameSize.SetWidth( aFormatFrameSize.GetWidth() + nDiff );
if ( aFormatFrameSize.GetWidth() < 0 )
aFormatFrameSize.SetWidth( -aFormatFrameSize.GetWidth() );
rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
// The outer cells of the last row are responsible to adjust a surrounding cell.
// Last line check:
if ( pBox->GetUpper()->GetUpper() &&
pBox->GetUpper() != pBox->GetUpper()->GetUpper()->GetTabLines().back())
{
pBox = nullptr;
}
else
{
// Middle cell check:
if ( pBox != pBox->GetUpper()->GetTabBoxes().front() )
nDiff = nRightDiff;
if ( pBox != pBox->GetUpper()->GetTabBoxes().back() )
nDiff -= nRightDiff;
pBox = nDiff ? pBox->GetUpper()->GetUpper() : nullptr;
}
}
}
}
}
static void lcl_ProcessBoxPtr( SwTableBox *pBox, std::deque<SwTableBox*> &rBoxArr,
bool bBefore )
{
if ( !pBox->GetTabLines().empty() )
{
const SwTableLines &rLines = pBox->GetTabLines();
for ( size_t i = 0; i < rLines.size(); ++i )
{
const SwTableBoxes &rBoxes = rLines[i]->GetTabBoxes();
for ( size_t j = 0; j < rBoxes.size(); ++j )
::lcl_ProcessBoxPtr( rBoxes[j], rBoxArr, bBefore );
}
}
else if ( bBefore )
rBoxArr.push_front( pBox );
else
rBoxArr.push_back( pBox );
}
static void lcl_AdjustBox( SwTableBox *pBox, const tools::Long nDiff, Parm &rParm );
static void lcl_AdjustLines( SwTableLines &rLines, const tools::Long nDiff, Parm &rParm )
{
for ( size_t i = 0; i < rLines.size(); ++i )
{
SwTableBox *pBox = rLines[i]->GetTabBoxes()
[rLines[i]->GetTabBoxes().size()-1];
lcl_AdjustBox( pBox, nDiff, rParm );
}
}
static void lcl_AdjustBox( SwTableBox *pBox, const tools::Long nDiff, Parm &rParm )
{
if ( !pBox->GetTabLines().empty() )
::lcl_AdjustLines( pBox->GetTabLines(), nDiff, rParm );
// Adjust the size of the box.
SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
aFormatFrameSize.SetWidth( aFormatFrameSize.GetWidth() + nDiff );
rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
}
void SwTable::SetTabCols( const SwTabCols &rNew, const SwTabCols &rOld,
const SwTableBox *pStart, bool bCurRowOnly )
{
CHECK_TABLE( *this )
SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout>()); // delete HTML-Layout
// FME: Made rOld const. The caller is responsible for passing correct
// values of rOld. Therefore we do not have to call GetTabCols anymore:
//GetTabCols( rOld, pStart );
Parm aParm( rNew, rOld );
OSL_ENSURE( rOld.Count() == rNew.Count(), "Number of columns changed.");
// Convert the edges. We need to adjust the size of the table and some boxes.
// For the size adjustment, we must not make use of the Modify, since that'd
// adjust all boxes, which we really don't want.
SwFrameFormat *pFormat = GetFrameFormat();
aParm.nOldWish = aParm.nNewWish = pFormat->GetFrameSize().GetWidth();
if ( (rOld.GetLeft() != rNew.GetLeft()) ||
(rOld.GetRight()!= rNew.GetRight()) )
{
LockModify();
{
SvxLRSpaceItem aLR( pFormat->GetLRSpace() );
SvxShadowItem aSh( pFormat->GetShadow() );
SwTwips nShRight = aSh.CalcShadowSpace( SvxShadowItemSide::RIGHT );
SwTwips nShLeft = aSh.CalcShadowSpace( SvxShadowItemSide::LEFT );
aLR.SetLeft(SvxIndentValue::twips(rNew.GetLeft() - nShLeft));
aLR.SetRight(SvxIndentValue::twips(rNew.GetRightMax() - rNew.GetRight() - nShRight));
pFormat->SetFormatAttr( aLR );
// The alignment of the table needs to be adjusted accordingly.
// This is done by preserving the exact positions that have been
// set by the user.
SwFormatHoriOrient aOri( pFormat->GetHoriOrient() );
if( text::HoriOrientation::NONE != aOri.GetHoriOrient() &&
text::HoriOrientation::CENTER != aOri.GetHoriOrient() )
{
const bool bLeftDist = rNew.GetLeft() != nShLeft;
const bool bRightDist = rNew.GetRight() + nShRight != rNew.GetRightMax();
if(!bLeftDist && !bRightDist)
aOri.SetHoriOrient( text::HoriOrientation::FULL );
else if(!bRightDist && rNew.GetLeft() > nShLeft )
aOri.SetHoriOrient( text::HoriOrientation::RIGHT );
else if(!bLeftDist && rNew.GetRight() + nShRight < rNew.GetRightMax())
aOri.SetHoriOrient( text::HoriOrientation::LEFT );
else
{
// if an automatic table hasn't (really) changed size, then leave it as auto.
const tools::Long nOldWidth = rOld.GetRight() - rOld.GetLeft();
const tools::Long nNewWidth = rNew.GetRight() - rNew.GetLeft();
if (aOri.GetHoriOrient() != text::HoriOrientation::FULL
|| std::abs(nOldWidth - nNewWidth) > COLFUZZY)
{
aOri.SetHoriOrient(text::HoriOrientation::LEFT_AND_WIDTH);
}
}
}
pFormat->SetFormatAttr( aOri );
}
const tools::Long nAct = rOld.GetRight() - rOld.GetLeft(); // +1 why?
tools::Long nTabDiff = 0;
if ( rOld.GetLeft() != rNew.GetLeft() )
{
nTabDiff = rOld.GetLeft() - rNew.GetLeft();
nTabDiff *= aParm.nOldWish;
nTabDiff /= nAct;
}
if ( rOld.GetRight() != rNew.GetRight() )
{
tools::Long nDiff = rNew.GetRight() - rOld.GetRight();
nDiff *= aParm.nOldWish;
nDiff /= nAct;
nTabDiff += nDiff;
if( !IsNewModel() )
::lcl_AdjustLines( GetTabLines(), nDiff, aParm );
}
// Adjust the size of the table, watch out for stretched tables.
if ( nTabDiff )
{
aParm.nNewWish += nTabDiff;
if ( aParm.nNewWish < 0 )
aParm.nNewWish = USHRT_MAX; // Oops! Have to roll back.
SwFormatFrameSize aSz( pFormat->GetFrameSize() );
if ( aSz.GetWidth() != aParm.nNewWish )
{
aSz.SetWidth( aParm.nNewWish );
aSz.SetWidthPercent( 0 );
pFormat->SetFormatAttr( aSz );
}
}
UnlockModify();
}
if( IsNewModel() )
NewSetTabCols( aParm, rNew, rOld, pStart, bCurRowOnly );
else
{
if ( bCurRowOnly )
{
// To adjust the current row, we need to process all its boxes,
// similar to the filling of the TabCols (see GetTabCols()).
// Unfortunately we again have to take care to adjust the boxes
// from back to front, respectively from outer to inner.
// The best way to achieve this is probably to track the boxes
// in a PtrArray.
const SwTableBoxes &rBoxes = pStart->GetUpper()->GetTabBoxes();
for ( size_t i = 0; i < rBoxes.size(); ++i )
::lcl_ProcessBoxPtr( rBoxes[i], aParm.aBoxArr, false );
const SwTableLine *pLine = pStart->GetUpper()->GetUpper() ?
pStart->GetUpper()->GetUpper()->GetUpper() : nullptr;
const SwTableBox *pExcl = pStart->GetUpper()->GetUpper();
while ( pLine )
{
const SwTableBoxes &rBoxes2 = pLine->GetTabBoxes();
bool bBefore = true;
for ( size_t i = 0; i < rBoxes2.size(); ++i )
{
if ( rBoxes2[i] != pExcl )
::lcl_ProcessBoxPtr( rBoxes2[i], aParm.aBoxArr, bBefore );
else
bBefore = false;
}
pExcl = pLine->GetUpper();
pLine = pLine->GetUpper() ? pLine->GetUpper()->GetUpper() : nullptr;
}
// After we've inserted a bunch of boxes (hopefully all and in
// correct order), we just need to process them in reverse order.
for ( int j = aParm.aBoxArr.size()-1; j >= 0; --j )
{
SwTableBox *pBox = aParm.aBoxArr[j];
::lcl_ProcessBoxSet( pBox, aParm );
}
}
else
{
// Adjusting the entire table is 'easy'. All boxes without lines are
// adjusted, as are their superiors. Of course we need to process
// in reverse order to prevent fooling ourselves!
SwTableLines &rLines = GetTabLines();
for ( size_t i = rLines.size(); i > 0; )
{
--i;
::lcl_ProcessLine( rLines[i], aParm );
}
}
}
#ifdef DBG_UTIL
CheckBoxWidth(GetTabLines(), *GetFrameFormat());
#endif
}
typedef std::pair<sal_uInt16, sal_uInt16> ColChange;
typedef std::list< ColChange > ChangeList;
static void lcl_AdjustWidthsInLine( SwTableLine* pLine, ChangeList& rOldNew,
Parm& rParm, sal_uInt16 nColFuzzy )
{
ChangeList::iterator pCurr = rOldNew.begin();
if( pCurr == rOldNew.end() )
return;
const size_t nCount = pLine->GetTabBoxes().size();
SwTwips nBorder = 0;
SwTwips nRest = 0;
for( size_t i = 0; i < nCount; ++i )
{
SwTableBox* pBox = pLine->GetTabBoxes()[i];
SwTwips nWidth = pBox->GetFrameFormat()->GetFrameSize().GetWidth();
SwTwips nNewWidth = nWidth - nRest;
nRest = 0;
nBorder += nWidth;
if( pCurr != rOldNew.end() && nBorder + nColFuzzy >= pCurr->first )
{
nBorder -= nColFuzzy;
while( pCurr != rOldNew.end() && nBorder > pCurr->first )
++pCurr;
if( pCurr != rOldNew.end() )
{
nBorder += nColFuzzy;
if( nBorder + nColFuzzy >= pCurr->first )
{
if( pCurr->second == pCurr->first )
nRest = 0;
else
nRest = pCurr->second - nBorder;
nNewWidth += nRest;
++pCurr;
}
}
}
if( nNewWidth != nWidth )
{
if( nNewWidth < 0 )
{
nRest += 1 - nNewWidth;
nNewWidth = 1;
}
SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
aFormatFrameSize.SetWidth( nNewWidth );
rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
}
}
}
static void lcl_CalcNewWidths( std::vector<sal_uInt16> &rSpanPos, ChangeList& rChanges,
SwTableLine* pLine, tools::Long nWish, tools::Long nWidth, bool bTop )
{
if( rChanges.empty() )
{
rSpanPos.clear();
return;
}
if( rSpanPos.empty() )
{
rChanges.clear();
return;
}
std::vector<sal_uInt16> aNewSpanPos;
ChangeList::iterator pCurr = rChanges.begin();
ChangeList aNewChanges { *pCurr }; // Nullposition
std::vector<sal_uInt16>::iterator pSpan = rSpanPos.begin();
sal_uInt16 nCurr = 0;
SwTwips nOrgSum = 0;
bool bRowSpan = false;
sal_uInt16 nRowSpanCount = 0;
const size_t nCount = pLine->GetTabBoxes().size();
for( size_t nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
{
SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
SwTwips nCurrWidth = pBox->GetFrameFormat()->GetFrameSize().GetWidth();
const sal_Int32 nRowSpan = pBox->getRowSpan();
const bool bCurrRowSpan = bTop ? nRowSpan < 0 :
( nRowSpan > 1 || nRowSpan < -1 );
if( bRowSpan || bCurrRowSpan )
aNewSpanPos.push_back( nRowSpanCount );
bRowSpan = bCurrRowSpan;
nOrgSum += nCurrWidth;
const sal_uInt16 nPos = lcl_MulDiv64<sal_uInt16>(
lcl_MulDiv64<sal_uInt64>(nOrgSum, nWidth, nWish),
nWish, nWidth);
while( pCurr != rChanges.end() && pCurr->first < nPos )
{
++nCurr;
++pCurr;
}
bool bNew = true;
if( pCurr != rChanges.end() && pCurr->first <= nPos &&
pCurr->first != pCurr->second )
{
pSpan = std::find_if(pSpan, rSpanPos.end(),
[nCurr](const sal_uInt16 nSpan) { return nSpan >= nCurr; });
if( pSpan != rSpanPos.end() && *pSpan == nCurr )
{
aNewChanges.push_back( *pCurr );
++nRowSpanCount;
bNew = false;
}
}
if( bNew )
{
ColChange aTmp( nPos, nPos );
aNewChanges.push_back( aTmp );
++nRowSpanCount;
}
}
pCurr = aNewChanges.begin();
ChangeList::iterator pLast = pCurr;
ChangeList::iterator pLeftMove = pCurr;
while( pCurr != aNewChanges.end() )
{
if( pLeftMove == pCurr )
{
while( ++pLeftMove != aNewChanges.end() && pLeftMove->first <= pLeftMove->second )
;
}
if( pCurr->second == pCurr->first )
{
if( pLeftMove != aNewChanges.end() && pCurr->second > pLeftMove->second )
{
if( pLeftMove->first == pLast->first )
pCurr->second = pLeftMove->second;
else
{
pCurr->second = lcl_MulDiv64<sal_uInt16>(
pCurr->first - pLast->first,
pLeftMove->second - pLast->second,
pLeftMove->first - pLast->first) + pLast->second;
}
}
pLast = pCurr;
++pCurr;
}
else if( pCurr->second > pCurr->first )
{
pLast = pCurr;
++pCurr;
ChangeList::iterator pNext = pCurr;
while( pNext != pLeftMove && pNext->second == pNext->first &&
pNext->second < pLast->second )
++pNext;
while( pCurr != pNext )
{
if( pNext == aNewChanges.end() || pNext->first == pLast->first )
pCurr->second = pLast->second;
else
{
pCurr->second = lcl_MulDiv64<sal_uInt16>(
pCurr->first - pLast->first,
pNext->second - pLast->second,
pNext->first - pLast->first) + pLast->second;
}
++pCurr;
}
pLast = pCurr;
}
else
{
pLast = pCurr;
++pCurr;
}
}
rChanges.swap(aNewChanges);
rSpanPos.swap(aNewSpanPos);
}
void SwTable::NewSetTabCols( Parm &rParm, const SwTabCols &rNew,
const SwTabCols &rOld, const SwTableBox *pStart, bool bCurRowOnly )
{
#if OSL_DEBUG_LEVEL > 1
static int nCallCount = 0;
++nCallCount;
#endif
// First step: evaluate which lines have been moved/which widths changed
ChangeList aOldNew;
const tools::Long nNewWidth = rParm.rNew.GetRight() - rParm.rNew.GetLeft();
const tools::Long nOldWidth = rParm.rOld.GetRight() - rParm.rOld.GetLeft();
if( nNewWidth < 1 || nOldWidth < 1 )
return;
for( size_t i = 0; i <= rOld.Count(); ++i )
{
tools::Long nNewPos;
tools::Long nOldPos;
if( i == rOld.Count() )
{
nOldPos = rParm.rOld.GetRight() - rParm.rOld.GetLeft();
nNewPos = rParm.rNew.GetRight() - rParm.rNew.GetLeft();
}
else
{
nOldPos = rOld[i] - rParm.rOld.GetLeft();
nNewPos = rNew[i] - rParm.rNew.GetLeft();
}
nNewPos = lcl_MulDiv64<tools::Long>(nNewPos, rParm.nNewWish, nNewWidth);
nOldPos = lcl_MulDiv64<tools::Long>(nOldPos, rParm.nOldWish, nOldWidth);
if( nOldPos != nNewPos && nNewPos > 0 && nOldPos > 0 )
{
ColChange aChg( o3tl::narrowing<sal_uInt16>(nOldPos), o3tl::narrowing<sal_uInt16>(nNewPos) );
aOldNew.push_back( aChg );
}
}
// Finished first step
int nCount = aOldNew.size();
if( !nCount )
return; // no change, nothing to do
SwTableLines &rLines = GetTabLines();
if( bCurRowOnly )
{
const SwTableLine* pCurrLine = pStart->GetUpper();
sal_uInt16 nCurr = rLines.GetPos( pCurrLine );
if( nCurr >= USHRT_MAX )
return;
ColChange aChg( 0, 0 );
aOldNew.push_front( aChg );
std::vector<sal_uInt16> aRowSpanPos;
if (nCurr > 0)
{
ChangeList aCopy;
sal_uInt16 nPos = 0;
for( const auto& rCop : aOldNew )
{
aCopy.push_back( rCop );
aRowSpanPos.push_back( nPos++ );
}
lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[nCurr],
rParm.nOldWish, nOldWidth, true );
sal_uInt16 j = nCurr;
while (!aRowSpanPos.empty() && j > 0)
{
j = o3tl::sanitizing_dec(j);
lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[j],
rParm.nOldWish, nOldWidth, true );
lcl_AdjustWidthsInLine( rLines[j], aCopy, rParm, 0 );
}
aRowSpanPos.clear();
}
if( nCurr+1 < o3tl::narrowing<sal_uInt16>(rLines.size()) )
{
ChangeList aCopy;
sal_uInt16 nPos = 0;
for( const auto& rCop : aOldNew )
{
aCopy.push_back( rCop );
aRowSpanPos.push_back( nPos++ );
}
lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[nCurr],
rParm.nOldWish, nOldWidth, false );
bool bGoOn = !aRowSpanPos.empty();
sal_uInt16 j = nCurr;
while( bGoOn )
{
lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[++j],
rParm.nOldWish, nOldWidth, false );
lcl_AdjustWidthsInLine( rLines[j], aCopy, rParm, 0 );
bGoOn = !aRowSpanPos.empty() && j+1 < o3tl::narrowing<sal_uInt16>(rLines.size());
}
}
::lcl_AdjustWidthsInLine( rLines[nCurr], aOldNew, rParm, COLFUZZY );
}
else
{
for( size_t i = 0; i < rLines.size(); ++i )
::lcl_AdjustWidthsInLine( rLines[i], aOldNew, rParm, COLFUZZY );
}
CHECK_TABLE( *this )
}
// return the pointer of the box specified.
static bool lcl_IsValidRowName( std::u16string_view rStr )
{
bool bIsValid = true;
size_t nLen = rStr.size();
for( size_t i = 0; i < nLen && bIsValid; ++i )
{
const sal_Unicode cChar = rStr[i];
if (cChar < '0' || cChar > '9')
bIsValid = false;
}
return bIsValid;
}
// #i80314#
// add 3rd parameter and its handling
sal_uInt16 SwTable::GetBoxNum( OUString& rStr, bool bFirstPart,
const bool bPerformValidCheck )
{
sal_uInt16 nRet = 0;
if( bFirstPart ) // true == column; false == row
{
sal_Int32 nPos = 0;
// the first one uses letters for addressing!
bool bFirst = true;
sal_uInt32 num = 0;
bool overflow = false;
while (nPos<rStr.getLength())
{
sal_Unicode cChar = rStr[nPos];
if ((cChar<'A' || cChar>'Z') && (cChar<'a' || cChar>'z'))
break;
cChar -= 'A';
if( cChar >= 26 )
cChar -= 'a' - '[';
if( bFirst )
bFirst = false;
else
++num;
num = num * 52 + cChar;
if (num > SAL_MAX_UINT16) {
overflow = true;
}
++nPos;
}
nRet = overflow ? SAL_MAX_UINT16 : num;
rStr = rStr.copy( nPos ); // Remove char from String
}
else
{
const sal_Int32 nPos = rStr.indexOf( "." );
if ( nPos<0 )
{
nRet = 0;
if ( !bPerformValidCheck || lcl_IsValidRowName( rStr ) )
{
nRet = o3tl::narrowing<sal_uInt16>(rStr.toInt32());
}
rStr.clear();
}
else
{
nRet = 0;
const std::u16string_view aText( rStr.subView( 0, nPos ) );
if ( !bPerformValidCheck || lcl_IsValidRowName( aText ) )
{
nRet = o3tl::narrowing<sal_uInt16>(o3tl::toInt32(aText));
}
rStr = rStr.copy( nPos+1 );
}
}
return nRet;
}
// #i80314#
// add 2nd parameter and its handling
const SwTableBox* SwTable::GetTableBox( const OUString& rName,
const bool bPerformValidCheck ) const
{
const SwTableBox* pBox = nullptr;
const SwTableLine* pLine;
const SwTableLines* pLines;
sal_uInt16 nLine, nBox;
OUString aNm( rName );
while( !aNm.isEmpty() )
{
nBox = SwTable::GetBoxNum( aNm, nullptr == pBox, bPerformValidCheck );
// first box ?
if( !pBox )
pLines = &GetTabLines();
else
{
pLines = &pBox->GetTabLines();
if( nBox )
--nBox;
}
nLine = SwTable::GetBoxNum( aNm, false, bPerformValidCheck );
// determine line
if( !nLine || nLine > pLines->size() )
return nullptr;
pLine = (*pLines)[ nLine-1 ];
// determine box
const SwTableBoxes* pBoxes = &pLine->GetTabBoxes();
if( nBox >= pBoxes->size() )
return nullptr;
pBox = (*pBoxes)[ nBox ];
}
// check if the box found has any contents
if( pBox && !pBox->GetSttNd() )
{
OSL_FAIL( "Box without content, looking for the next one!" );
// "drop this" until the first box
while( !pBox->GetTabLines().empty() )
pBox = pBox->GetTabLines().front()->GetTabBoxes().front();
}
return pBox;
}
SwTableBox* SwTable::GetTableBox( SwNodeOffset nSttIdx )
{
// For optimizations, don't always process the entire SortArray.
// Converting text to table, tries certain conditions
// to ask for a table box of a table that is not yet having a format
if(!GetFrameFormat())
return nullptr;
SwTableBox* pRet = nullptr;
SwNodes& rNds = GetFrameFormat()->GetDoc().GetNodes();
SwNodeOffset nIndex = nSttIdx + 1;
SwContentNode* pCNd = nullptr;
SwTableNode* pTableNd = nullptr;
while ( nIndex < rNds.Count() )
{
pTableNd = rNds[ nIndex ]->GetTableNode();
if ( pTableNd )
break;
pCNd = rNds[ nIndex ]->GetContentNode();
if ( pCNd )
break;
++nIndex;
}
if ( pCNd || pTableNd )
{
sw::BroadcastingModify* pModify = pCNd;
// #144862# Better handling of table in table
if ( pTableNd && pTableNd->GetTable().GetFrameFormat() )
pModify = pTableNd->GetTable().GetFrameFormat();
SwFrame* pFrame = pModify ? SwIterator<SwFrame,sw::BroadcastingModify>(*pModify).First() : nullptr;
while ( pFrame && !pFrame->IsCellFrame() )
pFrame = pFrame->GetUpper();
if ( pFrame )
pRet = const_cast<SwTableBox*>(static_cast<SwCellFrame*>(pFrame)->GetTabBox());
}
// In case the layout doesn't exist yet or anything else goes wrong.
if ( !pRet )
{
for (size_t n = m_TabSortContentBoxes.size(); n; )
{
if (m_TabSortContentBoxes[ --n ]->GetSttIdx() == nSttIdx)
{
return m_TabSortContentBoxes[ n ];
}
}
}
return pRet;
}
bool SwTable::IsTableComplex() const
{
// Returns true for complex tables, i.e. tables that contain nestings,
// like containing boxes not part of the first line, e.g. results of
// splits/merges which lead to more complex structures.
for (size_t n = 0; n < m_TabSortContentBoxes.size(); ++n)
{
if (m_TabSortContentBoxes[ n ]->GetUpper()->GetUpper())
{
return true;
}
}
return false;
}
SwTableLine::SwTableLine( SwTableLineFormat *pFormat, sal_uInt16 nBoxes,
SwTableBox *pUp )
: SwClient( pFormat )
, m_pUpper( pUp )
, m_eRedlineType( RedlineType::None )
{
m_aBoxes.reserve( nBoxes );
}
SwTableLine::~SwTableLine()
{
for (size_t i = 0; i < m_aBoxes.size(); ++i)
{
delete m_aBoxes[i];
}
// the TabelleLine can be deleted if it's the last client of the FrameFormat
sw::BroadcastingModify* pMod = GetFrameFormat();
pMod->Remove(*this); // remove,
if( !pMod->HasWriterListeners() )
delete pMod; // and delete
}
SwTableLineFormat* SwTableLine::ClaimFrameFormat()
{
// This method makes sure that this object is an exclusive SwTableLine client
// of an SwTableLineFormat object
// If other SwTableLine objects currently listen to the same SwTableLineFormat as
// this one, something needs to be done
SwTableLineFormat *pRet = GetFrameFormat();
SwIterator<SwTableLine,SwFormat> aIter( *pRet );
for( SwTableLine* pLast = aIter.First(); pLast; pLast = aIter.Next() )
{
if ( pLast != this )
{
// found another SwTableLine that is a client of the current Format
// create a new Format as a copy and use it for this object
SwTableLineFormat *pNewFormat = pRet->GetDoc().MakeTableLineFormat();
*pNewFormat = *pRet;
// register SwRowFrames that know me as clients at the new Format
SwIterator<SwRowFrame,SwFormat> aFrameIter( *pRet );
for( SwRowFrame* pFrame = aFrameIter.First(); pFrame; pFrame = aFrameIter.Next() )
if( pFrame->GetTabLine() == this )
pFrame->RegisterToFormat( *pNewFormat );
// register myself
pNewFormat->Add(*this);
pRet = pNewFormat;
break;
}
}
return pRet;
}
void SwTableLine::ChgFrameFormat(SwTableLineFormat* pNewFormat)
{
auto pOld = GetFrameFormat();
pOld->CallSwClientNotify(sw::TableLineFormatChanged(*pNewFormat, *this));
// Now, re-register self.
pNewFormat->Add(*this);
if(!pOld->HasWriterListeners())
delete pOld;
}
SwTwips SwTableLine::GetTableLineHeight( bool& bLayoutAvailable ) const
{
SwTwips nRet = 0;
bLayoutAvailable = false;
SwIterator<SwRowFrame,SwFormat> aIter( *GetFrameFormat() );
// A row could appear several times in headers/footers so only one chain of master/follow tables
// will be accepted...
const SwTabFrame* pChain = nullptr; // My chain
for( SwRowFrame* pLast = aIter.First(); pLast; pLast = aIter.Next() )
{
if (pLast->GetTabLine() != this)
continue;
const SwTabFrame* pTab = pLast->FindTabFrame();
if (!pTab)
continue;
bLayoutAvailable = ( pTab->IsVertical() ) ?
( 0 < pTab->getFrameArea().Height() ) :
( 0 < pTab->getFrameArea().Width() );
// The first one defines the chain, if a chain is defined, only members of the chain
// will be added.
if (!pChain || pChain->IsAnFollow( pTab ) || pTab->IsAnFollow(pChain))
{
pChain = pTab; // defines my chain (even it is already)
if( pTab->IsVertical() )
nRet += pLast->getFrameArea().Width();
else
nRet += pLast->getFrameArea().Height();
// Optimization, if there are no master/follows in my chain, nothing more to add
if( !pTab->HasFollow() && !pTab->IsFollow() )
break;
// This is not an optimization, this is necessary to avoid double additions of
// repeating rows
if( pTab->IsInHeadline(*pLast) )
break;
}
}
return nRet;
}
bool SwTableLine::IsEmpty() const
{
for (size_t i = 0; i < m_aBoxes.size(); ++i)
{
if ( !m_aBoxes[i]->IsEmpty() )
return false;
}
return true;
}
bool SwTable::IsEmpty() const
{
for (size_t i = 0; i < m_aLines.size(); ++i)
{
if ( !m_aLines[i]->IsEmpty() )
return false;
}
return true;
}
bool SwTable::HasDeletedRowOrCell() const
{
const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
if ( aRedlineTable.empty() )
return false;
SwRedlineTable::size_type nRedlinePos = 0;
for (size_t i = 0; i < m_aLines.size(); ++i)
{
// has a deleted row
if ( m_aLines[i]->IsDeleted(nRedlinePos) )
return true;
// has a deleted cell in the not deleted row
SwTableBoxes& rBoxes = m_aLines[i]->GetTabBoxes();
for( size_t j = 0; j < rBoxes.size(); ++j )
{
if ( RedlineType::Delete == rBoxes[j]->GetRedlineType() )
return true;
}
}
return false;
}
bool SwTable::IsDeleted() const
{
const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
if ( aRedlineTable.empty() )
return false;
SwRedlineTable::size_type nRedlinePos = 0;
for (size_t i = 0; i < m_aLines.size(); ++i)
{
if ( !m_aLines[i]->IsDeleted(nRedlinePos) )
return false;
}
return true;
}
void SwTable::GatherFormulas(std::vector<SwTableBoxFormula*>& rvFormulas)
{
GatherFormulas(GetFrameFormat()->GetDoc(), rvFormulas);
}
void SwTable::GatherFormulas(SwDoc& rDoc, std::vector<SwTableBoxFormula*>& rvFormulas)
{
rvFormulas.clear();
sw::TableFrameFormats* pTableFrameFormats = rDoc.GetTableFrameFormats();
for(SwTableFormat* pFormat : *pTableFrameFormats)
{
SwTable* pTable = FindTable(pFormat);
if (!pTable)
continue;
SwTableLines& rTableLines = pTable->GetTabLines();
for (SwTableLine* pTableLine : rTableLines)
{
SwTableBoxes& rTableBoxes = pTableLine->GetTabBoxes();
for (SwTableBox* pTableBox : rTableBoxes)
{
SwTableBoxFormat* pTableBoxFormat = pTableBox->GetFrameFormat();
if (const SwTableBoxFormula* pBoxFormula = pTableBoxFormat->GetItemIfSet( RES_BOXATR_FORMULA, false ))
{
const SwNode* pNd = pBoxFormula->GetNodeOfFormula();
if(!pNd || &pNd->GetNodes() != &pNd->GetDoc().GetNodes()) // is this ever valid or should we assert here?
continue;
rvFormulas.push_back(const_cast<SwTableBoxFormula*>(pBoxFormula));
}
}
}
}
}
void SwTable::Split(const UIName& sNewTableName, sal_uInt16 nSplitLine, SwHistory* pHistory)
{
SwTableFormulaUpdate aHint(this);
aHint.m_eFlags = TBL_SPLITTBL;
aHint.m_aData.pNewTableNm = &sNewTableName;
aHint.m_nSplitLine = nSplitLine;
std::vector<SwTableBoxFormula*> vFormulas;
GatherFormulas(vFormulas);
for(auto pBoxFormula: vFormulas)
{
const SwNode* pNd = pBoxFormula->GetNodeOfFormula();
const SwTableNode* pTableNd = pNd->FindTableNode();
if(pTableNd == nullptr)
continue;
if(&pTableNd->GetTable() == this)
{
sal_uInt16 nLnPos = SwTableFormula::GetLnPosInTable(*this, pBoxFormula->GetTableBox());
aHint.m_bBehindSplitLine = USHRT_MAX != nLnPos && aHint.m_nSplitLine <= nLnPos;
}
else
aHint.m_bBehindSplitLine = false;
pBoxFormula->ToSplitMergeBoxNmWithHistory(aHint, pHistory);
}
}
void SwTable::Merge(const SwTable& rTable, SwHistory* pHistory)
{
SwTableFormulaUpdate aHint(this);
aHint.m_eFlags = TBL_MERGETBL;
aHint.m_aData.pDelTable = &rTable;
std::vector<SwTableBoxFormula*> vFormulas;
GatherFormulas(vFormulas);
for(auto pBoxFormula: vFormulas)
pBoxFormula->ToSplitMergeBoxNmWithHistory(aHint, pHistory);
}
void SwTable::UpdateFields(TableFormulaUpdateFlags eFlags)
{
SwDoc& rDoc = GetFrameFormat()->GetDoc();
auto pFieldType = rDoc.getIDocumentFieldsAccess().GetFieldType(SwFieldIds::Table, OUString(), false);
if(!pFieldType)
return;
std::vector<SwFormatField*> vFields;
pFieldType->GatherFields(vFields);
for(auto pFormatField : vFields)
{
SwTableField* pField = static_cast<SwTableField*>(pFormatField->GetField());
// table where this field is located
const SwTableNode* pTableNd;
const SwTextNode& rTextNd = pFormatField->GetTextField()->GetTextNode();
pTableNd = rTextNd.FindTableNode();
if(pTableNd == nullptr || &pTableNd->GetTable() != this)
continue;
switch(eFlags)
{
case TBL_BOXNAME:
// to the external representation
pField->PtrToBoxNm(this);
break;
case TBL_RELBOXNAME:
// to the relative representation
pField->ToRelBoxNm(this);
break;
case TBL_BOXPTR:
// to the internal representation
// JP 17.06.96: internal representation on all formulas
// (reference to other table!!!)
pField->BoxNmToPtr( &pTableNd->GetTable() );
break;
default:
assert(false); // Only TBL_BOXNAME, TBL_RELBOXNAME and TBL_BOXPTR are supported
break;
}
}
// process all table box formulas
SwTableLines& rTableLines = GetTabLines();
for (SwTableLine* pTableLine : rTableLines)
{
SwTableBoxes& rTableBoxes = pTableLine->GetTabBoxes();
for (SwTableBox* pTableBox : rTableBoxes)
{
SwTableBoxFormat* pTableBoxFormat = pTableBox->GetFrameFormat();
if (const SwTableBoxFormula* pItem = pTableBoxFormat->GetItemIfSet( RES_BOXATR_FORMULA, false ))
{
// SwTableBoxFormula is non-shareable, so const_cast is somewhat OK
auto & rBoxFormula = const_cast<SwTableBoxFormula&>(*pItem);
if(eFlags == TBL_BOXPTR)
rBoxFormula.TryBoxNmToPtr();
else if(eFlags == TBL_RELBOXNAME)
rBoxFormula.TryRelBoxNm();
else
rBoxFormula.ChangeState();
}
}
}
}
void SwTable::dumpAsXml(xmlTextWriterPtr pWriter) const
{
(void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTable"));
(void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
(void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("table-format"), "%p", GetFrameFormat());
(void)xmlTextWriterStartElement(pWriter, BAD_CAST("lines"));
for (const auto& pLine : m_aLines)
{
pLine->dumpAsXml(pWriter);
}
(void)xmlTextWriterEndElement(pWriter);
(void)xmlTextWriterEndElement(pWriter);
}
// TODO Set HasTextChangesOnly=true, if needed based on the redlines in the cells.
// At tracked row deletion, return with the newest deletion of the row or
// at tracked row insertion, return with the oldest insertion in the row, which
// contain the change data of the row change.
// If the return value is SwRedlineTable::npos, there is no tracked row change.
SwRedlineTable::size_type SwTableLine::UpdateTextChangesOnly(
SwRedlineTable::size_type& rRedlinePos, bool bUpdateProperty ) const
{
SwRedlineTable::size_type nRet = SwRedlineTable::npos;
const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
// check table row property "HasTextChangesOnly", if it's defined and its
// value is false, and all text content is in delete redlines, the row is deleted
const SvxPrintItem *pHasTextChangesOnlyProp =
GetFrameFormat()->GetAttrSet().GetItem<SvxPrintItem>(RES_PRINT);
if ( pHasTextChangesOnlyProp && !pHasTextChangesOnlyProp->GetValue() )
{
const SwTableBoxes & rBoxes = GetTabBoxes();
size_t nBoxes = rBoxes.size();
bool bInsertion = false;
bool bPlainTextInLine = false;
SwRedlineTable::size_type nOldestRedline = SwRedlineTable::npos;
SwRedlineTable::size_type nNewestRedline = SwRedlineTable::npos;
for (size_t nBoxIndex = 0; nBoxIndex < nBoxes && rRedlinePos < aRedlineTable.size(); ++nBoxIndex)
{
auto pBox = rBoxes[nBoxIndex];
if ( pBox->IsEmpty( /*bWithRemainingNestedTable =*/ false ) )
{
// no text content, check the next cells
continue;
}
bool bHasRedlineInBox = false;
SwPosition aCellStart( *pBox->GetSttNd(), SwNodeOffset(0) );
SwPosition aCellEnd( *pBox->GetSttNd()->EndOfSectionNode(), SwNodeOffset(-1) );
SwNodeIndex pEndNodeIndex(aCellEnd.GetNode());
SwRangeRedline* pPreviousDeleteRedline = nullptr;
for( ; rRedlinePos < aRedlineTable.size(); ++rRedlinePos )
{
const SwRangeRedline* pRedline = aRedlineTable[ rRedlinePos ];
if ( pRedline->Start()->GetNodeIndex() > pEndNodeIndex.GetIndex() )
{
// no more redlines in the actual cell,
// check the next ones
break;
}
// redline in the cell
if ( aCellStart <= *pRedline->Start() )
{
if ( !bHasRedlineInBox )
{
bHasRedlineInBox = true;
// plain text before the first redline in the text
if ( pRedline->Start()->GetContentIndex() > 0 )
bPlainTextInLine = true;
}
RedlineType nType = pRedline->GetType();
// first insert redline
if ( !bInsertion )
{
if ( RedlineType::Insert == nType )
{
bInsertion = true;
}
else
{
// plain text between the delete redlines
if ( pPreviousDeleteRedline &&
*pPreviousDeleteRedline->End() < *pRedline->Start() &&
// in the same section, i.e. not in a nested table
pPreviousDeleteRedline->End()->nNode.GetNode().StartOfSectionNode() ==
pRedline->Start()->nNode.GetNode().StartOfSectionNode() )
{
bPlainTextInLine = true;
}
pPreviousDeleteRedline = const_cast<SwRangeRedline*>(pRedline);
}
}
// search newest and oldest redlines
if ( nNewestRedline == SwRedlineTable::npos ||
aRedlineTable[nNewestRedline]->GetRedlineData().GetTimeStamp() <
pRedline->GetRedlineData().GetTimeStamp() )
{
nNewestRedline = rRedlinePos;
}
if ( nOldestRedline == SwRedlineTable::npos ||
aRedlineTable[nOldestRedline]->GetRedlineData().GetTimeStamp() >
pRedline->GetRedlineData().GetTimeStamp() )
{
nOldestRedline = rRedlinePos;
}
}
}
// there is text content outside of redlines: not a deletion
if ( !bInsertion && ( !bHasRedlineInBox || ( pPreviousDeleteRedline &&
// in the same cell, i.e. not in a nested table
pPreviousDeleteRedline->End()->nNode.GetNode().StartOfSectionNode() ==
aCellEnd.GetNode().StartOfSectionNode() &&
( pPreviousDeleteRedline->End()->GetNode() < aCellEnd.GetNode() ||
pPreviousDeleteRedline->End()->GetContentIndex() <
aCellEnd.GetNode().GetContentNode()->Len() ) ) ) )
{
bPlainTextInLine = true;
// not deleted cell content: the row is not empty
// maybe insertion of a row, try to search it
bInsertion = true;
}
}
// choose return redline, if it exists or remove changed row attribute
if ( bInsertion && SwRedlineTable::npos != nOldestRedline &&
RedlineType::Insert == aRedlineTable[ nOldestRedline ]->GetType() )
{
// there is an insert redline, which is the oldest redline in the row
nRet = nOldestRedline;
}
else if ( !bInsertion && !bPlainTextInLine && SwRedlineTable::npos != nNewestRedline &&
RedlineType::Delete == aRedlineTable[ nNewestRedline ]->GetType() )
{
// there is a delete redline, which is the newest redline in the row,
// and no text outside of redlines, and no insert redline in the row,
// i.e. whole text content is deleted
nRet = nNewestRedline;
}
else
{
// no longer tracked row insertion or deletion
nRet = SwRedlineTable::npos;
// set TextChangesOnly = true to remove the tracked deletion
// FIXME Undo is not supported here (this is only a fallback,
// because using SetRowNotTracked() is not recommended here)
if ( bUpdateProperty )
{
SvxPrintItem aUnsetTracking(RES_PRINT, true);
SwFrameFormat *pFormat = const_cast<SwTableLine*>(this)->ClaimFrameFormat();
pFormat->LockModify();
pFormat->SetFormatAttr( aUnsetTracking );
pFormat->UnlockModify();
}
}
}
// cache the result
const_cast<SwTableLine*>(this)->SetRedlineType( SwRedlineTable::npos == nRet
? RedlineType::None
: aRedlineTable[ nRet ]->GetType());
return nRet;
}
SwRedlineTable::size_type SwTableLine::GetTableRedline() const
{
const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
const SwStartNode* pFirstBox = GetTabBoxes().front()->GetSttNd();
const SwStartNode* pLastBox = GetTabBoxes().back()->GetSttNd();
// Box with no start node
if ( !pFirstBox || !pLastBox )
return SwRedlineTable::npos;
const SwPosition aLineStart(*pFirstBox);
const SwPosition aLineEnd(*pLastBox);
SwRedlineTable::size_type n = 0;
const SwRangeRedline* pFnd = aRedlineTable.FindAtPosition( aLineStart, n, /*next=*/false );
if( pFnd && *pFnd->Start() < aLineStart && *pFnd->End() > aLineEnd )
return n;
return SwRedlineTable::npos;
}
bool SwTableLine::IsTracked(SwRedlineTable::size_type& rRedlinePos, bool bOnlyDeleted) const
{
SwRedlineTable::size_type nPos = UpdateTextChangesOnly(rRedlinePos);
if ( nPos != SwRedlineTable::npos )
{
const SwRedlineTable& aRedlineTable =
GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
if ( RedlineType::Delete == aRedlineTable[nPos]->GetType() ||
( !bOnlyDeleted && RedlineType::Insert == aRedlineTable[nPos]->GetType() ) )
return true;
}
return false;
}
bool SwTableLine::IsDeleted(SwRedlineTable::size_type& rRedlinePos) const
{
// if not a deleted row, check the deleted columns
if ( !IsTracked(rRedlinePos, /*bOnlyDeleted=*/true) )
{
const SwTableBoxes& rBoxes = GetTabBoxes();
for( size_t i = 0; i < rBoxes.size(); ++i )
{
// there is a not deleted column
if ( rBoxes[i]->GetRedlineType() != RedlineType::Delete )
return false;
}
}
return true;
}
RedlineType SwTableLine::GetRedlineType() const
{
const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
if ( aRedlineTable.empty() )
return RedlineType::None;
// check table row property "HasTextChangesOnly", if it's defined and its value is
// false, return with the cached redline type, if it exists, otherwise calculate it
const SvxPrintItem *pHasTextChangesOnlyProp =
GetFrameFormat()->GetAttrSet().GetItem<SvxPrintItem>(RES_PRINT);
if ( pHasTextChangesOnlyProp && !pHasTextChangesOnlyProp->GetValue() )
{
if ( RedlineType::None != m_eRedlineType )
return m_eRedlineType;
SwRedlineTable::size_type nPos = 0;
nPos = UpdateTextChangesOnly(nPos);
if ( nPos != SwRedlineTable::npos )
return aRedlineTable[nPos]->GetType();
}
else if ( RedlineType::None != m_eRedlineType )
// empty the cache
const_cast<SwTableLine*>(this)->SetRedlineType( RedlineType::None );
// is the whole table part of a changed text
SwRedlineTable::size_type nTableRedline = GetTableRedline();
if ( nTableRedline != SwRedlineTable::npos )
return aRedlineTable[nTableRedline]->GetType();
return RedlineType::None;
}
void SwTableLine::dumpAsXml(xmlTextWriterPtr pWriter) const
{
(void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTableLine"));
(void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
GetFrameFormat()->dumpAsXml(pWriter);
(void)xmlTextWriterStartElement(pWriter, BAD_CAST("boxes"));
for (const auto& pBox : m_aBoxes)
{
pBox->dumpAsXml(pWriter);
}
(void)xmlTextWriterEndElement(pWriter);
(void)xmlTextWriterEndElement(pWriter);
}
SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, sal_uInt16 nLines, SwTableLine *pUp )
: SwClient(nullptr)
, m_aLines()
, m_pStartNode(nullptr)
, m_pUpper(pUp)
, mnRowSpan(1)
, mbDummyFlag(false)
, mbDirectFormatting(false)
{
m_aLines.reserve( nLines );
CheckBoxFormat( pFormat )->Add(*this);
}
SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwNodeIndex &rIdx,
SwTableLine *pUp )
: SwClient(nullptr)
, m_aLines()
, m_pUpper(pUp)
, mnRowSpan(1)
, mbDummyFlag(false)
, mbDirectFormatting(false)
{
CheckBoxFormat( pFormat )->Add(*this);
m_pStartNode = rIdx.GetNode().GetStartNode();
// insert into the table
const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
assert(pTableNd && "In which table is that box?");
SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
GetTabSortBoxes());
SwTableBox* p = this; // error: &this
rSrtArr.insert( p ); // insert
}
SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwStartNode& rSttNd, SwTableLine *pUp )
: SwClient(nullptr)
, m_aLines()
, m_pStartNode(&rSttNd)
, m_pUpper(pUp)
, mnRowSpan(1)
, mbDummyFlag(false)
, mbDirectFormatting(false)
{
CheckBoxFormat( pFormat )->Add(*this);
// insert into the table
const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
assert(pTableNd && "In which table is the box?");
SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
GetTabSortBoxes());
SwTableBox* p = this; // error: &this
rSrtArr.insert( p ); // insert
}
void SwTableBox::RemoveFromTable()
{
if (m_pStartNode) // box containing contents?
{
// remove from table
const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
assert(pTableNd && "In which table is that box?");
SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
GetTabSortBoxes());
SwTableBox *p = this; // error: &this
rSrtArr.erase( p ); // remove
m_pStartNode = nullptr; // clear it so this is only run once
}
}
SwTableBox::~SwTableBox()
{
if (!GetFrameFormat()->GetDoc().IsInDtor())
{
RemoveFromTable();
}
// the TabelleBox can be deleted if it's the last client of the FrameFormat
sw::BroadcastingModify* pMod = GetFrameFormat();
pMod->Remove(*this); // remove,
if( !pMod->HasWriterListeners() )
delete pMod; // and delete
}
SwTableBoxFormat* SwTableBox::CheckBoxFormat( SwTableBoxFormat* pFormat )
{
// We might need to create a new format here, because the box must be
// added to the format solely if pFormat has a value or form.
if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_VALUE, false ) ||
SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_FORMULA, false ) )
{
SwTableBox* pOther = SwIterator<SwTableBox,SwFormat>( *pFormat ).First();
if( pOther )
{
SwTableBoxFormat* pNewFormat = pFormat->GetDoc().MakeTableBoxFormat();
pNewFormat->LockModify();
*pNewFormat = *pFormat;
// Remove values and formulas
pNewFormat->ResetFormatAttr( RES_BOXATR_FORMULA, RES_BOXATR_VALUE );
pNewFormat->UnlockModify();
pFormat = pNewFormat;
}
}
return pFormat;
}
SwTableBoxFormat* SwTableBox::ClaimFrameFormat()
{
// This method makes sure that this object is an exclusive SwTableBox client
// of an SwTableBoxFormat object
// If other SwTableBox objects currently listen to the same SwTableBoxFormat as
// this one, something needs to be done
SwTableBoxFormat *pRet = GetFrameFormat();
SwIterator<SwTableBox,SwFormat> aIter( *pRet );
for( SwTableBox* pLast = aIter.First(); pLast; pLast = aIter.Next() )
{
if ( pLast != this )
{
// Found another SwTableBox object
// create a new Format as a copy and assign me to it
// don't copy values and formulas
SwTableBoxFormat* pNewFormat = pRet->GetDoc().MakeTableBoxFormat();
pNewFormat->LockModify();
*pNewFormat = *pRet;
pNewFormat->ResetFormatAttr( RES_BOXATR_FORMULA, RES_BOXATR_VALUE );
pNewFormat->UnlockModify();
// re-register SwCellFrame objects that know me
SwIterator<SwCellFrame,SwFormat> aFrameIter( *pRet );
for( SwCellFrame* pCell = aFrameIter.First(); pCell; pCell = aFrameIter.Next() )
if( pCell->GetTabBox() == this )
pCell->RegisterToFormat( *pNewFormat );
// re-register myself
pNewFormat->Add(*this);
pRet = pNewFormat;
break;
}
}
return pRet;
}
void SwTableBox::ChgFrameFormat(SwTableBoxFormat* pNewFormat, bool bNeedToReregister)
{
SwFrameFormat* pOld = GetFrameFormat();
// tdf#84635 We set bNeedToReregister=false to avoid a quadratic slowdown on loading large tables,
// and since we are creating the table for the first time, no re-registration is necessary.
// First, re-register the Frames.
if(bNeedToReregister)
pOld->CallSwClientNotify(sw::TableBoxFormatChanged(*pNewFormat, *this));
// Now, re-register self.
pNewFormat->Add(*this);
if(!pOld->HasWriterListeners())
delete pOld;
}
// Return the name of this box. This is determined dynamically
// resulting from the position in the lines/boxes/tables.
void sw_GetTableBoxColStr( sal_uInt16 nCol, OUString& rNm )
{
const sal_uInt16 coDiff = 52; // 'A'-'Z' 'a' - 'z'
do {
const sal_uInt16 nCalc = nCol % coDiff;
if( nCalc >= 26 )
rNm = OUStringChar( sal_Unicode('a' - 26 + nCalc) ) + rNm;
else
rNm = OUStringChar( sal_Unicode('A' + nCalc) ) + rNm;
nCol = nCol - nCalc;
if( 0 == nCol )
break;
nCol /= coDiff;
--nCol;
} while( true );
}
Point SwTableBox::GetCoordinates() const
{
if( !m_pStartNode ) // box without content?
{
// search for the next first box?
return Point( 0, 0 );
}
const SwTable& rTable = m_pStartNode->FindTableNode()->GetTable();
sal_uInt16 nX, nY;
const SwTableBox* pBox = this;
do {
const SwTableLine* pLine = pBox->GetUpper();
// at the first level?
const SwTableLines* pLines = pLine->GetUpper()
? &pLine->GetUpper()->GetTabLines() : &rTable.GetTabLines();
nY = pLines->GetPos( pLine ) + 1 ;
nX = pBox->GetUpper()->GetBoxPos( pBox ) + 1;
pBox = pLine->GetUpper();
} while( pBox );
return Point( nX, nY );
}
OUString SwTableBox::GetName() const
{
if( !m_pStartNode ) // box without content?
{
// search for the next first box?
return OUString();
}
const SwTable& rTable = m_pStartNode->FindTableNode()->GetTable();
sal_uInt16 nPos;
OUString sNm, sTmp;
const SwTableBox* pBox = this;
do {
const SwTableLine* pLine = pBox->GetUpper();
// at the first level?
const SwTableLines* pLines = pLine->GetUpper()
? &pLine->GetUpper()->GetTabLines() : &rTable.GetTabLines();
nPos = pLines->GetPos( pLine ) + 1;
sTmp = OUString::number( nPos );
if( !sNm.isEmpty() )
sNm = sTmp + "." + sNm;
else
sNm = sTmp;
nPos = pBox->GetUpper()->GetBoxPos( pBox );
sTmp = OUString::number(nPos + 1);
pBox = pLine->GetUpper();
if( nullptr != pBox )
sNm = sTmp + "." + sNm;
else
sw_GetTableBoxColStr( nPos, sNm );
} while( pBox );
return sNm;
}
bool SwTableBox::IsInHeadline( const SwTable* pTable ) const
{
if( !GetUpper() ) // should only happen upon merge.
return false;
if( !pTable )
pTable = &m_pStartNode->FindTableNode()->GetTable();
const SwTableLine* pLine = GetUpper();
while( pLine->GetUpper() )
pLine = pLine->GetUpper()->GetUpper();
// Headerline?
return pTable->GetTabLines()[ 0 ] == pLine;
}
SwNodeOffset SwTableBox::GetSttIdx() const
{
return m_pStartNode ? m_pStartNode->GetIndex() : SwNodeOffset(0);
}
bool SwTableBox::IsEmpty( bool bWithRemainingNestedTable ) const
{
const SwStartNode *pSttNd = GetSttNd();
if ( !pSttNd )
return false;
const SwNode * pFirstNode = pSttNd->GetNodes()[pSttNd->GetIndex() + 1];
if ( pSttNd->GetIndex() + 2 == pSttNd->EndOfSectionIndex() )
{
// single empty node in the box
const SwContentNode *pCNd = pFirstNode->GetContentNode();
if ( pCNd && !pCNd->Len() )
return true;
// tdf#157011 OOXML w:std cell content is imported with terminating 0x01 characters,
// i.e. an empty box can contain double 0x01: handle it to avoid losing change tracking
// FIXME regression since commit b5c616d10bff3213840d4893d13b4493de71fa56
if ( pCNd && pCNd->Len() == 2 && pCNd->GetTextNode() )
{
const OUString &rText = pCNd->GetTextNode()->GetText();
if ( rText[0] == 0x01 && rText[1] == 0x01 )
return true;
}
}
else if ( bWithRemainingNestedTable )
{
if ( const SwTableNode * pTableNode = pFirstNode->GetTableNode() )
{
// empty nested table in the box and
// no text content after it
if ( pTableNode->EndOfSectionIndex() + 2 == pSttNd->EndOfSectionIndex() )
return pTableNode->GetTable().IsEmpty();
}
}
return false;
}
// retrieve information from the client
bool SwTable::GetInfo( SwFindNearestNode& rInfo ) const
{
if( GetFrameFormat() &&
GetFrameFormat()->GetFormatAttr( RES_PAGEDESC ).GetPageDesc() &&
!m_TabSortContentBoxes.empty() &&
m_TabSortContentBoxes[0]->GetSttNd()->GetNodes().IsDocNodes() )
rInfo.CheckNode( *m_TabSortContentBoxes[0]->GetSttNd()->FindTableNode() );
return true;
}
SwTable * SwTable::FindTable( SwFrameFormat const*const pFormat )
{
return pFormat
? SwIterator<SwTable,SwFormat>(*pFormat).First()
: nullptr;
}
SwTableNode* SwTable::GetTableNode() const
{
return !GetTabSortBoxes().empty() ?
const_cast<SwTableNode*>(GetTabSortBoxes()[ 0 ]->GetSttNd()->FindTableNode()) :
m_pTableNode;
}
void SwTable::SetRefObject( SwServerObject* pObj )
{
if( m_xRefObj.is() )
m_xRefObj->Closed();
m_xRefObj = pObj;
}
void SwTable::SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout> const& r)
{
m_xHTMLLayout = r;
}
static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
bool bChgAlign )
{
SwNodeOffset nNdPos = rBox.IsValidNumTextNd();
ChgTextToNum( rBox,rText,pCol,bChgAlign,nNdPos);
}
void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
bool bChgAlign, SwNodeOffset nNdPos )
{
if( NODE_OFFSET_MAX == nNdPos )
return;
SwDoc& rDoc = rBox.GetFrameFormat()->GetDoc();
SwTextNode* pTNd = rDoc.GetNodes()[ nNdPos ]->GetTextNode();
// assign adjustment
if( bChgAlign )
{
const SfxPoolItem* pItem;
pItem = &pTNd->SwContentNode::GetAttr( RES_PARATR_ADJUST );
SvxAdjust eAdjust = static_cast<const SvxAdjustItem*>(pItem)->GetAdjust();
if( SvxAdjust::Left == eAdjust || SvxAdjust::Block == eAdjust )
{
SvxAdjustItem aAdjust( *static_cast<const SvxAdjustItem*>(pItem) );
aAdjust.SetAdjust( SvxAdjust::Right );
pTNd->SetAttr( aAdjust );
}
}
// assign color or save "user color"
const SvxColorItem* pColorItem = nullptr;
if( pTNd->GetpSwAttrSet() )
pColorItem = pTNd->GetpSwAttrSet()->GetItemIfSet( RES_CHRATR_COLOR, false );
const std::optional<Color>& pOldNumFormatColor = rBox.GetSaveNumFormatColor();
std::optional<Color> pNewUserColor;
if (pColorItem)
pNewUserColor = pColorItem->GetValue();
if( ( pNewUserColor && pOldNumFormatColor &&
*pNewUserColor == *pOldNumFormatColor ) ||
( !pNewUserColor && !pOldNumFormatColor ))
{
// Keep the user color, set updated values, delete old NumFormatColor if needed
if( pCol )
// if needed, set the color
pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
else if( pColorItem )
{
pNewUserColor = rBox.GetSaveUserColor();
if( pNewUserColor )
pTNd->SetAttr( SvxColorItem( *pNewUserColor, RES_CHRATR_COLOR ));
else
pTNd->ResetAttr( RES_CHRATR_COLOR );
}
}
else
{
// Save user color, set NumFormat color if needed, but never reset the color
rBox.SetSaveUserColor( pNewUserColor ? *pNewUserColor : std::optional<Color>() );
if( pCol )
// if needed, set the color
pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
}
rBox.SetSaveNumFormatColor( pCol ? *pCol : std::optional<Color>() );
if( pTNd->GetText() != rText )
{
// Exchange text. Bugfix to keep Tabs (front and back!) and annotations (inword comment anchors)
const OUString& rOrig = pTNd->GetText();
sal_Int32 n;
for( n = 0; n < rOrig.getLength() && ('\x9' == rOrig[n] || CH_TXTATR_INWORD == rOrig[n]); ++n )
;
for( ; n < rOrig.getLength() && '\x01' == rOrig[n]; ++n )
;
SwContentIndex aIdx( pTNd, n );
for( n = rOrig.getLength(); n && ('\x9' == rOrig[--n] || CH_TXTATR_INWORD == rOrig[n]); )
;
sal_Int32 nEndPos = n;
n -= aIdx.GetIndex() - 1;
// Reset DontExpand-Flags before exchange, to retrigger expansion
{
SwContentIndex aResetIdx( aIdx, n );
pTNd->DontExpandFormat( aResetIdx.GetIndex(), false, false );
}
if( !rDoc.getIDocumentRedlineAccess().IsIgnoreRedline() && !rDoc.getIDocumentRedlineAccess().GetRedlineTable().empty() )
{
SwPaM aTemp(*pTNd, 0, *pTNd, rOrig.getLength());
rDoc.getIDocumentRedlineAccess().DeleteRedline(aTemp, true, RedlineType::Any);
}
// preserve comments inside of the number by deleting number portions starting from the back
sal_Int32 nCommentPos = pTNd->GetText().lastIndexOf( CH_TXTATR_INWORD, nEndPos );
while( nCommentPos > aIdx.GetIndex() )
{
pTNd->EraseText( SwContentIndex(pTNd, nCommentPos+1), nEndPos - nCommentPos, SwInsertFlags::EMPTYEXPAND );
// find the next non-sequential comment anchor
do
{
nEndPos = nCommentPos;
n = nEndPos - aIdx.GetIndex();
nCommentPos = pTNd->GetText().lastIndexOf( CH_TXTATR_INWORD, nEndPos );
--nEndPos;
}
while( nCommentPos > aIdx.GetIndex() && nCommentPos == nEndPos );
}
pTNd->EraseText( aIdx, n, SwInsertFlags::EMPTYEXPAND );
pTNd->InsertText( rText, aIdx, SwInsertFlags::EMPTYEXPAND );
if( rDoc.getIDocumentRedlineAccess().IsRedlineOn() )
{
SwPaM aTemp(*pTNd, 0, *pTNd, rText.getLength());
rDoc.getIDocumentRedlineAccess().AppendRedline(new SwRangeRedline(RedlineType::Insert, aTemp), true);
}
}
// assign vertical orientation
const SwFormatVertOrient* pVertOrientItem;
if( bChgAlign &&
( !(pVertOrientItem = rBox.GetFrameFormat()->GetItemIfSet( RES_VERT_ORIENT )) ||
text::VertOrientation::TOP == pVertOrientItem->GetVertOrient() ))
{
rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::BOTTOM ));
}
}
static void ChgNumToText( SwTableBox& rBox, sal_uLong nFormat )
{
SwNodeOffset nNdPos = rBox.IsValidNumTextNd( false );
if( NODE_OFFSET_MAX == nNdPos )
return;
SwDoc& rDoc = rBox.GetFrameFormat()->GetDoc();
SwTextNode* pTNd = rDoc.GetNodes()[ nNdPos ]->GetTextNode();
bool bChgAlign = rDoc.IsInsTableAlignNum();
const Color * pCol = nullptr;
if( getSwDefaultTextFormat() != nFormat )
{
// special text format:
OUString sTmp;
const OUString sText( pTNd->GetText() );
rDoc.GetNumberFormatter()->GetOutputString( sText, nFormat, sTmp, &pCol );
if( sText != sTmp )
{
// exchange text
// Reset DontExpand-Flags before exchange, to retrigger expansion
pTNd->DontExpandFormat( sText.getLength(), false, false );
SwContentIndex aIdx( pTNd, 0 );
pTNd->EraseText( aIdx, SAL_MAX_INT32, SwInsertFlags::EMPTYEXPAND );
pTNd->InsertText( sTmp, aIdx, SwInsertFlags::EMPTYEXPAND );
}
}
const SfxItemSet* pAttrSet = pTNd->GetpSwAttrSet();
// assign adjustment
const SvxAdjustItem* pAdjustItem;
if( bChgAlign && pAttrSet &&
(pAdjustItem = pAttrSet->GetItemIfSet( RES_PARATR_ADJUST, false )) &&
SvxAdjust::Right == pAdjustItem->GetAdjust() )
{
pTNd->SetAttr( SvxAdjustItem( SvxAdjust::Left, RES_PARATR_ADJUST ) );
}
// assign color or save "user color"
const SvxColorItem* pColorItem = nullptr;
if( pAttrSet )
pColorItem = pAttrSet->GetItemIfSet( RES_CHRATR_COLOR, false );
const std::optional<Color>& pOldNumFormatColor = rBox.GetSaveNumFormatColor();
std::optional<Color> pNewUserColor;
if (pColorItem)
pNewUserColor = pColorItem->GetValue();
if( ( pNewUserColor && pOldNumFormatColor &&
*pNewUserColor == *pOldNumFormatColor ) ||
( !pNewUserColor && !pOldNumFormatColor ))
{
// Keep the user color, set updated values, delete old NumFormatColor if needed
if( pCol )
// if needed, set the color
pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
else if( pColorItem )
{
pNewUserColor = rBox.GetSaveUserColor();
if( pNewUserColor )
pTNd->SetAttr( SvxColorItem( *pNewUserColor, RES_CHRATR_COLOR ));
else
pTNd->ResetAttr( RES_CHRATR_COLOR );
}
}
else
{
// Save user color, set NumFormat color if needed, but never reset the color
rBox.SetSaveUserColor( pNewUserColor );
if( pCol )
// if needed, set the color
pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
}
rBox.SetSaveNumFormatColor( pCol ? *pCol : std::optional<Color>() );
// assign vertical orientation
const SwFormatVertOrient* pVertOrientItem;
if( bChgAlign &&
(pVertOrientItem = rBox.GetFrameFormat()->GetItemIfSet( RES_VERT_ORIENT, false )) &&
text::VertOrientation::BOTTOM == pVertOrientItem->GetVertOrient() )
{
rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::TOP ));
}
}
void SwTableBoxFormat::BoxAttributeChanged(SwTableBox& rBox, const SwTableBoxNumFormat* pNewFormat, const SwTableBoxFormula* pNewFormula, const SwTableBoxValue* pNewValue, sal_uLong nOldFormat)
{
sal_uLong nNewFormat;
if(pNewFormat)
{
nNewFormat = pNewFormat->GetValue();
// new formatting
// is it newer or has the current been removed?
if( SfxItemState::SET != GetItemState(RES_BOXATR_VALUE, false))
pNewFormat = nullptr;
}
else
{
// fetch the current Item
pNewFormat = GetItemIfSet(RES_BOXATR_FORMAT, false);
nOldFormat = GetTableBoxNumFormat().GetValue();
nNewFormat = pNewFormat ? pNewFormat->GetValue() : nOldFormat;
}
// is it newer or has the current been removed?
if(pNewValue)
{
if(GetDoc().GetNumberFormatter()->IsTextFormat(nNewFormat))
nOldFormat = 0;
else
{
if(SfxItemState::SET == GetItemState(RES_BOXATR_VALUE, false))
nOldFormat = getSwDefaultTextFormat();
else
nNewFormat = getSwDefaultTextFormat();
}
}
// Logic:
// Value change: -> "simulate" a format change!
// Format change:
// Text -> !Text or format change:
// - align right for horizontal alignment, if LEFT or JUSTIFIED
// - align bottom for vertical alignment, if TOP is set, or default
// - replace text (color? negative numbers RED?)
// !Text -> Text:
// - align left for horizontal alignment, if RIGHT
// - align top for vertical alignment, if BOTTOM is set
SvNumberFormatter* pNumFormatr = GetDoc().GetNumberFormatter();
bool bNewIsTextFormat = pNumFormatr->IsTextFormat(nNewFormat);
if((!bNewIsTextFormat && nOldFormat != nNewFormat) || pNewFormula)
{
bool bIsNumFormat = false;
OUString aOrigText;
bool bChgText = true;
double fVal = 0;
if(!pNewValue)
pNewValue = GetItemIfSet(RES_BOXATR_VALUE, false);
if(!pNewValue)
{
// so far, no value has been set, so try to evaluate the content
SwNodeOffset nNdPos = rBox.IsValidNumTextNd();
if(NODE_OFFSET_MAX != nNdPos)
{
sal_uInt32 nTmpFormatIdx = nNewFormat;
OUString aText(GetDoc().GetNodes()[nNdPos] ->GetTextNode()->GetRedlineText());
aOrigText = aText;
if(aText.isEmpty())
bChgText = false;
else
{
// Keep Tabs
lcl_TabToBlankAtSttEnd(aText);
// JP 22.04.98: Bug 49659 -
// Special casing for percent
if(SvNumFormatType::PERCENT == pNumFormatr->GetType(nNewFormat))
{
sal_uInt32 nTmpFormat = 0;
if(GetDoc().IsNumberFormat(aText, nTmpFormat, fVal))
{
if(SvNumFormatType::NUMBER == pNumFormatr->GetType( nTmpFormat))
aText += "%";
bIsNumFormat = GetDoc().IsNumberFormat(aText, nTmpFormatIdx, fVal);
}
}
else
bIsNumFormat = GetDoc().IsNumberFormat(aText, nTmpFormatIdx, fVal);
if(bIsNumFormat)
{
// directly assign value - without Modify
bool bIsLockMod = IsModifyLocked();
LockModify();
SetFormatAttr(SwTableBoxValue(fVal));
if(!bIsLockMod)
UnlockModify();
}
}
}
}
else
{
fVal = pNewValue->GetValue();
bIsNumFormat = true;
}
// format contents with the new value assigned and write to paragraph
const Color* pCol = nullptr;
OUString sNewText;
bool bChangeFormat = true;
if(DBL_MAX == fVal)
{
sNewText = SwViewShell::GetShellRes()->aCalc_Error;
}
else
{
if(bIsNumFormat)
pNumFormatr->GetOutputString(fVal, nNewFormat, sNewText, &pCol);
else
{
// Original text could not be parsed as
// number/date/time/..., so keep the text.
#if 0
// Actually the text should be formatted
// according to the format, which may include
// additional text from the format, for example
// in {0;-0;"BAD: "@}. But other places when
// entering a new value or changing text or
// changing to a different format of type Text
// don't do this (yet?).
pNumFormatr->GetOutputString(aOrigText, nNewFormat, sNewText, &pCol);
#else
sNewText = aOrigText;
#endif
// Remove the newly assigned numbering format as well if text actually exists.
// Exception: assume user-defined formats are always intentional.
if (bChgText && pNumFormatr->IsTextFormat(nOldFormat)
&& !pNumFormatr->IsUserDefined(nNewFormat))
{
rBox.GetFrameFormat()->ResetFormatAttr(RES_BOXATR_FORMAT);
bChangeFormat = false;
}
}
if(!bChgText)
sNewText.clear();
}
// across all boxes
if (bChangeFormat)
ChgTextToNum(rBox, sNewText, pCol, GetDoc().IsInsTableAlignNum());
}
else if(bNewIsTextFormat && nOldFormat != nNewFormat)
ChgNumToText(rBox, nNewFormat);
}
SwTableBox* SwTableBoxFormat::SwTableBoxFormat::GetTableBox()
{
SwIterator<SwTableBox,SwFormat> aIter(*this);
auto pBox = aIter.First();
SAL_INFO_IF(!pBox, "sw.core", "no box found at format");
SAL_WARN_IF(pBox && aIter.Next(), "sw.core", "more than one box found at format");
return pBox;
}
// for detection of modifications (mainly TableBoxAttribute)
void SwTableBoxFormat::SwClientNotify(const SwModify& rMod, const SfxHint& rHint)
{
if(rHint.GetId() == SfxHintId::SwFormatChange
|| rHint.GetId() == SfxHintId::SwObjectDying
|| rHint.GetId() == SfxHintId::SwUpdateAttr)
{
SwFrameFormat::SwClientNotify(rMod, rHint);
return;
}
if(rHint.GetId() != SfxHintId::SwLegacyModify && rHint.GetId() != SfxHintId::SwAttrSetChange)
return;
if(IsModifyLocked() || GetDoc().IsInDtor())
{
SwFrameFormat::SwClientNotify(rMod, rHint);
return;
}
const SwTableBoxNumFormat* pNewFormat = nullptr;
const SwTableBoxFormula* pNewFormula = nullptr;
const SwTableBoxValue* pNewVal = nullptr;
sal_uLong nOldFormat = getSwDefaultTextFormat();
if(rHint.GetId() == SfxHintId::SwLegacyModify)
{
auto pLegacy = static_cast<const sw::LegacyModifyHint*>(&rHint);
switch(pLegacy->m_pNew ? pLegacy->m_pNew->Which() : 0)
{
case RES_BOXATR_FORMAT:
pNewFormat = static_cast<const SwTableBoxNumFormat*>(pLegacy->m_pNew);
nOldFormat = static_cast<const SwTableBoxNumFormat*>(pLegacy->m_pOld)->GetValue();
break;
case RES_BOXATR_FORMULA:
pNewFormula = static_cast<const SwTableBoxFormula*>(pLegacy->m_pNew);
break;
case RES_BOXATR_VALUE:
pNewVal = static_cast<const SwTableBoxValue*>(pLegacy->m_pNew);
break;
}
}
else // rHint.GetId() == SfxHintId::SwAttrSetChange
{
auto pChangeHint = static_cast<const sw::AttrSetChangeHint*>(&rHint);
const SfxItemSet& rSet = *pChangeHint->m_pNew->GetChgSet();
pNewFormat = rSet.GetItemIfSet( RES_BOXATR_FORMAT, false);
if(pNewFormat)
nOldFormat = pChangeHint->m_pOld->GetChgSet()->Get(RES_BOXATR_FORMAT).GetValue();
pNewFormula = rSet.GetItemIfSet(RES_BOXATR_FORMULA, false);
pNewVal = rSet.GetItemIfSet(RES_BOXATR_VALUE, false);
}
// something changed and some BoxAttribute remained in the set!
if( pNewFormat || pNewFormula || pNewVal )
{
GetDoc().getIDocumentFieldsAccess().SetFieldsDirty(true, nullptr, SwNodeOffset(0));
if(SfxItemState::SET == GetItemState(RES_BOXATR_FORMAT, false) ||
SfxItemState::SET == GetItemState(RES_BOXATR_VALUE, false) ||
SfxItemState::SET == GetItemState(RES_BOXATR_FORMULA, false) )
{
if(auto pBox = GetTableBox())
BoxAttributeChanged(*pBox, pNewFormat, pNewFormula, pNewVal, nOldFormat);
}
}
// call base class
SwFrameFormat::SwClientNotify(rMod, rHint);
}
bool SwTableBoxFormat::supportsFullDrawingLayerFillAttributeSet() const
{
return false;
}
bool SwTableFormat::supportsFullDrawingLayerFillAttributeSet() const
{
return false;
}
bool SwTableLineFormat::supportsFullDrawingLayerFillAttributeSet() const
{
return false;
}
bool SwTableBox::HasNumContent( double& rNum, sal_uInt32& rFormatIndex,
bool& rIsEmptyTextNd ) const
{
bool bRet = false;
SwNodeOffset nNdPos = IsValidNumTextNd();
if( NODE_OFFSET_MAX != nNdPos )
{
OUString aText( m_pStartNode->GetNodes()[ nNdPos ]->GetTextNode()->GetRedlineText() );
// Keep Tabs
lcl_TabToBlankAtSttEnd( aText );
rIsEmptyTextNd = aText.isEmpty();
SvNumberFormatter* pNumFormatr = GetFrameFormat()->GetDoc().GetNumberFormatter();
if( const SwTableBoxNumFormat* pItem = GetFrameFormat()->GetItemIfSet( RES_BOXATR_FORMAT, false) )
{
rFormatIndex = pItem->GetValue();
// Special casing for percent
if( !rIsEmptyTextNd && SvNumFormatType::PERCENT == pNumFormatr->GetType( rFormatIndex ))
{
sal_uInt32 nTmpFormat = 0;
if( GetFrameFormat()->GetDoc().IsNumberFormat( aText, nTmpFormat, rNum ) &&
SvNumFormatType::NUMBER == pNumFormatr->GetType( nTmpFormat ))
aText += "%";
}
}
else
rFormatIndex = 0;
bRet = GetFrameFormat()->GetDoc().IsNumberFormat( aText, rFormatIndex, rNum );
}
else
rIsEmptyTextNd = false;
return bRet;
}
bool SwTableBox::IsNumberChanged() const
{
bool bRet = true;
if( SfxItemState::SET == GetFrameFormat()->GetItemState( RES_BOXATR_FORMULA, false ))
{
const SwTableBoxNumFormat *pNumFormat = GetFrameFormat()->GetItemIfSet( RES_BOXATR_FORMAT, false );
const SwTableBoxValue *pValue = GetFrameFormat()->GetItemIfSet( RES_BOXATR_VALUE, false );
SwNodeOffset nNdPos;
if( pNumFormat && pValue && NODE_OFFSET_MAX != ( nNdPos = IsValidNumTextNd() ) )
{
OUString sNewText, sOldText( m_pStartNode->GetNodes()[ nNdPos ]->
GetTextNode()->GetRedlineText() );
lcl_DelTabsAtSttEnd( sOldText );
const Color* pCol = nullptr;
GetFrameFormat()->GetDoc().GetNumberFormatter()->GetOutputString(
pValue->GetValue(), pNumFormat->GetValue(), sNewText, &pCol );
bRet = sNewText != sOldText ||
!( ( !pCol && !GetSaveNumFormatColor() ) ||
( pCol && GetSaveNumFormatColor() &&
*pCol == *GetSaveNumFormatColor() ));
}
}
return bRet;
}
SwNodeOffset SwTableBox::IsValidNumTextNd( bool bCheckAttr ) const
{
SwNodeOffset nPos = NODE_OFFSET_MAX;
if( m_pStartNode )
{
SwNodeIndex aIdx( *m_pStartNode );
SwNodeOffset nIndex = aIdx.GetIndex();
const SwNodeOffset nIndexEnd = m_pStartNode->GetNodes()[ nIndex ]->EndOfSectionIndex();
const SwTextNode *pTextNode = nullptr;
while( ++nIndex < nIndexEnd )
{
const SwNode* pNode = m_pStartNode->GetNodes()[nIndex];
if( pNode->IsTableNode() )
{
pTextNode = nullptr;
break;
}
if( pNode->IsTextNode() )
{
if( pTextNode )
{
pTextNode = nullptr;
break;
}
else
{
pTextNode = pNode->GetTextNode();
nPos = nIndex;
}
}
}
if( pTextNode )
{
if( bCheckAttr )
{
const SwpHints* pHts = pTextNode->GetpSwpHints();
// do some tests if there's only text in the node!
// Flys/fields/...
if( pHts )
{
sal_Int32 nNextSetField = 0;
for( size_t n = 0; n < pHts->Count(); ++n )
{
const SwTextAttr* pAttr = pHts->Get(n);
if( RES_TXTATR_NOEND_BEGIN <= pAttr->Which() )
{
if ( (pAttr->GetStart() == nNextSetField)
&& (pAttr->Which() == RES_TXTATR_FIELD))
{
// #i104949# hideous hack for report builder:
// it inserts hidden variable-set fields at
// the beginning of para in cell, but they
// should not turn cell into text cell
const SwField* pField = pAttr->GetFormatField().GetField();
if (pField &&
(pField->GetTypeId() == SwFieldTypesEnum::Set) &&
(static_cast<SwSetExpField const*>
(pField)->GetSubType() &
SwGetSetExpType::Invisible))
{
nNextSetField = pAttr->GetStart() + 1;
continue;
}
}
else if( RES_TXTATR_ANNOTATION == pAttr->Which() ||
RES_TXTATR_FTN == pAttr->Which() )
{
continue;
}
nPos = NODE_OFFSET_MAX;
break;
}
}
}
}
}
else
nPos = NODE_OFFSET_MAX;
}
return nPos;
}
// is this a Formula box or one with numeric content (AutoSum)
sal_uInt16 SwTableBox::IsFormulaOrValueBox() const
{
sal_uInt16 nWhich = 0;
const SwTextNode* pTNd;
SwFrameFormat* pFormat = GetFrameFormat();
if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_FORMULA, false ))
nWhich = RES_BOXATR_FORMULA;
else if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_VALUE, false ) &&
!pFormat->GetDoc().GetNumberFormatter()->IsTextFormat(
pFormat->GetTableBoxNumFormat().GetValue() ))
nWhich = RES_BOXATR_VALUE;
else if( m_pStartNode && m_pStartNode->GetIndex() + 2 == m_pStartNode->EndOfSectionIndex()
&& nullptr != ( pTNd = m_pStartNode->GetNodes()[ m_pStartNode->GetIndex() + 1 ]
->GetTextNode() ) && pTNd->GetText().isEmpty())
nWhich = USHRT_MAX;
return nWhich;
}
void SwTableBox::ActualiseValueBox()
{
SwFrameFormat* pFormat = GetFrameFormat();
const SwTableBoxNumFormat *pFormatItem = pFormat->GetItemIfSet( RES_BOXATR_FORMAT, true );
if (!pFormatItem)
return;
const SwTableBoxValue *pValItem = pFormat->GetItemIfSet( RES_BOXATR_VALUE );
if (!pValItem)
return;
const sal_uLong nFormatId = pFormatItem->GetValue();
SwNodeOffset nNdPos = NODE_OFFSET_MAX;
SvNumberFormatter* pNumFormatr = pFormat->GetDoc().GetNumberFormatter();
if( !pNumFormatr->IsTextFormat( nFormatId ) &&
NODE_OFFSET_MAX != (nNdPos = IsValidNumTextNd()) )
{
double fVal = pValItem->GetValue();
const Color* pCol = nullptr;
OUString sNewText;
pNumFormatr->GetOutputString( fVal, nFormatId, sNewText, &pCol );
const OUString& rText = m_pStartNode->GetNodes()[ nNdPos ]->GetTextNode()->GetText();
if( rText != sNewText )
ChgTextToNum( *this, sNewText, pCol, false ,nNdPos);
}
}
SwRedlineTable::size_type SwTableBox::GetRedline() const
{
const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
const SwStartNode *pSttNd = GetSttNd();
if ( aRedlineTable.empty() || !pSttNd )
return SwRedlineTable::npos;
// check table row property "HasTextChangesOnly", if it's defined and its value is
// false, return with the first redline of the cell
const SvxPrintItem *pHasTextChangesOnlyProp =
GetFrameFormat()->GetAttrSet().GetItem<SvxPrintItem>(RES_PRINT);
if ( !pHasTextChangesOnlyProp || pHasTextChangesOnlyProp->GetValue() )
return SwRedlineTable::npos;
SwPosition aCellStart( *GetSttNd(), SwNodeOffset(0) );
SwPosition aCellEnd( *GetSttNd()->EndOfSectionNode(), SwNodeOffset(-1) );
SwNodeIndex pEndNodeIndex(aCellEnd.GetNode());
SwRedlineTable::size_type nRedlinePos = 0;
for( ; nRedlinePos < aRedlineTable.size(); ++nRedlinePos )
{
const SwRangeRedline* pRedline = aRedlineTable[ nRedlinePos ];
if ( pRedline->Start()->GetNodeIndex() > pEndNodeIndex.GetIndex() )
{
// no more redlines in the actual cell,
// check the next ones
break;
}
// redline in the cell
if ( aCellStart <= *pRedline->Start() )
return nRedlinePos;
}
return SwRedlineTable::npos;
}
RedlineType SwTableBox::GetRedlineType() const
{
SwRedlineTable::size_type nPos = GetRedline();
if ( nPos != SwRedlineTable::npos )
{
const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc().getIDocumentRedlineAccess().GetRedlineTable();
const SwRangeRedline* pRedline = aRedlineTable[ nPos ];
if ( RedlineType::Delete == pRedline->GetType() ||
RedlineType::Insert == pRedline->GetType() )
{
return pRedline->GetType();
}
}
return RedlineType::None;
}
void SwTableBox::dumpAsXml(xmlTextWriterPtr pWriter) const
{
(void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwTableBox"));
(void)xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", this);
(void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("start-node"), BAD_CAST(OString::number(static_cast<sal_Int32>(m_pStartNode->GetIndex())).getStr()));
(void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("rowspan"), BAD_CAST(OString::number(mnRowSpan).getStr()));
GetFrameFormat()->dumpAsXml(pWriter);
(void)xmlTextWriterEndElement(pWriter);
}
struct SwTableCellInfo::Impl
{
const SwTable * m_pTable;
const SwCellFrame * m_pCellFrame;
const SwTabFrame * m_pTabFrame;
typedef o3tl::sorted_vector<const SwTableBox *> TableBoxes_t;
TableBoxes_t m_HandledTableBoxes;
public:
Impl()
: m_pTable(nullptr), m_pCellFrame(nullptr), m_pTabFrame(nullptr)
{
}
void setTable(const SwTable * pTable)
{
m_pTable = pTable;
SwFrameFormat * pFrameFormat = m_pTable->GetFrameFormat();
m_pTabFrame = SwIterator<SwTabFrame,SwFormat>(*pFrameFormat).First();
if (m_pTabFrame && m_pTabFrame->IsFollow())
m_pTabFrame = m_pTabFrame->FindMaster(true);
}
const SwCellFrame * getCellFrame() const { return m_pCellFrame; }
const SwFrame * getNextFrameInTable(const SwFrame * pFrame);
const SwCellFrame * getNextCellFrame(const SwFrame * pFrame);
const SwCellFrame * getNextTableBoxsCellFrame(const SwFrame * pFrame);
bool getNext();
};
const SwFrame * SwTableCellInfo::Impl::getNextFrameInTable(const SwFrame * pFrame)
{
const SwFrame * pResult = nullptr;
if (((! pFrame->IsTabFrame()) || pFrame == m_pTabFrame) && pFrame->GetLower())
pResult = pFrame->GetLower();
else if (pFrame->GetNext())
pResult = pFrame->GetNext();
else
{
while (pFrame->GetUpper() != nullptr)
{
pFrame = pFrame->GetUpper();
if (pFrame->IsTabFrame())
{
m_pTabFrame = static_cast<const SwTabFrame *>(pFrame)->GetFollow();
pResult = m_pTabFrame;
break;
}
else if (pFrame->GetNext())
{
pResult = pFrame->GetNext();
break;
}
}
}
return pResult;
}
const SwCellFrame * SwTableCellInfo::Impl::getNextCellFrame(const SwFrame * pFrame)
{
const SwCellFrame * pResult = nullptr;
while ((pFrame = getNextFrameInTable(pFrame)) != nullptr)
{
if (pFrame->IsCellFrame())
{
pResult = static_cast<const SwCellFrame *>(pFrame);
break;
}
}
return pResult;
}
const SwCellFrame * SwTableCellInfo::Impl::getNextTableBoxsCellFrame(const SwFrame * pFrame)
{
const SwCellFrame * pResult = nullptr;
while ((pFrame = getNextCellFrame(pFrame)) != nullptr)
{
const SwCellFrame * pCellFrame = static_cast<const SwCellFrame *>(pFrame);
const SwTableBox * pTabBox = pCellFrame->GetTabBox();
auto aIt = m_HandledTableBoxes.insert(pTabBox);
if (aIt.second)
{
pResult = pCellFrame;
break;
}
}
return pResult;
}
const SwCellFrame * SwTableCellInfo::getCellFrame() const
{
return m_pImpl->getCellFrame();
}
bool SwTableCellInfo::Impl::getNext()
{
if (m_pCellFrame == nullptr)
{
if (m_pTabFrame != nullptr)
m_pCellFrame = Impl::getNextTableBoxsCellFrame(m_pTabFrame);
}
else
m_pCellFrame = Impl::getNextTableBoxsCellFrame(m_pCellFrame);
return m_pCellFrame != nullptr;
}
SwTableCellInfo::SwTableCellInfo(const SwTable * pTable)
: m_pImpl(std::make_unique<Impl>())
{
m_pImpl->setTable(pTable);
}
SwTableCellInfo::~SwTableCellInfo()
{
}
bool SwTableCellInfo::getNext()
{
return m_pImpl->getNext();
}
SwRect SwTableCellInfo::getRect() const
{
SwRect aRet;
if (getCellFrame() != nullptr)
aRet = getCellFrame()->getFrameArea();
return aRet;
}
const SwTableBox * SwTableCellInfo::getTableBox() const
{
const SwTableBox * pRet = nullptr;
if (getCellFrame() != nullptr)
pRet = getCellFrame()->GetTabBox();
return pRet;
}
void SwTable::RegisterToFormat( SwFormat& rFormat )
{
rFormat.Add(*this);
}
bool SwTable::HasLayout() const
{
const SwFrameFormat* pFrameFormat = GetFrameFormat();
//a table in a clipboard document doesn't have any layout information
return pFrameFormat && SwIterator<SwTabFrame,SwFormat>(*pFrameFormat).First();
}
void SwTableBox::RegisterToFormat( SwFormat& rFormat )
{
rFormat.Add(*this);
}
// free's any remaining child objects
SwTableLines::~SwTableLines()
{
for ( const_iterator it = begin(); it != end(); ++it )
delete *it;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V530 The return value of function 'remove' is required to be utilized.
↑ V530 The return value of function 'remove' is required to be utilized.
↑ V530 The return value of function 'InsertText' is required to be utilized.
↑ V530 The return value of function 'InsertText' is required to be utilized.
↑ V763 Parameter 'nOldFormat' is always rewritten in function body before being used.
↑ V1048 The 'nRet' variable was assigned the same value.