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