LibreOffice Module sw (master) 1
tblcpy.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
22#include <osl/diagnose.h>
23#include <svl/numformat.hxx>
24#include <frmfmt.hxx>
25#include <doc.hxx>
26#include <IDocumentUndoRedo.hxx>
32#include <pam.hxx>
33#include <swtable.hxx>
34#include <ndtxt.hxx>
35#include <tblsel.hxx>
36#include <poolfmt.hxx>
37#include <cellatr.hxx>
38#include <mvsave.hxx>
39#include <fmtanchr.hxx>
40#include <hints.hxx>
41#include <UndoTable.hxx>
42#include <fmtfsize.hxx>
43#include <frameformats.hxx>
44#include <deque>
45#include <memory>
46#include <numeric>
47
48static void lcl_CpyBox( const SwTable& rCpyTable, const SwTableBox* pCpyBox,
49 SwTable& rDstTable, SwTableBox* pDstBox,
50 bool bDelContent, SwUndoTableCpyTable* pUndo );
51
52// The following type will be used by table copy functions to describe
53// the structure of tables (or parts of tables).
54// It's for new table model only.
55
56namespace
57{
58 struct BoxSpanInfo
59 {
60 SwTableBox* mpBox;
61 SwTableBox* mpCopy;
62 sal_uInt16 mnColSpan;
63 bool mbSelected;
64 };
65
66 typedef std::vector< BoxSpanInfo > BoxStructure;
67 typedef std::vector< BoxStructure > LineStructure;
68 typedef std::deque< sal_uLong > ColumnStructure;
69
70 struct SubBox
71 {
72 SwTableBox *mpBox;
73 bool mbCovered;
74 };
75
76 typedef std::vector< SubBox > SubLine;
77 typedef std::vector< SubLine > SubTable;
78
79 class TableStructure
80 {
81 public:
82 LineStructure maLines;
83 ColumnStructure maCols;
84 sal_uInt16 mnStartCol;
85 sal_uInt16 mnAddLine;
86 void addLine( sal_uInt16 &rLine, const SwTableBoxes&, const SwSelBoxes*,
87 bool bNewModel );
88 void addBox( sal_uInt16 nLine, const SwSelBoxes*, SwTableBox *pBox,
89 sal_uLong &rnB, sal_uInt16 &rnC, ColumnStructure::iterator& rpCl,
90 BoxStructure::iterator& rpSel, bool &rbSel, bool bCover );
91 void incColSpan( sal_uInt16 nLine, sal_uInt16 nCol );
92 explicit TableStructure( const SwTable& rTable );
93 TableStructure( const SwTable& rTable, FndBox_ &rFndBox,
94 const SwSelBoxes& rSelBoxes,
95 LineStructure::size_type nMinSize );
96 LineStructure::size_type getLineCount() const
97 { return maLines.size(); }
98 void moreLines( const SwTable& rTable );
99 void assignBoxes( const TableStructure &rSource );
100 void copyBoxes( const SwTable& rSource, SwTable& rDstTable,
101 SwUndoTableCpyTable* pUndo ) const;
102 };
103
104 SubTable::iterator insertSubLine( SubTable& rSubTable, SwTableLine& rLine,
105 const SubTable::iterator& pStartLn );
106
107 SubTable::iterator insertSubBox( SubTable& rSubTable, SwTableBox& rBox,
108 SubTable::iterator pStartLn, const SubTable::iterator& pEndLn )
109 {
110 if( !rBox.GetTabLines().empty() )
111 {
112 SubTable::size_type nSize = static_cast<SubTable::size_type>(std::distance( pStartLn, pEndLn ));
113 if( nSize < rBox.GetTabLines().size() )
114 {
115 SubLine aSubLine;
116 for( const auto& rSubBox : *pStartLn )
117 {
118 SubBox aSub;
119 aSub.mpBox = rSubBox.mpBox;
120 aSub.mbCovered = true;
121 aSubLine.push_back( aSub );
122 }
123 do
124 {
125 rSubTable.insert( pEndLn, aSubLine );
126 } while( ++nSize < rBox.GetTabLines().size() );
127 }
128 for( auto pLine : rBox.GetTabLines() )
129 pStartLn = insertSubLine( rSubTable, *pLine, pStartLn );
130 OSL_ENSURE( pStartLn == pEndLn, "Sub line confusion" );
131 }
132 else
133 {
134 SubBox aSub;
135 aSub.mpBox = &rBox;
136 aSub.mbCovered = false;
137 while( pStartLn != pEndLn )
138 {
139 pStartLn->push_back( aSub );
140 aSub.mbCovered = true;
141 ++pStartLn;
142 }
143 }
144 return pStartLn;
145 }
146
147 SubTable::iterator insertSubLine( SubTable& rSubTable, SwTableLine& rLine,
148 const SubTable::iterator& pStartLn )
149 {
150 SubTable::iterator pMax = pStartLn;
151 ++pMax;
152 SubTable::difference_type nMax = 1;
153 for( auto pBox : rLine.GetTabBoxes() )
154 {
155 SubTable::iterator pTmp = insertSubBox( rSubTable, *pBox, pStartLn, pMax );
156 SubTable::difference_type nTmp = std::distance( pStartLn, pTmp );
157 if( nTmp > nMax )
158 {
159 pMax = pTmp;
160 nMax = nTmp;
161 }
162 }
163 return pMax;
164 }
165
166 TableStructure::TableStructure( const SwTable& rTable ) :
167 maLines( rTable.GetTabLines().size() ), mnStartCol(USHRT_MAX),
168 mnAddLine(0)
169 {
170 maCols.push_front(0);
171 sal_uInt16 nCnt = 0;
172 for( auto pLine : rTable.GetTabLines() )
173 addLine( nCnt, pLine->GetTabBoxes(), nullptr, rTable.IsNewModel() );
174 }
175
176 TableStructure::TableStructure( const SwTable& rTable,
177 FndBox_ &rFndBox, const SwSelBoxes& rSelBoxes,
178 LineStructure::size_type nMinSize )
179 : mnStartCol(USHRT_MAX), mnAddLine(0)
180 {
181 if( rFndBox.GetLines().empty() )
182 return;
183
184 bool bNoSelection = rSelBoxes.size() < 2;
185 FndLines_t &rFndLines = rFndBox.GetLines();
186 maCols.push_front(0);
187 const SwTableLine* pLine = rFndLines.front()->GetLine();
188 const sal_uInt16 nStartLn = rTable.GetTabLines().GetPos( pLine );
189 SwTableLines::size_type nEndLn = nStartLn;
190 if( rFndLines.size() > 1 )
191 {
192 pLine = rFndLines.back()->GetLine();
193 nEndLn = rTable.GetTabLines().GetPos( pLine );
194 }
195 if( nStartLn < USHRT_MAX && nEndLn < USHRT_MAX )
196 {
197 const SwTableLines &rLines = rTable.GetTabLines();
198 if( bNoSelection && nMinSize > nEndLn - nStartLn + 1 )
199 {
200 SwTableLines::size_type nNewEndLn = nStartLn + nMinSize - 1;
201 if( nNewEndLn >= rLines.size() )
202 {
203 mnAddLine = nNewEndLn - rLines.size() + 1;
204 nNewEndLn = rLines.size() - 1;
205 }
206 while( nEndLn < nNewEndLn )
207 {
208 SwTableLine *pLine2 = rLines[ ++nEndLn ];
209 SwTableBox *pTmpBox = pLine2->GetTabBoxes()[0];
210 FndLine_ *pInsLine = new FndLine_( pLine2, &rFndBox );
211 pInsLine->GetBoxes().insert(pInsLine->GetBoxes().begin(), std::make_unique<FndBox_>(pTmpBox, pInsLine));
212 rFndLines.push_back(std::unique_ptr<FndLine_>(pInsLine));
213 }
214 }
215 maLines.resize( nEndLn - nStartLn + 1 );
216 const SwSelBoxes* pSelBoxes = &rSelBoxes;
217 sal_uInt16 nCnt = 0;
218 for( SwTableLines::size_type nLine = nStartLn; nLine <= nEndLn; ++nLine )
219 {
220 addLine( nCnt, rLines[nLine]->GetTabBoxes(),
221 pSelBoxes, rTable.IsNewModel() );
222 if( bNoSelection )
223 pSelBoxes = nullptr;
224 }
225 }
226 if( bNoSelection && mnStartCol < USHRT_MAX )
227 {
228 sal_uInt16 nIdx = std::min(mnStartCol, o3tl::narrowing<sal_uInt16>(maLines[0].size()));
229 mnStartCol = std::accumulate(maLines[0].begin(), maLines[0].begin() + nIdx, sal_uInt16(0),
230 [](sal_uInt16 sum, const BoxSpanInfo& rInfo) { return sum + rInfo.mnColSpan; });
231 }
232 else
233 mnStartCol = USHRT_MAX;
234 }
235
236 void TableStructure::addLine( sal_uInt16 &rLine, const SwTableBoxes& rBoxes,
237 const SwSelBoxes* pSelBoxes, bool bNewModel )
238 {
239 bool bComplex = false;
240 if( !bNewModel )
241 for( SwTableBoxes::size_type nBox = 0; !bComplex && nBox < rBoxes.size(); ++nBox )
242 bComplex = !rBoxes[nBox]->GetTabLines().empty();
243 if( bComplex )
244 {
245 SubTable aSubTable;
246 SubLine aSubLine;
247 aSubTable.push_back( aSubLine );
248 SubTable::iterator pStartLn = aSubTable.begin();
249 SubTable::iterator pEndLn = aSubTable.end();
250 for( auto pBox : rBoxes )
251 insertSubBox( aSubTable, *pBox, pStartLn, pEndLn );
252 SubTable::size_type nSize = aSubTable.size();
253 if( nSize )
254 {
255 maLines.resize( maLines.size() + nSize - 1 );
256 while( pStartLn != pEndLn )
257 {
258 bool bSelected = false;
259 sal_uLong nBorder = 0;
260 sal_uInt16 nCol = 0;
261 maLines[rLine].reserve( pStartLn->size() );
262 BoxStructure::iterator pSel = maLines[rLine].end();
263 ColumnStructure::iterator pCol = maCols.begin();
264 for( const auto& rBox : *pStartLn )
265 {
266 addBox( rLine, pSelBoxes, rBox.mpBox, nBorder, nCol,
267 pCol, pSel, bSelected, rBox.mbCovered );
268 }
269 ++rLine;
270 ++pStartLn;
271 }
272 }
273 }
274 else
275 {
276 bool bSelected = false;
277 sal_uLong nBorder = 0;
278 sal_uInt16 nCol = 0;
279 maLines[rLine].reserve( rBoxes.size() );
280 ColumnStructure::iterator pCol = maCols.begin();
281 BoxStructure::iterator pSel = maLines[rLine].end();
282 for( auto pBox : rBoxes )
283 addBox( rLine, pSelBoxes, pBox, nBorder, nCol,
284 pCol, pSel, bSelected, false );
285 ++rLine;
286 }
287 }
288
289 void TableStructure::addBox( sal_uInt16 nLine, const SwSelBoxes* pSelBoxes,
290 SwTableBox *pBox, sal_uLong &rnBorder, sal_uInt16 &rnCol,
291 ColumnStructure::iterator& rpCol, BoxStructure::iterator& rpSel,
292 bool &rbSelected, bool bCovered )
293 {
294 BoxSpanInfo aInfo;
295 if( pSelBoxes &&
296 pSelBoxes->end() != pSelBoxes->find( pBox ) )
297 {
298 aInfo.mbSelected = true;
299 if( mnStartCol == USHRT_MAX )
300 {
301 mnStartCol = o3tl::narrowing<sal_uInt16>(maLines[nLine].size());
302 if( pSelBoxes->size() < 2 )
303 {
304 pSelBoxes = nullptr;
305 aInfo.mbSelected = false;
306 }
307 }
308 }
309 else
310 aInfo.mbSelected = false;
311 rnBorder += pBox->GetFrameFormat()->GetFrameSize().GetWidth();
312 const sal_uInt16 nLeftCol = rnCol;
313 while( rpCol != maCols.end() && *rpCol < rnBorder )
314 {
315 ++rnCol;
316 ++rpCol;
317 }
318 if( rpCol == maCols.end() || *rpCol > rnBorder )
319 {
320 rpCol = maCols.insert( rpCol, rnBorder );
321 incColSpan( nLine, rnCol );
322 }
323 aInfo.mnColSpan = rnCol - nLeftCol;
324 aInfo.mpCopy = nullptr;
325 aInfo.mpBox = bCovered ? nullptr : pBox;
326 maLines[nLine].push_back( aInfo );
327 if( !aInfo.mbSelected )
328 return;
329
330 if( rbSelected )
331 {
332 while( rpSel != maLines[nLine].end() )
333 {
334 rpSel->mbSelected = true;
335 ++rpSel;
336 }
337 }
338 else
339 {
340 rpSel = maLines[nLine].end();
341 rbSelected = true;
342 }
343 --rpSel;
344 }
345
346 void TableStructure::moreLines( const SwTable& rTable )
347 {
348 if( !mnAddLine )
349 return;
350
351 const SwTableLines &rLines = rTable.GetTabLines();
352 const sal_uInt16 nLineCount = rLines.size();
353 if( nLineCount < mnAddLine )
354 mnAddLine = nLineCount;
355 sal_uInt16 nLine = o3tl::narrowing<sal_uInt16>(maLines.size());
356 maLines.resize( nLine + mnAddLine );
357 while( mnAddLine )
358 {
359 SwTableLine *pLine = rLines[ nLineCount - mnAddLine ];
360 addLine( nLine, pLine->GetTabBoxes(), nullptr, rTable.IsNewModel() );
361 --mnAddLine;
362 }
363 }
364
365 void TableStructure::incColSpan( sal_uInt16 nLineMax, sal_uInt16 nNewCol )
366 {
367 for( sal_uInt16 nLine = 0; nLine < nLineMax; ++nLine )
368 {
369 BoxStructure::iterator pInfo = maLines[nLine].begin();
370 BoxStructure::iterator pEnd = maLines[nLine].end();
371 tools::Long nCol = pInfo->mnColSpan;
372 while( nNewCol > nCol && ++pInfo != pEnd )
373 nCol += pInfo->mnColSpan;
374 if( pInfo != pEnd )
375 ++(pInfo->mnColSpan);
376 }
377 }
378
379 void TableStructure::assignBoxes( const TableStructure &rSource )
380 {
381 LineStructure::const_iterator pFirstLine = rSource.maLines.begin();
382 LineStructure::const_iterator pLastLine = rSource.maLines.end();
383 if( pFirstLine == pLastLine )
384 return;
385 LineStructure::const_iterator pCurrLine = pFirstLine;
386 LineStructure::size_type nLineCount = maLines.size();
387 sal_uInt16 nFirstStartCol = 0;
388 {
389 BoxStructure::const_iterator pFirstBox = pFirstLine->begin();
390 if( pFirstBox != pFirstLine->end() && pFirstBox->mpBox &&
391 pFirstBox->mpBox->getDummyFlag() )
392 nFirstStartCol = pFirstBox->mnColSpan;
393 }
394 for( LineStructure::size_type nLine = 0; nLine < nLineCount; ++nLine )
395 {
396 BoxStructure::const_iterator pFirstBox = pCurrLine->begin();
397 BoxStructure::const_iterator pLastBox = pCurrLine->end();
398 sal_uInt16 nCurrStartCol = mnStartCol;
399 if( pFirstBox != pLastBox )
400 {
401 BoxStructure::const_iterator pTmpBox = pLastBox;
402 --pTmpBox;
403 if( pTmpBox->mpBox && pTmpBox->mpBox->getDummyFlag() )
404 --pLastBox;
405 if( pFirstBox != pLastBox && pFirstBox->mpBox &&
406 pFirstBox->mpBox->getDummyFlag() )
407 {
408 if( nCurrStartCol < USHRT_MAX )
409 {
410 if( pFirstBox->mnColSpan > nFirstStartCol )
411 nCurrStartCol += pFirstBox->mnColSpan - nFirstStartCol;
412 }
413 ++pFirstBox;
414 }
415 }
416 if( pFirstBox != pLastBox )
417 {
418 BoxStructure::const_iterator pCurrBox = pFirstBox;
419 BoxStructure &rBox = maLines[nLine];
420 BoxStructure::size_type nBoxCount = rBox.size();
421 sal_uInt16 nCol = 0;
422 for( BoxStructure::size_type nBox = 0; nBox < nBoxCount; ++nBox )
423 {
424 BoxSpanInfo& rInfo = rBox[nBox];
425 nCol += rInfo.mnColSpan;
426 if( rInfo.mbSelected || nCol > nCurrStartCol )
427 {
428 rInfo.mpCopy = pCurrBox->mpBox;
429 if( rInfo.mbSelected && rInfo.mpCopy->getDummyFlag() )
430 {
431 ++pCurrBox;
432 if( pCurrBox == pLastBox )
433 {
434 pCurrBox = pFirstBox;
435 if( pCurrBox->mpBox->getDummyFlag() )
436 ++pCurrBox;
437 }
438 rInfo.mpCopy = pCurrBox->mpBox;
439 }
440 ++pCurrBox;
441 if( pCurrBox == pLastBox )
442 {
443 if( rInfo.mbSelected )
444 pCurrBox = pFirstBox;
445 else
446 {
447 rInfo.mbSelected = rInfo.mpCopy == nullptr;
448 break;
449 }
450 }
451 rInfo.mbSelected = rInfo.mpCopy == nullptr;
452 }
453 }
454 }
455 ++pCurrLine;
456 if( pCurrLine == pLastLine )
457 pCurrLine = pFirstLine;
458 }
459 }
460
461 void TableStructure::copyBoxes( const SwTable& rSource, SwTable& rDstTable,
462 SwUndoTableCpyTable* pUndo ) const
463 {
464 LineStructure::size_type nLineCount = maLines.size();
465 for( LineStructure::size_type nLine = 0; nLine < nLineCount; ++nLine )
466 {
467 const BoxStructure &rBox = maLines[nLine];
468 BoxStructure::size_type nBoxCount = rBox.size();
469 for( BoxStructure::size_type nBox = 0; nBox < nBoxCount; ++nBox )
470 {
471 const BoxSpanInfo& rInfo = rBox[nBox];
472 if( ( rInfo.mpCopy && !rInfo.mpCopy->getDummyFlag() )
473 || rInfo.mbSelected )
474 {
475 SwTableBox *pBox = rInfo.mpBox;
476 if( pBox && pBox->getRowSpan() > 0 )
477 lcl_CpyBox( rSource, rInfo.mpCopy, rDstTable, pBox,
478 true, pUndo );
479 }
480 }
481 }
482 }
483}
484
490static void lcl_CpyBox( const SwTable& rCpyTable, const SwTableBox* pCpyBox,
491 SwTable& rDstTable, SwTableBox* pDstBox,
492 bool bDelContent, SwUndoTableCpyTable* pUndo )
493{
494 OSL_ENSURE( ( !pCpyBox || pCpyBox->GetSttNd() ) && pDstBox->GetSttNd(),
495 "No content in this Box" );
496
497 SwDoc* pCpyDoc = rCpyTable.GetFrameFormat()->GetDoc();
498 SwDoc* pDoc = rDstTable.GetFrameFormat()->GetDoc();
499
500 // First copy the new content and then delete the old one.
501 // Do not create empty Sections, otherwise they will be deleted!
502 std::unique_ptr< SwNodeRange > pRg( pCpyBox ?
503 new SwNodeRange ( *pCpyBox->GetSttNd(), SwNodeOffset(1),
504 *pCpyBox->GetSttNd()->EndOfSectionNode() ) : nullptr );
505
506 SwNodeIndex aInsIdx( *pDstBox->GetSttNd(), bDelContent ? SwNodeOffset(1) :
507 pDstBox->GetSttNd()->EndOfSectionIndex() -
508 pDstBox->GetSttIdx() );
509
510 if( pUndo )
511 pUndo->AddBoxBefore( *pDstBox, bDelContent );
512
513 bool bUndoRedline = pUndo && pDoc->getIDocumentRedlineAccess().IsRedlineOn();
514 ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
515
516 SwNodeIndex aSavePos( aInsIdx, -1 );
517 if (pRg)
518 pCpyDoc->GetDocumentContentOperationsManager().CopyWithFlyInFly(*pRg, aInsIdx.GetNode(), nullptr, false);
519 else
520 pDoc->GetNodes().MakeTextNode( aInsIdx.GetNode(), pDoc->GetDfltTextFormatColl() );
521 ++aSavePos;
522
523 SwTableLine* pLine = pDstBox->GetUpper();
524 while( pLine->GetUpper() )
525 pLine = pLine->GetUpper()->GetUpper();
526
527 bool bReplaceColl = true;
528 if( bDelContent && !bUndoRedline )
529 {
530 // Delete the Fly first, then the corresponding Nodes
531 SwNodeIndex aEndNdIdx( *aInsIdx.GetNode().EndOfSectionNode() );
532
533 // Move Bookmarks
534 {
535 SwPosition aMvPos( aInsIdx );
536 SwContentNode* pCNd = SwNodes::GoPrevious( &aMvPos );
537 assert(pCNd); // keep coverity happy
538 aMvPos.SetContent( pCNd->Len() );
539 SwDoc::CorrAbs( aInsIdx, aEndNdIdx, aMvPos );
540 }
541
542 // If we still have FlyFrames hanging around, delete them too
543 for( const auto pFly : *pDoc->GetSpzFrameFormats() )
544 {
545 SwFormatAnchor const*const pAnchor = &pFly->GetAnchor();
546 SwNode const*const pAnchorNode = pAnchor->GetAnchorNode();
547 if (pAnchorNode &&
548 ((RndStdIds::FLY_AT_PARA == pAnchor->GetAnchorId()) ||
549 (RndStdIds::FLY_AT_CHAR == pAnchor->GetAnchorId())) &&
550 aInsIdx <= *pAnchorNode && *pAnchorNode <= aEndNdIdx.GetNode() )
551 {
553 }
554 }
555
556 // If DestBox is a Headline Box and has Table style set, then
557 // DO NOT automatically set the TableHeadline style!
558 if( 1 < rDstTable.GetTabLines().size() &&
559 pLine == rDstTable.GetTabLines().front() )
560 {
561 SwContentNode* pCNd = aInsIdx.GetNode().GetContentNode();
562 if( !pCNd )
563 {
564 SwNodeIndex aTmp( aInsIdx );
565 pCNd = pDoc->GetNodes().GoNext( &aTmp );
566 }
567
568 if( pCNd &&
570 pCNd->GetFormatColl()->GetPoolFormatId() )
571 bReplaceColl = false;
572 }
573
574 pDoc->GetNodes().Delete( aInsIdx, aEndNdIdx.GetIndex() - aInsIdx.GetIndex() );
575 }
576
577 //b6341295: Table copy redlining will be managed by AddBoxAfter()
578 if( pUndo )
579 pUndo->AddBoxAfter( *pDstBox, aInsIdx, bDelContent );
580
581 // heading
582 SwTextNode *const pTextNd = aSavePos.GetNode().GetTextNode();
583 if( !pTextNd )
584 return;
585
586 const sal_uInt16 nPoolId = pTextNd->GetTextColl()->GetPoolFormatId();
587 if( bReplaceColl &&
588 (( 1 < rDstTable.GetTabLines().size() &&
589 pLine == rDstTable.GetTabLines().front() )
590 // Is the Table's content still valid?
591 ? RES_POOLCOLL_TABLE == nPoolId
592 : RES_POOLCOLL_TABLE_HDLN == nPoolId ) )
593 {
595 o3tl::narrowing<sal_uInt16>(
596 RES_POOLCOLL_TABLE == nPoolId
598 : RES_POOLCOLL_TABLE ) );
599 if( pColl ) // Apply style
600 {
601 SwPaM aPam( aSavePos );
602 aPam.SetMark();
604 pDoc->SetTextFormatColl( aPam, pColl );
605 }
606 }
607
608 // Delete the current Formula/Format/Value values
609 if( SfxItemState::SET == pDstBox->GetFrameFormat()->GetItemState( RES_BOXATR_FORMAT ) ||
610 SfxItemState::SET == pDstBox->GetFrameFormat()->GetItemState( RES_BOXATR_FORMULA ) ||
611 SfxItemState::SET == pDstBox->GetFrameFormat()->GetItemState( RES_BOXATR_VALUE ) )
612 {
615 }
616
617 // Copy the TableBoxAttributes - Formula/Format/Value
618 if( !pCpyBox )
619 return;
620
622 aBoxAttrSet.Put( pCpyBox->GetFrameFormat()->GetAttrSet() );
623 if( !aBoxAttrSet.Count() )
624 return;
625
626 const SwTableBoxNumFormat* pItem;
627 SvNumberFormatter* pN = pDoc->GetNumberFormatter( false );
628 if( pN && pN->HasMergeFormatTable() &&
629 (pItem = aBoxAttrSet.GetItemIfSet( RES_BOXATR_FORMAT, false )) )
630 {
631 sal_uLong nOldIdx = pItem->GetValue();
632 sal_uLong nNewIdx = pN->GetMergeFormatIndex( nOldIdx );
633 if( nNewIdx != nOldIdx )
634 aBoxAttrSet.Put( SwTableBoxNumFormat( nNewIdx ));
635 }
636 pDstBox->ClaimFrameFormat()->SetFormatAttr( aBoxAttrSet );
637}
638
639bool SwTable::InsNewTable( const SwTable& rCpyTable, const SwSelBoxes& rSelBoxes,
640 SwUndoTableCpyTable* pUndo )
641{
642 SwDoc* pDoc = GetFrameFormat()->GetDoc();
643 SwDoc* pCpyDoc = rCpyTable.GetFrameFormat()->GetDoc();
644
645 SwTableNumFormatMerge aTNFM( *pCpyDoc, *pDoc );
646
647 // Analyze source structure
648 TableStructure aCopyStruct( rCpyTable );
649
650 // Analyze target structure (from start box) and selected substructure
651 FndBox_ aFndBox( nullptr, nullptr );
652 { // get all boxes/lines
653 FndPara aPara( rSelBoxes, &aFndBox );
655 }
656 TableStructure aTarget( *this, aFndBox, rSelBoxes, aCopyStruct.getLineCount() );
657
658 bool bClear = false;
659 if( aTarget.mnAddLine && IsNewModel() )
660 {
661 SwSelBoxes aBoxes;
662 aBoxes.insert( GetTabLines().back()->GetTabBoxes().front() );
663 if( pUndo )
664 pUndo->InsertRow( *this, aBoxes, aTarget.mnAddLine );
665 else
666 InsertRow( pDoc, aBoxes, aTarget.mnAddLine, /*bBehind*/true );
667
668 aTarget.moreLines( *this );
669 bClear = true;
670 }
671
672 // Find mapping, if needed extend target table and/or selection
673 aTarget.assignBoxes( aCopyStruct );
674
675 {
676 // Change table formulas into relative representation
677 SwTableFormulaUpdate aMsgHint( &rCpyTable );
678 aMsgHint.m_eFlags = TBL_RELBOXNAME;
679 pCpyDoc->getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );
680 }
681
682 // delete frames
683 aFndBox.SetTableLines( *this );
684 if( bClear )
685 aFndBox.ClearLineBehind();
686 aFndBox.DelFrames( *this );
687
688 // copy boxes
689 aTarget.copyBoxes( rCpyTable, *this, pUndo );
690
691 // adjust row span attributes accordingly
692
693 // make frames
694 aFndBox.MakeFrames( *this );
695
696 return true;
697}
698
704bool SwTable::InsTable( const SwTable& rCpyTable, const SwNodeIndex& rSttBox,
705 SwUndoTableCpyTable* pUndo )
706{
707 SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout>()); // Delete HTML Layout
708
709 SwDoc* pDoc = GetFrameFormat()->GetDoc();
710
711 SwTableNode* pTableNd = SwDoc::IsIdxInTable( rSttBox );
712
713 // Find the Box, to which should be copied:
714 SwTableBox* pMyBox = GetTableBox(
715 rSttBox.GetNode().FindTableBoxStartNode()->GetIndex() );
716
717 OSL_ENSURE( pMyBox, "Index is not in a Box in this Table" );
718
719 // First delete the Table's Frames
720 FndBox_ aFndBox( nullptr, nullptr );
721 aFndBox.DelFrames( pTableNd->GetTable() );
722
723 SwDoc* pCpyDoc = rCpyTable.GetFrameFormat()->GetDoc();
724
725 {
726 // Convert Table formulas to their relative representation
727 SwTableFormulaUpdate aMsgHint( &rCpyTable );
728 aMsgHint.m_eFlags = TBL_RELBOXNAME;
729 pCpyDoc->getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );
730 }
731
732 SwTableNumFormatMerge aTNFM( *pCpyDoc, *pDoc );
733
734 bool bDelContent = true;
735 const SwTableBox* pTmp;
736
737 for( auto pLine : rCpyTable.GetTabLines() )
738 {
739 // Get the first from the CopyLine
740 const SwTableBox* pCpyBox = pLine->GetTabBoxes().front();
741 while( !pCpyBox->GetTabLines().empty() )
742 pCpyBox = pCpyBox->GetTabLines().front()->GetTabBoxes().front();
743
744 do {
745 // First copy the new content and then delete the old one.
746 // Do not create empty Sections, otherwise they will be deleted!
747 lcl_CpyBox( rCpyTable, pCpyBox, *this, pMyBox, bDelContent, pUndo );
748
749 pTmp = pCpyBox->FindNextBox( rCpyTable, pCpyBox, false );
750 if( !pTmp )
751 break; // no more Boxes
752 pCpyBox = pTmp;
753
754 pTmp = pMyBox->FindNextBox( *this, pMyBox, false );
755 if( !pTmp )
756 bDelContent = false; // No space left?
757 else
758 pMyBox = const_cast<SwTableBox*>(pTmp);
759
760 } while( true );
761
762 // Find the topmost Line
763 SwTableLine* pNxtLine = pMyBox->GetUpper();
764 while( pNxtLine->GetUpper() )
765 pNxtLine = pNxtLine->GetUpper()->GetUpper();
766 const SwTableLines::size_type nPos = GetTabLines().GetPos( pNxtLine ) + 1;
767 // Is there a next?
768 if( nPos >= GetTabLines().size() )
769 bDelContent = false; // there is none, all goes into the last Box
770 else
771 {
772 // Find the next Box with content
773 pNxtLine = GetTabLines()[ nPos ];
774 pMyBox = pNxtLine->GetTabBoxes().front();
775 while( !pMyBox->GetTabLines().empty() )
776 pMyBox = pMyBox->GetTabLines().front()->GetTabBoxes().front();
777 bDelContent = true;
778 }
779 }
780
781 aFndBox.MakeFrames( pTableNd->GetTable() ); // Create the Frames anew
782 return true;
783}
784
785bool SwTable::InsTable( const SwTable& rCpyTable, const SwSelBoxes& rSelBoxes,
786 SwUndoTableCpyTable* pUndo )
787{
788 OSL_ENSURE( !rSelBoxes.empty(), "Missing selection" );
789
790 SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout>()); // Delete HTML Layout
791
792 if( IsNewModel() || rCpyTable.IsNewModel() )
793 return InsNewTable( rCpyTable, rSelBoxes, pUndo );
794
795 OSL_ENSURE( !rCpyTable.IsTableComplex(), "Table too complex" );
796
797 SwDoc* pDoc = GetFrameFormat()->GetDoc();
798 SwDoc* pCpyDoc = rCpyTable.GetFrameFormat()->GetDoc();
799
800 SwTableNumFormatMerge aTNFM( *pCpyDoc, *pDoc );
801
802 FndLine_ *pFLine;
803 FndBox_ aFndBox( nullptr, nullptr );
804 // Find all Boxes/Lines
805 {
806 FndPara aPara( rSelBoxes, &aFndBox );
808 }
809
810 // Special case: If a Box is located in a Table, copy it to all selected
811 // Boxes!
812 if( 1 != rCpyTable.GetTabSortBoxes().size() )
813 {
814 FndBox_* pFndBox;
815
816 const FndLines_t::size_type nFndCnt = aFndBox.GetLines().size();
817 if( !nFndCnt )
818 return false;
819
820 // Check if we have enough space for all Lines and Boxes
821 SwTableLines::size_type nTstLns = 0;
822 pFLine = aFndBox.GetLines().front().get();
823 sal_uInt16 nSttLine = GetTabLines().GetPos( pFLine->GetLine() );
824 // Do we have as many rows, actually?
825 if( 1 == nFndCnt )
826 {
827 // Is there still enough space in the Table?
828 if( (GetTabLines().size() - nSttLine ) <
829 rCpyTable.GetTabLines().size() )
830 {
831 // If we don't have enough Lines, then see if we can insert
832 // new ones to reach our goal. But only if the SSelection
833 // contains a Box!
834 if( 1 < rSelBoxes.size() )
835 return false;
836
837 const sal_uInt16 nNewLns = rCpyTable.GetTabLines().size() -
838 (GetTabLines().size() - nSttLine );
839
840 // See if the Box count is high enough for the Lines
841 SwTableLine* pLastLn = GetTabLines().back();
842
843 SwTableBox* pSttBox = pFLine->GetBoxes()[0]->GetBox();
844 const SwTableBoxes::size_type nSttBox = pFLine->GetLine()->GetBoxPos( pSttBox );
845 for( SwTableLines::size_type n = rCpyTable.GetTabLines().size() - nNewLns;
846 n < rCpyTable.GetTabLines().size(); ++n )
847 {
848 SwTableLine* pCpyLn = rCpyTable.GetTabLines()[ n ];
849
850 if( pLastLn->GetTabBoxes().size() < nSttBox ||
851 ( pLastLn->GetTabBoxes().size() - nSttBox ) <
852 pCpyLn->GetTabBoxes().size() )
853 return false;
854
855 // Test for nesting
856 for( SwTableBoxes::size_type nBx = 0; nBx < pCpyLn->GetTabBoxes().size(); ++nBx )
857 if( !pLastLn->GetTabBoxes()[ nSttBox + nBx ]->GetSttNd() )
858 return false;
859 }
860 // We have enough space for the to-be-copied, so insert new
861 // rows accordingly.
862 SwTableBox* pInsBox = pLastLn->GetTabBoxes()[ nSttBox ];
863 OSL_ENSURE( pInsBox && pInsBox->GetSttNd(),
864 "no ContentBox or it's not in this Table" );
865 SwSelBoxes aBoxes;
866
867 if( pUndo
868 ? !pUndo->InsertRow( *this, SelLineFromBox( pInsBox,
869 aBoxes ), nNewLns )
870 : !InsertRow( pDoc, SelLineFromBox( pInsBox,
871 aBoxes ), nNewLns, /*bBehind*/true ) )
872 return false;
873 }
874
875 nTstLns = rCpyTable.GetTabLines().size(); // copy this many
876 }
877 else if( 0 == (nFndCnt % rCpyTable.GetTabLines().size()) )
878 nTstLns = nFndCnt;
879 else
880 return false; // not enough space for the rows
881
882 for( SwTableLines::size_type nLn = 0; nLn < nTstLns; ++nLn )
883 {
884 // We have enough rows, so check the Boxes per row
885 pFLine = aFndBox.GetLines()[ nLn % nFndCnt ].get();
886 SwTableLine* pLine = pFLine->GetLine();
887 SwTableBox* pSttBox = pFLine->GetBoxes()[0]->GetBox();
888 const SwTableBoxes::size_type nSttBox = pLine->GetBoxPos( pSttBox );
889 std::unique_ptr<FndLine_> pInsFLine;
890 if( nLn >= nFndCnt )
891 {
892 // We have more rows in the ClipBoard than we have selected
893 pInsFLine.reset(new FndLine_( GetTabLines()[ nSttLine + nLn ],
894 &aFndBox ));
895 pLine = pInsFLine->GetLine();
896 }
897 SwTableLine* pCpyLn = rCpyTable.GetTabLines()[ nLn %
898 rCpyTable.GetTabLines().size() ];
899
900 // Selected too few rows?
901 if( pInsFLine )
902 {
903 // We insert a new row into the FndBox
904 if( pLine->GetTabBoxes().size() < nSttBox ||
905 pLine->GetTabBoxes().size() - nSttBox < pFLine->GetBoxes().size() )
906 {
907 return false;
908 }
909
910 // Test for nesting
911 for (FndBoxes_t::size_type nBx = 0; nBx < pFLine->GetBoxes().size(); ++nBx)
912 {
913 SwTableBox *pTmpBox = pLine->GetTabBoxes()[ nSttBox + nBx ];
914 if( !pTmpBox->GetSttNd() )
915 {
916 return false;
917 }
918 // if Ok, insert the Box into the FndLine
919 pFndBox = new FndBox_( pTmpBox, pInsFLine.get() );
920 pInsFLine->GetBoxes().insert( pInsFLine->GetBoxes().begin() + nBx,
921 std::unique_ptr<FndBox_>(pFndBox));
922 }
923 aFndBox.GetLines().insert( aFndBox.GetLines().begin() + nLn, std::move(pInsFLine));
924 }
925 else if( pFLine->GetBoxes().size() == 1 )
926 {
927 if( pLine->GetTabBoxes().size() < nSttBox ||
928 ( pLine->GetTabBoxes().size() - nSttBox ) <
929 pCpyLn->GetTabBoxes().size() )
930 return false;
931
932 // Test for nesting
933 for( SwTableBoxes::size_type nBx = 0; nBx < pCpyLn->GetTabBoxes().size(); ++nBx )
934 {
935 SwTableBox *pTmpBox = pLine->GetTabBoxes()[ nSttBox + nBx ];
936 if( !pTmpBox->GetSttNd() )
937 return false;
938 // if Ok, insert the Box into the FndLine
939 if( nBx == pFLine->GetBoxes().size() )
940 {
941 pFndBox = new FndBox_( pTmpBox, pFLine );
942 pFLine->GetBoxes().insert(pFLine->GetBoxes().begin() + nBx,
943 std::unique_ptr<FndBox_>(pFndBox));
944 }
945 }
946 }
947 else
948 {
949 // Match the selected Boxes with the ones in the Clipboard
950 // (n times)
951 if( 0 != ( pFLine->GetBoxes().size() %
952 pCpyLn->GetTabBoxes().size() ))
953 return false;
954
955 // Test for nesting
956 for (auto &rpBox : pFLine->GetBoxes())
957 {
958 if (!rpBox->GetBox()->GetSttNd())
959 return false;
960 }
961 }
962 }
963
964 if( aFndBox.GetLines().empty() )
965 return false;
966 }
967
968 {
969 // Convert Table formulas to their relative representation
970 SwTableFormulaUpdate aMsgHint( &rCpyTable );
971 aMsgHint.m_eFlags = TBL_RELBOXNAME;
972 pCpyDoc->getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );
973 }
974
975 // Delete the Frames
976 aFndBox.SetTableLines( *this );
977 //Not dispose accessible table
978 aFndBox.DelFrames( *this );
979
980 if( 1 == rCpyTable.GetTabSortBoxes().size() )
981 {
982 SwTableBox *pTmpBx = rCpyTable.GetTabSortBoxes()[0];
983 for (size_t n = 0; n < rSelBoxes.size(); ++n)
984 {
985 lcl_CpyBox( rCpyTable, pTmpBx, *this,
986 rSelBoxes[n], true, pUndo );
987 }
988 }
989 else
990 for (FndLines_t::size_type nLn = 0; nLn < aFndBox.GetLines().size(); ++nLn)
991 {
992 pFLine = aFndBox.GetLines()[ nLn ].get();
993 SwTableLine* pCpyLn = rCpyTable.GetTabLines()[
994 nLn % rCpyTable.GetTabLines().size() ];
995 for (FndBoxes_t::size_type nBx = 0; nBx < pFLine->GetBoxes().size(); ++nBx)
996 {
997 // Copy the pCpyBox into pMyBox
998 lcl_CpyBox( rCpyTable, pCpyLn->GetTabBoxes()[
999 nBx % pCpyLn->GetTabBoxes().size() ],
1000 *this, pFLine->GetBoxes()[nBx]->GetBox(), true, pUndo );
1001 }
1002 }
1003
1004 aFndBox.MakeFrames( *this );
1005 return true;
1006}
1007
1008static void FndContentLine( const SwTableLine* pLine, SwSelBoxes* pPara );
1009
1010static void FndContentBox( const SwTableBox* pBox, SwSelBoxes* pPara )
1011{
1012 if( !pBox->GetTabLines().empty() )
1013 {
1014 for( const SwTableLine* pLine : pBox->GetTabLines() )
1015 FndContentLine( pLine, pPara );
1016 }
1017 else
1018 pPara->insert( const_cast<SwTableBox*>(pBox) );
1019}
1020
1021static void FndContentLine( const SwTableLine* pLine, SwSelBoxes* pPara )
1022{
1023 for( const SwTableBox* pBox : pLine->GetTabBoxes() )
1024 FndContentBox(pBox, pPara );
1025}
1026
1027// Find all Boxes with content in this Box
1029 SwSelBoxes& rBoxes, bool bToTop )
1030{
1031 SwTableLine* pLine = const_cast<SwTableLine*>(pBox->GetUpper());
1032 if( bToTop )
1033 while( pLine->GetUpper() )
1034 pLine = pLine->GetUpper()->GetUpper();
1035
1036 // Delete all old ones
1037 rBoxes.clear();
1038 for( const auto& rpBox : pLine->GetTabBoxes() )
1039 FndContentBox(rpBox, &rBoxes );
1040 return rBoxes;
1041}
1042
1043/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
sal_uInt32 GetValue() const
void SetTableLines(const SwSelBoxes &rBoxes, const SwTable &rTable)
Definition: tblsel.cxx:2096
const FndLines_t & GetLines() const
Definition: tblsel.hxx:172
void ClearLineBehind()
Definition: tblsel.hxx:188
void MakeFrames(SwTable &rTable)
Definition: tblsel.cxx:2319
void DelFrames(SwTable &rTable)
Definition: tblsel.cxx:2158
const FndBoxes_t & GetBoxes() const
Definition: tblsel.hxx:202
const SwTableLine * GetLine() const
Definition: tblsel.hxx:204
virtual void UpdateTableFields(SfxPoolItem *pHt)=0
virtual void DelLayoutFormat(SwFrameFormat *pFormat)=0
static bool IsRedlineOn(const RedlineFlags eM)
virtual SwTextFormatColl * GetTextCollFromPool(sal_uInt16 nId, bool bRegardLanguage=true)=0
Return "Auto-Collection with ID.
sal_uInt16 Count() const
const T * GetItemIfSet(TypedWhichId< T > nWhich, bool bSrchInParent=true) const
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
sal_uInt32 GetMergeFormatIndex(sal_uInt32 nOldFmt) const
bool HasMergeFormatTable() const
tools::Long GetWidth() const
SwFormatColl * GetFormatColl() const
Definition: node.hxx:497
virtual sal_Int32 Len() const
Definition: node.cxx:1263
Definition: doc.hxx:194
void CorrAbs(const SwNode &rOldNode, const SwPosition &rNewPos, const sal_Int32 nOffset=0, bool bMoveCursor=false)
Definition: doccorr.cxx:169
static SwTableNode * IsIdxInTable(const SwNodeIndex &rIdx)
Definition: ndtbl.cxx:217
IDocumentUndoRedo & GetIDocumentUndoRedo()
Definition: doc.cxx:150
SwNodes & GetNodes()
Definition: doc.hxx:417
IDocumentFieldsAccess const & getIDocumentFieldsAccess() const
Definition: doc.cxx:363
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
Definition: doc.cxx:341
IDocumentLayoutAccess const & getIDocumentLayoutAccess() const
Definition: doc.cxx:411
IDocumentStylePoolAccess const & getIDocumentStylePoolAccess() const
Definition: doc.cxx:432
::sw::DocumentContentOperationsManager const & GetDocumentContentOperationsManager() const
Definition: doc.cxx:331
const SwTextFormatColl * GetDfltTextFormatColl() const
Definition: doc.hxx:784
const SwAttrPool & GetAttrPool() const
Definition: doc.hxx:1326
const SwFrameFormats * GetSpzFrameFormats() const
Definition: doc.hxx:752
bool SetTextFormatColl(const SwPaM &rRg, SwTextFormatColl *pFormat, const bool bReset=true, const bool bResetListAttrs=false, SwRootFrame const *pLayout=nullptr)
Add 4th optional parameter <bResetListAttrs>.
Definition: docfmt.cxx:1081
SvNumberFormatter * GetNumberFormatter(bool bCreate=true)
Definition: doc.hxx:1418
FlyAnchors.
Definition: fmtanchr.hxx:37
RndStdIds GetAnchorId() const
Definition: fmtanchr.hxx:67
SwNode * GetAnchorNode() const
Definition: atrfrm.cxx:1606
const SwDoc * GetDoc() const
The document is set in SwAttrPool now, therefore you always can access it.
Definition: format.hxx:139
sal_uInt16 GetPoolFormatId() const
Get and set Pool style IDs.
Definition: format.hxx:163
const SwFormatFrameSize & GetFrameSize(bool=true) const
Definition: fmtfsize.hxx:104
virtual bool ResetFormatAttr(sal_uInt16 nWhich1, sal_uInt16 nWhich2=0)
Definition: format.cxx:618
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
Definition: format.cxx:385
const SwAttrSet & GetAttrSet() const
For querying the attribute array.
Definition: format.hxx:136
virtual bool SetFormatAttr(const SfxPoolItem &rAttr)
Definition: format.cxx:447
Marks a node in the document model.
Definition: ndindex.hxx:31
SwNode & GetNode() const
Definition: ndindex.hxx:136
SwNodeOffset GetIndex() const
Definition: ndindex.hxx:171
Base class of the Writer document model elements.
Definition: node.hxx:98
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:897
SwNodeOffset GetIndex() const
Definition: node.hxx:312
const SwStartNode * FindTableBoxStartNode() const
Definition: node.hxx:218
SwNodeOffset EndOfSectionIndex() const
Definition: node.hxx:726
SwContentNode * GetContentNode()
Definition: node.hxx:664
const SwEndNode * EndOfSectionNode() const
Definition: node.hxx:731
SwTextNode * MakeTextNode(SwNode &rWhere, SwTextFormatColl *pColl, bool bNewFrames=true)
Implementations of "Make...Node" are in the given .cxx-files.
Definition: ndtxt.cxx:120
void Delete(const SwNodeIndex &rPos, SwNodeOffset nNodes=SwNodeOffset(1))
Definition: nodes.cxx:1065
static SwContentNode * GoPrevious(SwNodeIndex *)
Definition: nodes.cxx:1328
SwContentNode * GoNext(SwNodeIndex *) const
Definition: nodes.cxx:1294
PaM is Point and Mark: a selection of the document model.
Definition: pam.hxx:187
virtual void SetMark()
Unless this is called, the getter method of Mark will return Point.
Definition: pam.cxx:642
bool Move(SwMoveFnCollection const &fnMove=fnMoveForward, SwGoInDoc fnGo=GoInContent)
Movement of cursor.
Definition: pam.cxx:668
SwTableBox is one table cell in the document model.
Definition: swtable.hxx:426
SwTableLine * GetUpper()
Definition: swtable.hxx:460
sal_Int32 getRowSpan() const
Definition: swtable.hxx:523
SwNodeOffset GetSttIdx() const
Definition: swtable.cxx:2065
SwFrameFormat * GetFrameFormat()
Definition: swtable.hxx:464
SwTableLines & GetTabLines()
Definition: swtable.hxx:457
const SwStartNode * GetSttNd() const
Definition: swtable.hxx:478
SwTableBox * FindNextBox(const SwTable &, const SwTableBox *, bool bOvrTableLns=true) const
Definition: tblrwcl.cxx:2316
SwFrameFormat * ClaimFrameFormat()
Definition: swtable.cxx:1917
TableFormulaUpdateFlags m_eFlags
Definition: hints.hxx:286
SwTableLine is one table row in the document model.
Definition: swtable.hxx:364
SwTableBoxes & GetTabBoxes()
Definition: swtable.hxx:374
sal_uInt16 GetBoxPos(const SwTableBox *pBox) const
Definition: swtable.hxx:376
SwTableBox * GetUpper()
Definition: swtable.hxx:382
size_type size() const
Definition: swtable.hxx:76
SwTableLine * back() const
Definition: swtable.hxx:82
SwTableLine * front() const
Definition: swtable.hxx:81
std::vector< SwTableLine * >::size_type size_type
Definition: swtable.hxx:68
sal_uInt16 GetPos(const SwTableLine *pBox) const
Definition: swtable.hxx:98
bool empty() const
Definition: swtable.hxx:75
const SwTable & GetTable() const
Definition: node.hxx:542
SwTable is one table in the document model, containing rows (which contain cells).
Definition: swtable.hxx:113
void SetHTMLTableLayout(std::shared_ptr< SwHTMLTableLayout > const &r)
Definition: swtable.cxx:2157
bool InsNewTable(const SwTable &rCpyTable, const SwSelBoxes &, SwUndoTableCpyTable *pUndo)
Definition: tblcpy.cxx:639
SwTableLines & GetTabLines()
Definition: swtable.hxx:204
SwTableFormat * GetFrameFormat()
Definition: swtable.hxx:207
bool IsTableComplex() const
Definition: swtable.cxx:1441
bool InsertRow(SwDoc *, const SwSelBoxes &rBoxes, sal_uInt16 nCnt, bool bBehind)
SwTable::InsertRow(..) inserts one or more rows before or behind the selected boxes.
const SwTableBox * GetTableBox(const OUString &rName, const bool bPerformValidCheck=false) const
Definition: swtable.cxx:1340
bool InsTable(const SwTable &rCpyTable, const SwNodeIndex &, SwUndoTableCpyTable *pUndo)
Copy Table into this Box.
Definition: tblcpy.cxx:704
SwTableSortBoxes & GetTabSortBoxes()
Definition: swtable.hxx:265
bool IsNewModel() const
Definition: swtable.hxx:191
static SwSelBoxes & SelLineFromBox(const SwTableBox *pBox, SwSelBoxes &rBoxes, bool bToTop=true)
Definition: tblcpy.cxx:1028
Represents the style of a paragraph.
Definition: fmtcol.hxx:59
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:111
SwTextFormatColl * GetTextColl() const
Definition: ndtxt.hxx:891
void AddBoxAfter(const SwTableBox &rBox, const SwNodeIndex &rIdx, bool bDelContent)
Definition: untbl.cxx:2617
bool InsertRow(SwTable &rTable, const SwSelBoxes &rBoxes, sal_uInt16 nCnt)
Definition: untbl.cxx:2720
void AddBoxBefore(const SwTableBox &rBox, bool bDelContent)
Definition: untbl.cxx:2586
const_iterator find(const Value &x) const
bool empty() const
const_iterator end() const
size_type size() const
std::pair< const_iterator, bool > insert(Value &&x)
void CopyWithFlyInFly(const SwNodeRange &rRg, SwNode &rInsPos, const std::pair< const SwPaM &, const SwPosition & > *pCopiedPaM=nullptr, bool bMakeNewFrames=true, bool bDelRedlines=true, bool bCopyFlyAtFly=false, SwCopyFlags flags=SwCopyFlags::Default) const
note: rRg/rInsPos exclude a partially selected start text node; pCopiedPaM includes a partially selec...
constexpr TypedWhichId< SwTableBoxValue > RES_BOXATR_VALUE(152)
constexpr TypedWhichId< SwTableBoxFormula > RES_BOXATR_FORMULA(151)
constexpr TypedWhichId< SwTableBoxNumFormat > RES_BOXATR_FORMAT(RES_BOXATR_BEGIN)
@ TBL_RELBOXNAME
Definition: hints.hxx:272
sal_Int64 n
sal_uInt16 nPos
tools::Long const nBorder
size
enumrange< T >::Iterator begin(enumrange< T >)
end
long Long
SwNodeOffset min(const SwNodeOffset &a, const SwNodeOffset &b)
Definition: nodeoffset.hxx:35
bool GoInSection(SwPaM &rPam, SwMoveFnCollection const &fnMove)
Definition: pam.cxx:1164
SwMoveFnCollection const & fnMoveForward
SwPam::Move()/Find() default argument.
Definition: paminit.cxx:61
@ RES_POOLCOLL_TABLE
Subgroup table.
Definition: poolfmt.hxx:341
@ RES_POOLCOLL_TABLE_HDLN
Table of Contents - heading.
Definition: poolfmt.hxx:342
sal_uIntPtr sal_uLong
Marks a position in the document model.
Definition: pam.hxx:37
void SetContent(sal_Int32 nContentIndex)
Set content index, only valid to call this if the position points to a SwContentNode subclass.
Definition: pam.cxx:266
std::vector< SwTableBox * > SwTableBoxes
Definition: swtable.hxx:105
sal_Int32 mnColSpan
static void FndContentBox(const SwTableBox *pBox, SwSelBoxes *pPara)
Definition: tblcpy.cxx:1010
static void FndContentLine(const SwTableLine *pLine, SwSelBoxes *pPara)
Definition: tblcpy.cxx:1021
static void lcl_CpyBox(const SwTable &rCpyTable, const SwTableBox *pCpyBox, SwTable &rDstTable, SwTableBox *pDstBox, bool bDelContent, SwUndoTableCpyTable *pUndo)
Copy Table into this Box.
Definition: tblcpy.cxx:490
void ForEach_FndLineCopyCol(SwTableLines &rLines, FndPara *pFndPara)
This creates a structure mirroring the SwTable structure that contains all rows and non-leaf boxes (a...
Definition: tblsel.cxx:2090
std::vector< std::unique_ptr< FndLine_ > > FndLines_t
Definition: tblsel.hxx:155