LibreOffice Module sw (master)  1
swtable.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <hintids.hxx>
21 #include <hints.hxx>
22 #include <editeng/lrspitem.hxx>
23 #include <editeng/shaditem.hxx>
24 #include <editeng/adjustitem.hxx>
25 #include <editeng/colritem.hxx>
26 #include <osl/diagnose.h>
27 #include <sfx2/linkmgr.hxx>
28 #include <fmtfsize.hxx>
29 #include <fmtornt.hxx>
30 #include <fmtpdsc.hxx>
31 #include <fldbas.hxx>
32 #include <fmtfld.hxx>
33 #include <frmatr.hxx>
34 #include <doc.hxx>
35 #include <IDocumentLinksAdministration.hxx>
36 #include <IDocumentRedlineAccess.hxx>
37 #include <IDocumentFieldsAccess.hxx>
38 #include <docary.hxx>
39 #include <frame.hxx>
40 #include <swtable.hxx>
41 #include <ndtxt.hxx>
42 #include <tabcol.hxx>
43 #include <tabfrm.hxx>
44 #include <cellfrm.hxx>
45 #include <rowfrm.hxx>
46 #include <swserv.hxx>
47 #include <expfld.hxx>
48 #include <mdiexp.hxx>
49 #include <cellatr.hxx>
50 #include <txatbase.hxx>
51 #include <htmltbl.hxx>
52 #include <swtblfmt.hxx>
53 #include <ndindex.hxx>
54 #include <tblrwcl.hxx>
55 #include <shellres.hxx>
56 #include <viewsh.hxx>
57 #include <redline.hxx>
58 #include <vector>
59 #include <calbck.hxx>
60 
61 #ifdef DBG_UTIL
62 #define CHECK_TABLE(t) (t).CheckConsistency();
63 #else
64 #define CHECK_TABLE(t)
65 #endif
66 
67 using namespace com::sun::star;
68 
69 
70 #define COLFUZZY 20
71 
72 static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
73  bool bChgAlign, sal_uLong nNdPos );
74 
75 sal_Int32 SwTableBox::getRowSpan() const
76 {
77  return mnRowSpan;
78 }
79 
80 void SwTableBox::setRowSpan( sal_Int32 nNewRowSpan )
81 {
82  mnRowSpan = nNewRowSpan;
83 }
84 
85 bool SwTableBox::getDummyFlag() const
86 {
87  return mbDummyFlag;
88 }
89 
90 void SwTableBox::setDummyFlag( bool bDummy )
91 {
92  mbDummyFlag = bDummy;
93 }
94 
95 //JP 15.09.98: Bug 55741 - Keep tabs (front and rear)
96 static OUString& lcl_TabToBlankAtSttEnd( OUString& rText )
97 {
98  sal_Unicode c;
99  sal_Int32 n;
100 
101  for( n = 0; n < rText.getLength() && ' ' >= ( c = rText[n] ); ++n )
102  if( '\x9' == c )
103  rText = rText.replaceAt( n, 1, " " );
104  for( n = rText.getLength(); n && ' ' >= ( c = rText[--n] ); )
105  if( '\x9' == c )
106  rText = rText.replaceAt( n, 1, " " );
107  return rText;
108 }
109 
110 static OUString& lcl_DelTabsAtSttEnd( OUString& rText )
111 {
112  sal_Unicode c;
113  sal_Int32 n;
114  OUStringBuffer sBuff(rText);
115 
116  for( n = 0; n < sBuff.getLength() && ' ' >= ( c = sBuff[ n ]); ++n )
117  {
118  if( '\x9' == c )
119  sBuff.remove( n--, 1 );
120  }
121  for( n = sBuff.getLength(); n && ' ' >= ( c = sBuff[ --n ]); )
122  {
123  if( '\x9' == c )
124  sBuff.remove( n, 1 );
125  }
126  rText = sBuff.makeStringAndClear();
127  return rText;
128 }
129 
130 void InsTableBox( SwDoc& rDoc, SwTableNode* pTableNd,
131  SwTableLine* pLine, SwTableBoxFormat* pBoxFrameFormat,
132  SwTableBox* pBox,
133  sal_uInt16 nInsPos, sal_uInt16 nCnt )
134 {
135  OSL_ENSURE( pBox->GetSttNd(), "Box with no start node" );
136  SwNodeIndex aIdx( *pBox->GetSttNd(), +1 );
137  SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
138  if( !pCNd )
139  pCNd = rDoc.GetNodes().GoNext( &aIdx );
140  OSL_ENSURE( pCNd, "Box with no content node" );
141 
142  if( pCNd->IsTextNode() )
143  {
144  if( pBox->GetSaveNumFormatColor() && pCNd->GetpSwAttrSet() )
145  {
146  SwAttrSet aAttrSet( *pCNd->GetpSwAttrSet() );
147  if( pBox->GetSaveUserColor() )
148  aAttrSet.Put( SvxColorItem( *pBox->GetSaveUserColor(), RES_CHRATR_COLOR ));
149  else
150  aAttrSet.ClearItem( RES_CHRATR_COLOR );
151  rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
152  static_cast<SwTextNode*>(pCNd)->GetTextColl(),
153  &aAttrSet, nInsPos, nCnt );
154  }
155  else
156  rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
157  static_cast<SwTextNode*>(pCNd)->GetTextColl(),
158  pCNd->GetpSwAttrSet(),
159  nInsPos, nCnt );
160  }
161  else
162  rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
163  rDoc.GetDfltTextFormatColl(), nullptr,
164  nInsPos, nCnt );
165 
166  sal_Int32 nRowSpan = pBox->getRowSpan();
167  if( nRowSpan != 1 )
168  {
169  SwTableBoxes& rTableBoxes = pLine->GetTabBoxes();
170  for( sal_uInt16 i = 0; i < nCnt; ++i )
171  {
172  pBox = rTableBoxes[ i + nInsPos ];
173  pBox->setRowSpan( nRowSpan );
174  }
175  }
176 }
177 
178 SwTable::SwTable()
179  : SwClient( nullptr ),
180  m_pTableNode( nullptr ),
181  m_nGraphicsThatResize( 0 ),
182  m_nRowsToRepeat( 1 ),
183  m_bModifyLocked( false ),
184  m_bNewModel( true )
185 {
186  // default value set in the options
187  m_eTableChgMode = GetTableChgDefaultMode();
188 }
189 
190 SwTable::SwTable( const SwTable& rTable )
191  : SwClient( rTable.GetFrameFormat() ),
192  m_pTableNode( nullptr ),
193  m_eTableChgMode( rTable.m_eTableChgMode ),
194  m_nGraphicsThatResize( 0 ),
195  m_nRowsToRepeat( rTable.GetRowsToRepeat() ),
196  maTableStyleName(rTable.maTableStyleName),
197  m_bModifyLocked( false ),
198  m_bNewModel( rTable.m_bNewModel )
199 {
200 }
201 
202 void DelBoxNode( SwTableSortBoxes const & rSortCntBoxes )
203 {
204  for (size_t n = 0; n < rSortCntBoxes.size(); ++n)
205  {
206  rSortCntBoxes[ n ]->m_pStartNode = nullptr;
207  }
208 }
209 
210 SwTable::~SwTable()
211 {
212  if( m_xRefObj.is() )
213  {
214  SwDoc* pDoc = GetFrameFormat()->GetDoc();
215  if( !pDoc->IsInDtor() ) // then remove from the list
216  pDoc->getIDocumentLinksAdministration().GetLinkManager().RemoveServer( m_xRefObj.get() );
217 
218  m_xRefObj->Closed();
219  }
220 
221  // the table can be deleted if it's the last client of the FrameFormat
222  SwTableFormat* pFormat = GetFrameFormat();
223  pFormat->Remove( this ); // remove
224 
225  if( !pFormat->HasWriterListeners() )
226  pFormat->GetDoc()->DelTableFrameFormat( pFormat ); // and delete
227 
228  // Delete the pointers from the SortArray of the boxes. The objects
229  // are preserved and are deleted by the lines/boxes arrays dtor.
230  // Note: unfortunately not enough, pointers to the StartNode of the
231  // section need deletion.
232  DelBoxNode(m_TabSortContentBoxes);
233  m_TabSortContentBoxes.clear();
234 }
235 
236 namespace
237 {
238 
239 template<class T>
240 T lcl_MulDiv64(sal_uInt64 nA, sal_uInt64 nM, sal_uInt64 nD)
241 {
242  return static_cast<T>((nA*nM)/nD);
243 }
244 
245 }
246 
247 static void FormatInArr( std::vector<SwFormat*>& rFormatArr, SwFormat* pBoxFormat )
248 {
249  std::vector<SwFormat*>::const_iterator it = std::find( rFormatArr.begin(), rFormatArr.end(), pBoxFormat );
250  if ( it == rFormatArr.end() )
251  rFormatArr.push_back( pBoxFormat );
252 }
253 
254 static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const tools::Long nOld,
255  const tools::Long nNew, std::vector<SwFormat*>& rFormatArr );
256 
257 static void lcl_ModifyLines( SwTableLines &rLines, const tools::Long nOld,
258  const tools::Long nNew, std::vector<SwFormat*>& rFormatArr, const bool bCheckSum )
259 {
260  for ( size_t i = 0; i < rLines.size(); ++i )
261  ::lcl_ModifyBoxes( rLines[i]->GetTabBoxes(), nOld, nNew, rFormatArr );
262  if( bCheckSum )
263  {
264  for(SwFormat* pFormat : rFormatArr)
265  {
266  const SwTwips nBox = lcl_MulDiv64<SwTwips>(pFormat->GetFrameSize().GetWidth(), nNew, nOld);
267  SwFormatFrameSize aNewBox( SwFrameSize::Variable, nBox, 0 );
268  pFormat->LockModify();
269  pFormat->SetFormatAttr( aNewBox );
270  pFormat->UnlockModify();
271  }
272  }
273 }
274 
275 static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const tools::Long nOld,
276  const tools::Long nNew, std::vector<SwFormat*>& rFormatArr )
277 {
278  sal_uInt64 nSum = 0; // To avoid rounding errors we summarize all box widths
279  sal_uInt64 nOriginalSum = 0; // Sum of original widths
280  for ( size_t i = 0; i < rBoxes.size(); ++i )
281  {
282  SwTableBox &rBox = *rBoxes[i];
283  if ( !rBox.GetTabLines().empty() )
284  {
285  // For SubTables the rounding problem will not be solved :-(
286  ::lcl_ModifyLines( rBox.GetTabLines(), nOld, nNew, rFormatArr, false );
287  }
288  // Adjust the box
289  SwFrameFormat *pFormat = rBox.GetFrameFormat();
290  sal_uInt64 nBox = pFormat->GetFrameSize().GetWidth();
291  nOriginalSum += nBox;
292  nBox *= nNew;
293  nBox /= nOld;
294  const sal_uInt64 nWishedSum = lcl_MulDiv64<sal_uInt64>(nOriginalSum, nNew, nOld) - nSum;
295  if( nWishedSum > 0 )
296  {
297  if( nBox == nWishedSum )
298  FormatInArr( rFormatArr, pFormat );
299  else
300  {
301  nBox = nWishedSum;
302  pFormat = rBox.ClaimFrameFormat();
303  SwFormatFrameSize aNewBox( SwFrameSize::Variable, static_cast< SwTwips >(nBox), 0 );
304  pFormat->LockModify();
305  pFormat->SetFormatAttr( aNewBox );
306  pFormat->UnlockModify();
307  }
308  }
309  else {
310  OSL_FAIL( "Rounding error" );
311  }
312  nSum += nBox;
313  }
314 }
315 
316 void SwTable::SwClientNotify(const SwModify&, const SfxHint& rHint)
317 {
318  if (rHint.GetId() != SfxHintId::SwLegacyModify)
319  return;
320  auto pLegacy = static_cast<const sw::LegacyModifyHint*>(&rHint);
321  // catch SSize changes, to adjust the lines/boxes
322  const sal_uInt16 nWhich = pLegacy->GetWhich();
323  const SwFormatFrameSize* pNewSize = nullptr, *pOldSize = nullptr;
324  switch(nWhich)
325  {
326  case RES_ATTRSET_CHG:
327  {
328  if (pLegacy->m_pOld && pLegacy->m_pNew
329  && SfxItemState::SET == static_cast<const SwAttrSetChg*>(pLegacy->m_pNew)->GetChgSet()->GetItemState(
330  RES_FRM_SIZE,
331  false,
332  reinterpret_cast<const SfxPoolItem**>(&pNewSize)))
333  {
334  pOldSize = &static_cast<const SwAttrSetChg*>(pLegacy->m_pOld)->GetChgSet()->GetFrameSize();
335  }
336  }
337  break;
338  case RES_FRM_SIZE:
339  {
340  pOldSize = static_cast<const SwFormatFrameSize*>(pLegacy->m_pOld);
341  pNewSize = static_cast<const SwFormatFrameSize*>(pLegacy->m_pNew);
342  }
343  break;
344  default:
345  CheckRegistration(pLegacy->m_pOld);
346  }
347  if (pOldSize && pNewSize && !m_bModifyLocked)
348  AdjustWidths(pOldSize->GetWidth(), pNewSize->GetWidth());
349 }
350 
351 void SwTable::AdjustWidths( const tools::Long nOld, const tools::Long nNew )
352 {
353  std::vector<SwFormat*> aFormatArr;
354  aFormatArr.reserve( m_aLines[0]->GetTabBoxes().size() );
355  ::lcl_ModifyLines( m_aLines, nOld, nNew, aFormatArr, true );
356 }
357 
358 static void lcl_RefreshHidden( SwTabCols &rToFill, size_t nPos )
359 {
360  for ( size_t i = 0; i < rToFill.Count(); ++i )
361  {
362  if ( std::abs(static_cast<tools::Long>(nPos) - rToFill[i]) <= COLFUZZY )
363  {
364  rToFill.SetHidden( i, false );
365  break;
366  }
367  }
368 }
369 
370 static void lcl_SortedTabColInsert( SwTabCols &rToFill, const SwTableBox *pBox,
371  const SwFrameFormat *pTabFormat, const bool bHidden,
372  const bool bRefreshHidden )
373 {
374  const tools::Long nWish = pTabFormat->GetFrameSize().GetWidth();
375  OSL_ENSURE(nWish, "weird <= 0 width frmfrm");
376 
377  // The value for the left edge of the box is calculated from the
378  // widths of the previous boxes.
379  tools::Long nPos = 0;
380  tools::Long nLeftMin = 0;
381  tools::Long nRightMax = 0;
382  if (nWish != 0) //fdo#33012 0 width frmfmt
383  {
384  SwTwips nSum = 0;
385  const SwTableBox *pCur = pBox;
386  const SwTableLine *pLine = pBox->GetUpper();
387  const tools::Long nAct = rToFill.GetRight() - rToFill.GetLeft(); // +1 why?
388 
389  while ( pLine )
390  {
391  const SwTableBoxes &rBoxes = pLine->GetTabBoxes();
392  for ( size_t i = 0; i < rBoxes.size(); ++i )
393  {
394  const SwTwips nWidth = rBoxes[i]->GetFrameFormat()->GetFrameSize().GetWidth();
395  nSum += nWidth;
396  const tools::Long nTmp = lcl_MulDiv64<tools::Long>(nSum, nAct, nWish);
397 
398  if (rBoxes[i] != pCur)
399  {
400  if ( pLine == pBox->GetUpper() || 0 == nLeftMin )
401  nLeftMin = nTmp - nPos;
402  nPos = nTmp;
403  }
404  else
405  {
406  nSum -= nWidth;
407  if ( 0 == nRightMax )
408  nRightMax = nTmp - nPos;
409  break;
410  }
411  }
412  pCur = pLine->GetUpper();
413  pLine = pCur ? pCur->GetUpper() : nullptr;
414  }
415  }
416 
417  bool bInsert = !bRefreshHidden;
418  for ( size_t j = 0; bInsert && (j < rToFill.Count()); ++j )
419  {
420  tools::Long nCmp = rToFill[j];
421  if ( (nPos >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
422  (nPos <= (nCmp + COLFUZZY)) )
423  {
424  bInsert = false; // Already has it.
425  }
426  else if ( nPos < nCmp )
427  {
428  bInsert = false;
429  rToFill.Insert( nPos, bHidden, j );
430  }
431  }
432  if ( bInsert )
433  rToFill.Insert( nPos, bHidden, rToFill.Count() );
434  else if ( bRefreshHidden )
435  ::lcl_RefreshHidden( rToFill, nPos );
436 
437  if ( !bHidden || bRefreshHidden )
438  return;
439 
440  // calculate minimum/maximum values for the existing entries:
441  nLeftMin = nPos - nLeftMin;
442  nRightMax = nPos + nRightMax;
443 
444  // check if nPos is entry:
445  bool bFoundPos = false;
446  bool bFoundMax = false;
447  for ( size_t j = 0; !(bFoundPos && bFoundMax ) && j < rToFill.Count(); ++j )
448  {
449  SwTabColsEntry& rEntry = rToFill.GetEntry( j );
450  tools::Long nCmp = rToFill[j];
451 
452  if ( (nPos >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
453  (nPos <= (nCmp + COLFUZZY)) )
454  {
455  // check if nLeftMin is > old minimum for entry nPos:
456  const tools::Long nOldMin = rEntry.nMin;
457  if ( nLeftMin > nOldMin )
458  rEntry.nMin = nLeftMin;
459  // check if nRightMin is < old maximum for entry nPos:
460  const tools::Long nOldMax = rEntry.nMax;
461  if ( nRightMax < nOldMax )
462  rEntry.nMax = nRightMax;
463 
464  bFoundPos = true;
465  }
466  else if ( (nRightMax >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
467  (nRightMax <= (nCmp + COLFUZZY)) )
468  {
469  // check if nPos is > old minimum for entry nRightMax:
470  const tools::Long nOldMin = rEntry.nMin;
471  if ( nPos > nOldMin )
472  rEntry.nMin = nPos;
473 
474  bFoundMax = true;
475  }
476  }
477 }
478 
479 static void lcl_ProcessBoxGet( const SwTableBox *pBox, SwTabCols &rToFill,
480  const SwFrameFormat *pTabFormat, bool bRefreshHidden )
481 {
482  if ( !pBox->GetTabLines().empty() )
483  {
484  const SwTableLines &rLines = pBox->GetTabLines();
485  for ( size_t i = 0; i < rLines.size(); ++i )
486  {
487  const SwTableBoxes &rBoxes = rLines[i]->GetTabBoxes();
488  for ( size_t j = 0; j < rBoxes.size(); ++j )
489  ::lcl_ProcessBoxGet( rBoxes[j], rToFill, pTabFormat, bRefreshHidden);
490  }
491  }
492  else
493  ::lcl_SortedTabColInsert( rToFill, pBox, pTabFormat, false, bRefreshHidden );
494 }
495 
496 static void lcl_ProcessLineGet( const SwTableLine *pLine, SwTabCols &rToFill,
497  const SwFrameFormat *pTabFormat )
498 {
499  for ( size_t i = 0; i < pLine->GetTabBoxes().size(); ++i )
500  {
501  const SwTableBox *pBox = pLine->GetTabBoxes()[i];
502  if ( pBox->GetSttNd() )
503  ::lcl_SortedTabColInsert( rToFill, pBox, pTabFormat, true, false );
504  else
505  for ( size_t j = 0; j < pBox->GetTabLines().size(); ++j )
506  ::lcl_ProcessLineGet( pBox->GetTabLines()[j], rToFill, pTabFormat );
507  }
508 }
509 
510 void SwTable::GetTabCols( SwTabCols &rToFill, const SwTableBox *pStart,
511  bool bRefreshHidden, bool bCurRowOnly ) const
512 {
513  // Optimization: if bHidden is set, we only update the Hidden Array.
514  if ( bRefreshHidden )
515  {
516  // remove corrections
517  for ( size_t i = 0; i < rToFill.Count(); ++i )
518  {
519  SwTabColsEntry& rEntry = rToFill.GetEntry( i );
520  rEntry.nPos -= rToFill.GetLeft();
521  rEntry.nMin -= rToFill.GetLeft();
522  rEntry.nMax -= rToFill.GetLeft();
523  }
524 
525  // All are hidden, so add the visible ones.
526  for ( size_t i = 0; i < rToFill.Count(); ++i )
527  rToFill.SetHidden( i, true );
528  }
529  else
530  {
531  rToFill.Remove( 0, rToFill.Count() );
532  }
533 
534  // Insertion cases:
535  // 1. All boxes which are inferior to Line which is superior to the Start,
536  // as well as their inferior boxes if present.
537  // 2. Starting from the Line, the superior box plus its neighbours; but no inferiors.
538  // 3. Apply 2. to the Line superior to the chain of boxes,
539  // until the Line's superior is not a box but the table.
540  // Only those boxes are inserted that don't contain further rows. The insertion
541  // function takes care to avoid duplicates. In order to achieve this, we work
542  // with some degree of fuzzyness (to avoid rounding errors).
543  // Only the left edge of the boxes are inserted.
544  // Finally, the first entry is removed again, because it's already
545  // covered by the border.
546  // 4. Scan the table again and insert _all_ boxes, this time as hidden.
547 
548  const SwFrameFormat *pTabFormat = GetFrameFormat();
549 
550  // 1.
551  const SwTableBoxes &rBoxes = pStart->GetUpper()->GetTabBoxes();
552 
553  for ( size_t i = 0; i < rBoxes.size(); ++i )
554  ::lcl_ProcessBoxGet( rBoxes[i], rToFill, pTabFormat, bRefreshHidden );
555 
556  // 2. and 3.
557  const SwTableLine *pLine = pStart->GetUpper()->GetUpper() ?
558  pStart->GetUpper()->GetUpper()->GetUpper() : nullptr;
559  while ( pLine )
560  {
561  const SwTableBoxes &rBoxes2 = pLine->GetTabBoxes();
562  for ( size_t k = 0; k < rBoxes2.size(); ++k )
563  ::lcl_SortedTabColInsert( rToFill, rBoxes2[k],
564  pTabFormat, false, bRefreshHidden );
565  pLine = pLine->GetUpper() ? pLine->GetUpper()->GetUpper() : nullptr;
566  }
567 
568  if ( !bRefreshHidden )
569  {
570  // 4.
571  if ( !bCurRowOnly )
572  {
573  for ( size_t i = 0; i < m_aLines.size(); ++i )
574  ::lcl_ProcessLineGet( m_aLines[i], rToFill, pTabFormat );
575  }
576 
577  rToFill.Remove( 0 );
578  }
579 
580  // Now the coordinates are relative to the left table border - i.e.
581  // relative to SwTabCols.nLeft. However, they are expected
582  // relative to the left document border, i.e. SwTabCols.nLeftMin.
583  // So all values need to be extended by nLeft.
584  for ( size_t i = 0; i < rToFill.Count(); ++i )
585  {
586  SwTabColsEntry& rEntry = rToFill.GetEntry( i );
587  rEntry.nPos += rToFill.GetLeft();
588  rEntry.nMin += rToFill.GetLeft();
589  rEntry.nMax += rToFill.GetLeft();
590  }
591 }
592 
593 // Structure for parameter passing
594 struct Parm
595 {
596  const SwTabCols &rNew;
597  const SwTabCols &rOld;
598  tools::Long nNewWish,
599  nOldWish;
600  std::deque<SwTableBox*> aBoxArr;
601  SwShareBoxFormats aShareFormats;
602 
603  Parm( const SwTabCols &rN, const SwTabCols &rO )
604  : rNew( rN ), rOld( rO ), nNewWish(0), nOldWish(0)
605  {}
606 };
607 
608 static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm );
609 
610 static void lcl_ProcessLine( SwTableLine *pLine, Parm &rParm )
611 {
612  SwTableBoxes &rBoxes = pLine->GetTabBoxes();
613  for ( size_t i = rBoxes.size(); i > 0; )
614  {
615  --i;
616  ::lcl_ProcessBoxSet( rBoxes[i], rParm );
617  }
618 }
619 
620 static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm )
621 {
622  if ( !pBox->GetTabLines().empty() )
623  {
624  SwTableLines &rLines = pBox->GetTabLines();
625  for ( size_t i = rLines.size(); i > 0; )
626  {
627  --i;
628  lcl_ProcessLine( rLines[i], rParm );
629  }
630  }
631  else
632  {
633  // Search the old TabCols for the current position (calculate from
634  // left and right edge). Adjust the box if the values differ from
635  // the new TabCols. If the adjusted edge has no neighbour we also
636  // adjust all superior boxes.
637 
638  const tools::Long nOldAct = rParm.rOld.GetRight() -
639  rParm.rOld.GetLeft(); // +1 why?
640 
641  // The value for the left edge of the box is calculated from the
642  // widths of the previous boxes plus the left edge.
643  tools::Long nLeft = rParm.rOld.GetLeft();
644  const SwTableBox *pCur = pBox;
645  const SwTableLine *pLine = pBox->GetUpper();
646 
647  while ( pLine )
648  {
649  const SwTableBoxes &rBoxes = pLine->GetTabBoxes();
650  for ( size_t i = 0; (i < rBoxes.size()) && (rBoxes[i] != pCur); ++i)
651  {
652  nLeft += lcl_MulDiv64<tools::Long>(
653  rBoxes[i]->GetFrameFormat()->GetFrameSize().GetWidth(),
654  nOldAct, rParm.nOldWish);
655  }
656  pCur = pLine->GetUpper();
657  pLine = pCur ? pCur->GetUpper() : nullptr;
658  }
659  tools::Long nLeftDiff = 0;
660  tools::Long nRightDiff = 0;
661  if ( nLeft != rParm.rOld.GetLeft() ) // There are still boxes before this.
662  {
663  // Right edge is left edge plus width.
664  const tools::Long nWidth = lcl_MulDiv64<tools::Long>(
665  pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
666  nOldAct, rParm.nOldWish);
667  const tools::Long nRight = nLeft + nWidth;
668  size_t nLeftPos = 0;
669  size_t nRightPos = 0;
670  bool bFoundLeftPos = false;
671  bool bFoundRightPos = false;
672  for ( size_t i = 0; i < rParm.rOld.Count(); ++i )
673  {
674  if ( nLeft >= (rParm.rOld[i] - COLFUZZY) &&
675  nLeft <= (rParm.rOld[i] + COLFUZZY) )
676  {
677  nLeftPos = i;
678  bFoundLeftPos = true;
679  }
680  else if ( nRight >= (rParm.rOld[i] - COLFUZZY) &&
681  nRight <= (rParm.rOld[i] + COLFUZZY) )
682  {
683  nRightPos = i;
684  bFoundRightPos = true;
685  }
686  }
687  nLeftDiff = bFoundLeftPos ?
688  rParm.rOld[nLeftPos] - rParm.rNew[nLeftPos] : 0;
689  nRightDiff= bFoundRightPos ?
690  rParm.rNew[nRightPos] - rParm.rOld[nRightPos] : 0;
691  }
692  else // The first box.
693  {
694  nLeftDiff = rParm.rOld.GetLeft() - rParm.rNew.GetLeft();
695  if ( rParm.rOld.Count() )
696  {
697  // Calculate the difference to the edge touching the first box.
698  const tools::Long nWidth = lcl_MulDiv64<tools::Long>(
699  pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
700  nOldAct, rParm.nOldWish);
701  const tools::Long nTmp = nWidth + rParm.rOld.GetLeft();
702  for ( size_t i = 0; i < rParm.rOld.Count(); ++i )
703  {
704  if ( nTmp >= (rParm.rOld[i] - COLFUZZY) &&
705  nTmp <= (rParm.rOld[i] + COLFUZZY) )
706  {
707  nRightDiff = rParm.rNew[i] - rParm.rOld[i];
708  break;
709  }
710  }
711  }
712  }
713 
714  if( pBox->getRowSpan() == 1 )
715  {
716  const sal_uInt16 nPos = pBox->GetUpper()->GetBoxPos( pBox );
717  SwTableBoxes& rTableBoxes = pBox->GetUpper()->GetTabBoxes();
718  if( nPos && rTableBoxes[ nPos - 1 ]->getRowSpan() != 1 )
719  nLeftDiff = 0;
720  if( nPos + 1 < o3tl::narrowing<sal_uInt16>(rTableBoxes.size()) &&
721  rTableBoxes[ nPos + 1 ]->getRowSpan() != 1 )
722  nRightDiff = 0;
723  }
724  else
725  nLeftDiff = nRightDiff = 0;
726 
727  if ( nLeftDiff || nRightDiff )
728  {
729  // The difference is the actual difference amount. For stretched
730  // tables, it does not make sense to adjust the attributes of the
731  // boxes by this amount. The difference amount needs to be converted
732  // accordingly.
733  tools::Long nTmp = rParm.rNew.GetRight() - rParm.rNew.GetLeft(); // +1 why?
734  nLeftDiff *= rParm.nNewWish;
735  nLeftDiff /= nTmp;
736  nRightDiff *= rParm.nNewWish;
737  nRightDiff /= nTmp;
738  tools::Long nDiff = nLeftDiff + nRightDiff;
739 
740  // Adjust the box and all superiors by the difference amount.
741  while ( pBox )
742  {
743  SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
744  aFormatFrameSize.SetWidth( aFormatFrameSize.GetWidth() + nDiff );
745  if ( aFormatFrameSize.GetWidth() < 0 )
746  aFormatFrameSize.SetWidth( -aFormatFrameSize.GetWidth() );
747  rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
748 
749  // The outer cells of the last row are responsible to adjust a surrounding cell.
750  // Last line check:
751  if ( pBox->GetUpper()->GetUpper() &&
752  pBox->GetUpper() != pBox->GetUpper()->GetUpper()->GetTabLines().back())
753  {
754  pBox = nullptr;
755  }
756  else
757  {
758  // Middle cell check:
759  if ( pBox != pBox->GetUpper()->GetTabBoxes().front() )
760  nDiff = nRightDiff;
761 
762  if ( pBox != pBox->GetUpper()->GetTabBoxes().back() )
763  nDiff -= nRightDiff;
764 
765  pBox = nDiff ? pBox->GetUpper()->GetUpper() : nullptr;
766  }
767  }
768  }
769  }
770 }
771 
772 static void lcl_ProcessBoxPtr( SwTableBox *pBox, std::deque<SwTableBox*> &rBoxArr,
773  bool bBefore )
774 {
775  if ( !pBox->GetTabLines().empty() )
776  {
777  const SwTableLines &rLines = pBox->GetTabLines();
778  for ( size_t i = 0; i < rLines.size(); ++i )
779  {
780  const SwTableBoxes &rBoxes = rLines[i]->GetTabBoxes();
781  for ( size_t j = 0; j < rBoxes.size(); ++j )
782  ::lcl_ProcessBoxPtr( rBoxes[j], rBoxArr, bBefore );
783  }
784  }
785  else if ( bBefore )
786  rBoxArr.push_front( pBox );
787  else
788  rBoxArr.push_back( pBox );
789 }
790 
791 static void lcl_AdjustBox( SwTableBox *pBox, const tools::Long nDiff, Parm &rParm );
792 
793 static void lcl_AdjustLines( SwTableLines &rLines, const tools::Long nDiff, Parm &rParm )
794 {
795  for ( size_t i = 0; i < rLines.size(); ++i )
796  {
797  SwTableBox *pBox = rLines[i]->GetTabBoxes()
798  [rLines[i]->GetTabBoxes().size()-1];
799  lcl_AdjustBox( pBox, nDiff, rParm );
800  }
801 }
802 
803 static void lcl_AdjustBox( SwTableBox *pBox, const tools::Long nDiff, Parm &rParm )
804 {
805  if ( !pBox->GetTabLines().empty() )
806  ::lcl_AdjustLines( pBox->GetTabLines(), nDiff, rParm );
807 
808  // Adjust the size of the box.
809  SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
810  aFormatFrameSize.SetWidth( aFormatFrameSize.GetWidth() + nDiff );
811 
812  rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
813 }
814 
815 void SwTable::SetTabCols( const SwTabCols &rNew, const SwTabCols &rOld,
816  const SwTableBox *pStart, bool bCurRowOnly )
817 {
818  CHECK_TABLE( *this )
819 
820  SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout>()); // delete HTML-Layout
821 
822  // FME: Made rOld const. The caller is responsible for passing correct
823  // values of rOld. Therefore we do not have to call GetTabCols anymore:
824  //GetTabCols( rOld, pStart );
825 
826  Parm aParm( rNew, rOld );
827 
828  OSL_ENSURE( rOld.Count() == rNew.Count(), "Number of columns changed.");
829 
830  // Convert the edges. We need to adjust the size of the table and some boxes.
831  // For the size adjustment, we must not make use of the Modify, since that'd
832  // adjust all boxes, which we really don't want.
833  SwFrameFormat *pFormat = GetFrameFormat();
834  aParm.nOldWish = aParm.nNewWish = pFormat->GetFrameSize().GetWidth();
835  if ( (rOld.GetLeft() != rNew.GetLeft()) ||
836  (rOld.GetRight()!= rNew.GetRight()) )
837  {
838  LockModify();
839  {
840  SvxLRSpaceItem aLR( pFormat->GetLRSpace() );
841  SvxShadowItem aSh( pFormat->GetShadow() );
842 
843  SwTwips nShRight = aSh.CalcShadowSpace( SvxShadowItemSide::RIGHT );
844  SwTwips nShLeft = aSh.CalcShadowSpace( SvxShadowItemSide::LEFT );
845 
846  aLR.SetLeft ( rNew.GetLeft() - nShLeft );
847  aLR.SetRight( rNew.GetRightMax() - rNew.GetRight() - nShRight );
848  pFormat->SetFormatAttr( aLR );
849 
850  // The alignment of the table needs to be adjusted accordingly.
851  // This is done by preserving the exact positions that have been
852  // set by the user.
853  SwFormatHoriOrient aOri( pFormat->GetHoriOrient() );
854  if( text::HoriOrientation::NONE != aOri.GetHoriOrient() &&
855  text::HoriOrientation::CENTER != aOri.GetHoriOrient() )
856  {
857  const bool bLeftDist = rNew.GetLeft() != nShLeft;
858  const bool bRightDist = rNew.GetRight() + nShRight != rNew.GetRightMax();
859  if(!bLeftDist && !bRightDist)
860  aOri.SetHoriOrient( text::HoriOrientation::FULL );
861  else if(!bRightDist && rNew.GetLeft() > nShLeft )
862  aOri.SetHoriOrient( text::HoriOrientation::RIGHT );
863  else if(!bLeftDist && rNew.GetRight() + nShRight < rNew.GetRightMax())
864  aOri.SetHoriOrient( text::HoriOrientation::LEFT );
865  else
866  aOri.SetHoriOrient( text::HoriOrientation::LEFT_AND_WIDTH );
867  }
868  pFormat->SetFormatAttr( aOri );
869  }
870  const tools::Long nAct = rOld.GetRight() - rOld.GetLeft(); // +1 why?
871  tools::Long nTabDiff = 0;
872 
873  if ( rOld.GetLeft() != rNew.GetLeft() )
874  {
875  nTabDiff = rOld.GetLeft() - rNew.GetLeft();
876  nTabDiff *= aParm.nOldWish;
877  nTabDiff /= nAct;
878  }
879  if ( rOld.GetRight() != rNew.GetRight() )
880  {
881  tools::Long nDiff = rNew.GetRight() - rOld.GetRight();
882  nDiff *= aParm.nOldWish;
883  nDiff /= nAct;
884  nTabDiff += nDiff;
885  if( !IsNewModel() )
886  ::lcl_AdjustLines( GetTabLines(), nDiff, aParm );
887  }
888 
889  // Adjust the size of the table, watch out for stretched tables.
890  if ( nTabDiff )
891  {
892  aParm.nNewWish += nTabDiff;
893  if ( aParm.nNewWish < 0 )
894  aParm.nNewWish = USHRT_MAX; // Oops! Have to roll back.
895  SwFormatFrameSize aSz( pFormat->GetFrameSize() );
896  if ( aSz.GetWidth() != aParm.nNewWish )
897  {
898  aSz.SetWidth( aParm.nNewWish );
899  aSz.SetWidthPercent( 0 );
900  pFormat->SetFormatAttr( aSz );
901  }
902  }
903  UnlockModify();
904  }
905 
906  if( IsNewModel() )
907  NewSetTabCols( aParm, rNew, rOld, pStart, bCurRowOnly );
908  else
909  {
910  if ( bCurRowOnly )
911  {
912  // To adjust the current row, we need to process all its boxes,
913  // similar to the filling of the TabCols (see GetTabCols()).
914  // Unfortunately we again have to take care to adjust the boxes
915  // from back to front, respectively from outer to inner.
916  // The best way to achieve this is probably to track the boxes
917  // in a PtrArray.
918  const SwTableBoxes &rBoxes = pStart->GetUpper()->GetTabBoxes();
919  for ( size_t i = 0; i < rBoxes.size(); ++i )
920  ::lcl_ProcessBoxPtr( rBoxes[i], aParm.aBoxArr, false );
921 
922  const SwTableLine *pLine = pStart->GetUpper()->GetUpper() ?
923  pStart->GetUpper()->GetUpper()->GetUpper() : nullptr;
924  const SwTableBox *pExcl = pStart->GetUpper()->GetUpper();
925  while ( pLine )
926  {
927  const SwTableBoxes &rBoxes2 = pLine->GetTabBoxes();
928  bool bBefore = true;
929  for ( size_t i = 0; i < rBoxes2.size(); ++i )
930  {
931  if ( rBoxes2[i] != pExcl )
932  ::lcl_ProcessBoxPtr( rBoxes2[i], aParm.aBoxArr, bBefore );
933  else
934  bBefore = false;
935  }
936  pExcl = pLine->GetUpper();
937  pLine = pLine->GetUpper() ? pLine->GetUpper()->GetUpper() : nullptr;
938  }
939  // After we've inserted a bunch of boxes (hopefully all and in
940  // correct order), we just need to process them in reverse order.
941  for ( int j = aParm.aBoxArr.size()-1; j >= 0; --j )
942  {
943  SwTableBox *pBox = aParm.aBoxArr[j];
944  ::lcl_ProcessBoxSet( pBox, aParm );
945  }
946  }
947  else
948  {
949  // Adjusting the entire table is 'easy'. All boxes without lines are
950  // adjusted, as are their superiors. Of course we need to process
951  // in reverse order to prevent fooling ourselves!
952  SwTableLines &rLines = GetTabLines();
953  for ( size_t i = rLines.size(); i > 0; )
954  {
955  --i;
956  ::lcl_ProcessLine( rLines[i], aParm );
957  }
958  }
959  }
960 
961 #ifdef DBG_UTIL
962  {
963  // do some checking for correct table widths
964  SwTwips nSize = GetFrameFormat()->GetFrameSize().GetWidth();
965  for (size_t n = 0; n < m_aLines.size(); ++n)
966  {
967  CheckBoxWidth( *m_aLines[ n ], nSize );
968  }
969  }
970 #endif
971 }
972 
973 typedef std::pair<sal_uInt16, sal_uInt16> ColChange;
974 typedef std::list< ColChange > ChangeList;
975 
976 static void lcl_AdjustWidthsInLine( SwTableLine* pLine, ChangeList& rOldNew,
977  Parm& rParm, sal_uInt16 nColFuzzy )
978 {
979  ChangeList::iterator pCurr = rOldNew.begin();
980  if( pCurr == rOldNew.end() )
981  return;
982  const size_t nCount = pLine->GetTabBoxes().size();
983  SwTwips nBorder = 0;
984  SwTwips nRest = 0;
985  for( size_t i = 0; i < nCount; ++i )
986  {
987  SwTableBox* pBox = pLine->GetTabBoxes()[i];
988  SwTwips nWidth = pBox->GetFrameFormat()->GetFrameSize().GetWidth();
989  SwTwips nNewWidth = nWidth - nRest;
990  nRest = 0;
991  nBorder += nWidth;
992  if( pCurr != rOldNew.end() && nBorder + nColFuzzy >= pCurr->first )
993  {
994  nBorder -= nColFuzzy;
995  while( pCurr != rOldNew.end() && nBorder > pCurr->first )
996  ++pCurr;
997  if( pCurr != rOldNew.end() )
998  {
999  nBorder += nColFuzzy;
1000  if( nBorder + nColFuzzy >= pCurr->first )
1001  {
1002  if( pCurr->second == pCurr->first )
1003  nRest = 0;
1004  else
1005  nRest = pCurr->second - nBorder;
1006  nNewWidth += nRest;
1007  ++pCurr;
1008  }
1009  }
1010  }
1011  if( nNewWidth != nWidth )
1012  {
1013  if( nNewWidth < 0 )
1014  {
1015  nRest += 1 - nNewWidth;
1016  nNewWidth = 1;
1017  }
1018  SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
1019  aFormatFrameSize.SetWidth( nNewWidth );
1020  rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
1021  }
1022  }
1023 }
1024 
1025 static void lcl_CalcNewWidths( std::vector<sal_uInt16> &rSpanPos, ChangeList& rChanges,
1026  SwTableLine* pLine, tools::Long nWish, tools::Long nWidth, bool bTop )
1027 {
1028  if( rChanges.empty() )
1029  {
1030  rSpanPos.clear();
1031  return;
1032  }
1033  if( rSpanPos.empty() )
1034  {
1035  rChanges.clear();
1036  return;
1037  }
1038  std::vector<sal_uInt16> aNewSpanPos;
1039  ChangeList aNewChanges;
1040  ChangeList::iterator pCurr = rChanges.begin();
1041  aNewChanges.push_back( *pCurr ); // Nullposition
1042  std::vector<sal_uInt16>::iterator pSpan = rSpanPos.begin();
1043  sal_uInt16 nCurr = 0;
1044  SwTwips nOrgSum = 0;
1045  bool bRowSpan = false;
1046  sal_uInt16 nRowSpanCount = 0;
1047  const size_t nCount = pLine->GetTabBoxes().size();
1048  for( size_t nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
1049  {
1050  SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
1051  SwTwips nCurrWidth = pBox->GetFrameFormat()->GetFrameSize().GetWidth();
1052  const sal_Int32 nRowSpan = pBox->getRowSpan();
1053  const bool bCurrRowSpan = bTop ? nRowSpan < 0 :
1054  ( nRowSpan > 1 || nRowSpan < -1 );
1055  if( bRowSpan || bCurrRowSpan )
1056  aNewSpanPos.push_back( nRowSpanCount );
1057  bRowSpan = bCurrRowSpan;
1058  nOrgSum += nCurrWidth;
1059  const sal_uInt16 nPos = lcl_MulDiv64<sal_uInt16>(
1060  lcl_MulDiv64<sal_uInt64>(nOrgSum, nWidth, nWish),
1061  nWish, nWidth);
1062  while( pCurr != rChanges.end() && pCurr->first < nPos )
1063  {
1064  ++nCurr;
1065  ++pCurr;
1066  }
1067  bool bNew = true;
1068  if( pCurr != rChanges.end() && pCurr->first <= nPos &&
1069  pCurr->first != pCurr->second )
1070  {
1071  pSpan = std::find_if(pSpan, rSpanPos.end(),
1072  [nCurr](const sal_uInt16 nSpan) { return nSpan >= nCurr; });
1073  if( pSpan != rSpanPos.end() && *pSpan == nCurr )
1074  {
1075  aNewChanges.push_back( *pCurr );
1076  ++nRowSpanCount;
1077  bNew = false;
1078  }
1079  }
1080  if( bNew )
1081  {
1082  ColChange aTmp( nPos, nPos );
1083  aNewChanges.push_back( aTmp );
1084  ++nRowSpanCount;
1085  }
1086  }
1087 
1088  pCurr = aNewChanges.begin();
1089  ChangeList::iterator pLast = pCurr;
1090  ChangeList::iterator pLeftMove = pCurr;
1091  while( pCurr != aNewChanges.end() )
1092  {
1093  if( pLeftMove == pCurr )
1094  {
1095  while( ++pLeftMove != aNewChanges.end() && pLeftMove->first <= pLeftMove->second )
1096  ;
1097  }
1098  if( pCurr->second == pCurr->first )
1099  {
1100  if( pLeftMove != aNewChanges.end() && pCurr->second > pLeftMove->second )
1101  {
1102  if( pLeftMove->first == pLast->first )
1103  pCurr->second = pLeftMove->second;
1104  else
1105  {
1106  pCurr->second = lcl_MulDiv64<sal_uInt16>(
1107  pCurr->first - pLast->first,
1108  pLeftMove->second - pLast->second,
1109  pLeftMove->first - pLast->first) + pLast->second;
1110  }
1111  }
1112  pLast = pCurr;
1113  ++pCurr;
1114  }
1115  else if( pCurr->second > pCurr->first )
1116  {
1117  pLast = pCurr;
1118  ++pCurr;
1119  ChangeList::iterator pNext = pCurr;
1120  while( pNext != pLeftMove && pNext->second == pNext->first &&
1121  pNext->second < pLast->second )
1122  ++pNext;
1123  while( pCurr != pNext )
1124  {
1125  if( pNext == aNewChanges.end() || pNext->first == pLast->first )
1126  pCurr->second = pLast->second;
1127  else
1128  {
1129  pCurr->second = lcl_MulDiv64<sal_uInt16>(
1130  pCurr->first - pLast->first,
1131  pNext->second - pLast->second,
1132  pNext->first - pLast->first) + pLast->second;
1133  }
1134  ++pCurr;
1135  }
1136  pLast = pCurr;
1137  }
1138  else
1139  {
1140  pLast = pCurr;
1141  ++pCurr;
1142  }
1143  }
1144 
1145  rChanges.swap(aNewChanges);
1146  rSpanPos.swap(aNewSpanPos);
1147 }
1148 
1149 void SwTable::NewSetTabCols( Parm &rParm, const SwTabCols &rNew,
1150  const SwTabCols &rOld, const SwTableBox *pStart, bool bCurRowOnly )
1151 {
1152 #if OSL_DEBUG_LEVEL > 1
1153  static int nCallCount = 0;
1154  ++nCallCount;
1155 #endif
1156  // First step: evaluate which lines have been moved/which widths changed
1157  ChangeList aOldNew;
1158  const tools::Long nNewWidth = rParm.rNew.GetRight() - rParm.rNew.GetLeft();
1159  const tools::Long nOldWidth = rParm.rOld.GetRight() - rParm.rOld.GetLeft();
1160  if( nNewWidth < 1 || nOldWidth < 1 )
1161  return;
1162  for( size_t i = 0; i <= rOld.Count(); ++i )
1163  {
1164  tools::Long nNewPos;
1165  tools::Long nOldPos;
1166  if( i == rOld.Count() )
1167  {
1168  nOldPos = rParm.rOld.GetRight() - rParm.rOld.GetLeft();
1169  nNewPos = rParm.rNew.GetRight() - rParm.rNew.GetLeft();
1170  }
1171  else
1172  {
1173  nOldPos = rOld[i] - rParm.rOld.GetLeft();
1174  nNewPos = rNew[i] - rParm.rNew.GetLeft();
1175  }
1176  nNewPos = lcl_MulDiv64<tools::Long>(nNewPos, rParm.nNewWish, nNewWidth);
1177  nOldPos = lcl_MulDiv64<tools::Long>(nOldPos, rParm.nOldWish, nOldWidth);
1178  if( nOldPos != nNewPos && nNewPos > 0 && nOldPos > 0 )
1179  {
1180  ColChange aChg( o3tl::narrowing<sal_uInt16>(nOldPos), o3tl::narrowing<sal_uInt16>(nNewPos) );
1181  aOldNew.push_back( aChg );
1182  }
1183  }
1184  // Finished first step
1185  int nCount = aOldNew.size();
1186  if( !nCount )
1187  return; // no change, nothing to do
1188  SwTableLines &rLines = GetTabLines();
1189  if( bCurRowOnly )
1190  {
1191  const SwTableLine* pCurrLine = pStart->GetUpper();
1192  sal_uInt16 nCurr = rLines.GetPos( pCurrLine );
1193  if( nCurr >= USHRT_MAX )
1194  return;
1195 
1196  ColChange aChg( 0, 0 );
1197  aOldNew.push_front( aChg );
1198  std::vector<sal_uInt16> aRowSpanPos;
1199  if( nCurr )
1200  {
1201  ChangeList aCopy;
1202  sal_uInt16 nPos = 0;
1203  for( const auto& rCop : aOldNew )
1204  {
1205  aCopy.push_back( rCop );
1206  aRowSpanPos.push_back( nPos++ );
1207  }
1208  lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[nCurr],
1209  rParm.nOldWish, nOldWidth, true );
1210  bool bGoOn = !aRowSpanPos.empty();
1211  sal_uInt16 j = nCurr;
1212  while( bGoOn )
1213  {
1214  lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[--j],
1215  rParm.nOldWish, nOldWidth, true );
1216  lcl_AdjustWidthsInLine( rLines[j], aCopy, rParm, 0 );
1217  bGoOn = !aRowSpanPos.empty() && j > 0;
1218  }
1219  aRowSpanPos.clear();
1220  }
1221  if( nCurr+1 < o3tl::narrowing<sal_uInt16>(rLines.size()) )
1222  {
1223  ChangeList aCopy;
1224  sal_uInt16 nPos = 0;
1225  for( const auto& rCop : aOldNew )
1226  {
1227  aCopy.push_back( rCop );
1228  aRowSpanPos.push_back( nPos++ );
1229  }
1230  lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[nCurr],
1231  rParm.nOldWish, nOldWidth, false );
1232  bool bGoOn = !aRowSpanPos.empty();
1233  sal_uInt16 j = nCurr;
1234  while( bGoOn )
1235  {
1236  lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[++j],
1237  rParm.nOldWish, nOldWidth, false );
1238  lcl_AdjustWidthsInLine( rLines[j], aCopy, rParm, 0 );
1239  bGoOn = !aRowSpanPos.empty() && j+1 < o3tl::narrowing<sal_uInt16>(rLines.size());
1240  }
1241  }
1242  ::lcl_AdjustWidthsInLine( rLines[nCurr], aOldNew, rParm, COLFUZZY );
1243  }
1244  else
1245  {
1246  for( size_t i = 0; i < rLines.size(); ++i )
1247  ::lcl_AdjustWidthsInLine( rLines[i], aOldNew, rParm, COLFUZZY );
1248  }
1249  CHECK_TABLE( *this )
1250 }
1251 
1252 // return the pointer of the box specified.
1253 static bool lcl_IsValidRowName( const OUString& rStr )
1254 {
1255  bool bIsValid = true;
1256  sal_Int32 nLen = rStr.getLength();
1257  for( sal_Int32 i = 0; i < nLen && bIsValid; ++i )
1258  {
1259  const sal_Unicode cChar = rStr[i];
1260  if (cChar < '0' || cChar > '9')
1261  bIsValid = false;
1262  }
1263  return bIsValid;
1264 }
1265 
1266 // #i80314#
1267 // add 3rd parameter and its handling
1268 sal_uInt16 SwTable::GetBoxNum( OUString& rStr, bool bFirstPart,
1269  const bool bPerformValidCheck )
1270 {
1271  sal_uInt16 nRet = 0;
1272  if( bFirstPart ) // true == column; false == row
1273  {
1274  sal_Int32 nPos = 0;
1275  // the first one uses letters for addressing!
1276  bool bFirst = true;
1277  sal_uInt32 num = 0;
1278  bool overflow = false;
1279  while (nPos<rStr.getLength())
1280  {
1281  sal_Unicode cChar = rStr[nPos];
1282  if ((cChar<'A' || cChar>'Z') && (cChar<'a' || cChar>'z'))
1283  break;
1284  cChar -= 'A';
1285  if( cChar >= 26 )
1286  cChar -= 'a' - '[';
1287  if( bFirst )
1288  bFirst = false;
1289  else
1290  ++num;
1291  num = num * 52 + cChar;
1292  if (num > SAL_MAX_UINT16) {
1293  overflow = true;
1294  }
1295  ++nPos;
1296  }
1297  nRet = overflow ? SAL_MAX_UINT16 : num;
1298  rStr = rStr.copy( nPos ); // Remove char from String
1299  }
1300  else
1301  {
1302  const sal_Int32 nPos = rStr.indexOf( "." );
1303  if ( nPos<0 )
1304  {
1305  nRet = 0;
1306  if ( !bPerformValidCheck || lcl_IsValidRowName( rStr ) )
1307  {
1308  nRet = o3tl::narrowing<sal_uInt16>(rStr.toInt32());
1309  }
1310  rStr.clear();
1311  }
1312  else
1313  {
1314  nRet = 0;
1315  const OUString aText( rStr.copy( 0, nPos ) );
1316  if ( !bPerformValidCheck || lcl_IsValidRowName( aText ) )
1317  {
1318  nRet = o3tl::narrowing<sal_uInt16>(aText.toInt32());
1319  }
1320  rStr = rStr.copy( nPos+1 );
1321  }
1322  }
1323  return nRet;
1324 }
1325 
1326 // #i80314#
1327 // add 2nd parameter and its handling
1328 const SwTableBox* SwTable::GetTableBox( const OUString& rName,
1329  const bool bPerformValidCheck ) const
1330 {
1331  const SwTableBox* pBox = nullptr;
1332  const SwTableLine* pLine;
1333  const SwTableLines* pLines;
1334 
1335  sal_uInt16 nLine, nBox;
1336  OUString aNm( rName );
1337  while( !aNm.isEmpty() )
1338  {
1339  nBox = SwTable::GetBoxNum( aNm, nullptr == pBox, bPerformValidCheck );
1340  // first box ?
1341  if( !pBox )
1342  pLines = &GetTabLines();
1343  else
1344  {
1345  pLines = &pBox->GetTabLines();
1346  if( nBox )
1347  --nBox;
1348  }
1349 
1350  nLine = SwTable::GetBoxNum( aNm, false, bPerformValidCheck );
1351 
1352  // determine line
1353  if( !nLine || nLine > pLines->size() )
1354  return nullptr;
1355  pLine = (*pLines)[ nLine-1 ];
1356 
1357  // determine box
1358  const SwTableBoxes* pBoxes = &pLine->GetTabBoxes();
1359  if( nBox >= pBoxes->size() )
1360  return nullptr;
1361  pBox = (*pBoxes)[ nBox ];
1362  }
1363 
1364  // check if the box found has any contents
1365  if( pBox && !pBox->GetSttNd() )
1366  {
1367  OSL_FAIL( "Box without content, looking for the next one!" );
1368  // "drop this" until the first box
1369  while( !pBox->GetTabLines().empty() )
1370  pBox = pBox->GetTabLines().front()->GetTabBoxes().front();
1371  }
1372  return pBox;
1373 }
1374 
1375 SwTableBox* SwTable::GetTableBox( sal_uLong nSttIdx )
1376 {
1377  // For optimizations, don't always process the entire SortArray.
1378  // Converting text to table, tries certain conditions
1379  // to ask for a table box of a table that is not yet having a format
1380  if(!GetFrameFormat())
1381  return nullptr;
1382  SwTableBox* pRet = nullptr;
1383  SwNodes& rNds = GetFrameFormat()->GetDoc()->GetNodes();
1384  sal_uLong nIndex = nSttIdx + 1;
1385  SwContentNode* pCNd = nullptr;
1386  SwTableNode* pTableNd = nullptr;
1387 
1388  while ( nIndex < rNds.Count() )
1389  {
1390  pTableNd = rNds[ nIndex ]->GetTableNode();
1391  if ( pTableNd )
1392  break;
1393 
1394  pCNd = rNds[ nIndex ]->GetContentNode();
1395  if ( pCNd )
1396  break;
1397 
1398  ++nIndex;
1399  }
1400 
1401  if ( pCNd || pTableNd )
1402  {
1403  sw::BroadcastingModify* pModify = pCNd;
1404  // #144862# Better handling of table in table
1405  if ( pTableNd && pTableNd->GetTable().GetFrameFormat() )
1406  pModify = pTableNd->GetTable().GetFrameFormat();
1407 
1408  SwFrame* pFrame = pModify ? SwIterator<SwFrame,sw::BroadcastingModify>(*pModify).First() : nullptr;
1409  while ( pFrame && !pFrame->IsCellFrame() )
1410  pFrame = pFrame->GetUpper();
1411  if ( pFrame )
1412  pRet = const_cast<SwTableBox*>(static_cast<SwCellFrame*>(pFrame)->GetTabBox());
1413  }
1414 
1415  // In case the layout doesn't exist yet or anything else goes wrong.
1416  if ( !pRet )
1417  {
1418  for (size_t n = m_TabSortContentBoxes.size(); n; )
1419  {
1420  if (m_TabSortContentBoxes[ --n ]->GetSttIdx() == nSttIdx)
1421  {
1422  return m_TabSortContentBoxes[ n ];
1423  }
1424  }
1425  }
1426  return pRet;
1427 }
1428 
1429 bool SwTable::IsTableComplex() const
1430 {
1431  // Returns true for complex tables, i.e. tables that contain nestings,
1432  // like containing boxes not part of the first line, e.g. results of
1433  // splits/merges which lead to more complex structures.
1434  for (size_t n = 0; n < m_TabSortContentBoxes.size(); ++n)
1435  {
1436  if (m_TabSortContentBoxes[ n ]->GetUpper()->GetUpper())
1437  {
1438  return true;
1439  }
1440  }
1441  return false;
1442 }
1443 
1444 SwTableLine::SwTableLine( SwTableLineFormat *pFormat, sal_uInt16 nBoxes,
1445  SwTableBox *pUp )
1446  : SwClient( pFormat ),
1447  m_aBoxes(),
1448  m_pUpper( pUp )
1449 {
1450  m_aBoxes.reserve( nBoxes );
1451 }
1452 
1453 SwTableLine::~SwTableLine()
1454 {
1455  for (size_t i = 0; i < m_aBoxes.size(); ++i)
1456  {
1457  delete m_aBoxes[i];
1458  }
1459  // the TabelleLine can be deleted if it's the last client of the FrameFormat
1460  sw::BroadcastingModify* pMod = GetFrameFormat();
1461  pMod->Remove( this ); // remove,
1462  if( !pMod->HasWriterListeners() )
1463  delete pMod; // and delete
1464 }
1465 
1466 SwFrameFormat* SwTableLine::ClaimFrameFormat()
1467 {
1468  // This method makes sure that this object is an exclusive SwTableLine client
1469  // of an SwTableLineFormat object
1470  // If other SwTableLine objects currently listen to the same SwTableLineFormat as
1471  // this one, something needs to be done
1472  SwTableLineFormat *pRet = static_cast<SwTableLineFormat*>(GetFrameFormat());
1473  SwIterator<SwTableLine,SwFormat> aIter( *pRet );
1474  for( SwTableLine* pLast = aIter.First(); pLast; pLast = aIter.Next() )
1475  {
1476  if ( pLast != this )
1477  {
1478  // found another SwTableLine that is a client of the current Format
1479  // create a new Format as a copy and use it for this object
1480  SwTableLineFormat *pNewFormat = pRet->GetDoc()->MakeTableLineFormat();
1481  *pNewFormat = *pRet;
1482 
1483  // register SwRowFrames that know me as clients at the new Format
1484  SwIterator<SwRowFrame,SwFormat> aFrameIter( *pRet );
1485  for( SwRowFrame* pFrame = aFrameIter.First(); pFrame; pFrame = aFrameIter.Next() )
1486  if( pFrame->GetTabLine() == this )
1487  pFrame->RegisterToFormat( *pNewFormat );
1488 
1489  // register myself
1490  pNewFormat->Add( this );
1491  pRet = pNewFormat;
1492  break;
1493  }
1494  }
1495 
1496  return pRet;
1497 }
1498 
1499 void SwTableLine::ChgFrameFormat(SwTableLineFormat* pNewFormat)
1500 {
1501  auto pOld = GetFrameFormat();
1502  pOld->CallSwClientNotify(sw::TableLineFormatChanged(*pNewFormat, *this));
1503  // Now, re-register self.
1504  pNewFormat->Add(this);
1505  if(!pOld->HasWriterListeners())
1506  delete pOld;
1507 }
1508 
1509 SwTwips SwTableLine::GetTableLineHeight( bool& bLayoutAvailable ) const
1510 {
1511  SwTwips nRet = 0;
1512  bLayoutAvailable = false;
1513  SwIterator<SwRowFrame,SwFormat> aIter( *GetFrameFormat() );
1514  // A row could appear several times in headers/footers so only one chain of master/follow tables
1515  // will be accepted...
1516  const SwTabFrame* pChain = nullptr; // My chain
1517  for( SwRowFrame* pLast = aIter.First(); pLast; pLast = aIter.Next() )
1518  {
1519  if( pLast->GetTabLine() == this )
1520  {
1521  const SwTabFrame* pTab = pLast->FindTabFrame();
1522  bLayoutAvailable = ( pTab && pTab->IsVertical() ) ?
1523  ( 0 < pTab->getFrameArea().Height() ) :
1524  ( 0 < pTab->getFrameArea().Width() );
1525 
1526  // The first one defines the chain, if a chain is defined, only members of the chain
1527  // will be added.
1528  if (pTab && (!pChain || pChain->IsAnFollow( pTab ) || pTab->IsAnFollow(pChain)))
1529  {
1530  pChain = pTab; // defines my chain (even it is already)
1531  if( pTab->IsVertical() )
1532  nRet += pLast->getFrameArea().Width();
1533  else
1534  nRet += pLast->getFrameArea().Height();
1535  // Optimization, if there are no master/follows in my chain, nothing more to add
1536  if( !pTab->HasFollow() && !pTab->IsFollow() )
1537  break;
1538  // This is not an optimization, this is necessary to avoid double additions of
1539  // repeating rows
1540  if( pTab->IsInHeadline(*pLast) )
1541  break;
1542  }
1543  }
1544  }
1545  return nRet;
1546 }
1547 
1548 bool SwTableLine::IsEmpty() const
1549 {
1550  for (size_t i = 0; i < m_aBoxes.size(); ++i)
1551  {
1552  if ( !m_aBoxes[i]->IsEmpty() )
1553  return false;
1554  }
1555  return true;
1556 }
1557 
1558 SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, sal_uInt16 nLines, SwTableLine *pUp )
1559  : SwClient(nullptr)
1560  , m_aLines()
1561  , m_pStartNode(nullptr)
1562  , m_pUpper(pUp)
1563  , mnRowSpan(1)
1564  , mbDummyFlag(false)
1565  , mbDirectFormatting(false)
1566 {
1567  m_aLines.reserve( nLines );
1568  CheckBoxFormat( pFormat )->Add( this );
1569 }
1570 
1571 SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwNodeIndex &rIdx,
1572  SwTableLine *pUp )
1573  : SwClient(nullptr)
1574  , m_aLines()
1575  , m_pUpper(pUp)
1576  , mnRowSpan(1)
1577  , mbDummyFlag(false)
1578  , mbDirectFormatting(false)
1579 {
1580  CheckBoxFormat( pFormat )->Add( this );
1581 
1582  m_pStartNode = rIdx.GetNode().GetStartNode();
1583 
1584  // insert into the table
1585  const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
1586  assert(pTableNd && "In which table is that box?");
1587  SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
1588  GetTabSortBoxes());
1589  SwTableBox* p = this; // error: &this
1590  rSrtArr.insert( p ); // insert
1591 }
1592 
1593 SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwStartNode& rSttNd, SwTableLine *pUp )
1594  : SwClient(nullptr)
1595  , m_aLines()
1596  , m_pStartNode(&rSttNd)
1597  , m_pUpper(pUp)
1598  , mnRowSpan(1)
1599  , mbDummyFlag(false)
1600  , mbDirectFormatting(false)
1601 {
1602  CheckBoxFormat( pFormat )->Add( this );
1603 
1604  // insert into the table
1605  const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
1606  OSL_ENSURE( pTableNd, "In which table is the box?" );
1607  SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
1608  GetTabSortBoxes());
1609  SwTableBox* p = this; // error: &this
1610  rSrtArr.insert( p ); // insert
1611 }
1612 
1613 void SwTableBox::RemoveFromTable()
1614 {
1615  if (m_pStartNode) // box containing contents?
1616  {
1617  // remove from table
1618  const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
1619  assert(pTableNd && "In which table is that box?");
1620  SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
1621  GetTabSortBoxes());
1622  SwTableBox *p = this; // error: &this
1623  rSrtArr.erase( p ); // remove
1624  m_pStartNode = nullptr; // clear it so this is only run once
1625  }
1626 }
1627 
1628 SwTableBox::~SwTableBox()
1629 {
1630  if (!GetFrameFormat()->GetDoc()->IsInDtor())
1631  {
1632  RemoveFromTable();
1633  }
1634 
1635  // the TabelleBox can be deleted if it's the last client of the FrameFormat
1636  sw::BroadcastingModify* pMod = GetFrameFormat();
1637  pMod->Remove( this ); // remove,
1638  if( !pMod->HasWriterListeners() )
1639  delete pMod; // and delete
1640 }
1641 
1642 SwTableBoxFormat* SwTableBox::CheckBoxFormat( SwTableBoxFormat* pFormat )
1643 {
1644  // We might need to create a new format here, because the box must be
1645  // added to the format solely if pFormat has a value or form.
1646  if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_VALUE, false ) ||
1647  SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_FORMULA, false ) )
1648  {
1649  SwTableBox* pOther = SwIterator<SwTableBox,SwFormat>( *pFormat ).First();
1650  if( pOther )
1651  {
1652  SwTableBoxFormat* pNewFormat = pFormat->GetDoc()->MakeTableBoxFormat();
1653  pNewFormat->LockModify();
1654  *pNewFormat = *pFormat;
1655 
1656  // Remove values and formulas
1657  pNewFormat->ResetFormatAttr( RES_BOXATR_FORMULA, RES_BOXATR_VALUE );
1658  pNewFormat->UnlockModify();
1659 
1660  pFormat = pNewFormat;
1661  }
1662  }
1663  return pFormat;
1664 }
1665 
1666 SwFrameFormat* SwTableBox::ClaimFrameFormat()
1667 {
1668  // This method makes sure that this object is an exclusive SwTableBox client
1669  // of an SwTableBoxFormat object
1670  // If other SwTableBox objects currently listen to the same SwTableBoxFormat as
1671  // this one, something needs to be done
1672  SwTableBoxFormat *pRet = static_cast<SwTableBoxFormat*>(GetFrameFormat());
1673  SwIterator<SwTableBox,SwFormat> aIter( *pRet );
1674  for( SwTableBox* pLast = aIter.First(); pLast; pLast = aIter.Next() )
1675  {
1676  if ( pLast != this )
1677  {
1678  // Found another SwTableBox object
1679  // create a new Format as a copy and assign me to it
1680  // don't copy values and formulas
1681  SwTableBoxFormat* pNewFormat = pRet->GetDoc()->MakeTableBoxFormat();
1682  pNewFormat->LockModify();
1683  *pNewFormat = *pRet;
1684  pNewFormat->ResetFormatAttr( RES_BOXATR_FORMULA, RES_BOXATR_VALUE );
1685  pNewFormat->UnlockModify();
1686 
1687  // re-register SwCellFrame objects that know me
1688  SwIterator<SwCellFrame,SwFormat> aFrameIter( *pRet );
1689  for( SwCellFrame* pCell = aFrameIter.First(); pCell; pCell = aFrameIter.Next() )
1690  if( pCell->GetTabBox() == this )
1691  pCell->RegisterToFormat( *pNewFormat );
1692 
1693  // re-register myself
1694  pNewFormat->Add( this );
1695  pRet = pNewFormat;
1696  break;
1697  }
1698  }
1699  return pRet;
1700 }
1701 
1702 void SwTableBox::ChgFrameFormat(SwTableBoxFormat* pNewFormat, bool bNeedToReregister)
1703 {
1704  SwFrameFormat* pOld = GetFrameFormat();
1705  // tdf#84635 We set bNeedToReregister=false to avoid a quadratic slowdown on loading large tables,
1706  // and since we are creating the table for the first time, no re-registration is necessary.
1707  // First, re-register the Frames.
1708  if(bNeedToReregister)
1709  pOld->CallSwClientNotify(sw::TableBoxFormatChanged(*pNewFormat, *this));
1710  // Now, re-register self.
1711  pNewFormat->Add(this);
1712  if(!pOld->HasWriterListeners())
1713  delete pOld;
1714 }
1715 
1716 // Return the name of this box. This is determined dynamically
1717 // resulting from the position in the lines/boxes/tables.
1718 void sw_GetTableBoxColStr( sal_uInt16 nCol, OUString& rNm )
1719 {
1720  const sal_uInt16 coDiff = 52; // 'A'-'Z' 'a' - 'z'
1721 
1722  do {
1723  const sal_uInt16 nCalc = nCol % coDiff;
1724  if( nCalc >= 26 )
1725  rNm = OUStringChar( sal_Unicode('a' - 26 + nCalc) ) + rNm;
1726  else
1727  rNm = OUStringChar( sal_Unicode('A' + nCalc) ) + rNm;
1728 
1729  nCol = nCol - nCalc;
1730  if( 0 == nCol )
1731  break;
1732  nCol /= coDiff;
1733  --nCol;
1734  } while( true );
1735 }
1736 
1737 Point SwTableBox::GetCoordinates() const
1738 {
1739  if( !m_pStartNode ) // box without content?
1740  {
1741  // search for the next first box?
1742  return Point( 0, 0 );
1743  }
1744 
1745  const SwTable& rTable = m_pStartNode->FindTableNode()->GetTable();
1746  sal_uInt16 nX, nY;
1747  const SwTableBox* pBox = this;
1748  do {
1749  const SwTableLine* pLine = pBox->GetUpper();
1750  // at the first level?
1751  const SwTableLines* pLines = pLine->GetUpper()
1752  ? &pLine->GetUpper()->GetTabLines() : &rTable.GetTabLines();
1753 
1754  nY = pLines->GetPos( pLine ) + 1 ;
1755  nX = pBox->GetUpper()->GetBoxPos( pBox ) + 1;
1756  pBox = pLine->GetUpper();
1757  } while( pBox );
1758  return Point( nX, nY );
1759 }
1760 
1761 OUString SwTableBox::GetName() const
1762 {
1763  if( !m_pStartNode ) // box without content?
1764  {
1765  // search for the next first box?
1766  return OUString();
1767  }
1768 
1769  const SwTable& rTable = m_pStartNode->FindTableNode()->GetTable();
1770  sal_uInt16 nPos;
1771  OUString sNm, sTmp;
1772  const SwTableBox* pBox = this;
1773  do {
1774  const SwTableLine* pLine = pBox->GetUpper();
1775  // at the first level?
1776  const SwTableLines* pLines = pLine->GetUpper()
1777  ? &pLine->GetUpper()->GetTabLines() : &rTable.GetTabLines();
1778 
1779  nPos = pLines->GetPos( pLine ) + 1;
1780  sTmp = OUString::number( nPos );
1781  if( !sNm.isEmpty() )
1782  sNm = sTmp + "." + sNm;
1783  else
1784  sNm = sTmp;
1785 
1786  nPos = pBox->GetUpper()->GetBoxPos( pBox );
1787  sTmp = OUString::number(nPos + 1);
1788  pBox = pLine->GetUpper();
1789  if( nullptr != pBox )
1790  sNm = sTmp + "." + sNm;
1791  else
1792  sw_GetTableBoxColStr( nPos, sNm );
1793 
1794  } while( pBox );
1795  return sNm;
1796 }
1797 
1798 bool SwTableBox::IsInHeadline( const SwTable* pTable ) const
1799 {
1800  if( !GetUpper() ) // should only happen upon merge.
1801  return false;
1802 
1803  if( !pTable )
1804  pTable = &m_pStartNode->FindTableNode()->GetTable();
1805 
1806  const SwTableLine* pLine = GetUpper();
1807  while( pLine->GetUpper() )
1808  pLine = pLine->GetUpper()->GetUpper();
1809 
1810  // Headerline?
1811  return pTable->GetTabLines()[ 0 ] == pLine;
1812 }
1813 
1814 sal_uLong SwTableBox::GetSttIdx() const
1815 {
1816  return m_pStartNode ? m_pStartNode->GetIndex() : 0;
1817 }
1818 
1819 bool SwTableBox::IsEmpty() const
1820 {
1821  const SwStartNode *pSttNd = GetSttNd();
1822  if( pSttNd &&
1823  pSttNd->GetIndex() + 2 == pSttNd->EndOfSectionIndex() )
1824  {
1825  const SwContentNode *pCNd =
1826  pSttNd->GetNodes()[pSttNd->GetIndex()+1]->GetContentNode();
1827  if( pCNd && !pCNd->Len() )
1828  return true;
1829  }
1830 
1831  return false;
1832 }
1833 
1834  // retrieve information from the client
1835 bool SwTable::GetInfo( SfxPoolItem& rInfo ) const
1836 {
1837  switch( rInfo.Which() )
1838  {
1839  case RES_AUTOFMT_DOCNODE:
1840  {
1841  const SwTableNode* pNode = GetTableNode();
1842  if (pNode && &pNode->GetNodes() == static_cast<SwAutoFormatGetDocNode&>(rInfo).pNodes)
1843  {
1844  if (!m_TabSortContentBoxes.empty())
1845  {
1846  SwNodeIndex aIdx( *m_TabSortContentBoxes[0]->GetSttNd() );
1847  GetFrameFormat()->GetDoc()->GetNodes().GoNext( &aIdx );
1848  }
1849  return false;
1850  }
1851  break;
1852  }
1853  case RES_FINDNEARESTNODE:
1854  if( GetFrameFormat() &&
1855  GetFrameFormat()->GetFormatAttr( RES_PAGEDESC ).GetPageDesc() &&
1856  !m_TabSortContentBoxes.empty() &&
1857  m_TabSortContentBoxes[0]->GetSttNd()->GetNodes().IsDocNodes() )
1858  static_cast<SwFindNearestNode&>(rInfo).CheckNode( *
1859  m_TabSortContentBoxes[0]->GetSttNd()->FindTableNode() );
1860  break;
1861 
1862  case RES_CONTENT_VISIBLE:
1863  static_cast<SwPtrMsgPoolItem&>(rInfo).pObject = SwIterator<SwFrame,SwFormat>( *GetFrameFormat() ).First();
1864  return false;
1865  }
1866  return true;
1867 }
1868 
1869 SwTable * SwTable::FindTable( SwFrameFormat const*const pFormat )
1870 {
1871  return pFormat
1872  ? SwIterator<SwTable,SwFormat>(*pFormat).First()
1873  : nullptr;
1874 }
1875 
1876 SwTableNode* SwTable::GetTableNode() const
1877 {
1878  return !GetTabSortBoxes().empty() ?
1879  const_cast<SwTableNode*>(GetTabSortBoxes()[ 0 ]->GetSttNd()->FindTableNode()) :
1880  m_pTableNode;
1881 }
1882 
1883 void SwTable::SetRefObject( SwServerObject* pObj )
1884 {
1885  if( m_xRefObj.is() )
1886  m_xRefObj->Closed();
1887 
1888  m_xRefObj = pObj;
1889 }
1890 
1891 void SwTable::SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout> const& r)
1892 {
1893  m_xHTMLLayout = r;
1894 }
1895 
1896 static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
1897  bool bChgAlign )
1898 {
1899  sal_uLong nNdPos = rBox.IsValidNumTextNd();
1900  ChgTextToNum( rBox,rText,pCol,bChgAlign,nNdPos);
1901 }
1902 void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
1903  bool bChgAlign,sal_uLong nNdPos )
1904 {
1905 
1906  if( ULONG_MAX == nNdPos )
1907  return;
1908 
1909  SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
1910  SwTextNode* pTNd = pDoc->GetNodes()[ nNdPos ]->GetTextNode();
1911  const SfxPoolItem* pItem;
1912 
1913  // assign adjustment
1914  if( bChgAlign )
1915  {
1916  pItem = &pTNd->SwContentNode::GetAttr( RES_PARATR_ADJUST );
1917  SvxAdjust eAdjust = static_cast<const SvxAdjustItem*>(pItem)->GetAdjust();
1918  if( SvxAdjust::Left == eAdjust || SvxAdjust::Block == eAdjust )
1919  {
1920  SvxAdjustItem aAdjust( *static_cast<const SvxAdjustItem*>(pItem) );
1921  aAdjust.SetAdjust( SvxAdjust::Right );
1922  pTNd->SetAttr( aAdjust );
1923  }
1924  }
1925 
1926  // assign color or save "user color"
1927  if( !pTNd->GetpSwAttrSet() || SfxItemState::SET != pTNd->GetpSwAttrSet()->
1928  GetItemState( RES_CHRATR_COLOR, false, &pItem ))
1929  pItem = nullptr;
1930 
1931  const std::optional<Color>& pOldNumFormatColor = rBox.GetSaveNumFormatColor();
1932  std::optional<Color> pNewUserColor;
1933  if (pItem)
1934  pNewUserColor = static_cast<const SvxColorItem*>(pItem)->GetValue();
1935 
1936  if( ( pNewUserColor && pOldNumFormatColor &&
1937  *pNewUserColor == *pOldNumFormatColor ) ||
1938  ( !pNewUserColor && !pOldNumFormatColor ))
1939  {
1940  // Keep the user color, set updated values, delete old NumFormatColor if needed
1941  if( pCol )
1942  // if needed, set the color
1943  pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
1944  else if( pItem )
1945  {
1946  pNewUserColor = rBox.GetSaveUserColor();
1947  if( pNewUserColor )
1948  pTNd->SetAttr( SvxColorItem( *pNewUserColor, RES_CHRATR_COLOR ));
1949  else
1950  pTNd->ResetAttr( RES_CHRATR_COLOR );
1951  }
1952  }
1953  else
1954  {
1955  // Save user color, set NumFormat color if needed, but never reset the color
1956  rBox.SetSaveUserColor( pNewUserColor ? *pNewUserColor : std::optional<Color>() );
1957 
1958  if( pCol )
1959  // if needed, set the color
1960  pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
1961 
1962  }
1963  rBox.SetSaveNumFormatColor( pCol ? *pCol : std::optional<Color>() );
1964 
1965  if( pTNd->GetText() != rText )
1966  {
1967  // Exchange text. Bugfix to keep Tabs (front and back!) and annotations (inword comment anchors)
1968  const OUString& rOrig = pTNd->GetText();
1969  sal_Int32 n;
1970 
1971  for( n = 0; n < rOrig.getLength() && ('\x9' == rOrig[n] || CH_TXTATR_INWORD == rOrig[n]); ++n )
1972  ;
1973  for( ; n < rOrig.getLength() && '\x01' == rOrig[n]; ++n )
1974  ;
1975  SwIndex aIdx( pTNd, n );
1976  for( n = rOrig.getLength(); n && ('\x9' == rOrig[--n] || CH_TXTATR_INWORD == rOrig[n]); )
1977  ;
1978  sal_Int32 nEndPos = n;
1979  n -= aIdx.GetIndex() - 1;
1980 
1981  // Reset DontExpand-Flags before exchange, to retrigger expansion
1982  {
1983  SwIndex aResetIdx( aIdx, n );
1984  pTNd->DontExpandFormat( aResetIdx, false, false );
1985  }
1986 
1987  if( !pDoc->getIDocumentRedlineAccess().IsIgnoreRedline() && !pDoc->getIDocumentRedlineAccess().GetRedlineTable().empty() )
1988  {
1989  SwPaM aTemp(*pTNd, 0, *pTNd, rOrig.getLength());
1990  pDoc->getIDocumentRedlineAccess().DeleteRedline(aTemp, true, RedlineType::Any);
1991  }
1992 
1993  // preserve comments inside of the number by deleting number portions starting from the back
1994  sal_Int32 nCommentPos = pTNd->GetText().lastIndexOf( CH_TXTATR_INWORD, nEndPos );
1995  while( nCommentPos > aIdx.GetIndex() )
1996  {
1997  pTNd->EraseText( SwIndex(pTNd, nCommentPos+1), nEndPos - nCommentPos, SwInsertFlags::EMPTYEXPAND );
1998  // find the next non-sequential comment anchor
1999  do
2000  {
2001  nEndPos = nCommentPos;
2002  n = nEndPos - aIdx.GetIndex();
2003  nCommentPos = pTNd->GetText().lastIndexOf( CH_TXTATR_INWORD, nEndPos );
2004  --nEndPos;
2005  }
2006  while( nCommentPos > aIdx.GetIndex() && nCommentPos == nEndPos );
2007  }
2008 
2009  pTNd->EraseText( aIdx, n, SwInsertFlags::EMPTYEXPAND );
2010  pTNd->InsertText( rText, aIdx, SwInsertFlags::EMPTYEXPAND );
2011 
2012  if( pDoc->getIDocumentRedlineAccess().IsRedlineOn() )
2013  {
2014  SwPaM aTemp(*pTNd, 0, *pTNd, rText.getLength());
2015  pDoc->getIDocumentRedlineAccess().AppendRedline(new SwRangeRedline(RedlineType::Insert, aTemp), true);
2016  }
2017  }
2018 
2019  // assign vertical orientation
2020  if( bChgAlign &&
2021  ( SfxItemState::SET != rBox.GetFrameFormat()->GetItemState(
2022  RES_VERT_ORIENT, true, &pItem ) ||
2023  text::VertOrientation::TOP == static_cast<const SwFormatVertOrient*>(pItem)->GetVertOrient() ))
2024  {
2025  rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::BOTTOM ));
2026  }
2027 
2028 }
2029 
2030 static void ChgNumToText( SwTableBox& rBox, sal_uLong nFormat )
2031 {
2032  sal_uLong nNdPos = rBox.IsValidNumTextNd( false );
2033  if( ULONG_MAX == nNdPos )
2034  return;
2035 
2036  SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
2037  SwTextNode* pTNd = pDoc->GetNodes()[ nNdPos ]->GetTextNode();
2038  bool bChgAlign = pDoc->IsInsTableAlignNum();
2039  const SfxPoolItem* pItem;
2040 
2041  const Color * pCol = nullptr;
2042  if( getSwDefaultTextFormat() != nFormat )
2043  {
2044  // special text format:
2045  OUString sTmp;
2046  const OUString sText( pTNd->GetText() );
2047  pDoc->GetNumberFormatter()->GetOutputString( sText, nFormat, sTmp, &pCol );
2048  if( sText != sTmp )
2049  {
2050  // exchange text
2051  SwIndex aIdx( pTNd, sText.getLength() );
2052  // Reset DontExpand-Flags before exchange, to retrigger expansion
2053  pTNd->DontExpandFormat( aIdx, false, false );
2054  aIdx = 0;
2055  pTNd->EraseText( aIdx, SAL_MAX_INT32, SwInsertFlags::EMPTYEXPAND );
2056  pTNd->InsertText( sTmp, aIdx, SwInsertFlags::EMPTYEXPAND );
2057  }
2058  }
2059 
2060  const SfxItemSet* pAttrSet = pTNd->GetpSwAttrSet();
2061 
2062  // assign adjustment
2063  if( bChgAlign && pAttrSet && SfxItemState::SET == pAttrSet->GetItemState(
2064  RES_PARATR_ADJUST, false, &pItem ) &&
2065  SvxAdjust::Right == static_cast<const SvxAdjustItem*>(pItem)->GetAdjust() )
2066  {
2067  pTNd->SetAttr( SvxAdjustItem( SvxAdjust::Left, RES_PARATR_ADJUST ) );
2068  }
2069 
2070  // assign color or save "user color"
2071  if( !pAttrSet || SfxItemState::SET != pAttrSet->
2072  GetItemState( RES_CHRATR_COLOR, false, &pItem ))
2073  pItem = nullptr;
2074 
2075  const std::optional<Color>& pOldNumFormatColor = rBox.GetSaveNumFormatColor();
2076  std::optional<Color> pNewUserColor;
2077  if (pItem)
2078  pNewUserColor = static_cast<const SvxColorItem*>(pItem)->GetValue();
2079 
2080  if( ( pNewUserColor && pOldNumFormatColor &&
2081  *pNewUserColor == *pOldNumFormatColor ) ||
2082  ( !pNewUserColor && !pOldNumFormatColor ))
2083  {
2084  // Keep the user color, set updated values, delete old NumFormatColor if needed
2085  if( pCol )
2086  // if needed, set the color
2087  pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
2088  else if( pItem )
2089  {
2090  pNewUserColor = rBox.GetSaveUserColor();
2091  if( pNewUserColor )
2092  pTNd->SetAttr( SvxColorItem( *pNewUserColor, RES_CHRATR_COLOR ));
2093  else
2094  pTNd->ResetAttr( RES_CHRATR_COLOR );
2095  }
2096  }
2097  else
2098  {
2099  // Save user color, set NumFormat color if needed, but never reset the color
2100  rBox.SetSaveUserColor( pNewUserColor );
2101 
2102  if( pCol )
2103  // if needed, set the color
2104  pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
2105 
2106  }
2107  rBox.SetSaveNumFormatColor( pCol ? *pCol : std::optional<Color>() );
2108 
2109  // assign vertical orientation
2110  if( bChgAlign &&
2111  SfxItemState::SET == rBox.GetFrameFormat()->GetItemState(
2112  RES_VERT_ORIENT, false, &pItem ) &&
2113  text::VertOrientation::BOTTOM == static_cast<const SwFormatVertOrient*>(pItem)->GetVertOrient() )
2114  {
2115  rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::TOP ));
2116  }
2117 
2118 }
2119 
2120 // for detection of modifications (mainly TableBoxAttribute)
2121 void SwTableBoxFormat::SwClientNotify(const SwModify& rMod, const SfxHint& rHint)
2122 {
2123  if (rHint.GetId() != SfxHintId::SwLegacyModify)
2124  return;
2125  auto pLegacy = static_cast<const sw::LegacyModifyHint*>(&rHint);
2126  if(IsModifyLocked() || !GetDoc() || GetDoc()->IsInDtor())
2127  {
2128  SwFrameFormat::SwClientNotify(rMod, rHint);
2129  return;
2130  }
2131  const SwTableBoxNumFormat* pNewFormat = nullptr;
2132  const SwTableBoxFormula* pNewFormula = nullptr;
2133  const SwTableBoxValue* pNewVal = nullptr;
2134  sal_uLong nOldFormat = getSwDefaultTextFormat();
2135 
2136  switch(pLegacy->m_pNew ? pLegacy->m_pNew->Which() : 0)
2137  {
2138  case RES_ATTRSET_CHG:
2139  {
2140  const SfxItemSet& rSet = *static_cast<const SwAttrSetChg*>(pLegacy->m_pNew)->GetChgSet();
2141  if(SfxItemState::SET == rSet.GetItemState( RES_BOXATR_FORMAT, false, reinterpret_cast<const SfxPoolItem**>(&pNewFormat)))
2142  nOldFormat = static_cast<const SwAttrSetChg*>(pLegacy->m_pOld)->GetChgSet()->Get(RES_BOXATR_FORMAT).GetValue();
2143  rSet.GetItemState(RES_BOXATR_FORMULA, false, reinterpret_cast<const SfxPoolItem**>(&pNewFormula));
2144  rSet.GetItemState(RES_BOXATR_VALUE, false, reinterpret_cast<const SfxPoolItem**>(&pNewVal));
2145  break;
2146  }
2147  case RES_BOXATR_FORMAT:
2148  pNewFormat = static_cast<const SwTableBoxNumFormat*>(pLegacy->m_pNew);
2149  nOldFormat = static_cast<const SwTableBoxNumFormat*>(pLegacy->m_pOld)->GetValue();
2150  break;
2151  case RES_BOXATR_FORMULA:
2152  pNewFormula = static_cast<const SwTableBoxFormula*>(pLegacy->m_pNew);
2153  break;
2154  case RES_BOXATR_VALUE:
2155  pNewVal = static_cast<const SwTableBoxValue*>(pLegacy->m_pNew);
2156  break;
2157  }
2158 
2159  // something changed and some BoxAttribut remained in the set!
2160  if( pNewFormat || pNewFormula || pNewVal )
2161  {
2162  GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty(true, nullptr, 0);
2163 
2164  if( SfxItemState::SET == GetItemState( RES_BOXATR_FORMAT, false ) ||
2165  SfxItemState::SET == GetItemState( RES_BOXATR_VALUE, false ) ||
2166  SfxItemState::SET == GetItemState( RES_BOXATR_FORMULA, false ) )
2167  {
2168  // fetch the box
2169  SwIterator<SwTableBox,SwFormat> aIter( *this );
2170  SwTableBox* pBox = aIter.First();
2171  if( pBox )
2172  {
2173  OSL_ENSURE( !aIter.Next(), "zero or more than one box at format" );
2174 
2175  sal_uLong nNewFormat;
2176  if( pNewFormat )
2177  {
2178  nNewFormat = pNewFormat->GetValue();
2179  // new formatting
2180  // is it newer or has the current been removed?
2181  if( SfxItemState::SET != GetItemState( RES_BOXATR_VALUE, false ))
2182  pNewFormat = nullptr;
2183  }
2184  else
2185  {
2186  // fetch the current Item
2187  (void)GetItemState(RES_BOXATR_FORMAT, false, reinterpret_cast<const SfxPoolItem**>(&pNewFormat));
2188  nOldFormat = GetTableBoxNumFormat().GetValue();
2189  nNewFormat = pNewFormat ? pNewFormat->GetValue() : nOldFormat;
2190  }
2191 
2192  // is it newer or has the current been removed?
2193  if( pNewVal )
2194  {
2195  if( GetDoc()->GetNumberFormatter()->IsTextFormat(nNewFormat) )
2196  nOldFormat = 0;
2197  else
2198  {
2199  if( SfxItemState::SET == GetItemState( RES_BOXATR_VALUE, false ))
2200  nOldFormat = getSwDefaultTextFormat();
2201  else
2202  nNewFormat = getSwDefaultTextFormat();
2203  }
2204  }
2205 
2206  // Logic:
2207  // Value change: -> "simulate" a format change!
2208  // Format change:
2209  // Text -> !Text or format change:
2210  // - align right for horizontal alignment, if LEFT or JUSTIFIED
2211  // - align bottom for vertical alignment, if TOP is set, or default
2212  // - replace text (color? negative numbers RED?)
2213  // !Text -> Text:
2214  // - align left for horizontal alignment, if RIGHT
2215  // - align top for vertical alignment, if BOTTOM is set
2216  SvNumberFormatter* pNumFormatr = GetDoc()->GetNumberFormatter();
2217  bool bNewIsTextFormat = pNumFormatr->IsTextFormat( nNewFormat );
2218 
2219  if( (!bNewIsTextFormat && nOldFormat != nNewFormat) || pNewFormula )
2220  {
2221  bool bIsNumFormat = false;
2222  OUString aOrigText;
2223  bool bChgText = true;
2224  double fVal = 0;
2225  if( !pNewVal && SfxItemState::SET != GetItemState(
2226  RES_BOXATR_VALUE, false, reinterpret_cast<const SfxPoolItem**>(&pNewVal) ))
2227  {
2228  // so far, no value has been set, so try to evaluate the content
2229  sal_uLong nNdPos = pBox->IsValidNumTextNd();
2230  if( ULONG_MAX != nNdPos )
2231  {
2232  sal_uInt32 nTmpFormatIdx = nNewFormat;
2233  OUString aText( GetDoc()->GetNodes()[ nNdPos ]
2234  ->GetTextNode()->GetRedlineText());
2235  aOrigText = aText;
2236  if( aText.isEmpty() )
2237  bChgText = false;
2238  else
2239  {
2240  // Keep Tabs
2241  lcl_TabToBlankAtSttEnd( aText );
2242 
2243  // JP 22.04.98: Bug 49659 -
2244  // Special casing for percent
2245  if( SvNumFormatType::PERCENT ==
2246  pNumFormatr->GetType( nNewFormat ))
2247  {
2248  sal_uInt32 nTmpFormat = 0;
2249  if( GetDoc()->IsNumberFormat(
2250  aText, nTmpFormat, fVal ))
2251  {
2252  if( SvNumFormatType::NUMBER ==
2253  pNumFormatr->GetType( nTmpFormat ))
2254  aText += "%";
2255 
2256  bIsNumFormat = GetDoc()->IsNumberFormat(
2257  aText, nTmpFormatIdx, fVal );
2258  }
2259  }
2260  else
2261  bIsNumFormat = GetDoc()->IsNumberFormat(
2262  aText, nTmpFormatIdx, fVal );
2263 
2264  if( bIsNumFormat )
2265  {
2266  // directly assign value - without Modify
2267  bool bIsLockMod = IsModifyLocked();
2268  LockModify();
2269  SetFormatAttr( SwTableBoxValue( fVal ));
2270  if( !bIsLockMod )
2271  UnlockModify();
2272  }
2273  }
2274  }
2275  }
2276  else
2277  {
2278  fVal = pNewVal->GetValue();
2279  bIsNumFormat = true;
2280  }
2281 
2282  // format contents with the new value assigned and write to paragraph
2283  const Color* pCol = nullptr;
2284  OUString sNewText;
2285  if( DBL_MAX == fVal )
2286  {
2287  sNewText = SwViewShell::GetShellRes()->aCalc_Error;
2288  }
2289  else
2290  {
2291  if (bIsNumFormat)
2292  pNumFormatr->GetOutputString( fVal, nNewFormat, sNewText, &pCol );
2293  else
2294  {
2295  // Original text could not be parsed as
2296  // number/date/time/..., so keep the text.
2297 #if 0
2298  // Actually the text should be formatted
2299  // according to the format, which may include
2300  // additional text from the format, for example
2301  // in {0;-0;"BAD: "@}. But other places when
2302  // entering a new value or changing text or
2303  // changing to a different format of type Text
2304  // don't do this (yet?).
2305  pNumFormatr->GetOutputString( aOrigText, nNewFormat, sNewText, &pCol );
2306 #else
2307  sNewText = aOrigText;
2308 #endif
2309  }
2310 
2311  if( !bChgText )
2312  {
2313  sNewText.clear();
2314  }
2315  }
2316 
2317  // across all boxes
2318  ChgTextToNum( *pBox, sNewText, pCol,
2319  GetDoc()->IsInsTableAlignNum() );
2320 
2321  }
2322  else if( bNewIsTextFormat && nOldFormat != nNewFormat )
2323  {
2324  ChgNumToText( *pBox, nNewFormat );
2325  }
2326  }
2327  }
2328  }
2329  // call base class
2330  SwFrameFormat::SwClientNotify(rMod, rHint);
2331 }
2332 
2333 bool SwTableBoxFormat::supportsFullDrawingLayerFillAttributeSet() const
2334 {
2335  return false;
2336 }
2337 
2338 bool SwTableFormat::supportsFullDrawingLayerFillAttributeSet() const
2339 {
2340  return false;
2341 }
2342 
2343 bool SwTableLineFormat::supportsFullDrawingLayerFillAttributeSet() const
2344 {
2345  return false;
2346 }
2347 
2348 bool SwTableBox::HasNumContent( double& rNum, sal_uInt32& rFormatIndex,
2349  bool& rIsEmptyTextNd ) const
2350 {
2351  bool bRet = false;
2352  sal_uLong nNdPos = IsValidNumTextNd();
2353  if( ULONG_MAX != nNdPos )
2354  {
2355  OUString aText( m_pStartNode->GetNodes()[ nNdPos ]->GetTextNode()->GetRedlineText() );
2356  // Keep Tabs
2357  lcl_TabToBlankAtSttEnd( aText );
2358  rIsEmptyTextNd = aText.isEmpty();
2359  SvNumberFormatter* pNumFormatr = GetFrameFormat()->GetDoc()->GetNumberFormatter();
2360 
2361  const SfxPoolItem* pItem;
2362  if( SfxItemState::SET == GetFrameFormat()->GetItemState( RES_BOXATR_FORMAT, false, &pItem ))
2363  {
2364  rFormatIndex = static_cast<const SwTableBoxNumFormat*>(pItem)->GetValue();
2365  // Special casing for percent
2366  if( !rIsEmptyTextNd && SvNumFormatType::PERCENT == pNumFormatr->GetType( rFormatIndex ))
2367  {
2368  sal_uInt32 nTmpFormat = 0;
2369  if( GetFrameFormat()->GetDoc()->IsNumberFormat( aText, nTmpFormat, rNum ) &&
2370  SvNumFormatType::NUMBER == pNumFormatr->GetType( nTmpFormat ))
2371  aText += "%";
2372  }
2373  }
2374  else
2375  rFormatIndex = 0;
2376 
2377  bRet = GetFrameFormat()->GetDoc()->IsNumberFormat( aText, rFormatIndex, rNum );
2378  }
2379  else
2380  rIsEmptyTextNd = false;
2381  return bRet;
2382 }
2383 
2384 bool SwTableBox::IsNumberChanged() const
2385 {
2386  bool bRet = true;
2387 
2388  if( SfxItemState::SET == GetFrameFormat()->GetItemState( RES_BOXATR_FORMULA, false ))
2389  {
2390  const SwTableBoxNumFormat *pNumFormat;
2391  const SwTableBoxValue *pValue;
2392 
2393  if( SfxItemState::SET != GetFrameFormat()->GetItemState( RES_BOXATR_VALUE, false,
2394  reinterpret_cast<const SfxPoolItem**>(&pValue) ))
2395  pValue = nullptr;
2396  if( SfxItemState::SET != GetFrameFormat()->GetItemState( RES_BOXATR_FORMAT, false,
2397  reinterpret_cast<const SfxPoolItem**>(&pNumFormat) ))
2398  pNumFormat = nullptr;
2399 
2400  sal_uLong nNdPos;
2401  if( pNumFormat && pValue && ULONG_MAX != ( nNdPos = IsValidNumTextNd() ) )
2402  {
2403  OUString sNewText, sOldText( m_pStartNode->GetNodes()[ nNdPos ]->
2404  GetTextNode()->GetRedlineText() );
2405  lcl_DelTabsAtSttEnd( sOldText );
2406 
2407  const Color* pCol = nullptr;
2408  GetFrameFormat()->GetDoc()->GetNumberFormatter()->GetOutputString(
2409  pValue->GetValue(), pNumFormat->GetValue(), sNewText, &pCol );
2410 
2411  bRet = sNewText != sOldText ||
2412  !( ( !pCol && !GetSaveNumFormatColor() ) ||
2413  ( pCol && GetSaveNumFormatColor() &&
2414  *pCol == *GetSaveNumFormatColor() ));
2415  }
2416  }
2417  return bRet;
2418 }
2419 
2420 sal_uLong SwTableBox::IsValidNumTextNd( bool bCheckAttr ) const
2421 {
2422  sal_uLong nPos = ULONG_MAX;
2423  if( m_pStartNode )
2424  {
2425  SwNodeIndex aIdx( *m_pStartNode );
2426  sal_uLong nIndex = aIdx.GetIndex();
2427  const sal_uLong nIndexEnd = m_pStartNode->GetNodes()[ nIndex ]->EndOfSectionIndex();
2428  const SwTextNode *pTextNode = nullptr;
2429  while( ++nIndex < nIndexEnd )
2430  {
2431  const SwNode* pNode = m_pStartNode->GetNodes()[nIndex];
2432  if( pNode->IsTableNode() )
2433  {
2434  pTextNode = nullptr;
2435  break;
2436  }
2437  if( pNode->IsTextNode() )
2438  {
2439  if( pTextNode )
2440  {
2441  pTextNode = nullptr;
2442  break;
2443  }
2444  else
2445  {
2446  pTextNode = pNode->GetTextNode();
2447  nPos = nIndex;
2448  }
2449  }
2450  }
2451  if( pTextNode )
2452  {
2453  if( bCheckAttr )
2454  {
2455  const SwpHints* pHts = pTextNode->GetpSwpHints();
2456  // do some tests if there's only text in the node!
2457  // Flys/fields/...
2458  if( pHts )
2459  {
2460  sal_Int32 nNextSetField = 0;
2461  for( size_t n = 0; n < pHts->Count(); ++n )
2462  {
2463  const SwTextAttr* pAttr = pHts->Get(n);
2464  if( RES_TXTATR_NOEND_BEGIN <= pAttr->Which() )
2465  {
2466  if ( (pAttr->GetStart() == nNextSetField)
2467  && (pAttr->Which() == RES_TXTATR_FIELD))
2468  {
2469  // #i104949# hideous hack for report builder:
2470  // it inserts hidden variable-set fields at
2471  // the beginning of para in cell, but they
2472  // should not turn cell into text cell
2473  const SwField* pField = pAttr->GetFormatField().GetField();
2474  if (pField &&
2475  (pField->GetTypeId() == SwFieldTypesEnum::Set) &&
2476  (0 != (static_cast<SwSetExpField const*>
2477  (pField)->GetSubType() &
2478  nsSwExtendedSubType::SUB_INVISIBLE)))
2479  {
2480  nNextSetField = pAttr->GetStart() + 1;
2481  continue;
2482  }
2483  }
2484  else if( RES_TXTATR_ANNOTATION == pAttr->Which() )
2485  {
2486  continue;
2487  }
2488  nPos = ULONG_MAX;
2489  break;
2490  }
2491  }
2492  }
2493  }
2494  }
2495  else
2496  nPos = ULONG_MAX;
2497  }
2498  return nPos;
2499 }
2500 
2501 // is this a Formula box or one with numeric content (AutoSum)
2502 sal_uInt16 SwTableBox::IsFormulaOrValueBox() const
2503 {
2504  sal_uInt16 nWhich = 0;
2505  const SwTextNode* pTNd;
2506  SwFrameFormat* pFormat = GetFrameFormat();
2507  if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_FORMULA, false ))
2508  nWhich = RES_BOXATR_FORMULA;
2509  else if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_VALUE, false ) &&
2510  !pFormat->GetDoc()->GetNumberFormatter()->IsTextFormat(
2511  pFormat->GetTableBoxNumFormat().GetValue() ))
2512  nWhich = RES_BOXATR_VALUE;
2513  else if( m_pStartNode && m_pStartNode->GetIndex() + 2 == m_pStartNode->EndOfSectionIndex()
2514  && nullptr != ( pTNd = m_pStartNode->GetNodes()[ m_pStartNode->GetIndex() + 1 ]
2515  ->GetTextNode() ) && pTNd->GetText().isEmpty())
2516  nWhich = USHRT_MAX;
2517 
2518  return nWhich;
2519 }
2520 
2521 void SwTableBox::ActualiseValueBox()
2522 {
2523  const SfxPoolItem *pFormatItem, *pValItem;
2524  SwFrameFormat* pFormat = GetFrameFormat();
2525  if( SfxItemState::SET != pFormat->GetItemState( RES_BOXATR_FORMAT, true, &pFormatItem )
2526  || SfxItemState::SET != pFormat->GetItemState( RES_BOXATR_VALUE, true, &pValItem ))
2527  return;
2528 
2529  const sal_uLong nFormatId = static_cast<const SwTableBoxNumFormat*>(pFormatItem)->GetValue();
2530  sal_uLong nNdPos = ULONG_MAX;
2531  SvNumberFormatter* pNumFormatr = pFormat->GetDoc()->GetNumberFormatter();
2532 
2533  if( !pNumFormatr->IsTextFormat( nFormatId ) &&
2534  ULONG_MAX != (nNdPos = IsValidNumTextNd()) )
2535  {
2536  double fVal = static_cast<const SwTableBoxValue*>(pValItem)->GetValue();
2537  const Color* pCol = nullptr;
2538  OUString sNewText;
2539  pNumFormatr->GetOutputString( fVal, nFormatId, sNewText, &pCol );
2540 
2541  const OUString& rText = m_pStartNode->GetNodes()[ nNdPos ]->GetTextNode()->GetText();
2542  if( rText != sNewText )
2543  ChgTextToNum( *this, sNewText, pCol, false ,nNdPos);
2544  }
2545 }
2546 
2547 struct SwTableCellInfo::Impl
2548 {
2549  const SwTable * m_pTable;
2550  const SwCellFrame * m_pCellFrame;
2551  const SwTabFrame * m_pTabFrame;
2552  typedef o3tl::sorted_vector<const SwTableBox *> TableBoxes_t;
2553  TableBoxes_t m_HandledTableBoxes;
2554 
2555 public:
2556  Impl()
2557  : m_pTable(nullptr), m_pCellFrame(nullptr), m_pTabFrame(nullptr)
2558  {
2559  }
2560 
2561  void setTable(const SwTable * pTable)
2562  {
2563  m_pTable = pTable;
2564  SwFrameFormat * pFrameFormat = m_pTable->GetFrameFormat();
2565  m_pTabFrame = SwIterator<SwTabFrame,SwFormat>(*pFrameFormat).First();
2566  if (m_pTabFrame && m_pTabFrame->IsFollow())
2567  m_pTabFrame = m_pTabFrame->FindMaster(true);
2568  }
2569 
2570  const SwCellFrame * getCellFrame() const { return m_pCellFrame; }
2571 
2572  const SwFrame * getNextFrameInTable(const SwFrame * pFrame);
2573  const SwCellFrame * getNextCellFrame(const SwFrame * pFrame);
2574  const SwCellFrame * getNextTableBoxsCellFrame(const SwFrame * pFrame);
2575  bool getNext();
2576 };
2577 
2578 const SwFrame * SwTableCellInfo::Impl::getNextFrameInTable(const SwFrame * pFrame)
2579 {
2580  const SwFrame * pResult = nullptr;
2581 
2582  if (((! pFrame->IsTabFrame()) || pFrame == m_pTabFrame) && pFrame->GetLower())
2583  pResult = pFrame->GetLower();
2584  else if (pFrame->GetNext())
2585  pResult = pFrame->GetNext();
2586  else
2587  {
2588  while (pFrame->GetUpper() != nullptr)
2589  {
2590  pFrame = pFrame->GetUpper();
2591 
2592  if (pFrame->IsTabFrame())
2593  {
2594  m_pTabFrame = static_cast<const SwTabFrame *>(pFrame)->GetFollow();
2595  pResult = m_pTabFrame;
2596  break;
2597  }
2598  else if (pFrame->GetNext())
2599  {
2600  pResult = pFrame->GetNext();
2601  break;
2602  }
2603  }
2604  }
2605 
2606  return pResult;
2607 }
2608 
2609 const SwCellFrame * SwTableCellInfo::Impl::getNextCellFrame(const SwFrame * pFrame)
2610 {
2611  const SwCellFrame * pResult = nullptr;
2612 
2613  while ((pFrame = getNextFrameInTable(pFrame)) != nullptr)
2614  {
2615  if (pFrame->IsCellFrame())
2616  {
2617  pResult = static_cast<const SwCellFrame *>(pFrame);
2618  break;
2619  }
2620  }
2621 
2622  return pResult;
2623 }
2624 
2625 const SwCellFrame * SwTableCellInfo::Impl::getNextTableBoxsCellFrame(const SwFrame * pFrame)
2626 {
2627  const SwCellFrame * pResult = nullptr;
2628 
2629  while ((pFrame = getNextCellFrame(pFrame)) != nullptr)
2630  {
2631  const SwCellFrame * pCellFrame = static_cast<const SwCellFrame *>(pFrame);
2632  const SwTableBox * pTabBox = pCellFrame->GetTabBox();
2633  auto aIt = m_HandledTableBoxes.insert(pTabBox);
2634  if (aIt.second)
2635  {
2636  pResult = pCellFrame;
2637  break;
2638  }
2639  }
2640 
2641  return pResult;
2642 }
2643 
2644 const SwCellFrame * SwTableCellInfo::getCellFrame() const
2645 {
2646  return m_pImpl->getCellFrame();
2647 }
2648 
2649 bool SwTableCellInfo::Impl::getNext()
2650 {
2651  if (m_pCellFrame == nullptr)
2652  {
2653  if (m_pTabFrame != nullptr)
2654  m_pCellFrame = Impl::getNextTableBoxsCellFrame(m_pTabFrame);
2655  }
2656  else
2657  m_pCellFrame = Impl::getNextTableBoxsCellFrame(m_pCellFrame);
2658 
2659  return m_pCellFrame != nullptr;
2660 }
2661 
2662 SwTableCellInfo::SwTableCellInfo(const SwTable * pTable)
2663  : m_pImpl(std::make_unique<Impl>())
2664 {
2665  m_pImpl->setTable(pTable);
2666 }
2667 
2668 SwTableCellInfo::~SwTableCellInfo()
2669 {
2670 }
2671 
2672 bool SwTableCellInfo::getNext()
2673 {
2674  return m_pImpl->getNext();
2675 }
2676 
2677 SwRect SwTableCellInfo::getRect() const
2678 {
2679  SwRect aRet;
2680 
2681  if (getCellFrame() != nullptr)
2682  aRet = getCellFrame()->getFrameArea();
2683 
2684  return aRet;
2685 }
2686 
2687 const SwTableBox * SwTableCellInfo::getTableBox() const
2688 {
2689  const SwTableBox * pRet = nullptr;
2690 
2691  if (getCellFrame() != nullptr)
2692  pRet = getCellFrame()->GetTabBox();
2693 
2694  return pRet;
2695 }
2696 
2697 void SwTable::RegisterToFormat( SwFormat& rFormat )
2698 {
2699  rFormat.Add( this );
2700 }
2701 
2702 bool SwTable::HasLayout() const
2703 {
2704  const SwFrameFormat* pFrameFormat = GetFrameFormat();
2705  //a table in a clipboard document doesn't have any layout information
2706  return pFrameFormat && SwIterator<SwTabFrame,SwFormat>(*pFrameFormat).First();
2707 }
2708 
2709 void SwTableBox::RegisterToFormat( SwFormat& rFormat )
2710 {
2711  rFormat.Add( this );
2712 }
2713 
2714 // free's any remaining child objects
2715 SwTableLines::~SwTableLines()
2716 {
2717  for ( const_iterator it = begin(); it != end(); ++it )
2718  delete *it;
2719 }
2720 
2721 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SwTableLine::SwTableLine
SwTableLine(SwTableLineFormat *, sal_uInt16 nBoxes, SwTableBox *pUp)
Definition: swtable.cxx:1444
ChangeList
std::list< ColChange > ChangeList
Definition: swtable.cxx:974
SwTableBox::GetSaveNumFormatColor
const std::optional< Color > & GetSaveNumFormatColor() const
Definition: swtable.hxx:487
SwTable::m_pTableNode
SwTableNode * m_pTableNode
Definition: swtable.hxx:125
SwAttrSetChg::GetChgSet
const SwAttrSet * GetChgSet() const
What has changed.
Definition: hints.hxx:299
SwTable::~SwTable
virtual ~SwTable() override
Definition: swtable.cxx:210
SwTable::IsTableComplex
bool IsTableComplex() const
Definition: swtable.cxx:1429
SwFormat::GetTableBoxNumFormat
const SwTableBoxNumFormat & GetTableBoxNumFormat(bool=true) const
TableBox attributes - implemented in cellatr.hxx.
Definition: cellatr.hxx:105
tools::SvRef::is
bool is() const
SwStartNode
Starts a section of nodes in the document model.
Definition: node.hxx:312
SwFrameFormat::SwClientNotify
virtual void SwClientNotify(const SwModify &, const SfxHint &) override
Definition: atrfrm.cxx:2627
SwFrame
Base class of the Writer layout elements.
Definition: frame.hxx:313
SwTableLine::GetTableLineHeight
SwTwips GetTableLineHeight(bool &bLayoutAvailable) const
Definition: swtable.cxx:1509
SwContentNode::Len
virtual sal_Int32 Len() const
Definition: node.cxx:1246
SvxSizeItem::GetWidth
tools::Long GetWidth() const
RES_PAGEDESC
constexpr TypedWhichId< SwFormatPageDesc > RES_PAGEDESC(93)
SwNode::GetIndex
sal_uLong GetIndex() const
Definition: node.hxx:291
SwTable::SwClientNotify
virtual void SwClientNotify(const SwModify &, const SfxHint &) override
Definition: swtable.cxx:316
Parm::rOld
const SwTabCols & rOld
Definition: swtable.cxx:597
SwDoc::MakeTableLineFormat
SwTableLineFormat * MakeTableLineFormat()
Definition: docfmt.cxx:1716
nIndex
sal_Int32 nIndex
SwModify::Add
void Add(SwClient *pDepend)
Definition: calbck.cxx:173
SwFlowFrame::IsFollow
bool IsFollow() const
Definition: flowfrm.hxx:166
SwNodes::Count
sal_uLong Count() const
Definition: ndarr.hxx:142
SwTable::RegisterToFormat
void RegisterToFormat(SwFormat &rFormat)
Definition: swtable.cxx:2697
lcl_DelTabsAtSttEnd
static OUString & lcl_DelTabsAtSttEnd(OUString &rText)
Definition: swtable.cxx:110
sw::LegacyModifyHint::GetWhich
sal_uInt16 GetWhich() const
Definition: calbck.hxx:72
SwFormatField::GetField
const SwField * GetField() const
Definition: fmtfld.hxx:110
SwTable::GetTableBox
const SwTableBox * GetTableBox(const OUString &rName, const bool bPerformValidCheck=false) const
Definition: swtable.cxx:1328
SwTable::HasLayout
bool HasLayout() const
Definition: swtable.cxx:2702
RES_BOXATR_FORMAT
constexpr TypedWhichId< SwTableBoxNumFormat > RES_BOXATR_FORMAT(RES_BOXATR_BEGIN)
SwTextNode::GetText
const OUString & GetText() const
Definition: ndtxt.hxx:215
SwViewShell::GetShellRes
static ShellResource * GetShellRes()
Definition: viewsh.cxx:2547
SwTableBox::GetSttIdx
sal_uLong GetSttIdx() const
Definition: swtable.cxx:1814
SwTableCellInfo::Impl::TableBoxes_t
o3tl::sorted_vector< const SwTableBox * > TableBoxes_t
Definition: swtable.cxx:2552
SwTextNode::SetAttr
virtual bool SetAttr(const SfxPoolItem &) override
overriding to handle change of certain paragraph attributes
Definition: ndtxt.cxx:4856
SwTextNode::GetpSwpHints
SwpHints * GetpSwpHints()
Definition: ndtxt.hxx:223
GetValue
std::string GetValue
SwDoc::GetNumberFormatter
SvNumberFormatter * GetNumberFormatter(bool bCreate=true)
Definition: doc.hxx:1411
nsSwExtendedSubType::SUB_INVISIBLE
const SwExtendedSubType SUB_INVISIBLE
Invisible.
Definition: fldbas.hxx:212
IDocumentRedlineAccess::AppendRedline
virtual AppendResult AppendRedline(SwRangeRedline *pNewRedl, bool bCallDelete)=0
Append a new redline.
Parm::rNew
const SwTabCols & rNew
Definition: swtable.cxx:596
SwDoc::IsInsTableAlignNum
bool IsInsTableAlignNum() const
Definition: doc.cxx:1685
RES_FRM_SIZE
constexpr TypedWhichId< SwFormatFrameSize > RES_FRM_SIZE(89)
lcl_CalcNewWidths
static void lcl_CalcNewWidths(std::vector< sal_uInt16 > &rSpanPos, ChangeList &rChanges, SwTableLine *pLine, tools::Long nWish, tools::Long nWidth, bool bTop)
Definition: swtable.cxx:1025
sal_uLong
sal_uIntPtr sal_uLong
tools::Long
long Long
SwField
Base class of all fields.
Definition: fldbas.hxx:289
SwTabFrame
SwTabFrame is one table in the document layout, containing rows (which contain cells).
Definition: tabfrm.hxx:46
SwTabCols::GetLeft
tools::Long GetLeft() const
Definition: tabcol.hxx:78
SwTabCols::GetRightMax
tools::Long GetRightMax() const
Definition: tabcol.hxx:80
SwTextNode::DontExpandFormat
bool DontExpandFormat(const SwIndex &rIdx, bool bFlag=true, bool bFormatToTextAttributes=true)
When appropriate set DontExpand-flag at INet or character styles respectively.
Definition: ndtxt.cxx:1595
n
sal_Int64 n
SwDoc
Definition: doc.hxx:188
SwTableLine::ClaimFrameFormat
SwFrameFormat * ClaimFrameFormat()
Definition: swtable.cxx:1466
SwIterator::Next
TElementType * Next()
Definition: calbck.hxx:333
SwFlowFrame::HasFollow
bool HasFollow() const
Definition: flowfrm.hxx:165
SwDoc::getIDocumentLinksAdministration
IDocumentLinksAdministration const & getIDocumentLinksAdministration() const
Definition: doc.cxx:260
SwTableBox::setDummyFlag
void setDummyFlag(bool bDummy)
Definition: swtable.cxx:90
SvNumberFormatter::GetType
SvNumFormatType GetType(sal_uInt32 nFIndex) const
SwTableLine
SwTableLine is one table row in the document model.
Definition: swtable.hxx:351
SwNodeIndex::GetNode
SwNode & GetNode() const
Definition: ndindex.hxx:119
SwTable::SetRefObject
void SetRefObject(SwServerObject *)
Definition: swtable.cxx:1883
ShellResource::aCalc_Error
OUString aCalc_Error
Definition: shellres.hxx:41
SwTableFormat::supportsFullDrawingLayerFillAttributeSet
virtual bool supportsFullDrawingLayerFillAttributeSet() const override
Definition: swtable.cxx:2338
SwTableBoxValue::GetValue
double GetValue() const
Definition: cellatr.hxx:95
SwTableBox::IsInHeadline
bool IsInHeadline(const SwTable *pTable) const
Definition: swtable.cxx:1798
SwFrame::IsCellFrame
bool IsCellFrame() const
Definition: frame.hxx:1223
SwRect
Of course Writer needs its own rectangles.
Definition: swrect.hxx:34
SwTableLines::begin
iterator begin()
Definition: swtable.hxx:76
SwTextAttr::Which
sal_uInt16 Which() const
Definition: txatbase.hxx:114
RES_BOXATR_VALUE
constexpr TypedWhichId< SwTableBoxValue > RES_BOXATR_VALUE(152)
SwModify::Remove
SwClient * Remove(SwClient *pDepend)
Definition: calbck.cxx:226
SwTableLines::front
SwTableLine * front() const
Definition: swtable.hxx:80
SwModify::HasWriterListeners
bool HasWriterListeners() const
Definition: calbck.hxx:197
pObject
EmbeddedObjectRef * pObject
lcl_RefreshHidden
static void lcl_RefreshHidden(SwTabCols &rToFill, size_t nPos)
Definition: swtable.cxx:358
RES_TXTATR_ANNOTATION
constexpr TypedWhichId< SwFormatField > RES_TXTATR_ANNOTATION(59)
SwTable::GetFrameFormat
SwTableFormat * GetFrameFormat()
Definition: swtable.hxx:203
SfxHint::GetId
SfxHintId GetId() const
SwTableBox::RemoveFromTable
void RemoveFromTable()
Definition: swtable.cxx:1613
SwTabCols::GetEntry
const SwTabColsEntry & GetEntry(size_t nPos) const
Definition: tabcol.hxx:74
SwTableLines::size
size_type size() const
Definition: swtable.hxx:75
SwTableCellInfo::getCellFrame
const SwCellFrame * getCellFrame() const
Definition: swtable.cxx:2644
SwTableBox::RegisterToFormat
void RegisterToFormat(SwFormat &rFormat)
Definition: swtable.cxx:2709
SwTableBox::getRowSpan
sal_Int32 getRowSpan() const
Definition: swtable.cxx:75
SwTableLine::m_aBoxes
SwTableBoxes m_aBoxes
Definition: swtable.hxx:353
SwDoc::DelTableFrameFormat
void DelTableFrameFormat(SwTableFormat *pFormat)
Definition: docfmt.cxx:726
SwTableLines::back
SwTableLine * back() const
Definition: swtable.hxx:81
SwDoc::getIDocumentFieldsAccess
IDocumentFieldsAccess const & getIDocumentFieldsAccess() const
Definition: doc.cxx:357
RES_VERT_ORIENT
constexpr TypedWhichId< SwFormatVertOrient > RES_VERT_ORIENT(102)
sw_GetTableBoxColStr
void sw_GetTableBoxColStr(sal_uInt16 nCol, OUString &rNm)
Definition: swtable.cxx:1718
SwTable::m_aLines
SwTableLines m_aLines
Definition: swtable.hxx:115
SwTableBox::IsFormulaOrValueBox
sal_uInt16 IsFormulaOrValueBox() const
Definition: swtable.cxx:2502
SwTableLine::ChgFrameFormat
void ChgFrameFormat(SwTableLineFormat *pNewFormat)
Definition: swtable.cxx:1499
Parm::aShareFormats
SwShareBoxFormats aShareFormats
Definition: swtable.cxx:601
sal_Unicode
sal_uInt16 sal_Unicode
SwTableBox::SetSaveUserColor
void SetSaveUserColor(std::optional< Color > p)
Definition: swtable.hxx:488
SwTable::GetTabCols
void GetTabCols(SwTabCols &rToFill, const SwTableBox *pStart, bool bHidden=false, bool bCurRowOnly=false) const
Definition: swtable.cxx:510
CH_TXTATR_INWORD
#define CH_TXTATR_INWORD
Definition: hintids.hxx:171
SwCellFrame::GetTabBox
const SwTableBox * GetTabBox() const
Definition: cellfrm.hxx:51
lcl_ProcessBoxSet
static void lcl_ProcessBoxSet(SwTableBox *pBox, Parm &rParm)
Definition: swtable.cxx:620
SwRedlineTable::empty
bool empty() const
Definition: docary.hxx:260
SwFrameAreaDefinition::getFrameArea
const SwRect & getFrameArea() const
Definition: frame.hxx:178
SAL_MAX_UINT16
#define SAL_MAX_UINT16
SwTextAttr
A wrapper around SfxPoolItem to store the start position of (usually) a text portion, with an optional end.
Definition: txatbase.hxx:41
SwDoc::GetDfltTextFormatColl
const SwTextFormatColl * GetDfltTextFormatColl() const
Definition: doc.hxx:776
IDocumentRedlineAccess::IsRedlineOn
static bool IsRedlineOn(const RedlineFlags eM)
Definition: IDocumentRedlineAccess.hxx:93
SwTableCellInfo::Impl::m_pTabFrame
const SwTabFrame * m_pTabFrame
Definition: swtable.cxx:2551
SwNodes::InsBoxen
bool InsBoxen(SwTableNode *, SwTableLine *, SwTableBoxFormat *, SwTextFormatColl *, const SfxItemSet *pAutoAttr, sal_uInt16 nInsPos, sal_uInt16 nCnt=1)
Insert a new box in the line before InsPos.
Definition: ndtbl.cxx:231
SwTableBox::~SwTableBox
virtual ~SwTableBox() override
Definition: swtable.cxx:1628
SwTable::AdjustWidths
void AdjustWidths(const tools::Long nOld, const tools::Long nNew)
Definition: swtable.cxx:351
nCount
int nCount
sfx2::LinkManager::RemoveServer
void RemoveServer(SvLinkSource *rObj)
SwTable::UnlockModify
void UnlockModify()
Definition: swtable.hxx:184
SwNodeIndex::GetIndex
sal_uLong GetIndex() const
Definition: ndindex.hxx:152
SwTextAttr::GetStart
sal_Int32 GetStart() const
Definition: txatbase.hxx:86
SwTable::m_eTableChgMode
TableChgMode m_eTableChgMode
Definition: swtable.hxx:128
SwTableBox::SwTableBox
SwTableBox(const SwTableBox &)=delete
SwTable::SetTabCols
void SetTabCols(const SwTabCols &rNew, const SwTabCols &rOld, const SwTableBox *pStart, bool bCurRowOnly)
Definition: swtable.cxx:815
SwRect::Width
void Width(tools::Long nNew)
Definition: swrect.hxx:186
IDocumentFieldsAccess::SetFieldsDirty
virtual bool SetFieldsDirty(bool b, const SwNode *pChk, sal_uLong nLen)=0
SwTable::SetHTMLTableLayout
void SetHTMLTableLayout(std::shared_ptr< SwHTMLTableLayout > const &r)
Definition: swtable.cxx:1891
SwTableNode::GetTable
const SwTable & GetTable() const
Definition: node.hxx:499
SwTableCellInfo::SwTableCellInfo
SwTableCellInfo(SwTableCellInfo const &)=delete
SwTextAttr::GetFormatField
const SwFormatField & GetFormatField() const
Definition: txatbase.hxx:195
SwTable::SwTable
SwTable()
Definition: swtable.cxx:178
SwTable::NewSetTabCols
void NewSetTabCols(Parm &rP, const SwTabCols &rNew, const SwTabCols &rOld, const SwTableBox *pStart, bool bCurRowOnly)
Definition: swtable.cxx:1149
o3tl::sorted_vector::size
size_type size() const
SwTable::GetInfo
virtual bool GetInfo(SfxPoolItem &) const override
Definition: swtable.cxx:1835
SwTableLines::const_iterator
std::vector< SwTableLine * >::const_iterator const_iterator
Definition: swtable.hxx:69
SwTableBox::IsValidNumTextNd
sal_uLong IsValidNumTextNd(bool bCheckAttr=true) const
Definition: swtable.cxx:2420
RES_FINDNEARESTNODE
constexpr TypedWhichId< SwFindNearestNode > RES_FINDNEARESTNODE(184)
SwTableBox::ActualiseValueBox
void ActualiseValueBox()
Definition: swtable.cxx:2521
ChgNumToText
static void ChgNumToText(SwTableBox &rBox, sal_uLong nFormat)
Definition: swtable.cxx:2030
SwTableCellInfo::Impl::getCellFrame
const SwCellFrame * getCellFrame() const
Definition: swtable.cxx:2570
SwTableBox::m_pStartNode
const SwStartNode * m_pStartNode
Definition: swtable.hxx:405
SwTable::m_xRefObj
tools::SvRef< SwServerObject > m_xRefObj
Definition: swtable.hxx:117
SwFormat
Base class for various Writer styles.
Definition: format.hxx:46
SwClient::CheckRegistration
std::optional< sw::ModifyChangedHint > CheckRegistration(const SfxPoolItem *pOldValue)
Definition: calbck.cxx:78
SwTable::m_TabSortContentBoxes
SwTableSortBoxes m_TabSortContentBoxes
Definition: swtable.hxx:116
SwTable::GetTabSortBoxes
SwTableSortBoxes & GetTabSortBoxes()
Definition: swtable.hxx:261
SwTableBox::GetValue
double GetValue(SwTableCalcPara &rPara) const
Get value of this box.
Definition: cellfml.cxx:80
SwPaM
PaM is Point and Mark: a selection of the document model.
Definition: pam.hxx:136
SwContentNode::GetpSwAttrSet
const SwAttrSet * GetpSwAttrSet() const
Definition: node.hxx:450
SwTableBox::GetName
OUString GetName() const
Definition: swtable.cxx:1761
lcl_AdjustLines
static void lcl_AdjustLines(SwTableLines &rLines, const tools::Long nDiff, Parm &rParm)
Definition: swtable.cxx:793
GetTableChgDefaultMode
TableChgMode GetTableChgDefaultMode()
Definition: edtwin3.cxx:103
SwTable::FindTable
static SwTable * FindTable(SwFrameFormat const *const pFormat)
Definition: swtable.cxx:1869
tools::SvRef::get
T * get() const
RES_TXTATR_FIELD
constexpr TypedWhichId< SwFormatField > RES_TXTATR_FIELD(RES_TXTATR_NOEND_BEGIN)
SwShareBoxFormats::SetSize
void SetSize(SwTableBox &rBox, const SwFormatFrameSize &rSz)
Definition: tblrwcl.cxx:3316
SwFrameFormat
Style of a layout element.
Definition: frmfmt.hxx:58
SwpHints::Count
size_t Count() const
Definition: ndhints.hxx:142
SwTabFrame::FindMaster
SwTabFrame * FindMaster(bool bFirstMaster=false) const
Definition: flowfrm.cxx:774
SAL_MAX_INT32
#define SAL_MAX_INT32
SwpHints::Get
SwTextAttr * Get(size_t nPos) const
Definition: ndhints.hxx:144
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
SvxAdjust
SvxAdjust
i
int i
SwTableBoxFormat::supportsFullDrawingLayerFillAttributeSet
virtual bool supportsFullDrawingLayerFillAttributeSet() const override
Definition: swtable.cxx:2333
SwTableLines::empty
bool empty() const
Definition: swtable.hxx:74
CheckBoxWidth
void CheckBoxWidth(const SwTableLine &rLine, SwTwips nSize)
Definition: tblrwcl.cxx:2571
SwTableBox::GetSaveUserColor
const std::optional< Color > & GetSaveUserColor() const
Definition: swtable.hxx:486
SvxShadowItem::CalcShadowSpace
sal_uInt16 CalcShadowSpace(SvxShadowItemSide nShadow) const
SwTable::LockModify
void LockModify()
Definition: swtable.hxx:183
SvNumberFormatter::IsTextFormat
bool IsTextFormat(sal_uInt32 nFIndex) const
SwIterator::First
TElementType * First()
Definition: calbck.hxx:325
IDocumentRedlineAccess::DeleteRedline
virtual bool DeleteRedline(const SwPaM &rPam, bool bSaveInUndo, RedlineType nDelType)=0
SwTableBox::IsEmpty
bool IsEmpty() const
Definition: swtable.cxx:1819
SwNode::GetContentNode
SwContentNode * GetContentNode()
Definition: node.hxx:616
SwFrame::GetUpper
SwLayoutFrame * GetUpper()
Definition: frame.hxx:677
SwTableBox::getDummyFlag
bool getDummyFlag() const
Definition: swtable.cxx:85
RES_ATTRSET_CHG
constexpr TypedWhichId< SwAttrSetChg > RES_ATTRSET_CHG(163)
lcl_ModifyBoxes
static void lcl_ModifyBoxes(SwTableBoxes &rBoxes, const tools::Long nOld, const tools::Long nNew, std::vector< SwFormat * > &rFormatArr)
Definition: swtable.cxx:275
SwIndex
Marks a character position inside a document model node.
Definition: index.hxx:33
SwModify::UnlockModify
void UnlockModify()
Definition: calbck.hxx:204
Parm::aBoxArr
std::deque< SwTableBox * > aBoxArr
Definition: swtable.cxx:600
ColChange
std::pair< sal_uInt16, sal_uInt16 > ColChange
Definition: swtable.cxx:973
SwModify::LockModify
void LockModify()
Definition: calbck.hxx:203
SwTableLine::GetFrameFormat
SwFrameFormat * GetFrameFormat()
Definition: swtable.hxx:373
RES_AUTOFMT_DOCNODE
constexpr TypedWhichId< SwAutoFormatGetDocNode > RES_AUTOFMT_DOCNODE(173)
lcl_AdjustBox
static void lcl_AdjustBox(SwTableBox *pBox, const tools::Long nDiff, Parm &rParm)
Definition: swtable.cxx:803
SwTableBox::SetSaveNumFormatColor
void SetSaveNumFormatColor(std::optional< Color > p)
Definition: swtable.hxx:489
size
size
SwFormat::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
Definition: format.cxx:388
SwTableBox::m_aLines
SwTableLines m_aLines
Definition: swtable.hxx:404
SwNodeIndex
Marks a node in the document model.
Definition: ndindex.hxx:31
SwTableBox::GetFrameFormat
SwFrameFormat * GetFrameFormat()
Definition: swtable.hxx:434
SwNode::GetNodes
SwNodes & GetNodes()
Node is in which nodes-array/doc?
Definition: node.hxx:694
SwTable::m_xHTMLLayout
std::shared_ptr< SwHTMLTableLayout > m_xHTMLLayout
Definition: swtable.hxx:119
o3tl::sorted_vector::empty
bool empty() const
SvxAdjustItem::SetAdjust
void SetAdjust(const SvxAdjust eType)
SwFormat::GetDoc
const SwDoc * GetDoc() const
The document is set in SwAttrPool now, therefore you always can access it.
Definition: format.hxx:123
SwTable::GetBoxNum
static sal_uInt16 GetBoxNum(OUString &rStr, bool bFirst=false, const bool bPerformValidCheck=false)
Definition: swtable.cxx:1268
SwTabCols::Remove
void Remove(size_t nPos, size_t nCount=1)
Definition: tabcol.cxx:86
SwNode::GetStartNode
SwStartNode * GetStartNode()
Definition: node.hxx:592
InsTableBox
void InsTableBox(SwDoc &rDoc, SwTableNode *pTableNd, SwTableLine *pLine, SwTableBoxFormat *pBoxFrameFormat, SwTableBox *pBox, sal_uInt16 nInsPos, sal_uInt16 nCnt)
Definition: swtable.cxx:130
SwTableLine::GetBoxPos
sal_uInt16 GetBoxPos(const SwTableBox *pBox) const
Definition: swtable.hxx:363
SwTableCellInfo::getTableBox
const SwTableBox * getTableBox() const
Definition: swtable.cxx:2687
DelBoxNode
void DelBoxNode(SwTableSortBoxes const &rSortCntBoxes)
Definition: swtable.cxx:202
SwTable::GetTabLines
SwTableLines & GetTabLines()
Definition: swtable.hxx:200
SwTwips
tools::Long SwTwips
Definition: swtypes.hxx:50
SwTable
SwTable is one table in the document model, containing rows (which contain cells).
Definition: swtable.hxx:111
SvxSizeItem::SetWidth
void SetWidth(tools::Long n)
SwTableBox::GetTabLines
SwTableLines & GetTabLines()
Definition: swtable.hxx:427
SwTableLines::reserve
void reserve(size_type nSize)
Definition: swtable.hxx:92
IDocumentRedlineAccess::IsIgnoreRedline
virtual bool IsIgnoreRedline() const =0
SwTableBoxFormat::SwClientNotify
virtual void SwClientNotify(const SwModify &, const SfxHint &) override
Definition: swtable.cxx:2121
Parm::Parm
Parm(const SwTabCols &rN, const SwTabCols &rO)
Definition: swtable.cxx:603
nBorder
tools::Long const nBorder
SwTableCellInfo::Impl::m_HandledTableBoxes
TableBoxes_t m_HandledTableBoxes
Definition: swtable.cxx:2553
SwFormat::SetFormatAttr
virtual bool SetFormatAttr(const SfxPoolItem &rAttr)
Definition: format.cxx:450
CHECK_TABLE
#define CHECK_TABLE(t)
Definition: swtable.cxx:62
RES_CHRATR_COLOR
constexpr TypedWhichId< SvxColorItem > RES_CHRATR_COLOR(3)
lcl_TabToBlankAtSttEnd
static OUString & lcl_TabToBlankAtSttEnd(OUString &rText)
Definition: swtable.cxx:96
SwTextNode::EraseText
void EraseText(const SwIndex &rIdx, const sal_Int32 nCount=SAL_MAX_INT32, const SwInsertFlags nMode=SwInsertFlags::DEFAULT)
delete text content ATTENTION: must not be called with a range that overlaps the start of an attribut...
Definition: ndtxt.cxx:2653
SwTableBox::GetCoordinates
Point GetCoordinates() const
Definition: swtable.cxx:1737
SwTextNode::InsertText
OUString InsertText(const OUString &rStr, const SwIndex &rIdx, const SwInsertFlags nMode=SwInsertFlags::DEFAULT)
insert text content
Definition: ndtxt.cxx:2268
lcl_ProcessLineGet
static void lcl_ProcessLineGet(const SwTableLine *pLine, SwTabCols &rToFill, const SwFrameFormat *pTabFormat)
Definition: swtable.cxx:496
SwModify::IsModifyLocked
bool IsModifyLocked() const
Definition: calbck.hxx:205
SwTableLineFormat::supportsFullDrawingLayerFillAttributeSet
virtual bool supportsFullDrawingLayerFillAttributeSet() const override
Definition: swtable.cxx:2343
SwNode::EndOfSectionIndex
sal_uLong EndOfSectionIndex() const
Definition: node.hxx:678
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
Parm::nNewWish
tools::Long nNewWish
Definition: swtable.cxx:598
SwField::GetTypeId
SwFieldTypesEnum GetTypeId() const
Definition: fldbas.cxx:252
SwTextNode
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:79
SwTableBox::CheckBoxFormat
static SwTableBoxFormat * CheckBoxFormat(SwTableBoxFormat *)
Definition: swtable.cxx:1642
SwTableLine::GetTabBoxes
SwTableBoxes & GetTabBoxes()
Definition: swtable.hxx:361
lcl_SortedTabColInsert
static void lcl_SortedTabColInsert(SwTabCols &rToFill, const SwTableBox *pBox, const SwFrameFormat *pTabFormat, const bool bHidden, const bool bRefreshHidden)
Definition: swtable.cxx:370
SwFormat::ResetFormatAttr
virtual bool ResetFormatAttr(sal_uInt16 nWhich1, sal_uInt16 nWhich2=0)
Definition: format.cxx:624
SwDoc::getIDocumentRedlineAccess
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
Definition: doc.cxx:335
SwTableBoxes
std::vector< SwTableBox * > SwTableBoxes
Definition: swtable.hxx:104
mnRowSpan
sal_Int32 mnRowSpan
SwTableBox::GetSttNd
const SwStartNode * GetSttNd() const
Definition: swtable.hxx:448
lcl_ProcessLine
static void lcl_ProcessLine(SwTableLine *pLine, Parm &rParm)
Definition: swtable.cxx:610
SwpHints
An SwTextAttr container, stores all directly formatted text portions for a text node.
Definition: ndhints.hxx:67
SwTableBox::ChgFrameFormat
void ChgFrameFormat(SwTableBoxFormat *pNewFormat, bool bNeedToReregister=true)
Definition: swtable.cxx:1702
SwFrame::IsTabFrame
bool IsTabFrame() const
Definition: frame.hxx:1215
SfxItemSet::Get
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
SwTabColsEntry::nMin
tools::Long nMin
Definition: tabcol.hxx:31
SwTabCols::SetHidden
void SetHidden(size_t nPos, bool bValue)
Definition: tabcol.hxx:68
SwTableCellInfo::Impl::getNextFrameInTable
const SwFrame * getNextFrameInTable(const SwFrame *pFrame)
Definition: swtable.cxx:2578
SwTabColsEntry::nMax
tools::Long nMax
Definition: tabcol.hxx:32
SwTableCellInfo::getRect
SwRect getRect() const
Definition: swtable.cxx:2677
Parm::nOldWish
tools::Long nOldWish
Definition: swtable.cxx:598
SwIndex::GetIndex
sal_Int32 GetIndex() const
Definition: index.hxx:91
SwDoc::GetNodes
SwNodes & GetNodes()
Definition: doc.hxx:409
RES_BOXATR_FORMULA
constexpr TypedWhichId< SwTableBoxFormula > RES_BOXATR_FORMULA(151)
lcl_ProcessBoxGet
static void lcl_ProcessBoxGet(const SwTableBox *pBox, SwTabCols &rToFill, const SwFrameFormat *pTabFormat, bool bRefreshHidden)
Definition: swtable.cxx:479
SwTabCols::Insert
void Insert(tools::Long nValue, bool bValue, size_t nPos)
Definition: tabcol.cxx:69
SwTableBox
SwTableBox is one table cell in the document model.
Definition: swtable.hxx:395
SwFrame::GetLower
SwFrame * GetLower()
Definition: findfrm.cxx:170
p
void * p
SwTableBox::ClaimFrameFormat
SwFrameFormat * ClaimFrameFormat()
Definition: swtable.cxx:1666
SwFlowFrame::IsAnFollow
bool IsAnFollow(const SwFlowFrame *pFlow) const
Definition: flowfrm.cxx:727
SwFormat::GetFrameSize
const SwFormatFrameSize & GetFrameSize(bool=true) const
Definition: fmtfsize.hxx:104
sw::BroadcastingModify::CallSwClientNotify
virtual void CallSwClientNotify(const SfxHint &rHint) const override
Definition: calbck.cxx:326
SwNode::FindTableNode
SwTableNode * FindTableNode()
Search table node, in which it is.
Definition: node.cxx:357
SwTableLine::GetUpper
SwTableBox * GetUpper()
Definition: swtable.hxx:369
SwDoc::IsNumberFormat
bool IsNumberFormat(const OUString &rString, sal_uInt32 &F_Index, double &fOutNumber)
Definition: ndtbl.cxx:4017
IDocumentLinksAdministration::GetLinkManager
virtual sfx2::LinkManager & GetLinkManager()=0
CntUInt32Item::GetValue
sal_uInt32 GetValue() const
SwTableCellInfo::Impl::m_pCellFrame
const SwCellFrame * m_pCellFrame
Definition: swtable.cxx:2550
SwFrame::IsVertical
bool IsVertical() const
Definition: frame.hxx:970
SwDoc::IsInDtor
bool IsInDtor() const
Definition: doc.hxx:404
COLFUZZY
#define COLFUZZY
Definition: swtable.cxx:70
SwNode::IsTableNode
bool IsTableNode() const
Definition: node.hxx:641
SwTableBox::setRowSpan
void setRowSpan(sal_Int32 nNewRowSpan)
Definition: swtable.cxx:80
SwTableLines::GetPos
sal_uInt16 GetPos(const SwTableLine *pBox) const
Definition: swtable.hxx:97
lcl_IsValidRowName
static bool lcl_IsValidRowName(const OUString &rStr)
Definition: swtable.cxx:1253
SwTableCellInfo::Impl::getNextTableBoxsCellFrame
const SwCellFrame * getNextTableBoxsCellFrame(const SwFrame *pFrame)
Definition: swtable.cxx:2625
SwTableCellInfo::Impl::setTable
void setTable(const SwTable *pTable)
Definition: swtable.cxx:2561
SwTableLines::end
iterator end()
Definition: swtable.hxx:78
SwTabColsEntry::nPos
tools::Long nPos
Definition: tabcol.hxx:30
SwFrameSize::Variable
Frame is variable in Var-direction.
IDocumentRedlineAccess::GetRedlineTable
virtual const SwRedlineTable & GetRedlineTable() const =0
SwTableBox::HasNumContent
bool HasNumContent(double &rNum, sal_uInt32 &rFormatIndex, bool &rIsEmptyTextNd) const
Definition: swtable.cxx:2348
o3tl::sorted_vector::insert
std::pair< const_iterator, bool > insert(Value &&x)
ChgTextToNum
static void ChgTextToNum(SwTableBox &rBox, const OUString &rText, const Color *pCol, bool bChgAlign, sal_uLong nNdPos)
Definition: swtable.cxx:1902
SwTextNode::ResetAttr
virtual bool ResetAttr(sal_uInt16 nWhich1, sal_uInt16 nWhich2=0) override
Definition: ndtxt.cxx:5089
SwTable::IsNewModel
bool IsNewModel() const
Definition: swtable.hxx:187
lcl_AdjustWidthsInLine
static void lcl_AdjustWidthsInLine(SwTableLine *pLine, ChangeList &rOldNew, Parm &rParm, sal_uInt16 nColFuzzy)
Definition: swtable.cxx:976
SwTableBox::GetUpper
SwTableLine * GetUpper()
Definition: swtable.hxx:430
SwTableCellInfo::Impl::getNextCellFrame
const SwCellFrame * getNextCellFrame(const SwFrame *pFrame)
Definition: swtable.cxx:2609
lcl_ProcessBoxPtr
static void lcl_ProcessBoxPtr(SwTableBox *pBox, std::deque< SwTableBox * > &rBoxArr, bool bBefore)
Definition: swtable.cxx:772
RES_CONTENT_VISIBLE
constexpr TypedWhichId< SwPtrMsgPoolItem > RES_CONTENT_VISIBLE(185)
SwNode::IsTextNode
bool IsTextNode() const
Definition: node.hxx:637
SwRect::Height
void Height(tools::Long nNew)
Definition: swrect.hxx:190
SwTabCols::GetRight
tools::Long GetRight() const
Definition: tabcol.hxx:79
lcl_ModifyLines
static void lcl_ModifyLines(SwTableLines &rLines, const tools::Long nOld, const tools::Long nNew, std::vector< SwFormat * > &rFormatArr, const bool bCheckSum)
Definition: swtable.cxx:257
SwTableBox::IsNumberChanged
bool IsNumberChanged() const
Definition: swtable.cxx:2384
SwTable::m_bModifyLocked
bool m_bModifyLocked
Definition: swtable.hxx:137
o3tl::sorted_vector::clear
void clear()
SwNodes::GoNext
SwContentNode * GoNext(SwNodeIndex *) const
Definition: nodes.cxx:1293
SwTableLine::~SwTableLine
virtual ~SwTableLine() override
Definition: swtable.cxx:1453
getSwDefaultTextFormat
constexpr sal_uInt32 getSwDefaultTextFormat()
The number formatter's default locale's @ Text format.
Definition: cellatr.hxx:34
SvNumberFormatter::GetOutputString
void GetOutputString(const double &fOutNumber, sal_uInt32 nFIndex, OUString &sOutString, const Color **ppColor, bool bUseStarFormat=false)
SfxPoolItem::Which
sal_uInt16 Which() const
RES_PARATR_ADJUST
constexpr TypedWhichId< SvxAdjustItem > RES_PARATR_ADJUST(64)
FormatInArr
static void FormatInArr(std::vector< SwFormat * > &rFormatArr, SwFormat *pBoxFormat)
Definition: swtable.cxx:247
SwTableCellInfo::Impl::m_pTable
const SwTable * m_pTable
Definition: swtable.cxx:2549
SwTableLine::IsEmpty
bool IsEmpty() const
Definition: swtable.cxx:1548
SwCellFrame
SwCellFrame is one table cell in the document layout.
Definition: cellfrm.hxx:30
SwDoc::MakeTableBoxFormat
SwTableBoxFormat * MakeTableBoxFormat()
Definition: docfmt.cxx:1708
nPos
sal_uInt16 nPos
o3tl::sorted_vector< const SwTableBox * >
SwNode::GetTextNode
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:850
o3tl::sorted_vector::erase
size_type erase(const Value &x)
SwTabCols::Count
size_t Count() const
Definition: tabcol.hxx:65
SwRowFrame
SwRowFrame is one table row in the document layout.
Definition: rowfrm.hxx:28
SwTabFrame::IsInHeadline
bool IsInHeadline(const SwFrame &rFrame) const
Definition: tabfrm.cxx:5710
SwTableCellInfo::m_pImpl
std::unique_ptr< Impl > m_pImpl
Definition: swtable.hxx:511
SwFrame::FindTabFrame
SwTabFrame * FindTabFrame()
Definition: frame.hxx:1096
SwTable::GetTableNode
SwTableNode * GetTableNode() const
Definition: swtable.cxx:1876
SwFrame::GetNext
SwFrame * GetNext()
Definition: frame.hxx:675
SwNode
Base class of the Writer document model elements.
Definition: node.hxx:80
void
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo
Generated on Fri Jul 30 2021 18:28:40 for LibreOffice Module sw (master) by   doxygen 1.8.10