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 <pagefrm.hxx>
21 : #include <rootfrm.hxx>
22 : #include <dcontact.hxx>
23 : #include <flyfrm.hxx>
24 : #include <txtfrm.hxx>
25 : #include <cellfrm.hxx>
26 : #include <swtable.hxx>
27 : #include <fmtfsize.hxx>
28 : #include <editeng/boxitem.hxx>
29 : #include <editeng/shaditem.hxx>
30 : #include <fmtclds.hxx>
31 : #include <viewimp.hxx>
32 : #include <sortedobjs.hxx>
33 : #include <hints.hxx>
34 :
35 : // No inline cause we need the function pointers
36 3812 : long SwFrm::GetTopMargin() const
37 3812 : { return Prt().Top(); }
38 104240 : long SwFrm::GetBottomMargin() const
39 104240 : { return Frm().Height() -Prt().Height() -Prt().Top(); }
40 246 : long SwFrm::GetLeftMargin() const
41 246 : { return Prt().Left(); }
42 164 : long SwFrm::GetRightMargin() const
43 164 : { return Frm().Width() - Prt().Width() - Prt().Left(); }
44 14386 : long SwFrm::GetPrtLeft() const
45 14386 : { return Frm().Left() + Prt().Left(); }
46 595134 : long SwFrm::GetPrtBottom() const
47 595134 : { return Frm().Top() + Prt().Height() + Prt().Top(); }
48 844 : long SwFrm::GetPrtRight() const
49 844 : { return Frm().Left() + Prt().Width() + Prt().Left(); }
50 95552 : long SwFrm::GetPrtTop() const
51 95552 : { return Frm().Top() + Prt().Top(); }
52 :
53 0 : bool SwFrm::SetMinLeft( long nDeadline )
54 : {
55 0 : SwTwips nDiff = nDeadline - Frm().Left();
56 0 : if( nDiff > 0 )
57 : {
58 0 : Frm().Left( nDeadline );
59 0 : Prt().Width( Prt().Width() - nDiff );
60 0 : return true;
61 : }
62 0 : return false;
63 : }
64 :
65 468 : bool SwFrm::SetMaxBottom( long nDeadline )
66 : {
67 468 : SwTwips nDiff = Frm().Top() + Frm().Height() - nDeadline;
68 468 : if( nDiff > 0 )
69 : {
70 0 : Frm().Height( Frm().Height() - nDiff );
71 0 : Prt().Height( Prt().Height() - nDiff );
72 0 : return true;
73 : }
74 468 : return false;
75 : }
76 :
77 0 : bool SwFrm::SetMinTop( long nDeadline )
78 : {
79 0 : SwTwips nDiff = nDeadline - Frm().Top();
80 0 : if( nDiff > 0 )
81 : {
82 0 : Frm().Top( nDeadline );
83 0 : Prt().Height( Prt().Height() - nDiff );
84 0 : return true;
85 : }
86 0 : return false;
87 : }
88 :
89 0 : bool SwFrm::SetMaxRight( long nDeadline )
90 : {
91 0 : SwTwips nDiff = Frm().Left() + Frm().Width() - nDeadline;
92 0 : if( nDiff > 0 )
93 : {
94 0 : Frm().Width( Frm().Width() - nDiff );
95 0 : Prt().Width( Prt().Width() - nDiff );
96 0 : return true;
97 : }
98 0 : return false;
99 : }
100 :
101 559 : void SwFrm::MakeBelowPos( const SwFrm* pUp, const SwFrm* pPrv, bool bNotify )
102 : {
103 559 : if( pPrv )
104 : {
105 251 : maFrm.Pos( pPrv->Frm().Pos() );
106 251 : maFrm.Pos().Y() += pPrv->Frm().Height();
107 : }
108 : else
109 : {
110 308 : maFrm.Pos( pUp->Frm().Pos() );
111 308 : maFrm.Pos() += pUp->Prt().Pos();
112 : }
113 559 : if( bNotify )
114 252 : maFrm.Pos().Y() += 1;
115 559 : }
116 :
117 0 : void SwFrm::MakeUpperPos( const SwFrm* pUp, const SwFrm* pPrv, bool bNotify )
118 : {
119 0 : if( pPrv )
120 : {
121 0 : maFrm.Pos( pPrv->Frm().Pos() );
122 0 : maFrm.Pos().Y() -= Frm().Height();
123 : }
124 : else
125 : {
126 0 : maFrm.Pos( pUp->Frm().Pos() );
127 0 : maFrm.Pos() += pUp->Prt().Pos();
128 0 : maFrm.Pos().Y() += pUp->Prt().Height() - maFrm.Height();
129 : }
130 0 : if( bNotify )
131 0 : maFrm.Pos().Y() -= 1;
132 0 : }
133 :
134 0 : void SwFrm::MakeLeftPos( const SwFrm* pUp, const SwFrm* pPrv, bool bNotify )
135 : {
136 0 : if( pPrv )
137 : {
138 0 : maFrm.Pos( pPrv->Frm().Pos() );
139 0 : maFrm.Pos().X() -= Frm().Width();
140 : }
141 : else
142 : {
143 0 : maFrm.Pos( pUp->Frm().Pos() );
144 0 : maFrm.Pos() += pUp->Prt().Pos();
145 0 : maFrm.Pos().X() += pUp->Prt().Width() - maFrm.Width();
146 : }
147 0 : if( bNotify )
148 0 : maFrm.Pos().X() -= 1;
149 0 : }
150 :
151 0 : void SwFrm::MakeRightPos( const SwFrm* pUp, const SwFrm* pPrv, bool bNotify )
152 : {
153 0 : if( pPrv )
154 : {
155 0 : maFrm.Pos( pPrv->Frm().Pos() );
156 0 : maFrm.Pos().X() += pPrv->Frm().Width();
157 : }
158 : else
159 : {
160 0 : maFrm.Pos( pUp->Frm().Pos() );
161 0 : maFrm.Pos() += pUp->Prt().Pos();
162 : }
163 0 : if( bNotify )
164 0 : maFrm.Pos().X() += 1;
165 0 : }
166 :
167 41790 : void SwFrm::SetTopBottomMargins( long nTop, long nBot )
168 : {
169 41790 : Prt().Top( nTop );
170 41790 : Prt().Height( Frm().Height() - nTop - nBot );
171 41790 : }
172 :
173 0 : void SwFrm::SetBottomTopMargins( long nBot, long nTop )
174 : {
175 0 : Prt().Top( nTop );
176 0 : Prt().Height( Frm().Height() - nTop - nBot );
177 0 : }
178 :
179 122503 : void SwFrm::SetLeftRightMargins( long nLeft, long nRight)
180 : {
181 122503 : Prt().Left( nLeft );
182 122503 : Prt().Width( Frm().Width() - nLeft - nRight );
183 122503 : }
184 :
185 2 : void SwFrm::SetRightLeftMargins( long nRight, long nLeft)
186 : {
187 2 : Prt().Left( nLeft );
188 2 : Prt().Width( Frm().Width() - nLeft - nRight );
189 2 : }
190 :
191 : /// checks the layout direction and invalidates the lower frames rekursivly, if necessary.
192 14094 : void SwFrm::CheckDirChange()
193 : {
194 14094 : bool bOldVert = GetVerticalFlag();
195 14094 : bool bOldRev = IsReverse();
196 14094 : bool bOldR2L = GetRightToLeftFlag();
197 14094 : SetInvalidVert( true );
198 14094 : SetInvalidR2L( true );
199 14094 : bool bChg = bOldR2L != IsRightToLeft();
200 14094 : bool bOldVertL2R = IsVertLR();
201 14094 : if( ( IsVertical() != bOldVert ) || bChg || IsReverse() != bOldRev || bOldVertL2R != IsVertLR() )
202 : {
203 66 : InvalidateAll();
204 66 : if( IsLayoutFrm() )
205 : {
206 : // set minimum row height for vertical cells in horizontal table:
207 60 : if ( IsCellFrm() && GetUpper() )
208 : {
209 36 : if ( IsVertical() != GetUpper()->IsVertical() &&
210 0 : static_cast<SwCellFrm*>(this)->GetTabBox()->getRowSpan() == 1 )
211 : {
212 : enum {
213 : MIN_VERT_CELL_HEIGHT = 1135
214 : };
215 :
216 0 : SwTableLine* pLine = const_cast<SwTableLine*>(static_cast<SwCellFrm*>(this)->GetTabBox()->GetUpper());
217 0 : SwFrameFormat* pFrameFormat = pLine->GetFrameFormat();
218 0 : SwFormatFrmSize aNew( pFrameFormat->GetFrmSize() );
219 0 : if ( ATT_FIX_SIZE != aNew.GetHeightSizeType() )
220 0 : aNew.SetHeightSizeType( ATT_MIN_SIZE );
221 0 : if ( aNew.GetHeight() < MIN_VERT_CELL_HEIGHT )
222 0 : aNew.SetHeight( MIN_VERT_CELL_HEIGHT );
223 0 : SwDoc* pDoc = pFrameFormat->GetDoc();
224 0 : pDoc->SetAttr( aNew, *pLine->ClaimFrameFormat() );
225 : }
226 : }
227 :
228 60 : SwFrm* pFrm = static_cast<SwLayoutFrm*>(this)->Lower();
229 60 : const SwFormatCol* pCol = NULL;
230 60 : SwLayoutFrm* pBody = 0;
231 60 : if( pFrm )
232 : {
233 60 : if( IsPageFrm() )
234 : {
235 : // If we're a page frame and we change our layout direction,
236 : // we have to look for columns and rearrange them.
237 0 : pBody = static_cast<SwPageFrm*>(this)->FindBodyCont();
238 0 : if(pBody && pBody->Lower() && pBody->Lower()->IsColumnFrm())
239 0 : pCol = &static_cast<SwPageFrm*>(this)->GetFormat()->GetCol();
240 : }
241 60 : else if( pFrm->IsColumnFrm() )
242 : {
243 0 : pBody = static_cast<SwLayoutFrm*>(this);
244 0 : const SwFrameFormat *pFormat = pBody->GetFormat();
245 0 : if( pFormat )
246 0 : pCol = &pFormat->GetCol();
247 : }
248 : }
249 207 : while( pFrm )
250 : {
251 87 : pFrm->CheckDirChange();
252 87 : pFrm = pFrm->GetNext();
253 : }
254 60 : if( pCol )
255 0 : pBody->AdjustColumns( pCol, true );
256 : }
257 6 : else if( IsTextFrm() )
258 6 : static_cast<SwTextFrm*>(this)->Prepare( PREP_CLEAR );
259 :
260 : // #i31698# - notify anchored objects also for page frames.
261 : // Remove code above for special handling of page frames
262 66 : if ( GetDrawObjs() )
263 : {
264 0 : const SwSortedObjs *pObjs = GetDrawObjs();
265 0 : const size_t nCnt = pObjs->size();
266 0 : for ( size_t i = 0; i < nCnt; ++i )
267 : {
268 0 : SwAnchoredObject* pAnchoredObj = (*pObjs)[i];
269 0 : if( pAnchoredObj->ISA(SwFlyFrm) )
270 0 : static_cast<SwFlyFrm*>(pAnchoredObj)->CheckDirChange();
271 : else
272 : {
273 : // OD 2004-04-06 #i26791# - direct object
274 : // positioning no longer needed. Instead
275 : // invalidate
276 0 : pAnchoredObj->InvalidateObjPos();
277 : }
278 : // #i31698# - update layout direction of
279 : // anchored object
280 : {
281 0 : ::setContextWritingMode( pAnchoredObj->DrawObj(), pAnchoredObj->GetAnchorFrmContainingAnchPos() );
282 0 : pAnchoredObj->UpdateLayoutDir();
283 : }
284 : }
285 : }
286 : }
287 14094 : }
288 :
289 : /// returns the position for anchors based on frame direction
290 : // OD 2004-03-10 #i11860# - consider lower space and line spacing of
291 : // previous frame according to new option 'Use former object positioning'
292 2199 : Point SwFrm::GetFrmAnchorPos( bool bIgnoreFlysAnchoredAtThisFrame ) const
293 : {
294 2199 : Point aAnchor = Frm().Pos();
295 :
296 2199 : if ( ( IsVertical() && !IsVertLR() ) || IsRightToLeft() )
297 0 : aAnchor.X() += Frm().Width();
298 :
299 2199 : if ( IsTextFrm() )
300 : {
301 : SwTwips nBaseOfstForFly =
302 2142 : static_cast<const SwTextFrm*>(this)->GetBaseOfstForFly( bIgnoreFlysAnchoredAtThisFrame );
303 2142 : if ( IsVertical() )
304 0 : aAnchor.Y() += nBaseOfstForFly;
305 : else
306 2142 : aAnchor.X() += nBaseOfstForFly;
307 :
308 : // OD 2004-03-10 #i11860# - if option 'Use former object positioning'
309 : // is OFF, consider the lower space and the line spacing of the
310 : // previous frame and the spacing considered for the page grid
311 2142 : const SwTextFrm* pThisTextFrm = static_cast<const SwTextFrm*>(this);
312 : const SwTwips nUpperSpaceAmountConsideredForPrevFrmAndPageGrid =
313 2142 : pThisTextFrm->GetUpperSpaceAmountConsideredForPrevFrmAndPageGrid();
314 2142 : if ( IsVertical() )
315 : {
316 0 : aAnchor.X() -= nUpperSpaceAmountConsideredForPrevFrmAndPageGrid;
317 : }
318 : else
319 : {
320 2142 : aAnchor.Y() += nUpperSpaceAmountConsideredForPrevFrmAndPageGrid;
321 : }
322 : }
323 :
324 2199 : return aAnchor;
325 : }
326 :
327 69905 : void SwFrm::DestroyImpl()
328 : {
329 69905 : mbInDtor = true;
330 :
331 : // accessible objects for fly and cell frames have been already disposed
332 : // by the destructors of the derived classes.
333 69905 : if( IsAccessibleFrm() && !(IsFlyFrm() || IsCellFrm()) && GetDep() )
334 : {
335 46519 : SwRootFrm *pRootFrm = getRootFrm();
336 46519 : if( pRootFrm && pRootFrm->IsAnyShellAccessible() )
337 : {
338 0 : SwViewShell *pVSh = pRootFrm->GetCurrShell();
339 0 : if( pVSh && pVSh->Imp() )
340 : {
341 : OSL_ENSURE( !GetLower(), "Lowers should be dispose already!" );
342 0 : pVSh->Imp()->DisposeAccessibleFrm( this );
343 : }
344 : }
345 : }
346 :
347 69905 : if( mpDrawObjs )
348 : {
349 508 : for ( size_t i = mpDrawObjs->size(); i; )
350 : {
351 184 : SwAnchoredObject* pAnchoredObj = (*mpDrawObjs)[--i];
352 184 : if ( pAnchoredObj->ISA(SwFlyFrm) )
353 : {
354 73 : SwFrm::DestroyFrm(static_cast<SwFlyFrm*>(pAnchoredObj));
355 : }
356 : else
357 : {
358 111 : SdrObject* pSdrObj = pAnchoredObj->DrawObj();
359 : SwDrawContact* pContact =
360 111 : static_cast<SwDrawContact*>(pSdrObj->GetUserCall());
361 : OSL_ENSURE( pContact,
362 : "<SwFrm::~SwFrm> - missing contact for drawing object" );
363 111 : if ( pContact )
364 : {
365 111 : pContact->DisconnectObjFromLayout( pSdrObj );
366 : }
367 : }
368 : }
369 162 : delete mpDrawObjs;
370 162 : mpDrawObjs = 0;
371 : }
372 69905 : }
373 :
374 69905 : SwFrm::~SwFrm()
375 : {
376 : assert(m_isInDestroy); // check that only DestroySwFrm does "delete"
377 : #if OSL_DEBUG_LEVEL > 0
378 : // JP 15.10.2001: for detection of access to deleted frames
379 : mpDrawObjs = reinterpret_cast<SwSortedObjs*>(0x33333333);
380 : #endif
381 69905 : }
382 :
383 69905 : void SwFrm::DestroyFrm(SwFrm *const pFrm)
384 : {
385 69905 : if (pFrm)
386 : {
387 69905 : pFrm->m_isInDestroy = true;
388 69905 : pFrm->DestroyImpl();
389 : assert(pFrm->mbInDtor); // check that nobody forgot to call base class
390 69905 : delete pFrm;
391 : }
392 69905 : }
393 :
394 1538180 : const SwFrameFormat * SwLayoutFrm::GetFormat() const
395 : {
396 1538180 : return static_cast< const SwFrameFormat * >( GetDep() );
397 : }
398 :
399 27545743 : SwFrameFormat * SwLayoutFrm::GetFormat()
400 : {
401 27545743 : return static_cast< SwFrameFormat * >( GetDep() );
402 : }
403 :
404 111 : void SwLayoutFrm::SetFrameFormat( SwFrameFormat *pNew )
405 : {
406 111 : if ( pNew != GetFormat() )
407 : {
408 111 : SwFormatChg aOldFormat( GetFormat() );
409 111 : pNew->Add( this );
410 222 : SwFormatChg aNewFormat( pNew );
411 222 : ModifyNotification( &aOldFormat, &aNewFormat );
412 : }
413 111 : }
414 :
415 38006 : SwContentFrm::SwContentFrm( SwContentNode * const pContent, SwFrm* pSib ) :
416 : SwFrm( pContent, pSib ),
417 38006 : SwFlowFrm( (SwFrm&)*this )
418 : {
419 38006 : }
420 :
421 37180 : void SwContentFrm::DestroyImpl()
422 : {
423 : const SwContentNode* pCNd;
424 74360 : if( 0 != ( pCNd = PTR_CAST( SwContentNode, GetRegisteredIn() )) &&
425 37180 : !pCNd->GetDoc()->IsInDtor() )
426 : {
427 : //Unregister from root if I'm still in turbo there.
428 37180 : SwRootFrm *pRoot = getRootFrm();
429 37180 : if( pRoot && pRoot->GetTurbo() == this )
430 : {
431 0 : pRoot->DisallowTurbo();
432 0 : pRoot->ResetTurbo();
433 : }
434 : }
435 :
436 37180 : SwFrm::DestroyImpl();
437 37180 : }
438 :
439 37180 : SwContentFrm::~SwContentFrm()
440 : {
441 37180 : }
442 :
443 54 : void SwContentFrm::RegisterToNode( SwContentNode& rNode )
444 : {
445 54 : rNode.Add( this );
446 54 : }
447 :
448 32725 : void SwLayoutFrm::DestroyImpl()
449 : {
450 65450 : while (!m_VertPosOrientFrmsFor.empty())
451 : {
452 0 : SwAnchoredObject *pObj = *m_VertPosOrientFrmsFor.begin();
453 0 : pObj->ClearVertPosOrientFrm();
454 : }
455 :
456 : assert(m_VertPosOrientFrmsFor.empty());
457 :
458 32725 : SwFrm *pFrm = m_pLower;
459 :
460 32725 : if( GetFormat() && !GetFormat()->GetDoc()->IsInDtor() )
461 : {
462 77024 : while ( pFrm )
463 : {
464 : //First delete the Objs of the Frm because they can't unregister
465 : //from the page after remove.
466 : //We don't want to create an endless loop only because one couldn't
467 : //unregister.
468 :
469 81442 : while ( pFrm->GetDrawObjs() && pFrm->GetDrawObjs()->size() )
470 : {
471 3518 : const size_t nCnt = pFrm->GetDrawObjs()->size();
472 : // #i28701#
473 3518 : SwAnchoredObject* pAnchoredObj = (*pFrm->GetDrawObjs())[0];
474 3518 : if ( pAnchoredObj->ISA(SwFlyFrm) )
475 : {
476 1846 : SwFrm::DestroyFrm(static_cast<SwFlyFrm*>(pAnchoredObj));
477 : assert(!pFrm->GetDrawObjs() || nCnt > pFrm->GetDrawObjs()->size());
478 : }
479 : else
480 : {
481 1672 : SdrObject* pSdrObj = pAnchoredObj->DrawObj();
482 : SwDrawContact* pContact =
483 1672 : static_cast<SwDrawContact*>(pSdrObj->GetUserCall());
484 : OSL_ENSURE( pContact,
485 : "<SwFrm::~SwFrm> - missing contact for drawing object" );
486 1672 : if ( pContact )
487 : {
488 1672 : pContact->DisconnectObjFromLayout( pSdrObj );
489 : }
490 :
491 2354 : if ( pFrm->GetDrawObjs() &&
492 682 : nCnt == pFrm->GetDrawObjs()->size() )
493 : {
494 0 : pFrm->GetDrawObjs()->Remove( *pAnchoredObj );
495 : }
496 : }
497 : }
498 38962 : pFrm->RemoveFromLayout();
499 38962 : SwFrm::DestroyFrm(pFrm);
500 38962 : pFrm = m_pLower;
501 : }
502 : //Delete the Flys, the last one also deletes the array.
503 38080 : while ( GetDrawObjs() && GetDrawObjs()->size() )
504 : {
505 18 : const size_t nCnt = GetDrawObjs()->size();
506 :
507 : // #i28701#
508 18 : SwAnchoredObject* pAnchoredObj = (*GetDrawObjs())[0];
509 18 : if ( pAnchoredObj->ISA(SwFlyFrm) )
510 : {
511 0 : SwFrm::DestroyFrm(static_cast<SwFlyFrm*>(pAnchoredObj));
512 : assert(!GetDrawObjs() || nCnt > GetDrawObjs()->size());
513 : }
514 : else
515 : {
516 18 : SdrObject* pSdrObj = pAnchoredObj->DrawObj();
517 : SwDrawContact* pContact =
518 18 : static_cast<SwDrawContact*>(pSdrObj->GetUserCall());
519 : OSL_ENSURE( pContact,
520 : "<SwFrm::~SwFrm> - missing contact for drawing object" );
521 18 : if ( pContact )
522 : {
523 18 : pContact->DisconnectObjFromLayout( pSdrObj );
524 : }
525 :
526 18 : if ( GetDrawObjs() && nCnt == GetDrawObjs()->size() )
527 : {
528 0 : GetDrawObjs()->Remove( *pAnchoredObj );
529 : }
530 : }
531 : }
532 : }
533 : else
534 : {
535 48913 : while( pFrm )
536 : {
537 21525 : SwFrm *pNxt = pFrm->GetNext();
538 21525 : SwFrm::DestroyFrm(pFrm);
539 21525 : pFrm = pNxt;
540 : }
541 : }
542 :
543 32725 : SwFrm::DestroyImpl();
544 32725 : }
545 :
546 32725 : SwLayoutFrm::~SwLayoutFrm()
547 : {
548 32725 : }
549 :
550 : /**
551 : |* The paintarea is the area, in which the content of a frame is allowed
552 : |* to be displayed. This region could be larger than the printarea (Prt())
553 : |* of the upper, it includes e.g. often the margin of the page.
554 : |*/
555 141210 : const SwRect SwFrm::PaintArea() const
556 : {
557 : // NEW TABLES
558 : // Cell frames may not leave their upper:
559 141210 : SwRect aRect = IsRowFrm() ? GetUpper()->Frm() : Frm();
560 141210 : const bool bVert = IsVertical();
561 141210 : SwRectFn fnRect = bVert ? ( IsVertLR() ? fnRectVertL2R : fnRectVert ) : fnRectHori;
562 141210 : long nRight = (aRect.*fnRect->fnGetRight)();
563 141210 : long nLeft = (aRect.*fnRect->fnGetLeft)();
564 141210 : const SwFrm* pTmp = this;
565 141210 : bool bLeft = true;
566 141210 : bool bRight = true;
567 141210 : long nRowSpan = 0;
568 625149 : while( pTmp )
569 : {
570 527570 : if( pTmp->IsCellFrm() && pTmp->GetUpper() &&
571 43631 : pTmp->GetUpper()->IsVertical() != pTmp->IsVertical() )
572 0 : nRowSpan = static_cast<const SwCellFrm*>(pTmp)->GetTabBox()->getRowSpan();
573 483939 : long nTmpRight = (pTmp->Frm().*fnRect->fnGetRight)();
574 483939 : long nTmpLeft = (pTmp->Frm().*fnRect->fnGetLeft)();
575 483939 : if( pTmp->IsRowFrm() && nRowSpan > 1 )
576 : {
577 0 : const SwFrm* pNxt = pTmp;
578 0 : while( --nRowSpan > 0 && pNxt->GetNext() )
579 0 : pNxt = pNxt->GetNext();
580 0 : if( pTmp->IsVertical() )
581 0 : nTmpLeft = (pNxt->Frm().*fnRect->fnGetLeft)();
582 : else
583 0 : nTmpRight = (pNxt->Frm().*fnRect->fnGetRight)();
584 : }
585 : OSL_ENSURE( pTmp, "PaintArea lost in time and space" );
586 1658487 : if( pTmp->IsPageFrm() || pTmp->IsFlyFrm() ||
587 1373311 : pTmp->IsCellFrm() || pTmp->IsRowFrm() || //nobody leaves a table!
588 247545 : pTmp->IsRootFrm() )
589 : {
590 236394 : if( bLeft || nLeft < nTmpLeft )
591 141303 : nLeft = nTmpLeft;
592 236394 : if( bRight || nTmpRight < nRight )
593 141567 : nRight = nTmpRight;
594 236394 : if( pTmp->IsPageFrm() || pTmp->IsFlyFrm() || pTmp->IsRootFrm() )
595 141210 : break;
596 95184 : bLeft = false;
597 95184 : bRight = false;
598 : }
599 247545 : else if( pTmp->IsColumnFrm() ) // nobody enters neightbour columns
600 : {
601 1048 : bool bR2L = pTmp->IsRightToLeft();
602 : // the first column has _no_ influence to the left range
603 1048 : if( bR2L ? pTmp->GetNext() : pTmp->GetPrev() )
604 : {
605 507 : if( bLeft || nLeft < nTmpLeft )
606 507 : nLeft = nTmpLeft;
607 507 : bLeft = false;
608 : }
609 : // the last column has _no_ influence to the right range
610 1048 : if( bR2L ? pTmp->GetPrev() : pTmp->GetNext() )
611 : {
612 690 : if( bRight || nTmpRight < nRight )
613 690 : nRight = nTmpRight;
614 690 : bRight = false;
615 : }
616 : }
617 246497 : else if( bVert && pTmp->IsBodyFrm() )
618 : {
619 : // Header and footer frames have always horizontal direction and
620 : // limit the body frame.
621 : // A previous frame of a body frame must be a header,
622 : // the next frame of a body frame may be a footnotecontainer or
623 : // a footer. The footnotecontainer has the same direction like
624 : // the body frame.
625 0 : if( pTmp->GetPrev() && ( bLeft || nLeft < nTmpLeft ) )
626 : {
627 0 : nLeft = nTmpLeft;
628 0 : bLeft = false;
629 : }
630 0 : if( pTmp->GetNext() &&
631 0 : ( pTmp->GetNext()->IsFooterFrm() || pTmp->GetNext()->GetNext() )
632 0 : && ( bRight || nTmpRight < nRight ) )
633 : {
634 0 : nRight = nTmpRight;
635 0 : bRight = false;
636 : }
637 : }
638 342729 : pTmp = pTmp->GetUpper();
639 : }
640 141210 : (aRect.*fnRect->fnSetLeft)( nLeft );
641 141210 : (aRect.*fnRect->fnSetRight)( nRight );
642 141210 : return aRect;
643 : }
644 :
645 : /**
646 : |* The unionframe is the framearea (Frm()) of a frame expanded by the
647 : |* printarea, if there's a negative margin at the left or right side.
648 : |*/
649 42225 : const SwRect SwFrm::UnionFrm( bool bBorder ) const
650 : {
651 42225 : bool bVert = IsVertical();
652 42225 : SwRectFn fnRect = bVert ? ( IsVertLR() ? fnRectVertL2R : fnRectVert ) : fnRectHori;
653 42225 : long nLeft = (Frm().*fnRect->fnGetLeft)();
654 42225 : long nWidth = (Frm().*fnRect->fnGetWidth)();
655 42225 : long nPrtLeft = (Prt().*fnRect->fnGetLeft)();
656 42225 : long nPrtWidth = (Prt().*fnRect->fnGetWidth)();
657 42225 : if( nPrtLeft + nPrtWidth > nWidth )
658 1 : nWidth = nPrtLeft + nPrtWidth;
659 42225 : if( nPrtLeft < 0 )
660 : {
661 38 : nLeft += nPrtLeft;
662 38 : nWidth -= nPrtLeft;
663 : }
664 42225 : SwTwips nRight = nLeft + nWidth;
665 42225 : long nAdd = 0;
666 42225 : if( bBorder )
667 : {
668 27185 : SwBorderAttrAccess aAccess( SwFrm::GetCache(), this );
669 27185 : const SwBorderAttrs &rAttrs = *aAccess.Get();
670 27185 : const SvxBoxItem &rBox = rAttrs.GetBox();
671 27185 : if ( rBox.GetLeft() )
672 23 : nLeft -= rBox.CalcLineSpace( SvxBoxItemLine::LEFT );
673 27162 : else if ( rAttrs.IsBorderDist() )
674 0 : nLeft -= rBox.GetDistance( SvxBoxItemLine::LEFT ) + 1;
675 27185 : if ( rBox.GetRight() )
676 23 : nAdd += rBox.CalcLineSpace( SvxBoxItemLine::RIGHT );
677 27162 : else if ( rAttrs.IsBorderDist() )
678 0 : nAdd += rBox.GetDistance( SvxBoxItemLine::RIGHT ) + 1;
679 27185 : if( rAttrs.GetShadow().GetLocation() != SVX_SHADOW_NONE )
680 : {
681 0 : const SvxShadowItem &rShadow = rAttrs.GetShadow();
682 0 : nLeft -= rShadow.CalcShadowSpace( SvxShadowItemSide::LEFT );
683 0 : nAdd += rShadow.CalcShadowSpace( SvxShadowItemSide::RIGHT );
684 27185 : }
685 : }
686 42225 : if( IsTextFrm() && static_cast<const SwTextFrm*>(this)->HasPara() )
687 : {
688 29884 : long nTmp = static_cast<const SwTextFrm*>(this)->HangingMargin();
689 29884 : if( nTmp > nAdd )
690 0 : nAdd = nTmp;
691 : }
692 42225 : nWidth = nRight + nAdd - nLeft;
693 42225 : SwRect aRet( Frm() );
694 42225 : (aRet.*fnRect->fnSetPosX)( nLeft );
695 42225 : (aRet.*fnRect->fnSetWidth)( nWidth );
696 42225 : return aRet;
697 177 : }
698 :
699 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
