Line data Source code
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 <editeng/lrspitem.hxx>
22 : #include <editeng/boxitem.hxx>
23 : #include <editeng/brushitem.hxx>
24 : #include <editeng/frmdiritem.hxx>
25 : #include <fesh.hxx>
26 : #include <fmtornt.hxx>
27 : #include <fmtfsize.hxx>
28 : #include <fmtlsplt.hxx>
29 : #include <fmtrowsplt.hxx>
30 : #include <tabcol.hxx>
31 : #include <frmatr.hxx>
32 : #include <cellfrm.hxx>
33 : #include <tabfrm.hxx>
34 : #include <cntfrm.hxx>
35 : #include <txtfrm.hxx>
36 : #include <svx/svxids.hrc>
37 : #include <doc.hxx>
38 : #include <IDocumentUndoRedo.hxx>
39 : #include <IDocumentState.hxx>
40 : #include <IDocumentLayoutAccess.hxx>
41 : #include "pam.hxx"
42 : #include "swcrsr.hxx"
43 : #include "viscrs.hxx"
44 : #include "swtable.hxx"
45 : #include "htmltbl.hxx"
46 : #include "tblsel.hxx"
47 : #include "swtblfmt.hxx"
48 : #include "docary.hxx"
49 : #include "ndindex.hxx"
50 : #include "undobj.hxx"
51 : #include <calbck.hxx>
52 : #include <UndoTable.hxx>
53 : #include <o3tl/enumrange.hxx>
54 :
55 : using ::editeng::SvxBorderLine;
56 : using namespace ::com::sun::star;
57 :
58 : // See swtable.cxx too
59 : #define COLFUZZY 20L
60 :
61 3 : inline bool IsSame( long nA, long nB ) { return std::abs(nA-nB) <= COLFUZZY; }
62 :
63 : class SwTableFormatCmp
64 : {
65 : public:
66 : SwFrameFormat *pOld,
67 : *pNew;
68 : sal_Int16 nType;
69 :
70 : SwTableFormatCmp( SwFrameFormat *pOld, SwFrameFormat *pNew, sal_Int16 nType );
71 :
72 : static SwFrameFormat *FindNewFormat( std::vector<SwTableFormatCmp*> &rArr, SwFrameFormat*pOld, sal_Int16 nType );
73 : static void Delete( std::vector<SwTableFormatCmp*> &rArr );
74 : };
75 :
76 45 : SwTableFormatCmp::SwTableFormatCmp( SwFrameFormat *pO, SwFrameFormat *pN, sal_Int16 nT )
77 45 : : pOld ( pO ), pNew ( pN ), nType( nT )
78 : {
79 45 : }
80 :
81 49 : SwFrameFormat *SwTableFormatCmp::FindNewFormat( std::vector<SwTableFormatCmp*> &rArr, SwFrameFormat *pOld, sal_Int16 nType )
82 : {
83 229 : for ( auto pCmp : rArr )
84 : {
85 184 : if ( pCmp->pOld == pOld && pCmp->nType == nType )
86 4 : return pCmp->pNew;
87 : }
88 45 : return 0;
89 : }
90 :
91 6 : void SwTableFormatCmp::Delete( std::vector<SwTableFormatCmp*> &rArr )
92 : {
93 51 : for ( auto pCmp : rArr )
94 45 : delete pCmp;
95 6 : }
96 :
97 31 : static void lcl_GetStartEndCell( const SwCursor& rCrsr,
98 : SwLayoutFrm *&prStart, SwLayoutFrm *&prEnd )
99 : {
100 : OSL_ENSURE( rCrsr.GetContentNode() && rCrsr.GetContentNode( false ),
101 : "Tab selection not at ContentNode" );
102 :
103 31 : Point aPtPos, aMkPos;
104 31 : const SwShellCrsr* pShCrsr = dynamic_cast<const SwShellCrsr*>(&rCrsr);
105 31 : if( pShCrsr )
106 : {
107 12 : aPtPos = pShCrsr->GetPtPos();
108 12 : aMkPos = pShCrsr->GetMkPos();
109 : }
110 :
111 : // Robust:
112 31 : SwContentNode* pPointNd = rCrsr.GetContentNode();
113 31 : SwContentNode* pMarkNd = rCrsr.GetContentNode(false);
114 :
115 31 : SwFrm* pPointFrm = pPointNd ? pPointNd->getLayoutFrm( pPointNd->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPtPos ) : 0;
116 31 : SwFrm* pMarkFrm = pMarkNd ? pMarkNd->getLayoutFrm( pMarkNd->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aMkPos ) : 0;
117 :
118 31 : prStart = pPointFrm ? pPointFrm->GetUpper() : 0;
119 31 : prEnd = pMarkFrm ? pMarkFrm->GetUpper() : 0;
120 31 : }
121 :
122 17 : static bool lcl_GetBoxSel( const SwCursor& rCursor, SwSelBoxes& rBoxes,
123 : bool bAllCrsr = false )
124 : {
125 : const SwTableCursor* pTableCrsr =
126 17 : dynamic_cast<const SwTableCursor*>(&rCursor);
127 17 : if( pTableCrsr )
128 12 : ::GetTableSelCrs( *pTableCrsr, rBoxes );
129 : else
130 : {
131 5 : const SwPaM *pCurPam = &rCursor, *pSttPam = pCurPam;
132 5 : do {
133 5 : const SwNode* pNd = pCurPam->GetNode().FindTableBoxStartNode();
134 5 : if( pNd )
135 : {
136 5 : SwTableBox* pBox = const_cast<SwTableBox*>(pNd->FindTableNode()->GetTable().
137 10 : GetTableBox( pNd->GetIndex() ));
138 5 : rBoxes.insert( pBox );
139 : }
140 5 : } while( bAllCrsr &&
141 : pSttPam != ( pCurPam = pCurPam->GetNext()) );
142 : }
143 17 : return !rBoxes.empty();
144 : }
145 :
146 1 : inline void InsertLine( std::vector<SwTableLine*>& rLineArr, SwTableLine* pLine )
147 : {
148 1 : if( rLineArr.end() == std::find( rLineArr.begin(), rLineArr.end(), pLine ) )
149 1 : rLineArr.push_back( pLine );
150 1 : }
151 :
152 0 : static bool lcl_IsAnLower( const SwTableLine *pLine, const SwTableLine *pAssumed )
153 : {
154 0 : const SwTableLine *pTmp = pAssumed->GetUpper() ?
155 0 : pAssumed->GetUpper()->GetUpper() : 0;
156 0 : while ( pTmp )
157 : {
158 0 : if ( pTmp == pLine )
159 0 : return true;
160 0 : pTmp = pTmp->GetUpper() ? pTmp->GetUpper()->GetUpper() : 0;
161 : }
162 0 : return false;
163 : }
164 :
165 : struct LinesAndTable
166 : {
167 : std::vector<SwTableLine*> &m_rLines;
168 : const SwTable &m_rTable;
169 : bool m_bInsertLines;
170 :
171 1 : LinesAndTable(std::vector<SwTableLine*> &rL, const SwTable &rTable) :
172 1 : m_rLines(rL), m_rTable(rTable), m_bInsertLines(true) {}
173 : };
174 :
175 : bool _FindLine( _FndLine & rLine, LinesAndTable* pPara );
176 :
177 2 : bool _FindBox( _FndBox & rBox, LinesAndTable* pPara )
178 : {
179 2 : if (!rBox.GetLines().empty())
180 : {
181 1 : pPara->m_bInsertLines = true;
182 2 : for (_FndLine & rFndLine : rBox.GetLines())
183 1 : _FindLine(rFndLine, pPara);
184 :
185 1 : if (pPara->m_bInsertLines)
186 : {
187 1 : const SwTableLines &rLines = (rBox.GetBox())
188 0 : ? rBox.GetBox()->GetTabLines()
189 1 : : pPara->m_rTable.GetTabLines();
190 1 : if (rBox.GetLines().size() == rLines.size())
191 : {
192 0 : for ( auto pLine : rLines )
193 0 : ::InsertLine(pPara->m_rLines, pLine);
194 : }
195 : else
196 1 : pPara->m_bInsertLines = false;
197 : }
198 : }
199 1 : else if (rBox.GetBox())
200 : {
201 1 : ::InsertLine(pPara->m_rLines, static_cast<SwTableLine*>(rBox.GetBox()->GetUpper()));
202 : }
203 2 : return true;
204 : }
205 :
206 1 : bool _FindLine( _FndLine& rLine, LinesAndTable* pPara )
207 : {
208 6 : for (_FndBoxes::iterator it = rLine.GetBoxes().begin();
209 4 : it != rLine.GetBoxes().end(); ++it)
210 : {
211 1 : _FindBox(*it, pPara);
212 : }
213 1 : return true;
214 : }
215 :
216 1 : static void lcl_CollectLines( std::vector<SwTableLine*> &rArr, const SwCursor& rCursor, bool bRemoveLines )
217 : {
218 : // Collect the selected Boxes first
219 1 : SwSelBoxes aBoxes;
220 1 : if( !::lcl_GetBoxSel( rCursor, aBoxes ))
221 1 : return ;
222 :
223 : // Copy the selected structure
224 1 : const SwTable &rTable = aBoxes[0]->GetSttNd()->FindTableNode()->GetTable();
225 1 : LinesAndTable aPara( rArr, rTable );
226 2 : _FndBox aFndBox( 0, 0 );
227 : {
228 1 : _FndPara aTmpPara( aBoxes, &aFndBox );
229 1 : ForEach_FndLineCopyCol( (SwTableLines&)rTable.GetTabLines(), &aTmpPara );
230 : }
231 :
232 : // Collect the Lines which only contain selected Boxes
233 1 : ::_FindBox(aFndBox, &aPara);
234 :
235 : // Remove lines, that have a common superordinate row.
236 : // (Not for row split)
237 1 : if ( bRemoveLines )
238 : {
239 2 : for ( std::vector<SwTableLine*>::size_type i = 0; i < rArr.size(); ++i )
240 : {
241 1 : SwTableLine *pUpLine = rArr[i];
242 2 : for ( std::vector<SwTableLine*>::size_type k = 0; k < rArr.size(); ++k )
243 : {
244 1 : if ( k != i && ::lcl_IsAnLower( pUpLine, rArr[k] ) )
245 : {
246 0 : rArr.erase( rArr.begin() + k );
247 0 : if ( k <= i )
248 0 : --i;
249 0 : --k;
250 : }
251 : }
252 : }
253 1 : }
254 : }
255 :
256 0 : static void lcl_ProcessRowAttr( std::vector<SwTableFormatCmp*>& rFormatCmp, SwTableLine* pLine, const SfxPoolItem& rNew )
257 : {
258 : SwFrameFormat *pNewFormat;
259 0 : if ( 0 != (pNewFormat = SwTableFormatCmp::FindNewFormat( rFormatCmp, pLine->GetFrameFormat(), 0 )))
260 0 : pLine->ChgFrameFormat( static_cast<SwTableLineFormat*>(pNewFormat) );
261 : else
262 : {
263 0 : SwFrameFormat *pOld = pLine->GetFrameFormat();
264 0 : SwFrameFormat *pNew = pLine->ClaimFrameFormat();
265 0 : pNew->SetFormatAttr( rNew );
266 0 : rFormatCmp.push_back( new SwTableFormatCmp( pOld, pNew, 0 ) );
267 : }
268 0 : }
269 :
270 : static void lcl_ProcessBoxSize( std::vector<SwTableFormatCmp*> &rFormatCmp, SwTableBox *pBox, const SwFormatFrmSize &rNew );
271 :
272 0 : static void lcl_ProcessRowSize( std::vector<SwTableFormatCmp*> &rFormatCmp, SwTableLine *pLine, const SwFormatFrmSize &rNew )
273 : {
274 0 : lcl_ProcessRowAttr( rFormatCmp, pLine, rNew );
275 0 : SwTableBoxes &rBoxes = pLine->GetTabBoxes();
276 0 : for ( auto pBox : rBoxes )
277 0 : ::lcl_ProcessBoxSize( rFormatCmp, pBox, rNew );
278 0 : }
279 :
280 0 : static void lcl_ProcessBoxSize( std::vector<SwTableFormatCmp*> &rFormatCmp, SwTableBox *pBox, const SwFormatFrmSize &rNew )
281 : {
282 0 : SwTableLines &rLines = pBox->GetTabLines();
283 0 : if ( !rLines.empty() )
284 : {
285 0 : SwFormatFrmSize aSz( rNew );
286 0 : aSz.SetHeight( rNew.GetHeight() ? rNew.GetHeight() / rLines.size() : 0 );
287 0 : for ( auto pLine : rLines )
288 0 : ::lcl_ProcessRowSize( rFormatCmp, pLine, aSz );
289 : }
290 0 : }
291 :
292 0 : void SwDoc::SetRowSplit( const SwCursor& rCursor, const SwFormatRowSplit &rNew )
293 : {
294 0 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
295 0 : if( pTableNd )
296 : {
297 0 : std::vector<SwTableLine*> aRowArr; // For Lines collecting
298 0 : ::lcl_CollectLines( aRowArr, rCursor, false );
299 :
300 0 : if( !aRowArr.empty() )
301 : {
302 0 : if (GetIDocumentUndoRedo().DoesUndo())
303 : {
304 0 : GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTable(*pTableNd));
305 : }
306 :
307 0 : std::vector<SwTableFormatCmp*> aFormatCmp;
308 0 : aFormatCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
309 :
310 0 : for( auto pLn : aRowArr )
311 0 : ::lcl_ProcessRowAttr( aFormatCmp, pLn, rNew );
312 :
313 0 : SwTableFormatCmp::Delete( aFormatCmp );
314 0 : getIDocumentState().SetModified();
315 0 : }
316 : }
317 0 : }
318 :
319 0 : void SwDoc::GetRowSplit( const SwCursor& rCursor, SwFormatRowSplit *& rpSz )
320 : {
321 0 : rpSz = 0;
322 :
323 0 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
324 0 : if( pTableNd )
325 : {
326 0 : std::vector<SwTableLine*> aRowArr; // For Lines collecting
327 0 : ::lcl_CollectLines( aRowArr, rCursor, false );
328 :
329 0 : if( !aRowArr.empty() )
330 : {
331 0 : rpSz = &(SwFormatRowSplit&)aRowArr[0]->GetFrameFormat()->GetRowSplit();
332 :
333 0 : if (rpSz)
334 : {
335 0 : for ( auto pLn : aRowArr )
336 : {
337 0 : if ( (*rpSz).GetValue() != pLn->GetFrameFormat()->GetRowSplit().GetValue() )
338 : {
339 0 : rpSz = 0;
340 0 : break;
341 : }
342 : }
343 : }
344 0 : if ( rpSz )
345 0 : rpSz = new SwFormatRowSplit( *rpSz );
346 0 : }
347 : }
348 0 : }
349 :
350 : /* Class: SwDoc
351 : * Methods: SetRowHeight(), GetRowHeight()
352 : *
353 : * The line height is calculated from the Selection.
354 : * Starting with every Cell within the Selection, all Cells are iterated
355 : * through in an upwards fashion.
356 : *
357 : * The topmost Line gets the requested value, all Lines below it get
358 : * a respective value that is calculated from the relation of the old and
359 : * new size of the topmost Line in the lower line's own size.
360 : *
361 : * All changed Lines may get an own FrameFormat.
362 : * Of course we can only touch every Line once.
363 : */
364 :
365 0 : void SwDoc::SetRowHeight( const SwCursor& rCursor, const SwFormatFrmSize &rNew )
366 : {
367 0 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
368 0 : if( pTableNd )
369 : {
370 0 : std::vector<SwTableLine*> aRowArr; // For Lines collecting
371 0 : ::lcl_CollectLines( aRowArr, rCursor, true );
372 :
373 0 : if( !aRowArr.empty() )
374 : {
375 0 : if (GetIDocumentUndoRedo().DoesUndo())
376 : {
377 0 : GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTable(*pTableNd));
378 : }
379 :
380 0 : std::vector<SwTableFormatCmp*> aFormatCmp;
381 0 : aFormatCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
382 0 : for ( auto pLn : aRowArr )
383 0 : ::lcl_ProcessRowSize( aFormatCmp, pLn, rNew );
384 0 : SwTableFormatCmp::Delete( aFormatCmp );
385 :
386 0 : getIDocumentState().SetModified();
387 0 : }
388 : }
389 0 : }
390 :
391 0 : void SwDoc::GetRowHeight( const SwCursor& rCursor, SwFormatFrmSize *& rpSz )
392 : {
393 0 : rpSz = 0;
394 :
395 0 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
396 0 : if( pTableNd )
397 : {
398 0 : std::vector<SwTableLine*> aRowArr; // For Lines collecting
399 0 : ::lcl_CollectLines( aRowArr, rCursor, true );
400 :
401 0 : if( !aRowArr.empty() )
402 : {
403 0 : rpSz = &(SwFormatFrmSize&)aRowArr[0]->GetFrameFormat()->GetFrmSize();
404 :
405 0 : if (rpSz)
406 : {
407 0 : for ( auto pLn : aRowArr )
408 : {
409 0 : if ( *rpSz != pLn->GetFrameFormat()->GetFrmSize() )
410 : {
411 0 : rpSz = 0;
412 0 : break;
413 : }
414 : }
415 : }
416 0 : if ( rpSz )
417 0 : rpSz = new SwFormatFrmSize( *rpSz );
418 0 : }
419 : }
420 0 : }
421 :
422 1 : bool SwDoc::BalanceRowHeight( const SwCursor& rCursor, bool bTstOnly )
423 : {
424 1 : bool bRet = false;
425 1 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
426 1 : if( pTableNd )
427 : {
428 1 : std::vector<SwTableLine*> aRowArr; // For Lines collecting
429 1 : ::lcl_CollectLines( aRowArr, rCursor, true );
430 :
431 1 : if( 1 < aRowArr.size() )
432 : {
433 0 : if( !bTstOnly )
434 : {
435 0 : long nHeight = 0;
436 :
437 0 : for ( auto pLn : aRowArr )
438 : {
439 0 : SwIterator<SwFrm,SwFormat> aIter( *pLn->GetFrameFormat() );
440 0 : SwFrm* pFrm = aIter.First();
441 0 : while ( pFrm )
442 : {
443 0 : nHeight = std::max( nHeight, pFrm->Frm().Height() );
444 0 : pFrm = aIter.Next();
445 : }
446 0 : }
447 0 : SwFormatFrmSize aNew( ATT_MIN_SIZE, 0, nHeight );
448 :
449 0 : if (GetIDocumentUndoRedo().DoesUndo())
450 : {
451 0 : GetIDocumentUndoRedo().AppendUndo(
452 0 : new SwUndoAttrTable(*pTableNd));
453 : }
454 :
455 0 : std::vector<SwTableFormatCmp*> aFormatCmp;
456 0 : aFormatCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
457 0 : for( auto pLn : aRowArr )
458 0 : ::lcl_ProcessRowSize( aFormatCmp, pLn, aNew );
459 0 : SwTableFormatCmp::Delete( aFormatCmp );
460 :
461 0 : getIDocumentState().SetModified();
462 : }
463 0 : bRet = true;
464 1 : }
465 : }
466 1 : return bRet;
467 : }
468 :
469 0 : void SwDoc::SetRowBackground( const SwCursor& rCursor, const SvxBrushItem &rNew )
470 : {
471 0 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
472 0 : if( pTableNd )
473 : {
474 0 : std::vector<SwTableLine*> aRowArr; // For Lines collecting
475 0 : ::lcl_CollectLines( aRowArr, rCursor, true );
476 :
477 0 : if( !aRowArr.empty() )
478 : {
479 0 : if (GetIDocumentUndoRedo().DoesUndo())
480 : {
481 0 : GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTable(*pTableNd));
482 : }
483 :
484 0 : std::vector<SwTableFormatCmp*> aFormatCmp;
485 0 : aFormatCmp.reserve( std::max( 255, (int)aRowArr.size() ) );
486 :
487 0 : for( auto pLn : aRowArr )
488 0 : ::lcl_ProcessRowAttr( aFormatCmp, pLn, rNew );
489 :
490 0 : SwTableFormatCmp::Delete( aFormatCmp );
491 0 : getIDocumentState().SetModified();
492 0 : }
493 : }
494 0 : }
495 :
496 0 : bool SwDoc::GetRowBackground( const SwCursor& rCursor, SvxBrushItem &rToFill )
497 : {
498 0 : bool bRet = false;
499 0 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
500 0 : if( pTableNd )
501 : {
502 0 : std::vector<SwTableLine*> aRowArr; // For Lines collecting
503 0 : ::lcl_CollectLines( aRowArr, rCursor, true );
504 :
505 0 : if( !aRowArr.empty() )
506 : {
507 0 : rToFill = aRowArr[0]->GetFrameFormat()->makeBackgroundBrushItem();
508 :
509 0 : bRet = true;
510 0 : for ( std::vector<SwTableLine*>::size_type i = 1; i < aRowArr.size(); ++i )
511 0 : if ( rToFill != aRowArr[i]->GetFrameFormat()->makeBackgroundBrushItem() )
512 : {
513 0 : bRet = false;
514 0 : break;
515 : }
516 0 : }
517 : }
518 0 : return bRet;
519 : }
520 :
521 206 : inline void InsertCell( std::vector<SwCellFrm*>& rCellArr, SwCellFrm* pCellFrm )
522 : {
523 206 : if( rCellArr.end() == std::find( rCellArr.begin(), rCellArr.end(), pCellFrm ) )
524 206 : rCellArr.push_back( pCellFrm );
525 206 : }
526 :
527 31 : static void lcl_CollectCells( std::vector<SwCellFrm*> &rArr, const SwRect &rUnion,
528 : SwTabFrm *pTab )
529 : {
530 31 : SwLayoutFrm *pCell = pTab->FirstCell();
531 215 : do
532 : {
533 : // If the Cell contains a CellFrame, we need to use it
534 : // in order to get to the Cell
535 430 : while ( !pCell->IsCellFrm() )
536 0 : pCell = pCell->GetUpper();
537 : OSL_ENSURE( pCell, "Frame is not a Cell" );
538 215 : if ( rUnion.IsOver( pCell->Frm() ) )
539 206 : ::InsertCell( rArr, static_cast<SwCellFrm*>(pCell) );
540 :
541 : // Make sure the Cell is left (Areas)
542 215 : SwLayoutFrm *pTmp = pCell;
543 215 : do
544 215 : { pTmp = pTmp->GetNextLayoutLeaf();
545 : } while ( pCell->IsAnLower( pTmp ) );
546 215 : pCell = pTmp;
547 215 : } while( pCell && pTab->IsAnLower( pCell ) );
548 31 : }
549 :
550 5 : void SwDoc::SetTabBorders( const SwCursor& rCursor, const SfxItemSet& rSet )
551 : {
552 5 : SwContentNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetContentNode();
553 5 : SwTableNode* pTableNd = pCntNd ? pCntNd->FindTableNode() : 0;
554 5 : if( !pTableNd )
555 5 : return ;
556 :
557 : SwLayoutFrm *pStart, *pEnd;
558 5 : ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
559 :
560 5 : SwSelUnions aUnions;
561 5 : ::MakeSelUnions( aUnions, pStart, pEnd );
562 :
563 5 : if( !aUnions.empty() )
564 : {
565 5 : SwTable& rTable = pTableNd->GetTable();
566 5 : if (GetIDocumentUndoRedo().DoesUndo())
567 : {
568 5 : GetIDocumentUndoRedo().AppendUndo( new SwUndoAttrTable(*pTableNd) );
569 : }
570 :
571 5 : std::vector<SwTableFormatCmp*> aFormatCmp;
572 5 : aFormatCmp.reserve( 255 );
573 : const SvxBoxItem* pSetBox;
574 : const SvxBoxInfoItem *pSetBoxInfo;
575 :
576 5 : const SvxBorderLine* pLeft = 0;
577 5 : const SvxBorderLine* pRight = 0;
578 5 : const SvxBorderLine* pTop = 0;
579 5 : const SvxBorderLine* pBottom = 0;
580 5 : const SvxBorderLine* pHori = 0;
581 5 : const SvxBorderLine* pVert = 0;
582 5 : bool bHoriValid = true, bVertValid = true,
583 5 : bTopValid = true, bBottomValid = true,
584 5 : bLeftValid = true, bRightValid = true;
585 :
586 : // The Flags in the BoxInfo Item decide whether a BorderLine is valid!
587 5 : if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_BORDER_INNER, false,
588 5 : reinterpret_cast<const SfxPoolItem**>(&pSetBoxInfo)) )
589 : {
590 5 : pHori = pSetBoxInfo->GetHori();
591 5 : pVert = pSetBoxInfo->GetVert();
592 :
593 5 : bHoriValid = pSetBoxInfo->IsValid(SvxBoxInfoItemValidFlags::HORI);
594 5 : bVertValid = pSetBoxInfo->IsValid(SvxBoxInfoItemValidFlags::VERT);
595 :
596 : // Do we want to evaluate these?
597 5 : bTopValid = pSetBoxInfo->IsValid(SvxBoxInfoItemValidFlags::TOP);
598 5 : bBottomValid = pSetBoxInfo->IsValid(SvxBoxInfoItemValidFlags::BOTTOM);
599 5 : bLeftValid = pSetBoxInfo->IsValid(SvxBoxInfoItemValidFlags::LEFT);
600 5 : bRightValid = pSetBoxInfo->IsValid(SvxBoxInfoItemValidFlags::RIGHT);
601 : }
602 :
603 5 : if( SfxItemState::SET == rSet.GetItemState( RES_BOX, false,
604 5 : reinterpret_cast<const SfxPoolItem**>(&pSetBox)) )
605 : {
606 5 : pLeft = pSetBox->GetLeft();
607 5 : pRight = pSetBox->GetRight();
608 5 : pTop = pSetBox->GetTop();
609 5 : pBottom = pSetBox->GetBottom();
610 : }
611 : else
612 : {
613 : // Not set, thus not valid values
614 0 : bTopValid = bBottomValid = bLeftValid = bRightValid = false;
615 0 : pSetBox = 0;
616 : }
617 :
618 5 : bool bFirst = true;
619 10 : for ( SwSelUnions::size_type i = 0; i < aUnions.size(); ++i )
620 : {
621 5 : SwSelUnion *pUnion = &aUnions[i];
622 5 : SwTabFrm *pTab = pUnion->GetTable();
623 5 : const SwRect &rUnion = pUnion->GetUnion();
624 5 : const bool bLast = (i == aUnions.size() - 1);
625 :
626 5 : std::vector<SwCellFrm*> aCellArr;
627 5 : aCellArr.reserve( 255 );
628 5 : ::lcl_CollectCells( aCellArr, pUnion->GetUnion(), pTab );
629 :
630 : // All Cell Borders that match the UnionRect or extend it are
631 : // Outer Borders. All others are Inner Borders.
632 :
633 : // New: The Outer Borders can, depending on whether it's a
634 : // Start/Middle/Follow Table (for Selection via FollowTabs),
635 : // also not be Outer Borders.
636 : // Outer Borders are set on the left, right, at the top and at the bottom.
637 : // Inner Borders are only set at the top and on the left.
638 53 : for ( auto pCell : aCellArr )
639 : {
640 48 : const bool bVert = pTab->IsVertical();
641 48 : const bool bRTL = pTab->IsRightToLeft();
642 : bool bTopOver, bLeftOver, bRightOver, bBottomOver;
643 48 : if ( bVert )
644 : {
645 0 : bTopOver = pCell->Frm().Right() >= rUnion.Right();
646 0 : bLeftOver = pCell->Frm().Top() <= rUnion.Top();
647 0 : bRightOver = pCell->Frm().Bottom() >= rUnion.Bottom();
648 0 : bBottomOver = pCell->Frm().Left() <= rUnion.Left();
649 : }
650 : else
651 : {
652 48 : bTopOver = pCell->Frm().Top() <= rUnion.Top();
653 48 : bLeftOver = pCell->Frm().Left() <= rUnion.Left();
654 48 : bRightOver = pCell->Frm().Right() >= rUnion.Right();
655 48 : bBottomOver = pCell->Frm().Bottom() >= rUnion.Bottom();
656 : }
657 :
658 48 : if ( bRTL )
659 : {
660 0 : bool bTmp = bRightOver;
661 0 : bRightOver = bLeftOver;
662 0 : bLeftOver = bTmp;
663 : }
664 :
665 : // Do not set anything by default in HeadlineRepeats
666 48 : if ( pTab->IsFollow() &&
667 0 : ( pTab->IsInHeadline( *pCell ) ||
668 : // Same holds for follow flow rows
669 0 : pCell->IsInFollowFlowRow() ) )
670 0 : continue;
671 :
672 48 : SvxBoxItem aBox( pCell->GetFormat()->GetBox() );
673 :
674 48 : sal_Int16 nType = 0;
675 :
676 : // Top Border
677 48 : if( bTopValid )
678 : {
679 36 : if ( bFirst && bTopOver )
680 : {
681 12 : aBox.SetLine( pTop, SvxBoxItemLine::TOP );
682 12 : nType |= 0x0001;
683 : }
684 24 : else if ( bHoriValid )
685 : {
686 24 : aBox.SetLine( 0, SvxBoxItemLine::TOP );
687 24 : nType |= 0x0002;
688 : }
689 : }
690 :
691 : // Fix fdo#62470 correct the input for RTL table
692 48 : if (bRTL)
693 : {
694 0 : if( bLeftOver && bRightOver)
695 : {
696 0 : if ( bLeftValid )
697 : {
698 0 : aBox.SetLine( pLeft, SvxBoxItemLine::RIGHT );
699 0 : nType |= 0x0010;
700 : }
701 0 : if ( bRightValid )
702 : {
703 0 : aBox.SetLine( pRight, SvxBoxItemLine::LEFT );
704 0 : nType |= 0x0004;
705 : }
706 : }
707 : else
708 : {
709 0 : if ( bLeftValid )
710 : {
711 0 : aBox.SetLine( bRightOver ? pLeft : 0, SvxBoxItemLine::RIGHT );
712 0 : bVertValid ? nType |= 0x0020 : nType |= 0x0010;
713 : }
714 0 : if ( bLeftOver )
715 : {
716 0 : if ( bRightValid )
717 : {
718 0 : aBox.SetLine( pRight, SvxBoxItemLine::LEFT );
719 0 : nType |= 0x0004;
720 : }
721 : }
722 0 : else if ( bVertValid )
723 : {
724 0 : aBox.SetLine( pVert, SvxBoxItemLine::LEFT );
725 0 : nType |= 0x0008;
726 : }
727 : }
728 : }
729 : else
730 : {
731 : // Left Border
732 48 : if ( bLeftOver )
733 : {
734 18 : if( bLeftValid )
735 : {
736 12 : aBox.SetLine( pLeft, SvxBoxItemLine::LEFT );
737 12 : nType |= 0x0004;
738 : }
739 : }
740 30 : else if( bVertValid )
741 : {
742 24 : aBox.SetLine( pVert, SvxBoxItemLine::LEFT );
743 24 : nType |= 0x0008;
744 : }
745 :
746 : // Right Border
747 48 : if( bRightValid )
748 : {
749 36 : if ( bRightOver )
750 : {
751 12 : aBox.SetLine( pRight, SvxBoxItemLine::RIGHT );
752 12 : nType |= 0x0010;
753 : }
754 24 : else if ( bVertValid )
755 : {
756 24 : aBox.SetLine( 0, SvxBoxItemLine::RIGHT );
757 24 : nType |= 0x0020;
758 : }
759 : }
760 : }
761 :
762 : // Bottom Border
763 48 : if ( bLast && bBottomOver )
764 : {
765 28 : if( bBottomValid )
766 : {
767 12 : aBox.SetLine( pBottom, SvxBoxItemLine::BOTTOM );
768 12 : nType |= 0x0040;
769 : }
770 : }
771 34 : else if( bHoriValid )
772 : {
773 24 : aBox.SetLine( pHori, SvxBoxItemLine::BOTTOM );
774 24 : nType |= 0x0080;
775 : }
776 :
777 48 : if( pSetBox )
778 : {
779 240 : for( SvxBoxItemLine k : o3tl::enumrange<SvxBoxItemLine>() )
780 192 : aBox.SetDistance( pSetBox->GetDistance( k ), k );
781 : }
782 :
783 48 : SwTableBox *pBox = const_cast<SwTableBox*>(pCell->GetTabBox());
784 : SwFrameFormat *pNewFormat;
785 48 : if ( 0 != (pNewFormat = SwTableFormatCmp::FindNewFormat( aFormatCmp, pBox->GetFrameFormat(), nType )))
786 4 : pBox->ChgFrameFormat( static_cast<SwTableBoxFormat*>(pNewFormat) );
787 : else
788 : {
789 44 : SwFrameFormat *pOld = pBox->GetFrameFormat();
790 44 : SwFrameFormat *pNew = pBox->ClaimFrameFormat();
791 44 : pNew->SetFormatAttr( aBox );
792 44 : aFormatCmp.push_back( new SwTableFormatCmp( pOld, pNew, nType ) );
793 : }
794 48 : }
795 :
796 5 : bFirst = false;
797 5 : }
798 :
799 5 : SwHTMLTableLayout *pTableLayout = rTable.GetHTMLTableLayout();
800 5 : if( pTableLayout )
801 : {
802 0 : SwContentFrm* pFrm = rCursor.GetContentNode()->getLayoutFrm( rCursor.GetContentNode()->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout() );
803 0 : SwTabFrm* pTabFrm = pFrm->ImplFindTabFrm();
804 :
805 : pTableLayout->BordersChanged(
806 0 : pTableLayout->GetBrowseWidthByTabFrm( *pTabFrm ), true );
807 : }
808 5 : SwTableFormatCmp::Delete( aFormatCmp );
809 5 : ::ClearFEShellTabCols();
810 5 : getIDocumentState().SetModified();
811 5 : }
812 : }
813 :
814 0 : static void lcl_SetLineStyle( SvxBorderLine *pToSet,
815 : const Color *pColor, const SvxBorderLine *pBorderLine)
816 : {
817 0 : if ( pBorderLine )
818 : {
819 0 : if ( !pColor )
820 : {
821 0 : Color aTmp( pToSet->GetColor() );
822 0 : *pToSet = *pBorderLine;
823 0 : pToSet->SetColor( aTmp );
824 : }
825 : else
826 0 : *pToSet = *pBorderLine;
827 : }
828 0 : if ( pColor )
829 0 : pToSet->SetColor( *pColor );
830 0 : }
831 :
832 0 : void SwDoc::SetTabLineStyle( const SwCursor& rCursor,
833 : const Color* pColor, bool bSetLine,
834 : const SvxBorderLine* pBorderLine )
835 : {
836 0 : SwContentNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetContentNode();
837 0 : SwTableNode* pTableNd = pCntNd ? pCntNd->FindTableNode() : 0;
838 0 : if( !pTableNd )
839 0 : return ;
840 :
841 : SwLayoutFrm *pStart, *pEnd;
842 0 : ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
843 :
844 0 : SwSelUnions aUnions;
845 0 : ::MakeSelUnions( aUnions, pStart, pEnd );
846 :
847 0 : if( !aUnions.empty() )
848 : {
849 0 : SwTable& rTable = pTableNd->GetTable();
850 0 : if (GetIDocumentUndoRedo().DoesUndo())
851 : {
852 0 : GetIDocumentUndoRedo().AppendUndo(new SwUndoAttrTable(*pTableNd));
853 : }
854 :
855 0 : for( auto &rU : aUnions )
856 : {
857 0 : SwSelUnion *pUnion = &rU;
858 0 : SwTabFrm *pTab = pUnion->GetTable();
859 0 : std::vector<SwCellFrm*> aCellArr;
860 0 : aCellArr.reserve( 255 );
861 0 : ::lcl_CollectCells( aCellArr, pUnion->GetUnion(), pTab );
862 :
863 0 : for ( auto pCell : aCellArr )
864 : {
865 : // Do not set anything by default in HeadlineRepeats
866 0 : if ( pTab->IsFollow() && pTab->IsInHeadline( *pCell ) )
867 0 : continue;
868 :
869 0 : const_cast<SwTableBox*>(pCell->GetTabBox())->ClaimFrameFormat();
870 0 : SwFrameFormat *pFormat = pCell->GetFormat();
871 0 : SvxBoxItem aBox( pFormat->GetBox() );
872 :
873 0 : if ( !pBorderLine && bSetLine )
874 0 : aBox = *static_cast<const SvxBoxItem*>(::GetDfltAttr( RES_BOX ));
875 : else
876 : {
877 0 : if ( aBox.GetTop() )
878 0 : ::lcl_SetLineStyle( const_cast<SvxBorderLine*>(aBox.GetTop()),
879 0 : pColor, pBorderLine );
880 0 : if ( aBox.GetBottom() )
881 0 : ::lcl_SetLineStyle( const_cast<SvxBorderLine*>(aBox.GetBottom()),
882 0 : pColor, pBorderLine );
883 0 : if ( aBox.GetLeft() )
884 0 : ::lcl_SetLineStyle( const_cast<SvxBorderLine*>(aBox.GetLeft()),
885 0 : pColor, pBorderLine );
886 0 : if ( aBox.GetRight() )
887 0 : ::lcl_SetLineStyle( const_cast<SvxBorderLine*>(aBox.GetRight()),
888 0 : pColor, pBorderLine );
889 : }
890 0 : pFormat->SetFormatAttr( aBox );
891 0 : }
892 0 : }
893 :
894 0 : SwHTMLTableLayout *pTableLayout = rTable.GetHTMLTableLayout();
895 0 : if( pTableLayout )
896 : {
897 0 : SwContentFrm* pFrm = rCursor.GetContentNode()->getLayoutFrm( rCursor.GetContentNode()->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout() );
898 0 : SwTabFrm* pTabFrm = pFrm->ImplFindTabFrm();
899 :
900 : pTableLayout->BordersChanged(
901 0 : pTableLayout->GetBrowseWidthByTabFrm( *pTabFrm ), true );
902 : }
903 0 : ::ClearFEShellTabCols();
904 0 : getIDocumentState().SetModified();
905 0 : }
906 : }
907 :
908 26 : void SwDoc::GetTabBorders( const SwCursor& rCursor, SfxItemSet& rSet )
909 : {
910 26 : SwContentNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetContentNode();
911 26 : SwTableNode* pTableNd = pCntNd ? pCntNd->FindTableNode() : 0;
912 26 : if( !pTableNd )
913 26 : return ;
914 :
915 : SwLayoutFrm *pStart, *pEnd;
916 26 : ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
917 :
918 26 : SwSelUnions aUnions;
919 26 : ::MakeSelUnions( aUnions, pStart, pEnd );
920 :
921 26 : if( !aUnions.empty() )
922 : {
923 26 : SvxBoxItem aSetBox (static_cast<const SvxBoxItem &>( rSet.Get(RES_BOX )));
924 52 : SvxBoxInfoItem aSetBoxInfo(static_cast<const SvxBoxInfoItem&>( rSet.Get(SID_ATTR_BORDER_INNER)));
925 :
926 26 : bool bTopSet = false,
927 26 : bBottomSet = false,
928 26 : bLeftSet = false,
929 26 : bRightSet = false,
930 26 : bHoriSet = false,
931 26 : bVertSet = false,
932 26 : bDistanceSet = false,
933 26 : bRTLTab = false;
934 :
935 26 : aSetBoxInfo.ResetFlags();
936 :
937 52 : for ( SwSelUnions::size_type i = 0; i < aUnions.size(); ++i )
938 : {
939 26 : SwSelUnion *pUnion = &aUnions[i];
940 26 : const SwTabFrm *pTab = pUnion->GetTable();
941 26 : const SwRect &rUnion = pUnion->GetUnion();
942 26 : const bool bFirst = i == 0;
943 26 : const bool bLast = (i == aUnions.size() - 1);
944 :
945 26 : std::vector<SwCellFrm*> aCellArr;
946 26 : aCellArr.reserve(255);
947 26 : ::lcl_CollectCells( aCellArr, rUnion, const_cast<SwTabFrm*>(pTab) );
948 :
949 184 : for ( auto pCell : aCellArr )
950 : {
951 158 : const bool bVert = pTab->IsVertical();
952 158 : const bool bRTL = bRTLTab = pTab->IsRightToLeft();
953 : bool bTopOver, bLeftOver, bRightOver, bBottomOver;
954 158 : if ( bVert )
955 : {
956 0 : bTopOver = pCell->Frm().Right() >= rUnion.Right();
957 0 : bLeftOver = pCell->Frm().Top() <= rUnion.Top();
958 0 : bRightOver = pCell->Frm().Bottom() >= rUnion.Bottom();
959 0 : bBottomOver = pCell->Frm().Left() <= rUnion.Left();
960 : }
961 : else
962 : {
963 158 : bTopOver = pCell->Frm().Top() <= rUnion.Top();
964 158 : bLeftOver = pCell->Frm().Left() <= rUnion.Left();
965 158 : bRightOver = pCell->Frm().Right() >= rUnion.Right();
966 158 : bBottomOver = pCell->Frm().Bottom() >= rUnion.Bottom();
967 : }
968 :
969 158 : if ( bRTL )
970 : {
971 0 : bool bTmp = bRightOver;
972 0 : bRightOver = bLeftOver;
973 0 : bLeftOver = bTmp;
974 : }
975 :
976 158 : const SwFrameFormat *pFormat = pCell->GetFormat();
977 158 : const SvxBoxItem &rBox = pFormat->GetBox();
978 :
979 : // Top Border
980 158 : if ( bFirst && bTopOver )
981 : {
982 58 : if (aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::TOP))
983 : {
984 58 : if ( !bTopSet )
985 26 : { bTopSet = true;
986 26 : aSetBox.SetLine( rBox.GetTop(), SvxBoxItemLine::TOP );
987 : }
988 128 : else if ((aSetBox.GetTop() && rBox.GetTop() &&
989 96 : !(*aSetBox.GetTop() == *rBox.GetTop())) ||
990 32 : ((!aSetBox.GetTop()) != (!rBox.GetTop()))) // != expression is true, if one and only one of the two pointers is !0
991 : {
992 0 : aSetBoxInfo.SetValid(SvxBoxInfoItemValidFlags::TOP, false );
993 0 : aSetBox.SetLine( 0, SvxBoxItemLine::TOP );
994 : }
995 : }
996 : }
997 :
998 : // Left Border
999 158 : if ( bLeftOver )
1000 : {
1001 66 : if (aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::LEFT))
1002 : {
1003 66 : if ( !bLeftSet )
1004 26 : { bLeftSet = true;
1005 26 : aSetBox.SetLine( rBox.GetLeft(), SvxBoxItemLine::LEFT );
1006 : }
1007 160 : else if ((aSetBox.GetLeft() && rBox.GetLeft() &&
1008 120 : !(*aSetBox.GetLeft() == *rBox.GetLeft())) ||
1009 40 : ((!aSetBox.GetLeft()) != (!rBox.GetLeft())))
1010 : {
1011 0 : aSetBoxInfo.SetValid(SvxBoxInfoItemValidFlags::LEFT, false );
1012 0 : aSetBox.SetLine( 0, SvxBoxItemLine::LEFT );
1013 : }
1014 : }
1015 : }
1016 : else
1017 : {
1018 92 : if (aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::VERT))
1019 : {
1020 86 : if ( !bVertSet )
1021 22 : { bVertSet = true;
1022 22 : aSetBoxInfo.SetLine( rBox.GetLeft(), SvxBoxInfoItemLine::VERT );
1023 : }
1024 256 : else if ((aSetBoxInfo.GetVert() && rBox.GetLeft() &&
1025 190 : !(*aSetBoxInfo.GetVert() == *rBox.GetLeft())) ||
1026 62 : ((!aSetBoxInfo.GetVert()) != (!rBox.GetLeft())))
1027 2 : { aSetBoxInfo.SetValid( SvxBoxInfoItemValidFlags::VERT, false );
1028 2 : aSetBoxInfo.SetLine( 0, SvxBoxInfoItemLine::VERT );
1029 : }
1030 : }
1031 : }
1032 :
1033 : // Right Border
1034 158 : if ( aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::RIGHT) && bRightOver )
1035 : {
1036 66 : if ( !bRightSet )
1037 26 : { bRightSet = true;
1038 26 : aSetBox.SetLine( rBox.GetRight(), SvxBoxItemLine::RIGHT );
1039 : }
1040 160 : else if ((aSetBox.GetRight() && rBox.GetRight() &&
1041 120 : !(*aSetBox.GetRight() == *rBox.GetRight())) ||
1042 40 : (!aSetBox.GetRight() != !rBox.GetRight()))
1043 0 : { aSetBoxInfo.SetValid( SvxBoxInfoItemValidFlags::RIGHT, false );
1044 0 : aSetBox.SetLine( 0, SvxBoxItemLine::RIGHT );
1045 : }
1046 : }
1047 :
1048 : // Bottom Border
1049 158 : if ( bLast && bBottomOver )
1050 : {
1051 116 : if ( aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::BOTTOM) )
1052 : {
1053 57 : if ( !bBottomSet )
1054 26 : { bBottomSet = true;
1055 26 : aSetBox.SetLine( rBox.GetBottom(), SvxBoxItemLine::BOTTOM );
1056 : }
1057 124 : else if ((aSetBox.GetBottom() && rBox.GetBottom() &&
1058 92 : !(*aSetBox.GetBottom() == *rBox.GetBottom())) ||
1059 30 : (!aSetBox.GetBottom() != !rBox.GetBottom()))
1060 1 : { aSetBoxInfo.SetValid( SvxBoxInfoItemValidFlags::BOTTOM, false );
1061 1 : aSetBox.SetLine( 0, SvxBoxItemLine::BOTTOM );
1062 : }
1063 : }
1064 : }
1065 : // In all Lines, except for the last one, the horizontal Line
1066 : // is taken from the Bottom Line.
1067 : else
1068 : {
1069 100 : if (aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::HORI))
1070 : {
1071 92 : if ( !bHoriSet )
1072 22 : { bHoriSet = true;
1073 22 : aSetBoxInfo.SetLine( rBox.GetBottom(), SvxBoxInfoItemLine::HORI );
1074 : }
1075 280 : else if ((aSetBoxInfo.GetHori() && rBox.GetBottom() &&
1076 208 : !(*aSetBoxInfo.GetHori() == *rBox.GetBottom())) ||
1077 68 : ((!aSetBoxInfo.GetHori()) != (!rBox.GetBottom())))
1078 : {
1079 2 : aSetBoxInfo.SetValid( SvxBoxInfoItemValidFlags::HORI, false );
1080 2 : aSetBoxInfo.SetLine( 0, SvxBoxInfoItemLine::HORI );
1081 : }
1082 : }
1083 : }
1084 :
1085 : // Distance to text
1086 158 : if (aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::DISTANCE))
1087 : {
1088 158 : if( !bDistanceSet ) // Set on first iteration
1089 : {
1090 26 : bDistanceSet = true;
1091 130 : for( SvxBoxItemLine k : o3tl::enumrange<SvxBoxItemLine>() )
1092 104 : aSetBox.SetDistance( rBox.GetDistance( k ), k );
1093 : }
1094 : else
1095 : {
1096 660 : for( SvxBoxItemLine k : o3tl::enumrange<SvxBoxItemLine>() )
1097 1056 : if( aSetBox.GetDistance( k ) !=
1098 528 : rBox.GetDistance( k ) )
1099 : {
1100 0 : aSetBoxInfo.SetValid( SvxBoxInfoItemValidFlags::DISTANCE, false );
1101 0 : aSetBox.SetDistance( 0 );
1102 0 : break;
1103 : }
1104 : }
1105 : }
1106 : }
1107 26 : }
1108 :
1109 : // fdo#62470 fix the reading for table format.
1110 26 : if ( bRTLTab )
1111 : {
1112 0 : SvxBoxItem aTempBox (static_cast<const SvxBoxItem &>( rSet.Get(RES_BOX )));
1113 0 : SvxBoxInfoItem aTempBoxInfo(static_cast<const SvxBoxInfoItem&>( rSet.Get(SID_ATTR_BORDER_INNER)));
1114 :
1115 0 : aTempBox.SetLine( aSetBox.GetRight(), SvxBoxItemLine::RIGHT);
1116 0 : aSetBox.SetLine( aSetBox.GetLeft(), SvxBoxItemLine::RIGHT);
1117 0 : aSetBox.SetLine( aTempBox.GetRight(), SvxBoxItemLine::LEFT);
1118 :
1119 0 : aTempBoxInfo.SetValid( SvxBoxInfoItemValidFlags::LEFT, aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::LEFT) );
1120 0 : aSetBoxInfo.SetValid( SvxBoxInfoItemValidFlags::LEFT, aSetBoxInfo.IsValid(SvxBoxInfoItemValidFlags::RIGHT) );
1121 0 : aSetBoxInfo.SetValid( SvxBoxInfoItemValidFlags::RIGHT, aTempBoxInfo.IsValid(SvxBoxInfoItemValidFlags::LEFT) );
1122 : }
1123 :
1124 26 : rSet.Put( aSetBox );
1125 52 : rSet.Put( aSetBoxInfo );
1126 26 : }
1127 : }
1128 :
1129 1 : void SwDoc::SetBoxAttr( const SwCursor& rCursor, const SfxPoolItem &rNew )
1130 : {
1131 1 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
1132 1 : SwSelBoxes aBoxes;
1133 1 : if( pTableNd && ::lcl_GetBoxSel( rCursor, aBoxes, true ) )
1134 : {
1135 1 : SwTable& rTable = pTableNd->GetTable();
1136 1 : if (GetIDocumentUndoRedo().DoesUndo())
1137 : {
1138 1 : GetIDocumentUndoRedo().AppendUndo( new SwUndoAttrTable(*pTableNd) );
1139 : }
1140 :
1141 1 : std::vector<SwTableFormatCmp*> aFormatCmp;
1142 1 : aFormatCmp.reserve(std::max<size_t>(255, aBoxes.size()));
1143 2 : for (size_t i = 0; i < aBoxes.size(); ++i)
1144 : {
1145 1 : SwTableBox *pBox = aBoxes[i];
1146 :
1147 : SwFrameFormat *pNewFormat;
1148 1 : if ( 0 != (pNewFormat = SwTableFormatCmp::FindNewFormat( aFormatCmp, pBox->GetFrameFormat(), 0 )))
1149 0 : pBox->ChgFrameFormat( static_cast<SwTableBoxFormat*>(pNewFormat) );
1150 : else
1151 : {
1152 1 : SwFrameFormat *pOld = pBox->GetFrameFormat();
1153 1 : SwFrameFormat *pNew = pBox->ClaimFrameFormat();
1154 1 : pNew->SetFormatAttr( rNew );
1155 1 : aFormatCmp.push_back( new SwTableFormatCmp( pOld, pNew, 0 ) );
1156 : }
1157 : }
1158 :
1159 1 : SwHTMLTableLayout *pTableLayout = rTable.GetHTMLTableLayout();
1160 1 : if( pTableLayout )
1161 : {
1162 0 : SwContentFrm* pFrm = rCursor.GetContentNode()->getLayoutFrm( rCursor.GetContentNode()->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout() );
1163 0 : SwTabFrm* pTabFrm = pFrm->ImplFindTabFrm();
1164 :
1165 : pTableLayout->Resize(
1166 0 : pTableLayout->GetBrowseWidthByTabFrm( *pTabFrm ), true );
1167 : }
1168 1 : SwTableFormatCmp::Delete( aFormatCmp );
1169 1 : getIDocumentState().SetModified();
1170 1 : }
1171 1 : }
1172 :
1173 3 : bool SwDoc::GetBoxAttr( const SwCursor& rCursor, SfxPoolItem& rToFill )
1174 : {
1175 3 : bool bRet = false;
1176 3 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
1177 3 : SwSelBoxes aBoxes;
1178 3 : if( pTableNd && lcl_GetBoxSel( rCursor, aBoxes ))
1179 : {
1180 3 : bRet = true;
1181 3 : bool bOneFound = false;
1182 3 : const sal_uInt16 nWhich = rToFill.Which();
1183 15 : for (size_t i = 0; i < aBoxes.size(); ++i)
1184 : {
1185 12 : switch ( nWhich )
1186 : {
1187 : case RES_BACKGROUND:
1188 : {
1189 : SvxBrushItem aBack =
1190 12 : aBoxes[i]->GetFrameFormat()->makeBackgroundBrushItem();
1191 12 : if( !bOneFound )
1192 : {
1193 3 : static_cast<SvxBrushItem&>(rToFill) = aBack;
1194 3 : bOneFound = true;
1195 : }
1196 9 : else if( rToFill != aBack )
1197 0 : bRet = false;
1198 : }
1199 12 : break;
1200 :
1201 : case RES_FRAMEDIR:
1202 : {
1203 : const SvxFrameDirectionItem& rDir =
1204 0 : aBoxes[i]->GetFrameFormat()->GetFrmDir();
1205 0 : if( !bOneFound )
1206 : {
1207 0 : static_cast<SvxFrameDirectionItem&>(rToFill) = rDir;
1208 0 : bOneFound = true;
1209 : }
1210 0 : else if( rToFill != rDir )
1211 0 : bRet = false;
1212 : }
1213 : }
1214 :
1215 12 : if ( !bRet )
1216 0 : break;
1217 : }
1218 : }
1219 3 : return bRet;
1220 : }
1221 :
1222 0 : void SwDoc::SetBoxAlign( const SwCursor& rCursor, sal_uInt16 nAlign )
1223 : {
1224 : OSL_ENSURE( nAlign == text::VertOrientation::NONE ||
1225 : nAlign == text::VertOrientation::CENTER ||
1226 : nAlign == text::VertOrientation::BOTTOM, "Wrong alignment" );
1227 0 : SwFormatVertOrient aVertOri( 0, nAlign );
1228 0 : SetBoxAttr( rCursor, aVertOri );
1229 0 : }
1230 :
1231 12 : sal_uInt16 SwDoc::GetBoxAlign( const SwCursor& rCursor )
1232 : {
1233 12 : sal_uInt16 nAlign = USHRT_MAX;
1234 12 : SwTableNode* pTableNd = rCursor.GetPoint()->nNode.GetNode().FindTableNode();
1235 12 : SwSelBoxes aBoxes;
1236 12 : if( pTableNd && ::lcl_GetBoxSel( rCursor, aBoxes ))
1237 : {
1238 51 : for (size_t i = 0; i < aBoxes.size(); ++i)
1239 : {
1240 : const SwFormatVertOrient &rOri =
1241 39 : aBoxes[i]->GetFrameFormat()->GetVertOrient();
1242 39 : if( USHRT_MAX == nAlign )
1243 12 : nAlign = static_cast<sal_uInt16>(rOri.GetVertOrient());
1244 27 : else if( rOri.GetVertOrient() != nAlign )
1245 : {
1246 0 : nAlign = USHRT_MAX;
1247 0 : break;
1248 : }
1249 : }
1250 : }
1251 12 : return nAlign;
1252 : }
1253 :
1254 0 : static sal_uInt16 lcl_CalcCellFit( const SwLayoutFrm *pCell )
1255 : {
1256 0 : SwTwips nRet = 0;
1257 0 : const SwFrm *pFrm = pCell->Lower(); // The whole Line
1258 0 : SWRECTFN( pCell )
1259 0 : while ( pFrm )
1260 : {
1261 0 : const SwTwips nAdd = (pFrm->Frm().*fnRect->fnGetWidth)() -
1262 0 : (pFrm->Prt().*fnRect->fnGetWidth)();
1263 :
1264 : // pFrm does not necessarily have to be a SwTextFrm!
1265 0 : const SwTwips nCalcFitToContent = pFrm->IsTextFrm() ?
1266 : const_cast<SwTextFrm*>(static_cast<const SwTextFrm*>(pFrm))->CalcFitToContent() :
1267 0 : (pFrm->Prt().*fnRect->fnGetWidth)();
1268 :
1269 0 : nRet = std::max( nRet, nCalcFitToContent + nAdd );
1270 0 : pFrm = pFrm->GetNext();
1271 : }
1272 : // Surrounding border as well as left and Right Border also need to be respected
1273 0 : nRet += (pCell->Frm().*fnRect->fnGetWidth)() -
1274 0 : (pCell->Prt().*fnRect->fnGetWidth)();
1275 :
1276 : // To compensate for the accuracy of calculation later on in SwTable::SetTabCols
1277 : // we keep adding up a little.
1278 0 : nRet += COLFUZZY;
1279 0 : return (sal_uInt16)std::max( long(MINLAY), nRet );
1280 : }
1281 :
1282 : /* The Line is within the Selection but not outlined by the TabCols.
1283 : *
1284 : * That means that the Line has been "split" by other Cells due to the
1285 : * two-dimensional representation used. Thus, we have to distribute the cell's
1286 : * default or minium value amongst the Cell it has been split by.
1287 : *
1288 : * First, we collect the Columns (not the Column separators) which overlap
1289 : * with the Cell. We then distribute the desired value according to the
1290 : * amount of overlapping amongst the Cells.
1291 : *
1292 : * A Cell's default value stays the same if it already has a larger value than
1293 : * the desired one. It's overwritten if it's smaller.
1294 : */
1295 0 : static void lcl_CalcSubColValues( std::vector<sal_uInt16> &rToFill, const SwTabCols &rCols,
1296 : const SwLayoutFrm *pCell, const SwLayoutFrm *pTab,
1297 : bool bWishValues )
1298 : {
1299 : const sal_uInt16 nWish = bWishValues ?
1300 : ::lcl_CalcCellFit( pCell ) :
1301 0 : MINLAY + sal_uInt16(pCell->Frm().Width() - pCell->Prt().Width());
1302 :
1303 0 : SWRECTFN( pTab )
1304 :
1305 0 : for ( size_t i = 0 ; i <= rCols.Count(); ++i )
1306 : {
1307 0 : long nColLeft = i == 0 ? rCols.GetLeft() : rCols[i-1];
1308 0 : long nColRight = i == rCols.Count() ? rCols.GetRight() : rCols[i];
1309 0 : nColLeft += rCols.GetLeftMin();
1310 0 : nColRight += rCols.GetLeftMin();
1311 :
1312 : // Adapt values to the proportions of the Table (Follows)
1313 0 : if ( rCols.GetLeftMin() != (pTab->Frm().*fnRect->fnGetLeft)() )
1314 : {
1315 0 : const long nDiff = (pTab->Frm().*fnRect->fnGetLeft)() - rCols.GetLeftMin();
1316 0 : nColLeft += nDiff;
1317 0 : nColRight += nDiff;
1318 : }
1319 0 : const long nCellLeft = (pCell->Frm().*fnRect->fnGetLeft)();
1320 0 : const long nCellRight = (pCell->Frm().*fnRect->fnGetRight)();
1321 :
1322 : // Calculate overlapping value
1323 0 : long nWidth = 0;
1324 0 : if ( nColLeft <= nCellLeft && nColRight >= (nCellLeft+COLFUZZY) )
1325 0 : nWidth = nColRight - nCellLeft;
1326 0 : else if ( nColLeft <= (nCellRight-COLFUZZY) && nColRight >= nCellRight )
1327 0 : nWidth = nCellRight - nColLeft;
1328 0 : else if ( nColLeft >= nCellLeft && nColRight <= nCellRight )
1329 0 : nWidth = nColRight - nColLeft;
1330 0 : if ( nWidth && pCell->Frm().Width() )
1331 : {
1332 0 : long nTmp = nWidth * nWish / pCell->Frm().Width();
1333 0 : if ( sal_uInt16(nTmp) > rToFill[i] )
1334 0 : rToFill[i] = sal_uInt16(nTmp);
1335 : }
1336 : }
1337 0 : }
1338 :
1339 : /**
1340 : * Retrievs new values to set the TabCols.
1341 : *
1342 : * We do not iterate over the TabCols' entries, but over the gaps that describe Cells.
1343 : *
1344 : * @param bWishValues == true: We calculate the desired value of all affected
1345 : * Cells for the current Selection/current Cell.
1346 : * If more Cells are within a Column, the highest
1347 : * desired value is returned.
1348 : * We set TabCol entries for which we did not calculate
1349 : * Cells to 0.
1350 : *
1351 : * @param bWishValues == false: The Selection is expanded vertically.
1352 : * We calculate the minimum value for every
1353 : * Column in the TabCols that intersects with the
1354 : * Selection.
1355 : */
1356 0 : static void lcl_CalcColValues( std::vector<sal_uInt16> &rToFill, const SwTabCols &rCols,
1357 : const SwLayoutFrm *pStart, const SwLayoutFrm *pEnd,
1358 : bool bWishValues )
1359 : {
1360 0 : SwSelUnions aUnions;
1361 : ::MakeSelUnions( aUnions, pStart, pEnd,
1362 0 : bWishValues ? nsSwTableSearchType::TBLSEARCH_NONE : nsSwTableSearchType::TBLSEARCH_COL );
1363 :
1364 0 : for ( auto &rU : aUnions )
1365 : {
1366 0 : SwSelUnion *pSelUnion = &rU;
1367 0 : const SwTabFrm *pTab = pSelUnion->GetTable();
1368 0 : const SwRect &rUnion = pSelUnion->GetUnion();
1369 :
1370 0 : SWRECTFN( pTab )
1371 0 : bool bRTL = pTab->IsRightToLeft();
1372 :
1373 0 : const SwLayoutFrm *pCell = pTab->FirstCell();
1374 0 : if (!pCell)
1375 0 : continue;
1376 0 : do
1377 : {
1378 0 : if ( pCell->IsCellFrm() && pCell->FindTabFrm() == pTab && ::IsFrmInTableSel( rUnion, pCell ) )
1379 : {
1380 0 : const long nCLeft = (pCell->Frm().*fnRect->fnGetLeft)();
1381 0 : const long nCRight = (pCell->Frm().*fnRect->fnGetRight)();
1382 :
1383 0 : bool bNotInCols = true;
1384 :
1385 0 : for ( size_t i = 0; i <= rCols.Count(); ++i )
1386 : {
1387 0 : sal_uInt16 nFit = rToFill[i];
1388 0 : long nColLeft = i == 0 ? rCols.GetLeft() : rCols[i-1];
1389 0 : long nColRight = i == rCols.Count() ? rCols.GetRight() : rCols[i];
1390 :
1391 0 : if ( bRTL )
1392 : {
1393 0 : long nTmpRight = nColRight;
1394 0 : nColRight = rCols.GetRight() - nColLeft;
1395 0 : nColLeft = rCols.GetRight() - nTmpRight;
1396 : }
1397 :
1398 0 : nColLeft += rCols.GetLeftMin();
1399 0 : nColRight += rCols.GetLeftMin();
1400 :
1401 : // Adapt values to the proportions of the Table (Follows)
1402 0 : long nLeftA = nColLeft;
1403 0 : long nRightA = nColRight;
1404 0 : if ( rCols.GetLeftMin() != sal_uInt16((pTab->Frm().*fnRect->fnGetLeft)()) )
1405 : {
1406 0 : const long nDiff = (pTab->Frm().*fnRect->fnGetLeft)() - rCols.GetLeftMin();
1407 0 : nLeftA += nDiff;
1408 0 : nRightA += nDiff;
1409 : }
1410 :
1411 : // We don't want to take a too close look
1412 0 : if ( ::IsSame(nCLeft, nLeftA) && ::IsSame(nCRight, nRightA))
1413 : {
1414 0 : bNotInCols = false;
1415 0 : if ( bWishValues )
1416 : {
1417 0 : const sal_uInt16 nWish = ::lcl_CalcCellFit( pCell );
1418 0 : if ( nWish > nFit )
1419 0 : nFit = nWish;
1420 : }
1421 : else
1422 0 : { const sal_uInt16 nMin = MINLAY + sal_uInt16(pCell->Frm().Width() -
1423 0 : pCell->Prt().Width());
1424 0 : if ( !nFit || nMin < nFit )
1425 0 : nFit = nMin;
1426 : }
1427 0 : if ( rToFill[i] < nFit )
1428 0 : rToFill[i] = nFit;
1429 : }
1430 : }
1431 0 : if ( bNotInCols )
1432 0 : ::lcl_CalcSubColValues( rToFill, rCols, pCell, pTab, bWishValues );
1433 : }
1434 0 : do {
1435 0 : pCell = pCell->GetNextLayoutLeaf();
1436 0 : } while( pCell && pCell->Frm().Width() == 0 );
1437 0 : } while ( pCell && pTab->IsAnLower( pCell ) );
1438 0 : }
1439 0 : }
1440 :
1441 0 : void SwDoc::AdjustCellWidth( const SwCursor& rCursor, bool bBalance )
1442 : {
1443 : // Check whether the current Crsr has it's Point/Mark in a Table
1444 0 : SwContentNode* pCntNd = rCursor.GetPoint()->nNode.GetNode().GetContentNode();
1445 0 : SwTableNode* pTableNd = pCntNd ? pCntNd->FindTableNode() : 0;
1446 0 : if( !pTableNd )
1447 0 : return ;
1448 :
1449 : SwLayoutFrm *pStart, *pEnd;
1450 0 : ::lcl_GetStartEndCell( rCursor, pStart, pEnd );
1451 :
1452 : // Collect TabCols; we reset the Table with them
1453 0 : SwFrm* pBoxFrm = pStart;
1454 0 : while( pBoxFrm && !pBoxFrm->IsCellFrm() )
1455 0 : pBoxFrm = pBoxFrm->GetUpper();
1456 :
1457 0 : if ( !pBoxFrm )
1458 0 : return; // Robust
1459 :
1460 0 : SwTabCols aTabCols;
1461 0 : GetTabCols( aTabCols, 0, static_cast<SwCellFrm*>(pBoxFrm) );
1462 :
1463 0 : if ( ! aTabCols.Count() )
1464 0 : return;
1465 :
1466 0 : std::vector<sal_uInt16> aWish(aTabCols.Count() + 1);
1467 0 : std::vector<sal_uInt16> aMins(aTabCols.Count() + 1);
1468 :
1469 0 : ::lcl_CalcColValues( aWish, aTabCols, pStart, pEnd, true );
1470 :
1471 : // It's more robust if we calculate the minimum values for the whole Table
1472 0 : const SwTabFrm *pTab = pStart->ImplFindTabFrm();
1473 0 : pStart = const_cast<SwLayoutFrm*>(static_cast<SwLayoutFrm const *>(pTab->FirstCell()));
1474 0 : pEnd = const_cast<SwLayoutFrm*>(pTab->FindLastContent()->GetUpper());
1475 0 : while( !pEnd->IsCellFrm() )
1476 0 : pEnd = pEnd->GetUpper();
1477 0 : ::lcl_CalcColValues( aMins, aTabCols, pStart, pEnd, false );
1478 :
1479 0 : if( bBalance )
1480 : {
1481 : // All Columns, which are now selected, have a desired value.
1482 : // We add up the current values, divide the result by their
1483 : // count and get a desired value for balancing.
1484 0 : sal_uInt16 nWish = 0, nCnt = 0;
1485 0 : for ( size_t i = 0; i <= aTabCols.Count(); ++i )
1486 : {
1487 0 : int nDiff = aWish[i];
1488 0 : if ( nDiff )
1489 : {
1490 0 : if ( i == 0 )
1491 0 : nWish += aTabCols[i] - aTabCols.GetLeft();
1492 0 : else if ( i == aTabCols.Count() )
1493 0 : nWish += aTabCols.GetRight() - aTabCols[i-1];
1494 : else
1495 0 : nWish += aTabCols[i] - aTabCols[i-1];
1496 0 : ++nCnt;
1497 : }
1498 : }
1499 0 : nWish /= nCnt;
1500 0 : for ( size_t i = 0; i < aWish.size(); ++i )
1501 0 : if ( aWish[i] )
1502 0 : aWish[i] = nWish;
1503 : }
1504 :
1505 0 : const long nOldRight = aTabCols.GetRight();
1506 :
1507 : // In order to make the implementation easier, but still use the available
1508 : // space properly, we do this twice.
1509 :
1510 : // The problem: The first column is getting wider, the others get slimmer
1511 : // only afterwards.
1512 : // The first column's desired width would be discarded as it would cause
1513 : // the Table's width to exceed the maximum width.
1514 0 : for ( int k = 0; k < 2; ++k )
1515 : {
1516 0 : for ( size_t i = 0; i <= aTabCols.Count(); ++i )
1517 : {
1518 0 : int nDiff = aWish[i];
1519 0 : if ( nDiff )
1520 : {
1521 0 : int nMin = aMins[i];
1522 0 : if ( nMin > nDiff )
1523 0 : nDiff = nMin;
1524 :
1525 0 : if ( i == 0 )
1526 : {
1527 0 : if( aTabCols.Count() )
1528 0 : nDiff -= aTabCols[0] - aTabCols.GetLeft();
1529 : else
1530 0 : nDiff -= aTabCols.GetRight() - aTabCols.GetLeft();
1531 : }
1532 0 : else if ( i == aTabCols.Count() )
1533 0 : nDiff -= aTabCols.GetRight() - aTabCols[i-1];
1534 : else
1535 0 : nDiff -= aTabCols[i] - aTabCols[i-1];
1536 :
1537 0 : long nTabRight = aTabCols.GetRight() + nDiff;
1538 :
1539 : // If the Table would become too wide, we restrict the
1540 : // adjusted amount to the allowed maximum.
1541 0 : if ( !bBalance && nTabRight > aTabCols.GetRightMax() )
1542 : {
1543 0 : const long nTmpD = nTabRight - aTabCols.GetRightMax();
1544 0 : nDiff -= nTmpD;
1545 0 : nTabRight -= nTmpD;
1546 : }
1547 0 : for ( size_t i2 = i; i2 < aTabCols.Count(); ++i2 )
1548 0 : aTabCols[i2] += nDiff;
1549 0 : aTabCols.SetRight( nTabRight );
1550 : }
1551 : }
1552 : }
1553 :
1554 0 : const long nNewRight = aTabCols.GetRight();
1555 :
1556 0 : SwFrameFormat *pFormat = pTableNd->GetTable().GetFrameFormat();
1557 0 : const sal_Int16 nOriHori = pFormat->GetHoriOrient().GetHoriOrient();
1558 :
1559 : // We can leave the "real" work to the SwTable now
1560 0 : SetTabCols( aTabCols, false, 0, static_cast<SwCellFrm*>(pBoxFrm) );
1561 :
1562 : // Alignment might have been changed in SetTabCols; restore old value
1563 0 : const SwFormatHoriOrient &rHori = pFormat->GetHoriOrient();
1564 0 : SwFormatHoriOrient aHori( rHori );
1565 0 : if ( aHori.GetHoriOrient() != nOriHori )
1566 : {
1567 0 : aHori.SetHoriOrient( nOriHori );
1568 0 : pFormat->SetFormatAttr( aHori );
1569 : }
1570 :
1571 : // We switch to left-adjusted for automatic width
1572 : // We adjust the right border for Border attributes
1573 0 : if( !bBalance && nNewRight < nOldRight )
1574 : {
1575 0 : if( aHori.GetHoriOrient() == text::HoriOrientation::FULL )
1576 : {
1577 0 : aHori.SetHoriOrient( text::HoriOrientation::LEFT );
1578 0 : pFormat->SetFormatAttr( aHori );
1579 : }
1580 : }
1581 :
1582 0 : getIDocumentState().SetModified();
1583 177 : }
1584 :
1585 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
