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 <svl/itemiter.hxx>
21 : #include <svtools/imap.hxx>
22 : #include <tools/helpers.hxx>
23 : #include <editeng/protitem.hxx>
24 : #include <editeng/opaqitem.hxx>
25 : #include <editeng/ulspitem.hxx>
26 : #include <editeng/frmdiritem.hxx>
27 : #include <drawdoc.hxx>
28 : #include <fmtfsize.hxx>
29 : #include <fmtclds.hxx>
30 : #include <fmtcntnt.hxx>
31 : #include <fmturl.hxx>
32 : #include <fmtsrnd.hxx>
33 : #include <fmtornt.hxx>
34 : #include <fmtcnct.hxx>
35 : #include <layhelp.hxx>
36 : #include <ndgrf.hxx>
37 : #include <tolayoutanchoredobjectposition.hxx>
38 : #include <fmtfollowtextflow.hxx>
39 : #include <sortedobjs.hxx>
40 : #include <objectformatter.hxx>
41 : #include <ndole.hxx>
42 : #include <swtable.hxx>
43 : #include <svx/svdpage.hxx>
44 : #include <svx/svdoashp.hxx>
45 : #include "layouter.hxx"
46 : #include "pagefrm.hxx"
47 : #include "rootfrm.hxx"
48 : #include "viewimp.hxx"
49 : #include "viewopt.hxx"
50 : #include "dcontact.hxx"
51 : #include "dflyobj.hxx"
52 : #include "dview.hxx"
53 : #include "frmtool.hxx"
54 : #include "hints.hxx"
55 : #include "tabfrm.hxx"
56 : #include "txtfrm.hxx"
57 : #include "notxtfrm.hxx"
58 : #include "flyfrms.hxx"
59 : #include "sectfrm.hxx"
60 : #include <vcl/svapp.hxx>
61 : #include "switerator.hxx"
62 : #include <IDocumentSettingAccess.hxx>
63 : #include <IDocumentLayoutAccess.hxx>
64 : #include <textboxhelper.hxx>
65 : #include <txtfly.hxx>
66 :
67 : using namespace ::com::sun::star;
68 :
69 2249781 : TYPEINIT2(SwFlyFrm,SwLayoutFrm,SwAnchoredObject);
70 :
71 3800 : SwFlyFrm::SwFlyFrm( SwFlyFrmFmt *pFmt, SwFrm* pSib, SwFrm *pAnch ) :
72 : SwLayoutFrm( pFmt, pSib ),
73 : SwAnchoredObject(), // #i26791#
74 : pPrevLink( 0 ),
75 : pNextLink( 0 ),
76 : bInCnt( false ),
77 : bAtCnt( false ),
78 : bLayout( false ),
79 : bAutoPosition( false ),
80 : bNoShrink( false ),
81 : bLockDeleteContent( false ),
82 3800 : m_bValidContentPos( false )
83 : {
84 3800 : mnType = FRMC_FLY;
85 :
86 3800 : bInvalid = bNotifyBack = true;
87 : bLocked = bMinHeight =
88 3800 : bHeightClipped = bWidthClipped = bFormatHeightOnly = false;
89 :
90 : // Size setting: Fixed size is always the width
91 3800 : const SwFmtFrmSize &rFrmSize = pFmt->GetFrmSize();
92 : sal_uInt16 nDir =
93 3800 : ((SvxFrameDirectionItem&)pFmt->GetFmtAttr( RES_FRAMEDIR )).GetValue();
94 3800 : if( FRMDIR_ENVIRONMENT == nDir )
95 : {
96 3706 : mbDerivedVert = true;
97 3706 : mbDerivedR2L = true;
98 : }
99 : else
100 : {
101 94 : mbInvalidVert = false;
102 94 : mbDerivedVert = false;
103 94 : mbDerivedR2L = false;
104 94 : if( FRMDIR_HORI_LEFT_TOP == nDir || FRMDIR_HORI_RIGHT_TOP == nDir )
105 : {
106 92 : mbVertLR = false;
107 92 : mbVertical = false;
108 : }
109 : else
110 : {
111 2 : const SwViewShell *pSh = getRootFrm() ? getRootFrm()->GetCurrShell() : 0;
112 2 : if( pSh && pSh->GetViewOptions()->getBrowseMode() )
113 : {
114 0 : mbVertLR = false;
115 0 : mbVertical = false;
116 : }
117 : else
118 : {
119 2 : mbVertical = true;
120 :
121 2 : if ( FRMDIR_VERT_TOP_LEFT == nDir )
122 0 : mbVertLR = true;
123 : else
124 2 : mbVertLR = false;
125 : }
126 : }
127 :
128 94 : mbInvalidR2L = false;
129 94 : if( FRMDIR_HORI_RIGHT_TOP == nDir )
130 0 : mbRightToLeft = true;
131 : else
132 94 : mbRightToLeft = false;
133 : }
134 :
135 3800 : Frm().Width( rFrmSize.GetWidth() );
136 3800 : Frm().Height( rFrmSize.GetHeightSizeType() == ATT_VAR_SIZE ? MINFLY : rFrmSize.GetHeight() );
137 :
138 : // Fixed or variable Height?
139 3800 : if ( rFrmSize.GetHeightSizeType() == ATT_MIN_SIZE )
140 110 : bMinHeight = true;
141 3690 : else if ( rFrmSize.GetHeightSizeType() == ATT_FIX_SIZE )
142 1454 : mbFixSize = true;
143 :
144 : // insert columns, if necessary
145 3800 : InsertColumns();
146 :
147 : // First the Init, then the Content:
148 : // This is due to the fact that the Content may have Objects/Frames,
149 : // which are then registered
150 3800 : InitDrawObj( false );
151 :
152 3800 : Chain( pAnch );
153 :
154 3800 : InsertCnt();
155 :
156 : // Put it somewhere outside so that out document is not formatted unnecessarily often
157 3800 : Frm().Pos().setX(FAR_AWAY);
158 3800 : Frm().Pos().setY(FAR_AWAY);
159 3800 : }
160 :
161 3800 : void SwFlyFrm::Chain( SwFrm* _pAnch )
162 : {
163 : // Connect to chain neighboors.
164 : // No problem, if a neighboor doesn't exist - the construction of the
165 : // neighboor will make the connection
166 3800 : const SwFmtChain& rChain = GetFmt()->GetChain();
167 3800 : if ( rChain.GetPrev() || rChain.GetNext() )
168 : {
169 16 : if ( rChain.GetNext() )
170 : {
171 8 : SwFlyFrm* pFollow = FindChainNeighbour( *rChain.GetNext(), _pAnch );
172 8 : if ( pFollow )
173 : {
174 : OSL_ENSURE( !pFollow->GetPrevLink(), "wrong chain detected" );
175 4 : if ( !pFollow->GetPrevLink() )
176 4 : SwFlyFrm::ChainFrames( this, pFollow );
177 : }
178 : }
179 16 : if ( rChain.GetPrev() )
180 : {
181 8 : SwFlyFrm *pMaster = FindChainNeighbour( *rChain.GetPrev(), _pAnch );
182 8 : if ( pMaster )
183 : {
184 : OSL_ENSURE( !pMaster->GetNextLink(), "wrong chain detected" );
185 4 : if ( !pMaster->GetNextLink() )
186 4 : SwFlyFrm::ChainFrames( pMaster, this );
187 : }
188 : }
189 : }
190 3800 : }
191 :
192 3800 : void SwFlyFrm::InsertCnt()
193 : {
194 3800 : if ( !GetPrevLink() )
195 : {
196 3796 : const SwFmtCntnt& rCntnt = GetFmt()->GetCntnt();
197 : OSL_ENSURE( rCntnt.GetCntntIdx(), ":-( no content prepared." );
198 3796 : sal_uLong nIndex = rCntnt.GetCntntIdx()->GetIndex();
199 : // Lower() means SwColumnFrm; the Content then needs to be instered into the (Column)BodyFrm
200 3796 : ::_InsertCnt( Lower() ? (SwLayoutFrm*)((SwLayoutFrm*)Lower())->Lower() : (SwLayoutFrm*)this,
201 7592 : GetFmt()->GetDoc(), nIndex );
202 :
203 : // NoTxt always have a fixed height.
204 3796 : if ( Lower() && Lower()->IsNoTxtFrm() )
205 : {
206 1866 : mbFixSize = true;
207 1866 : bMinHeight = false;
208 : }
209 : }
210 3800 : }
211 :
212 3800 : void SwFlyFrm::InsertColumns()
213 : {
214 : // #i97379#
215 : // Check, if column are allowed.
216 : // Columns are not allowed for fly frames, which represent graphics or embedded objects.
217 3800 : const SwFmtCntnt& rCntnt = GetFmt()->GetCntnt();
218 : OSL_ENSURE( rCntnt.GetCntntIdx(), "<SwFlyFrm::InsertColumns()> - no content prepared." );
219 3800 : SwNodeIndex aFirstCntnt( *(rCntnt.GetCntntIdx()), 1 );
220 3800 : if ( aFirstCntnt.GetNode().IsNoTxtNode() )
221 : {
222 5666 : return;
223 : }
224 :
225 1934 : const SwFmtCol &rCol = GetFmt()->GetCol();
226 1934 : if ( rCol.GetNumCols() > 1 )
227 : {
228 : // Start off PrtArea to be as large as Frm, so that we can put in the columns
229 : // properly. It'll adjust later on.
230 0 : Prt().Width( Frm().Width() );
231 0 : Prt().Height( Frm().Height() );
232 0 : const SwFmtCol aOld; // ChgColumns() also needs an old value passed
233 0 : ChgColumns( aOld, rCol );
234 1934 : }
235 : }
236 :
237 7600 : SwFlyFrm::~SwFlyFrm()
238 : {
239 : // Accessible objects for fly frames will be destroyed in this destructor.
240 : // For frames bound as char or frames that don't have an anchor we have
241 : // to do that ourselves. For any other frame the call RemoveFly at the
242 : // anchor will do that.
243 3800 : if( IsAccessibleFrm() && GetFmt() && (IsFlyInCntFrm() || !GetAnchorFrm()) )
244 : {
245 1464 : SwRootFrm *pRootFrm = getRootFrm();
246 1464 : if( pRootFrm && pRootFrm->IsAnyShellAccessible() )
247 : {
248 0 : SwViewShell *pVSh = pRootFrm->GetCurrShell();
249 0 : if( pVSh && pVSh->Imp() )
250 : {
251 : // Lowers aren't disposed already, so we have to do a recursive
252 : // dispose
253 0 : pVSh->Imp()->DisposeAccessibleFrm( this, true );
254 : }
255 : }
256 : }
257 :
258 3800 : if( GetFmt() && !GetFmt()->GetDoc()->IsInDtor() )
259 : {
260 : // OD 2004-01-19 #110582#
261 3800 : Unchain();
262 :
263 : // OD 2004-01-19 #110582#
264 3800 : DeleteCnt();
265 :
266 3800 : if ( GetAnchorFrm() )
267 3800 : AnchorFrm()->RemoveFly( this );
268 : }
269 :
270 3800 : FinitDrawObj();
271 3800 : }
272 :
273 0 : const IDocumentDrawModelAccess* SwFlyFrm::getIDocumentDrawModelAccess()
274 : {
275 0 : return GetFmt()->getIDocumentDrawModelAccess();
276 : }
277 :
278 : // OD 2004-01-19 #110582#
279 3800 : void SwFlyFrm::Unchain()
280 : {
281 3800 : if ( GetPrevLink() )
282 4 : UnchainFrames( GetPrevLink(), this );
283 3800 : if ( GetNextLink() )
284 4 : UnchainFrames( this, GetNextLink() );
285 3800 : }
286 :
287 : // OD 2004-01-19 #110582#
288 3800 : void SwFlyFrm::DeleteCnt()
289 : {
290 : // #110582#-2
291 3800 : if ( IsLockDeleteContent() )
292 3800 : return;
293 :
294 3800 : SwFrm* pFrm = pLower;
295 12286 : while ( pFrm )
296 : {
297 9730 : while ( pFrm->GetDrawObjs() && pFrm->GetDrawObjs()->size() )
298 : {
299 358 : SwAnchoredObject *pAnchoredObj = (*pFrm->GetDrawObjs())[0];
300 358 : if ( pAnchoredObj->ISA(SwFlyFrm) )
301 328 : delete pAnchoredObj;
302 30 : else if ( pAnchoredObj->ISA(SwAnchoredDrawObject) )
303 : {
304 : // OD 23.06.2003 #108784# - consider 'virtual' drawing objects
305 30 : SdrObject* pObj = pAnchoredObj->DrawObj();
306 30 : if ( pObj->ISA(SwDrawVirtObj) )
307 : {
308 0 : SwDrawVirtObj* pDrawVirtObj = static_cast<SwDrawVirtObj*>(pObj);
309 0 : pDrawVirtObj->RemoveFromWriterLayout();
310 0 : pDrawVirtObj->RemoveFromDrawingPage();
311 : }
312 : else
313 : {
314 : SwDrawContact* pContact =
315 30 : static_cast<SwDrawContact*>(::GetUserCall( pObj ));
316 30 : if ( pContact )
317 : {
318 30 : pContact->DisconnectFromLayout();
319 : }
320 : }
321 : }
322 : }
323 :
324 4686 : pFrm->Remove();
325 4686 : delete pFrm;
326 4686 : pFrm = pLower;
327 : }
328 :
329 3800 : InvalidatePage();
330 : }
331 :
332 2080 : sal_uInt32 SwFlyFrm::_GetOrdNumForNewRef( const SwFlyDrawContact* pContact )
333 : {
334 2080 : sal_uInt32 nOrdNum( 0L );
335 :
336 : // search for another Writer fly frame registered at same frame format
337 2080 : SwIterator<SwFlyFrm,SwFmt> aIter( *pContact->GetFmt() );
338 2080 : const SwFlyFrm* pFlyFrm( 0L );
339 4150 : for ( pFlyFrm = aIter.First(); pFlyFrm; pFlyFrm = aIter.Next() )
340 : {
341 2850 : if ( pFlyFrm != this )
342 : {
343 780 : break;
344 : }
345 : }
346 :
347 2080 : if ( pFlyFrm )
348 : {
349 : // another Writer fly frame found. Take its order number
350 780 : nOrdNum = pFlyFrm->GetVirtDrawObj()->GetOrdNum();
351 : }
352 : else
353 : {
354 : // no other Writer fly frame found. Take order number of 'master' object
355 : // #i35748# - use method <GetOrdNumDirect()> instead
356 : // of method <GetOrdNum()> to avoid a recalculation of the order number,
357 : // which isn't intended.
358 1300 : nOrdNum = pContact->GetMaster()->GetOrdNumDirect();
359 : }
360 :
361 2080 : return nOrdNum;
362 : }
363 :
364 3800 : SwVirtFlyDrawObj* SwFlyFrm::CreateNewRef( SwFlyDrawContact *pContact )
365 : {
366 3800 : SwVirtFlyDrawObj *pDrawObj = new SwVirtFlyDrawObj( *pContact->GetMaster(), this );
367 3800 : pDrawObj->SetModel( pContact->GetMaster()->GetModel() );
368 3800 : pDrawObj->SetUserCall( pContact );
369 :
370 : // The Reader creates the Masters and inserts them into the Page in
371 : // order to transport the z-order.
372 : // After creating the first Reference the Masters are removed from the
373 : // List and are not important anymore.
374 3800 : SdrPage* pPg( 0L );
375 3800 : if ( 0 != ( pPg = pContact->GetMaster()->GetPage() ) )
376 : {
377 1720 : const size_t nOrdNum = pContact->GetMaster()->GetOrdNum();
378 1720 : pPg->ReplaceObject( pDrawObj, nOrdNum );
379 : }
380 : // #i27030# - insert new <SwVirtFlyDrawObj> instance
381 : // into drawing page with correct order number
382 : else
383 : {
384 2080 : pContact->GetFmt()->getIDocumentDrawModelAccess()->GetDrawModel()->GetPage( 0 )->
385 2080 : InsertObject( pDrawObj, _GetOrdNumForNewRef( pContact ) );
386 : }
387 : // #i38889# - assure, that new <SwVirtFlyDrawObj> instance
388 : // is in a visible layer.
389 3800 : pContact->MoveObjToVisibleLayer( pDrawObj );
390 3800 : return pDrawObj;
391 : }
392 :
393 3800 : void SwFlyFrm::InitDrawObj( bool bNotify )
394 : {
395 : // Find ContactObject from the Format. If there's already one, we just
396 : // need to create a new Ref, else we create the Contact now.
397 :
398 3800 : IDocumentDrawModelAccess* pIDDMA = GetFmt()->getIDocumentDrawModelAccess();
399 3800 : SwFlyDrawContact *pContact = SwIterator<SwFlyDrawContact,SwFmt>::FirstElement( *GetFmt() );
400 3800 : if ( !pContact )
401 : {
402 : // #i52858# - method name changed
403 1074 : pContact = new SwFlyDrawContact( (SwFlyFrmFmt*)GetFmt(),
404 1074 : pIDDMA->GetOrCreateDrawModel() );
405 : }
406 : OSL_ENSURE( pContact, "InitDrawObj failed" );
407 : // OD 2004-03-22 #i26791#
408 3800 : SetDrawObj( *(CreateNewRef( pContact )) );
409 :
410 : // Set the right Layer
411 : // OD 2004-01-19 #110582#
412 3800 : SdrLayerID nHeavenId = pIDDMA->GetHeavenId();
413 3800 : SdrLayerID nHellId = pIDDMA->GetHellId();
414 : // OD 2004-03-22 #i26791#
415 7600 : GetVirtDrawObj()->SetLayer( GetFmt()->GetOpaque().GetValue()
416 : ? nHeavenId
417 7600 : : nHellId );
418 3800 : if ( bNotify )
419 0 : NotifyDrawObj();
420 3800 : }
421 :
422 3800 : void SwFlyFrm::FinitDrawObj()
423 : {
424 3800 : if ( !GetVirtDrawObj() )
425 3800 : return;
426 :
427 : // Deregister from SdrPageViews if the Objects is still selected there.
428 3800 : if ( !GetFmt()->GetDoc()->IsInDtor() )
429 : {
430 3800 : SwViewShell *p1St = getRootFrm()->GetCurrShell();
431 3800 : if ( p1St )
432 : {
433 162 : SwViewShell *pSh = p1St;
434 162 : do
435 : { // At the moment the Drawing can do just do an Unmark on everything,
436 : // as the Object was already removed
437 162 : if( pSh->HasDrawView() )
438 162 : pSh->Imp()->GetDrawView()->UnmarkAll();
439 162 : pSh = (SwViewShell*)pSh->GetNext();
440 :
441 : } while ( pSh != p1St );
442 : }
443 : }
444 :
445 : // Take VirtObject to the grave.
446 : // If the last VirtObject is destroyed, the DrawObject and the DrawContact
447 : // also need to be destroyed.
448 3800 : SwFlyDrawContact *pMyContact = 0;
449 3800 : if ( GetFmt() )
450 : {
451 3800 : bool bContinue = true;
452 3800 : SwIterator<SwFrm,SwFmt> aFrmIter( *GetFmt() );
453 6924 : for ( SwFrm* pFrm = aFrmIter.First(); pFrm; pFrm = aFrmIter.Next() )
454 3904 : if ( pFrm != this )
455 : {
456 : // don't delete Contact if there is still a Frm
457 780 : bContinue = false;
458 780 : break;
459 : }
460 :
461 3800 : if ( bContinue )
462 : // no Frm left, find Contact object to destroy
463 3020 : pMyContact = SwIterator<SwFlyDrawContact,SwFmt>::FirstElement( *GetFmt() );
464 : }
465 :
466 : // OD, OS 2004-03-31 #116203# - clear user call of Writer fly frame 'master'
467 : // <SdrObject> to assure, that a <SwXFrame::dispose()> doesn't delete the
468 : // Writer fly frame again.
469 3800 : if ( pMyContact )
470 : {
471 3020 : pMyContact->GetMaster()->SetUserCall( 0 );
472 : }
473 3800 : GetVirtDrawObj()->SetUserCall( 0 ); // Else calls delete of the ContactObj
474 3800 : delete GetVirtDrawObj(); // Deregisters itself at the Master
475 3800 : delete pMyContact; // Destroys the Master itself
476 : }
477 :
478 8 : void SwFlyFrm::ChainFrames( SwFlyFrm *pMaster, SwFlyFrm *pFollow )
479 : {
480 : OSL_ENSURE( pMaster && pFollow, "uncomplete chain" );
481 : OSL_ENSURE( !pMaster->GetNextLink(), "link can not be changed" );
482 : OSL_ENSURE( !pFollow->GetPrevLink(), "link can not be changed" );
483 :
484 8 : pMaster->pNextLink = pFollow;
485 8 : pFollow->pPrevLink = pMaster;
486 :
487 8 : if ( pMaster->ContainsCntnt() )
488 : {
489 : // To get a text flow we need to invalidate
490 4 : SwFrm *pInva = pMaster->FindLastLower();
491 4 : SWRECTFN( pMaster )
492 4 : const long nBottom = (pMaster->*fnRect->fnGetPrtBottom)();
493 12 : while ( pInva )
494 : {
495 4 : if( (pInva->Frm().*fnRect->fnBottomDist)( nBottom ) <= 0 )
496 : {
497 0 : pInva->InvalidateSize();
498 0 : pInva->Prepare( PREP_CLEAR );
499 0 : pInva = pInva->FindPrev();
500 : }
501 : else
502 4 : pInva = 0;
503 : }
504 : }
505 :
506 8 : if ( pFollow->ContainsCntnt() )
507 : {
508 : // There's only the content from the Masters left; the content from the Follow
509 : // does not have any Frames left (should always be exactly one empty TxtNode).
510 4 : SwFrm *pFrm = pFollow->ContainsCntnt();
511 : OSL_ENSURE( !pFrm->IsTabFrm() && !pFrm->FindNext(), "follow in chain contains content" );
512 4 : pFrm->Cut();
513 4 : delete pFrm;
514 : }
515 :
516 : // invalidate accessible relation set (accessibility wrapper)
517 8 : SwViewShell* pSh = pMaster->getRootFrm()->GetCurrShell();
518 8 : if( pSh )
519 : {
520 8 : SwRootFrm* pLayout = pMaster->getRootFrm();
521 8 : if( pLayout && pLayout->IsAnyShellAccessible() )
522 0 : pSh->Imp()->InvalidateAccessibleRelationSet( pMaster, pFollow );
523 : }
524 8 : }
525 :
526 8 : void SwFlyFrm::UnchainFrames( SwFlyFrm *pMaster, SwFlyFrm *pFollow )
527 : {
528 8 : pMaster->pNextLink = 0;
529 8 : pFollow->pPrevLink = 0;
530 :
531 8 : if ( pFollow->ContainsCntnt() )
532 : {
533 : // The Master sucks up the content of the Follow
534 6 : SwLayoutFrm *pUpper = pMaster;
535 6 : if ( pUpper->Lower()->IsColumnFrm() )
536 : {
537 0 : pUpper = static_cast<SwLayoutFrm*>(pUpper->GetLastLower());
538 0 : pUpper = static_cast<SwLayoutFrm*>(pUpper->Lower()); // The (Column)BodyFrm
539 : OSL_ENSURE( pUpper && pUpper->IsColBodyFrm(), "Missing ColumnBody" );
540 : }
541 6 : SwFlyFrm *pFoll = pFollow;
542 18 : while ( pFoll )
543 : {
544 6 : SwFrm *pTmp = ::SaveCntnt( pFoll );
545 6 : if ( pTmp )
546 6 : ::RestoreCntnt( pTmp, pUpper, pMaster->FindLastLower(), true );
547 6 : pFoll->SetCompletePaint();
548 6 : pFoll->InvalidateSize();
549 6 : pFoll = pFoll->GetNextLink();
550 : }
551 : }
552 :
553 : // The Follow needs his own content to be served
554 8 : const SwFmtCntnt &rCntnt = pFollow->GetFmt()->GetCntnt();
555 : OSL_ENSURE( rCntnt.GetCntntIdx(), ":-( No content prepared." );
556 8 : sal_uLong nIndex = rCntnt.GetCntntIdx()->GetIndex();
557 : // Lower() means SwColumnFrm: this one contains another SwBodyFrm
558 8 : ::_InsertCnt( pFollow->Lower() ? (SwLayoutFrm*)((SwLayoutFrm*)pFollow->Lower())->Lower()
559 : : (SwLayoutFrm*)pFollow,
560 16 : pFollow->GetFmt()->GetDoc(), ++nIndex );
561 :
562 : // invalidate accessible relation set (accessibility wrapper)
563 8 : SwViewShell* pSh = pMaster->getRootFrm()->GetCurrShell();
564 8 : if( pSh )
565 : {
566 0 : SwRootFrm* pLayout = pMaster->getRootFrm();
567 0 : if( pLayout && pLayout->IsAnyShellAccessible() )
568 0 : pSh->Imp()->InvalidateAccessibleRelationSet( pMaster, pFollow );
569 : }
570 8 : }
571 :
572 16 : SwFlyFrm *SwFlyFrm::FindChainNeighbour( SwFrmFmt &rChain, SwFrm *pAnch )
573 : {
574 : // We look for the Fly that's in the same Area.
575 : // Areas can for now only be Head/Footer or Flys.
576 :
577 16 : if ( !pAnch ) // If an Anchor was passed along, that one counts (ctor!)
578 0 : pAnch = AnchorFrm();
579 :
580 : SwLayoutFrm *pLay;
581 16 : if ( pAnch->IsInFly() )
582 0 : pLay = pAnch->FindFlyFrm();
583 : else
584 : {
585 : // FindFooterOrHeader is not appropriate here, as we may not have a
586 : // connection to the Anchor yet.
587 16 : pLay = pAnch->GetUpper();
588 80 : while ( pLay && !(pLay->GetType() & (FRM_HEADER|FRM_FOOTER)) )
589 48 : pLay = pLay->GetUpper();
590 : }
591 :
592 16 : SwIterator<SwFlyFrm,SwFmt> aIter( rChain );
593 16 : SwFlyFrm *pFly = aIter.First();
594 16 : if ( pLay )
595 : {
596 0 : while ( pFly )
597 : {
598 0 : if ( pFly->GetAnchorFrm() )
599 : {
600 0 : if ( pFly->GetAnchorFrm()->IsInFly() )
601 : {
602 0 : if ( pFly->AnchorFrm()->FindFlyFrm() == pLay )
603 0 : break;
604 : }
605 0 : else if ( pLay == pFly->FindFooterOrHeader() )
606 0 : break;
607 : }
608 0 : pFly = aIter.Next();
609 : }
610 : }
611 : else if ( pFly )
612 : {
613 : OSL_ENSURE( !aIter.Next(), "chain with more than one instance" );
614 : }
615 16 : return pFly;
616 : }
617 :
618 10 : SwFrm *SwFlyFrm::FindLastLower()
619 : {
620 10 : SwFrm *pRet = ContainsAny();
621 10 : if ( pRet && pRet->IsInTab() )
622 0 : pRet = pRet->FindTabFrm();
623 10 : SwFrm *pNxt = pRet;
624 180 : while ( pNxt && IsAnLower( pNxt ) )
625 160 : { pRet = pNxt;
626 160 : pNxt = pNxt->FindNext();
627 : }
628 10 : return pRet;
629 : }
630 :
631 84 : bool SwFlyFrm::FrmSizeChg( const SwFmtFrmSize &rFrmSize )
632 : {
633 84 : bool bRet = false;
634 84 : SwTwips nDiffHeight = Frm().Height();
635 84 : if ( rFrmSize.GetHeightSizeType() == ATT_VAR_SIZE )
636 42 : mbFixSize = bMinHeight = false;
637 : else
638 : {
639 42 : if ( rFrmSize.GetHeightSizeType() == ATT_FIX_SIZE )
640 : {
641 40 : mbFixSize = true;
642 40 : bMinHeight = false;
643 : }
644 2 : else if ( rFrmSize.GetHeightSizeType() == ATT_MIN_SIZE )
645 : {
646 2 : mbFixSize = false;
647 2 : bMinHeight = true;
648 : }
649 42 : nDiffHeight -= rFrmSize.GetHeight();
650 : }
651 : // If the Fly contains columns, we already need to set the Fly
652 : // and the Columns to the required value or else we run into problems.
653 84 : if ( Lower() )
654 : {
655 84 : if ( Lower()->IsColumnFrm() )
656 : {
657 0 : const SwRect aOld( GetObjRectWithSpaces() );
658 0 : const Size aOldSz( Prt().SSize() );
659 0 : const SwTwips nDiffWidth = Frm().Width() - rFrmSize.GetWidth();
660 0 : maFrm.Height( maFrm.Height() - nDiffHeight );
661 0 : maFrm.Width ( maFrm.Width() - nDiffWidth );
662 : // #i68520#
663 0 : InvalidateObjRectWithSpaces();
664 0 : maPrt.Height( maPrt.Height() - nDiffHeight );
665 0 : maPrt.Width ( maPrt.Width() - nDiffWidth );
666 0 : ChgLowersProp( aOldSz );
667 0 : ::Notify( this, FindPageFrm(), aOld );
668 0 : mbValidPos = false;
669 0 : bRet = true;
670 : }
671 84 : else if ( Lower()->IsNoTxtFrm() )
672 : {
673 64 : mbFixSize = true;
674 64 : bMinHeight = false;
675 : }
676 : }
677 84 : return bRet;
678 : }
679 :
680 378 : void SwFlyFrm::Modify( const SfxPoolItem* pOld, const SfxPoolItem * pNew )
681 : {
682 378 : sal_uInt8 nInvFlags = 0;
683 :
684 378 : if (pNew && pOld && RES_ATTRSET_CHG == pNew->Which())
685 : {
686 140 : SfxItemIter aNIter( *((SwAttrSetChg*)pNew)->GetChgSet() );
687 280 : SfxItemIter aOIter( *((SwAttrSetChg*)pOld)->GetChgSet() );
688 280 : SwAttrSetChg aOldSet( *(SwAttrSetChg*)pOld );
689 280 : SwAttrSetChg aNewSet( *(SwAttrSetChg*)pNew );
690 : while( true )
691 : {
692 : _UpdateAttr( (SfxPoolItem*)aOIter.GetCurItem(),
693 : (SfxPoolItem*)aNIter.GetCurItem(), nInvFlags,
694 140 : &aOldSet, &aNewSet );
695 140 : if( aNIter.IsAtEnd() )
696 140 : break;
697 0 : aNIter.NextItem();
698 0 : aOIter.NextItem();
699 : }
700 140 : if ( aOldSet.Count() || aNewSet.Count() )
701 144 : SwLayoutFrm::Modify( &aOldSet, &aNewSet );
702 : }
703 : else
704 238 : _UpdateAttr( pOld, pNew, nInvFlags );
705 :
706 378 : if ( nInvFlags != 0 )
707 : {
708 146 : _Invalidate();
709 146 : if ( nInvFlags & 0x01 )
710 : {
711 142 : _InvalidatePos();
712 : // #i68520#
713 142 : InvalidateObjRectWithSpaces();
714 : }
715 146 : if ( nInvFlags & 0x02 )
716 : {
717 84 : _InvalidateSize();
718 : // #i68520#
719 84 : InvalidateObjRectWithSpaces();
720 : }
721 146 : if ( nInvFlags & 0x04 )
722 84 : _InvalidatePrt();
723 146 : if ( nInvFlags & 0x08 )
724 128 : SetNotifyBack();
725 146 : if ( nInvFlags & 0x10 )
726 84 : SetCompletePaint();
727 146 : if ( ( nInvFlags & 0x40 ) && Lower() && Lower()->IsNoTxtFrm() )
728 78 : ClrContourCache( GetVirtDrawObj() );
729 : SwRootFrm *pRoot;
730 146 : if ( nInvFlags & 0x20 && 0 != (pRoot = getRootFrm()) )
731 84 : pRoot->InvalidateBrowseWidth();
732 : // #i28701#
733 146 : if ( nInvFlags & 0x80 )
734 : {
735 : // update sorted object lists, the Writer fly frame is registered at.
736 102 : UpdateObjInSortedList();
737 : }
738 :
739 : // #i87645# - reset flags for the layout process (only if something has been invalidated)
740 146 : ResetLayoutProcessBools();
741 : }
742 378 : }
743 :
744 378 : void SwFlyFrm::_UpdateAttr( const SfxPoolItem *pOld, const SfxPoolItem *pNew,
745 : sal_uInt8 &rInvFlags,
746 : SwAttrSetChg *pOldSet, SwAttrSetChg *pNewSet )
747 : {
748 378 : bool bClear = true;
749 378 : const sal_uInt16 nWhich = pOld ? pOld->Which() : pNew ? pNew->Which() : 0;
750 378 : SwViewShell *pSh = getRootFrm()->GetCurrShell();
751 378 : switch( nWhich )
752 : {
753 : case RES_VERT_ORIENT:
754 : case RES_HORI_ORIENT:
755 : // OD 22.09.2003 #i18732# - consider new option 'follow text flow'
756 : case RES_FOLLOW_TEXT_FLOW:
757 : {
758 : // ATTENTION: Always also change Action in ChgRePos()!
759 44 : rInvFlags |= 0x09;
760 : }
761 44 : break;
762 : // OD 2004-07-01 #i28701# - consider new option 'wrap influence on position'
763 : case RES_WRAP_INFLUENCE_ON_OBJPOS:
764 : {
765 0 : rInvFlags |= 0x89;
766 : }
767 0 : break;
768 : case RES_SURROUND:
769 : {
770 : // OD 2004-05-13 #i28701# - invalidate position on change of
771 : // wrapping style.
772 : //rInvFlags |= 0x40;
773 14 : rInvFlags |= 0x41;
774 : // The background needs to messaged and invalidated
775 14 : const SwRect aTmp( GetObjRectWithSpaces() );
776 14 : NotifyBackground( FindPageFrm(), aTmp, PREP_FLY_ATTR_CHG );
777 :
778 : // By changing the flow of frame-bound Frames, a vertical alignment
779 : // can be activated/deactivated => MakeFlyPos
780 14 : if( FLY_AT_FLY == GetFmt()->GetAnchor().GetAnchorId() )
781 0 : rInvFlags |= 0x09;
782 :
783 : // Delete contour in the Node if necessary
784 28 : if ( Lower() && Lower()->IsNoTxtFrm() &&
785 14 : !GetFmt()->GetSurround().IsContour() )
786 : {
787 10 : SwNoTxtNode *pNd = (SwNoTxtNode*)((SwCntntFrm*)Lower())->GetNode();
788 10 : if ( pNd->HasContour() )
789 0 : pNd->SetContour( 0 );
790 : }
791 : // #i28701# - perform reorder of object lists
792 : // at anchor frame and at page frame.
793 14 : rInvFlags |= 0x80;
794 : }
795 14 : break;
796 :
797 : case RES_PROTECT:
798 2 : if (pNew)
799 : {
800 2 : const SvxProtectItem *pP = (SvxProtectItem*)pNew;
801 2 : GetVirtDrawObj()->SetMoveProtect( pP->IsPosProtected() );
802 2 : GetVirtDrawObj()->SetResizeProtect( pP->IsSizeProtected() );
803 2 : if( pSh )
804 : {
805 2 : SwRootFrm* pLayout = getRootFrm();
806 2 : if( pLayout && pLayout->IsAnyShellAccessible() )
807 0 : pSh->Imp()->InvalidateAccessibleEditableState( true, this );
808 : }
809 : }
810 2 : break;
811 : case RES_COL:
812 0 : if (pOld && pNew)
813 : {
814 0 : ChgColumns( *(const SwFmtCol*)pOld, *(const SwFmtCol*)pNew );
815 0 : const SwFmtFrmSize &rNew = GetFmt()->GetFrmSize();
816 0 : if ( FrmSizeChg( rNew ) )
817 0 : NotifyDrawObj();
818 0 : rInvFlags |= 0x1A;
819 0 : break;
820 : }
821 :
822 : case RES_FRM_SIZE:
823 : case RES_FMT_CHG:
824 : {
825 84 : const SwFmtFrmSize &rNew = GetFmt()->GetFrmSize();
826 84 : if ( FrmSizeChg( rNew ) )
827 0 : NotifyDrawObj();
828 84 : rInvFlags |= 0x7F;
829 84 : if ( RES_FMT_CHG == nWhich )
830 : {
831 16 : SwRect aNew( GetObjRectWithSpaces() );
832 16 : SwRect aOld( maFrm );
833 16 : const SvxULSpaceItem &rUL = ((SwFmtChg*)pOld)->pChangedFmt->GetULSpace();
834 16 : aOld.Top( std::max( aOld.Top() - long(rUL.GetUpper()), 0L ) );
835 16 : aOld.SSize().Height()+= rUL.GetLower();
836 16 : const SvxLRSpaceItem &rLR = ((SwFmtChg*)pOld)->pChangedFmt->GetLRSpace();
837 16 : aOld.Left ( std::max( aOld.Left() - long(rLR.GetLeft()), 0L ) );
838 16 : aOld.SSize().Width() += rLR.GetRight();
839 16 : aNew.Union( aOld );
840 16 : NotifyBackground( FindPageFrm(), aNew, PREP_CLEAR );
841 :
842 : // Special case:
843 : // When assigning a template we cannot rely on the old column
844 : // attribute. As there need to be at least enough for ChgColumns,
845 : // we need to create a temporary attribute.
846 16 : SwFmtCol aCol;
847 16 : if ( Lower() && Lower()->IsColumnFrm() )
848 : {
849 0 : sal_uInt16 nCol = 0;
850 0 : SwFrm *pTmp = Lower();
851 0 : do
852 0 : { ++nCol;
853 0 : pTmp = pTmp->GetNext();
854 : } while ( pTmp );
855 0 : aCol.Init( nCol, 0, 1000 );
856 : }
857 16 : ChgColumns( aCol, GetFmt()->GetCol() );
858 : }
859 :
860 84 : SwFmtURL aURL( GetFmt()->GetURL() );
861 :
862 84 : SwFmtFrmSize *pNewFmtFrmSize = NULL;
863 84 : SwFmtChg *pOldFmtChg = NULL;
864 84 : if (nWhich == RES_FRM_SIZE)
865 68 : pNewFmtFrmSize = (SwFmtFrmSize*)pNew;
866 : else
867 16 : pOldFmtChg = (SwFmtChg*)pOld;
868 :
869 84 : if (aURL.GetMap() && (pNewFmtFrmSize || pOldFmtChg))
870 : {
871 : const SwFmtFrmSize &rOld = pNewFmtFrmSize ?
872 : *pNewFmtFrmSize :
873 2 : pOldFmtChg->pChangedFmt->GetFrmSize();
874 : //#35091# Can be "times zero", when loading the template
875 2 : if ( rOld.GetWidth() && rOld.GetHeight() )
876 : {
877 :
878 2 : Fraction aScaleX( rOld.GetWidth(), rNew.GetWidth() );
879 2 : Fraction aScaleY( rOld.GetHeight(), rOld.GetHeight() );
880 2 : aURL.GetMap()->Scale( aScaleX, aScaleY );
881 2 : SwFrmFmt *pFmt = GetFmt();
882 2 : pFmt->LockModify();
883 2 : pFmt->SetFmtAttr( aURL );
884 2 : pFmt->UnlockModify();
885 : }
886 : }
887 84 : const SvxProtectItem &rP = GetFmt()->GetProtect();
888 84 : GetVirtDrawObj()->SetMoveProtect( rP.IsPosProtected() );
889 84 : GetVirtDrawObj()->SetResizeProtect( rP.IsSizeProtected() );
890 :
891 84 : if ( pSh )
892 84 : pSh->InvalidateWindows( Frm() );
893 84 : const IDocumentDrawModelAccess* pIDDMA = GetFmt()->getIDocumentDrawModelAccess();
894 84 : const sal_uInt8 nId = GetFmt()->GetOpaque().GetValue() ?
895 76 : pIDDMA->GetHeavenId() :
896 160 : pIDDMA->GetHellId();
897 84 : GetVirtDrawObj()->SetLayer( nId );
898 :
899 84 : if ( Lower() )
900 : {
901 : // Delete contour in the Node if necessary
902 148 : if( Lower()->IsNoTxtFrm() &&
903 64 : !GetFmt()->GetSurround().IsContour() )
904 : {
905 62 : SwNoTxtNode *pNd = (SwNoTxtNode*)((SwCntntFrm*)Lower())->GetNode();
906 62 : if ( pNd->HasContour() )
907 0 : pNd->SetContour( 0 );
908 : }
909 22 : else if( !Lower()->IsColumnFrm() )
910 : {
911 22 : SwFrm* pFrm = GetLastLower();
912 22 : if( pFrm->IsTxtFrm() && ((SwTxtFrm*)pFrm)->IsUndersized() )
913 0 : pFrm->Prepare( PREP_ADJUST_FRM );
914 : }
915 : }
916 :
917 : // #i28701# - perform reorder of object lists
918 : // at anchor frame and at page frame.
919 84 : rInvFlags |= 0x80;
920 :
921 84 : break;
922 : }
923 : case RES_UL_SPACE:
924 : case RES_LR_SPACE:
925 : {
926 0 : rInvFlags |= 0x41;
927 0 : if( pSh && pSh->GetViewOptions()->getBrowseMode() )
928 0 : getRootFrm()->InvalidateBrowseWidth();
929 0 : SwRect aNew( GetObjRectWithSpaces() );
930 0 : SwRect aOld( maFrm );
931 0 : if (pNew)
932 : {
933 0 : if ( RES_UL_SPACE == nWhich )
934 : {
935 0 : const SvxULSpaceItem &rUL = *(SvxULSpaceItem*)pNew;
936 0 : aOld.Top( std::max( aOld.Top() - long(rUL.GetUpper()), 0L ) );
937 0 : aOld.SSize().Height()+= rUL.GetLower();
938 : }
939 : else
940 : {
941 0 : const SvxLRSpaceItem &rLR = *(SvxLRSpaceItem*)pNew;
942 0 : aOld.Left ( std::max( aOld.Left() - long(rLR.GetLeft()), 0L ) );
943 0 : aOld.SSize().Width() += rLR.GetRight();
944 : }
945 : }
946 0 : aNew.Union( aOld );
947 0 : NotifyBackground( FindPageFrm(), aNew, PREP_CLEAR );
948 : }
949 0 : break;
950 :
951 : case RES_TEXT_VERT_ADJUST:
952 : {
953 0 : InvalidateContentPos();
954 0 : rInvFlags |= 0x10;
955 : }
956 0 : break;
957 :
958 : case RES_BOX:
959 : case RES_SHADOW:
960 0 : rInvFlags |= 0x17;
961 0 : break;
962 :
963 : case RES_FRAMEDIR :
964 2 : SetDerivedVert( false );
965 2 : SetDerivedR2L( false );
966 2 : CheckDirChange();
967 2 : break;
968 :
969 : case RES_OPAQUE:
970 : {
971 4 : if ( pSh )
972 4 : pSh->InvalidateWindows( Frm() );
973 :
974 4 : const IDocumentDrawModelAccess* pIDDMA = GetFmt()->getIDocumentDrawModelAccess();
975 4 : const sal_uInt8 nId = ((SvxOpaqueItem*)pNew)->GetValue() ?
976 0 : pIDDMA->GetHeavenId() :
977 4 : pIDDMA->GetHellId();
978 4 : GetVirtDrawObj()->SetLayer( nId );
979 4 : if( pSh )
980 : {
981 4 : SwRootFrm* pLayout = getRootFrm();
982 4 : if( pLayout && pLayout->IsAnyShellAccessible() )
983 : {
984 0 : pSh->Imp()->DisposeAccessibleFrm( this );
985 0 : pSh->Imp()->AddAccessibleFrm( this );
986 : }
987 : }
988 : // #i28701# - perform reorder of object lists
989 : // at anchor frame and at page frame.
990 4 : rInvFlags |= 0x80;
991 : }
992 4 : break;
993 :
994 : case RES_URL:
995 : // The interface changes the frame size when interacting with text frames,
996 : // the Map, however, needs to be relative to FrmSize().
997 6 : if ( (!Lower() || !Lower()->IsNoTxtFrm()) && pNew && pOld &&
998 2 : ((SwFmtURL*)pNew)->GetMap() && ((SwFmtURL*)pOld)->GetMap() )
999 : {
1000 0 : const SwFmtFrmSize &rSz = GetFmt()->GetFrmSize();
1001 0 : if ( rSz.GetHeight() != Frm().Height() ||
1002 0 : rSz.GetWidth() != Frm().Width() )
1003 : {
1004 0 : SwFmtURL aURL( GetFmt()->GetURL() );
1005 0 : Fraction aScaleX( Frm().Width(), rSz.GetWidth() );
1006 0 : Fraction aScaleY( Frm().Height(), rSz.GetHeight() );
1007 0 : aURL.GetMap()->Scale( aScaleX, aScaleY );
1008 0 : SwFrmFmt *pFmt = GetFmt();
1009 0 : pFmt->LockModify();
1010 0 : pFmt->SetFmtAttr( aURL );
1011 0 : pFmt->UnlockModify();
1012 : }
1013 : }
1014 : // No invalidation necessary
1015 2 : break;
1016 :
1017 : case RES_CHAIN:
1018 0 : if (pNew)
1019 : {
1020 0 : SwFmtChain *pChain = (SwFmtChain*)pNew;
1021 0 : if ( pChain->GetNext() )
1022 : {
1023 0 : SwFlyFrm *pFollow = FindChainNeighbour( *pChain->GetNext() );
1024 0 : if ( GetNextLink() && pFollow != GetNextLink() )
1025 0 : SwFlyFrm::UnchainFrames( this, GetNextLink());
1026 0 : if ( pFollow )
1027 : {
1028 0 : if ( pFollow->GetPrevLink() &&
1029 0 : pFollow->GetPrevLink() != this )
1030 : SwFlyFrm::UnchainFrames( pFollow->GetPrevLink(),
1031 0 : pFollow );
1032 0 : if ( !GetNextLink() )
1033 0 : SwFlyFrm::ChainFrames( this, pFollow );
1034 : }
1035 : }
1036 0 : else if ( GetNextLink() )
1037 0 : SwFlyFrm::UnchainFrames( this, GetNextLink() );
1038 0 : if ( pChain->GetPrev() )
1039 : {
1040 0 : SwFlyFrm *pMaster = FindChainNeighbour( *pChain->GetPrev() );
1041 0 : if ( GetPrevLink() && pMaster != GetPrevLink() )
1042 0 : SwFlyFrm::UnchainFrames( GetPrevLink(), this );
1043 0 : if ( pMaster )
1044 : {
1045 0 : if ( pMaster->GetNextLink() &&
1046 0 : pMaster->GetNextLink() != this )
1047 : SwFlyFrm::UnchainFrames( pMaster,
1048 0 : pMaster->GetNextLink() );
1049 0 : if ( !GetPrevLink() )
1050 0 : SwFlyFrm::ChainFrames( pMaster, this );
1051 : }
1052 : }
1053 0 : else if ( GetPrevLink() )
1054 0 : SwFlyFrm::UnchainFrames( GetPrevLink(), this );
1055 : }
1056 : //fall-through
1057 : default:
1058 226 : bClear = false;
1059 : }
1060 378 : if ( bClear )
1061 : {
1062 152 : if ( pOldSet || pNewSet )
1063 : {
1064 136 : if ( pOldSet )
1065 136 : pOldSet->ClearItem( nWhich );
1066 272 : if ( pNewSet )
1067 136 : pNewSet->ClearItem( nWhich );
1068 : }
1069 : else
1070 16 : SwLayoutFrm::Modify( pOld, pNew );
1071 : }
1072 378 : }
1073 :
1074 : /// Gets information from the Modify
1075 66 : bool SwFlyFrm::GetInfo( SfxPoolItem & rInfo ) const
1076 : {
1077 66 : if( RES_AUTOFMT_DOCNODE == rInfo.Which() )
1078 66 : return false; // There's a FlyFrm, so use it
1079 0 : return true; // Continue searching
1080 : }
1081 :
1082 12115 : void SwFlyFrm::_Invalidate( SwPageFrm *pPage )
1083 : {
1084 12115 : InvalidatePage( pPage );
1085 12115 : bNotifyBack = bInvalid = true;
1086 :
1087 : SwFlyFrm *pFrm;
1088 12115 : if ( GetAnchorFrm() && 0 != (pFrm = AnchorFrm()->FindFlyFrm()) )
1089 : {
1090 : // Very bad case: If the Fly is bound within another Fly which
1091 : // contains columns, the Format should be from that one.
1092 1376 : if ( !pFrm->IsLocked() && !pFrm->IsColLocked() &&
1093 1032 : pFrm->Lower() && pFrm->Lower()->IsColumnFrm() )
1094 0 : pFrm->InvalidateSize();
1095 : }
1096 :
1097 : // #i85216#
1098 : // if vertical position is oriented at a layout frame inside a ghost section,
1099 : // assure that the position is invalidated and that the information about
1100 : // the vertical position oriented frame is cleared
1101 12115 : if ( GetVertPosOrientFrm() && GetVertPosOrientFrm()->IsLayoutFrm() )
1102 : {
1103 6263 : const SwSectionFrm* pSectFrm( GetVertPosOrientFrm()->FindSctFrm() );
1104 6263 : if ( pSectFrm && pSectFrm->GetSection() == 0 )
1105 : {
1106 0 : InvalidatePos();
1107 0 : ClearVertPosOrientFrm();
1108 : }
1109 : }
1110 12115 : }
1111 :
1112 : /** Change the relative position
1113 : *
1114 : * The position will be Fix automatically and the attribute is changed accordingly.
1115 : */
1116 0 : void SwFlyFrm::ChgRelPos( const Point &rNewPos )
1117 : {
1118 0 : if ( GetCurrRelPos() != rNewPos )
1119 : {
1120 0 : SwFrmFmt *pFmt = GetFmt();
1121 0 : const bool bVert = GetAnchorFrm()->IsVertical();
1122 0 : const SwTwips nNewY = bVert ? rNewPos.X() : rNewPos.Y();
1123 0 : SwTwips nTmpY = nNewY == LONG_MAX ? 0 : nNewY;
1124 0 : if( bVert )
1125 0 : nTmpY = -nTmpY;
1126 0 : SfxItemSet aSet( pFmt->GetDoc()->GetAttrPool(),
1127 0 : RES_VERT_ORIENT, RES_HORI_ORIENT);
1128 :
1129 0 : SwFmtVertOrient aVert( pFmt->GetVertOrient() );
1130 0 : SwTxtFrm *pAutoFrm = NULL;
1131 : // #i34948# - handle also at-page and at-fly anchored
1132 : // Writer fly frames
1133 0 : const RndStdIds eAnchorType = GetFrmFmt().GetAnchor().GetAnchorId();
1134 0 : if ( eAnchorType == FLY_AT_PAGE )
1135 : {
1136 0 : aVert.SetVertOrient( text::VertOrientation::NONE );
1137 0 : aVert.SetRelationOrient( text::RelOrientation::PAGE_FRAME );
1138 : }
1139 0 : else if ( eAnchorType == FLY_AT_FLY )
1140 : {
1141 0 : aVert.SetVertOrient( text::VertOrientation::NONE );
1142 0 : aVert.SetRelationOrient( text::RelOrientation::FRAME );
1143 : }
1144 0 : else if ( IsFlyAtCntFrm() || text::VertOrientation::NONE != aVert.GetVertOrient() )
1145 : {
1146 0 : if( text::RelOrientation::CHAR == aVert.GetRelationOrient() && IsAutoPos() )
1147 : {
1148 0 : if( LONG_MAX != nNewY )
1149 : {
1150 0 : aVert.SetVertOrient( text::VertOrientation::NONE );
1151 : sal_Int32 nOfs =
1152 0 : pFmt->GetAnchor().GetCntntAnchor()->nContent.GetIndex();
1153 : OSL_ENSURE( GetAnchorFrm()->IsTxtFrm(), "TxtFrm expected" );
1154 0 : pAutoFrm = (SwTxtFrm*)GetAnchorFrm();
1155 0 : while( pAutoFrm->GetFollow() &&
1156 0 : pAutoFrm->GetFollow()->GetOfst() <= nOfs )
1157 : {
1158 0 : if( pAutoFrm == GetAnchorFrm() )
1159 0 : nTmpY += pAutoFrm->GetRelPos().Y();
1160 0 : nTmpY -= pAutoFrm->GetUpper()->Prt().Height();
1161 0 : pAutoFrm = pAutoFrm->GetFollow();
1162 : }
1163 0 : nTmpY = ((SwFlyAtCntFrm*)this)->GetRelCharY(pAutoFrm)-nTmpY;
1164 : }
1165 : else
1166 0 : aVert.SetVertOrient( text::VertOrientation::CHAR_BOTTOM );
1167 : }
1168 : else
1169 : {
1170 0 : aVert.SetVertOrient( text::VertOrientation::NONE );
1171 0 : aVert.SetRelationOrient( text::RelOrientation::FRAME );
1172 : }
1173 : }
1174 0 : aVert.SetPos( nTmpY );
1175 0 : aSet.Put( aVert );
1176 :
1177 : // For Flys in the Cnt, the horizontal orientation is of no interest,
1178 : // as it's always 0
1179 0 : if ( !IsFlyInCntFrm() )
1180 : {
1181 0 : const SwTwips nNewX = bVert ? rNewPos.Y() : rNewPos.X();
1182 0 : SwTwips nTmpX = nNewX == LONG_MAX ? 0 : nNewX;
1183 0 : SwFmtHoriOrient aHori( pFmt->GetHoriOrient() );
1184 : // #i34948# - handle also at-page and at-fly anchored
1185 : // Writer fly frames
1186 0 : if ( eAnchorType == FLY_AT_PAGE )
1187 : {
1188 0 : aHori.SetHoriOrient( text::HoriOrientation::NONE );
1189 0 : aHori.SetRelationOrient( text::RelOrientation::PAGE_FRAME );
1190 0 : aHori.SetPosToggle( false );
1191 : }
1192 0 : else if ( eAnchorType == FLY_AT_FLY )
1193 : {
1194 0 : aHori.SetHoriOrient( text::HoriOrientation::NONE );
1195 0 : aHori.SetRelationOrient( text::RelOrientation::FRAME );
1196 0 : aHori.SetPosToggle( false );
1197 : }
1198 0 : else if ( IsFlyAtCntFrm() || text::HoriOrientation::NONE != aHori.GetHoriOrient() )
1199 : {
1200 0 : aHori.SetHoriOrient( text::HoriOrientation::NONE );
1201 0 : if( text::RelOrientation::CHAR == aHori.GetRelationOrient() && IsAutoPos() )
1202 : {
1203 0 : if( LONG_MAX != nNewX )
1204 : {
1205 0 : if( !pAutoFrm )
1206 : {
1207 0 : sal_Int32 nOfs = pFmt->GetAnchor().GetCntntAnchor()
1208 0 : ->nContent.GetIndex();
1209 : OSL_ENSURE( GetAnchorFrm()->IsTxtFrm(), "TxtFrm expected");
1210 0 : pAutoFrm = (SwTxtFrm*)GetAnchorFrm();
1211 0 : while( pAutoFrm->GetFollow() &&
1212 0 : pAutoFrm->GetFollow()->GetOfst() <= nOfs )
1213 0 : pAutoFrm = pAutoFrm->GetFollow();
1214 : }
1215 0 : nTmpX -= ((SwFlyAtCntFrm*)this)->GetRelCharX(pAutoFrm);
1216 : }
1217 : }
1218 : else
1219 0 : aHori.SetRelationOrient( text::RelOrientation::FRAME );
1220 0 : aHori.SetPosToggle( false );
1221 : }
1222 0 : aHori.SetPos( nTmpX );
1223 0 : aSet.Put( aHori );
1224 : }
1225 0 : SetCurrRelPos( rNewPos );
1226 0 : pFmt->GetDoc()->SetAttr( aSet, *pFmt );
1227 : }
1228 0 : }
1229 :
1230 : /** "Formats" the Frame; Frm and PrtArea.
1231 : *
1232 : * The FixSize is not inserted here.
1233 : */
1234 9859 : void SwFlyFrm::Format( const SwBorderAttrs *pAttrs )
1235 : {
1236 : OSL_ENSURE( pAttrs, "FlyFrm::Format, pAttrs is 0." );
1237 :
1238 9859 : ColLock();
1239 :
1240 9859 : if ( !mbValidSize )
1241 : {
1242 9859 : if ( Frm().Top() == FAR_AWAY && Frm().Left() == FAR_AWAY )
1243 : {
1244 : // Remove safety switch (see SwFrm::CTor)
1245 3516 : Frm().Pos().setX(0);
1246 3516 : Frm().Pos().setY(0);
1247 : // #i68520#
1248 3516 : InvalidateObjRectWithSpaces();
1249 : }
1250 :
1251 : // Check column width and set it if needed
1252 9859 : if ( Lower() && Lower()->IsColumnFrm() )
1253 0 : AdjustColumns( 0, false );
1254 :
1255 9859 : mbValidSize = true;
1256 :
1257 9859 : const SwTwips nUL = pAttrs->CalcTopLine() + pAttrs->CalcBottomLine();
1258 9859 : const SwTwips nLR = pAttrs->CalcLeftLine() + pAttrs->CalcRightLine();
1259 9859 : const SwFmtFrmSize &rFrmSz = GetFmt()->GetFrmSize();
1260 9859 : Size aRelSize( CalcRel( rFrmSz ) );
1261 :
1262 : OSL_ENSURE( pAttrs->GetSize().Height() != 0 || rFrmSz.GetHeightPercent(), "FrameAttr height is 0." );
1263 : OSL_ENSURE( pAttrs->GetSize().Width() != 0 || rFrmSz.GetWidthPercent(), "FrameAttr width is 0." );
1264 :
1265 9859 : SWRECTFN( this )
1266 9859 : if( !HasFixSize() )
1267 : {
1268 3421 : long nMinHeight = 0;
1269 3421 : if( IsMinHeight() )
1270 366 : nMinHeight = bVert ? aRelSize.Width() : aRelSize.Height();
1271 :
1272 3421 : SwTwips nRemaining = CalcContentHeight(pAttrs, nMinHeight, nUL);
1273 3421 : if( IsMinHeight() && (nRemaining + nUL) < nMinHeight )
1274 222 : nRemaining = nMinHeight - nUL;
1275 : // Because the Grow/Shrink of the Flys does not directly
1276 : // set the size - only indirectly by triggering a Format()
1277 : // via Invalidate() - the sizes need to be set here.
1278 : // Notification is running along already.
1279 : // As we already got a lot of zeros per attribute, we block them
1280 : // from now on.
1281 :
1282 3421 : if ( nRemaining < MINFLY )
1283 938 : nRemaining = MINFLY;
1284 :
1285 3421 : (Prt().*fnRect->fnSetHeight)( nRemaining );
1286 3421 : nRemaining -= (Frm().*fnRect->fnGetHeight)();
1287 3421 : (Frm().*fnRect->fnAddBottom)( nRemaining + nUL );
1288 : // #i68520#
1289 3421 : if ( nRemaining + nUL != 0 )
1290 : {
1291 1434 : InvalidateObjRectWithSpaces();
1292 : }
1293 3421 : mbValidSize = true;
1294 :
1295 3421 : std::map<SwFrmFmt*, SwFrmFmt*> aShapes = SwTextBoxHelper::findShapes(GetFmt()->GetDoc());
1296 3421 : if (aShapes.find(GetFmt()) != aShapes.end())
1297 : {
1298 : // This fly is a textbox of a draw shape.
1299 704 : SdrObject* pShape = aShapes[GetFmt()]->FindSdrObject();
1300 704 : if (SdrObjCustomShape* pCustomShape = PTR_CAST(SdrObjCustomShape, pShape))
1301 : {
1302 : // The shape is a customshape: then inform it about the calculated fly size.
1303 704 : Size aSize((Frm().*fnRect->fnGetWidth)(), (Frm().*fnRect->fnGetHeight)());
1304 704 : pCustomShape->SuggestTextFrameSize(aSize);
1305 : // Do the calculations normally done after touching editeng text of the shape.
1306 704 : pCustomShape->NbcSetOutlinerParaObjectForText(0, 0);
1307 : }
1308 3421 : }
1309 : }
1310 : else
1311 : {
1312 6438 : mbValidSize = true; // Fixed Frms do not Format itself
1313 : // Flys set their size using the attr
1314 6438 : SwTwips nNewSize = bVert ? aRelSize.Width() : aRelSize.Height();
1315 6438 : nNewSize -= nUL;
1316 6438 : if( nNewSize < MINFLY )
1317 4 : nNewSize = MINFLY;
1318 6438 : (Prt().*fnRect->fnSetHeight)( nNewSize );
1319 6438 : nNewSize += nUL - (Frm().*fnRect->fnGetHeight)();
1320 6438 : (Frm().*fnRect->fnAddBottom)( nNewSize );
1321 : // #i68520#
1322 6438 : if ( nNewSize != 0 )
1323 : {
1324 1704 : InvalidateObjRectWithSpaces();
1325 : }
1326 : }
1327 :
1328 9859 : if ( !bFormatHeightOnly )
1329 : {
1330 : OSL_ENSURE( aRelSize == CalcRel( rFrmSz ), "SwFlyFrm::Format CalcRel problem" );
1331 9509 : SwTwips nNewSize = bVert ? aRelSize.Height() : aRelSize.Width();
1332 :
1333 9509 : if ( rFrmSz.GetWidthSizeType() != ATT_FIX_SIZE )
1334 : {
1335 : // #i9046# Autowidth for fly frames
1336 912 : const SwTwips nAutoWidth = CalcAutoWidth();
1337 912 : if ( nAutoWidth )
1338 : {
1339 912 : if( ATT_MIN_SIZE == rFrmSz.GetWidthSizeType() )
1340 912 : nNewSize = std::max( nNewSize - nLR, nAutoWidth );
1341 : else
1342 0 : nNewSize = nAutoWidth;
1343 : }
1344 : }
1345 : else
1346 8597 : nNewSize -= nLR;
1347 :
1348 9509 : if( nNewSize < MINFLY )
1349 24 : nNewSize = MINFLY;
1350 9509 : (Prt().*fnRect->fnSetWidth)( nNewSize );
1351 9509 : nNewSize += nLR - (Frm().*fnRect->fnGetWidth)();
1352 9509 : (Frm().*fnRect->fnAddRight)( nNewSize );
1353 : // #i68520#
1354 9509 : if ( nNewSize != 0 )
1355 : {
1356 246 : InvalidateObjRectWithSpaces();
1357 : }
1358 : }
1359 : }
1360 9859 : ColUnlock();
1361 9859 : }
1362 :
1363 : // OD 14.03.2003 #i11760# - change parameter <bNoColl>: type <bool>;
1364 : // default value = false.
1365 : // OD 14.03.2003 #i11760# - add new parameter <bNoCalcFollow> with
1366 : // default value = false.
1367 : // OD 11.04.2003 #108824# - new parameter <bNoCalcFollow> was used by method
1368 : // <FormatWidthCols(..)> to avoid follow formatting
1369 : // for text frames. But, unformatted follows causes
1370 : // problems in method <SwCntntFrm::_WouldFit(..)>,
1371 : // which assumes that the follows are formatted.
1372 : // Thus, <bNoCalcFollow> no longer used by <FormatWidthCols(..)>.
1373 1726 : void CalcCntnt( SwLayoutFrm *pLay,
1374 : bool bNoColl,
1375 : bool bNoCalcFollow )
1376 : {
1377 : SwSectionFrm* pSect;
1378 1726 : bool bCollect = false;
1379 1726 : if( pLay->IsSctFrm() )
1380 : {
1381 1726 : pSect = (SwSectionFrm*)pLay;
1382 1726 : if( pSect->IsEndnAtEnd() && !bNoColl )
1383 : {
1384 0 : bCollect = true;
1385 0 : SwLayouter::CollectEndnotes( pLay->GetFmt()->GetDoc(), pSect );
1386 : }
1387 1726 : pSect->CalcFtnCntnt();
1388 : }
1389 : else
1390 0 : pSect = NULL;
1391 1726 : SwFrm *pFrm = pLay->ContainsAny();
1392 1726 : if ( !pFrm )
1393 : {
1394 162 : if( pSect )
1395 : {
1396 162 : if( pSect->HasFollow() )
1397 86 : pFrm = pSect->GetFollow()->ContainsAny();
1398 162 : if( !pFrm )
1399 : {
1400 76 : if( pSect->IsEndnAtEnd() )
1401 : {
1402 0 : if( bCollect )
1403 0 : pLay->GetFmt()->GetDoc()->getIDocumentLayoutAccess().GetLayouter()->
1404 0 : InsertEndnotes( pSect );
1405 0 : bool bLock = pSect->IsFtnLock();
1406 0 : pSect->SetFtnLock( true );
1407 0 : pSect->CalcFtnCntnt();
1408 0 : pSect->CalcFtnCntnt();
1409 0 : pSect->SetFtnLock( bLock );
1410 : }
1411 76 : return;
1412 : }
1413 86 : pFrm->_InvalidatePos();
1414 : }
1415 : else
1416 0 : return;
1417 : }
1418 1650 : pFrm->InvalidatePage();
1419 :
1420 : do
1421 : {
1422 : // local variables to avoid loops caused by anchored object positioning
1423 1650 : SwAnchoredObject* pAgainObj1 = 0;
1424 1650 : SwAnchoredObject* pAgainObj2 = 0;
1425 :
1426 : // FME 2007-08-30 #i81146# new loop control
1427 1650 : sal_uInt16 nLoopControlRuns = 0;
1428 1650 : const sal_uInt16 nLoopControlMax = 20;
1429 1650 : const SwFrm* pLoopControlCond = 0;
1430 :
1431 : SwFrm* pLast;
1432 9238 : do
1433 : {
1434 9238 : pLast = pFrm;
1435 18476 : if( pFrm->IsVertical() ?
1436 0 : ( pFrm->GetUpper()->Prt().Height() != pFrm->Frm().Height() )
1437 9238 : : ( pFrm->GetUpper()->Prt().Width() != pFrm->Frm().Width() ) )
1438 : {
1439 944 : pFrm->Prepare( PREP_FIXSIZE_CHG );
1440 944 : pFrm->_InvalidateSize();
1441 : }
1442 :
1443 9238 : if ( pFrm->IsTabFrm() )
1444 : {
1445 42 : ((SwTabFrm*)pFrm)->bCalcLowers = true;
1446 : // OD 26.08.2003 #i18103# - lock move backward of follow table,
1447 : // if no section content is formatted or follow table belongs
1448 : // to the section, which content is formatted.
1449 42 : if ( ((SwTabFrm*)pFrm)->IsFollow() &&
1450 0 : ( !pSect || pSect == pFrm->FindSctFrm() ) )
1451 : {
1452 0 : ((SwTabFrm*)pFrm)->bLockBackMove = true;
1453 : }
1454 : }
1455 :
1456 : // OD 14.03.2003 #i11760# - forbid format of follow, if requested.
1457 9238 : if ( bNoCalcFollow && pFrm->IsTxtFrm() )
1458 0 : static_cast<SwTxtFrm*>(pFrm)->ForbidFollowFormat();
1459 :
1460 9238 : pFrm->Calc();
1461 :
1462 : // OD 14.03.2003 #i11760# - reset control flag for follow format.
1463 9238 : if ( pFrm->IsTxtFrm() )
1464 : {
1465 9196 : static_cast<SwTxtFrm*>(pFrm)->AllowFollowFormat();
1466 : }
1467 :
1468 : // #111937# The keep-attribute can cause the position
1469 : // of the prev to be invalid:
1470 : // OD 2004-03-15 #116560# - Do not consider invalid previous frame
1471 : // due to its keep-attribute, if current frame is a follow or is locked.
1472 : // #i44049# - do not consider invalid previous
1473 : // frame due to its keep-attribute, if it can't move forward.
1474 : // #i57765# - do not consider invalid previous
1475 : // frame, if current frame has a column/page break before attribute.
1476 9238 : SwFrm* pTmpPrev = pFrm->FindPrev();
1477 9238 : SwFlowFrm* pTmpPrevFlowFrm = pTmpPrev && pTmpPrev->IsFlowFrm() ? SwFlowFrm::CastFlowFrm(pTmpPrev) : 0;
1478 9238 : SwFlowFrm* pTmpFlowFrm = pFrm->IsFlowFrm() ? SwFlowFrm::CastFlowFrm(pFrm) : 0;
1479 :
1480 17632 : bool bPrevInvalid = pTmpPrevFlowFrm && pTmpFlowFrm &&
1481 17522 : !pTmpFlowFrm->IsFollow() &&
1482 17412 : !StackHack::IsLocked() && // #i76382#
1483 16972 : !pTmpFlowFrm->IsJoinLocked() &&
1484 8270 : !pTmpPrev->GetValidPosFlag() &&
1485 8 : pLay->IsAnLower( pTmpPrev ) &&
1486 9242 : pTmpPrevFlowFrm->IsKeep( *pTmpPrev->GetAttrSet() ) &&
1487 9238 : pTmpPrevFlowFrm->IsKeepFwdMoveAllowed();
1488 :
1489 : // format floating screen objects anchored to the frame.
1490 9238 : bool bRestartLayoutProcess = false;
1491 9238 : if ( !bPrevInvalid && pFrm->GetDrawObjs() && pLay->IsAnLower( pFrm ) )
1492 : {
1493 156 : bool bAgain = false;
1494 156 : SwPageFrm* pPageFrm = pFrm->FindPageFrm();
1495 156 : size_t nCnt = pFrm->GetDrawObjs()->size();
1496 156 : size_t i = 0;
1497 446 : while ( i < nCnt )
1498 : {
1499 : // #i28701#
1500 156 : SwAnchoredObject* pAnchoredObj = (*pFrm->GetDrawObjs())[i];
1501 :
1502 : // determine if anchored object has to be
1503 : // formatted and, in case, format it
1504 156 : if ( !pAnchoredObj->PositionLocked() && pAnchoredObj->IsFormatPossible() )
1505 : {
1506 : // #i43737# - no invalidation of
1507 : // anchored object needed - causes loops for as-character
1508 : // anchored objects.
1509 : //pAnchoredObj->InvalidateObjPos();
1510 82 : SwRect aRect( pAnchoredObj->GetObjRect() );
1511 82 : if ( !SwObjectFormatter::FormatObj( *pAnchoredObj, pFrm, pPageFrm ) )
1512 : {
1513 12 : bRestartLayoutProcess = true;
1514 34 : break;
1515 : }
1516 : // #i3317# - restart layout process,
1517 : // if the position of the anchored object is locked now.
1518 70 : if ( pAnchoredObj->PositionLocked() )
1519 : {
1520 10 : bRestartLayoutProcess = true;
1521 10 : break;
1522 : }
1523 :
1524 60 : if ( aRect != pAnchoredObj->GetObjRect() )
1525 : {
1526 0 : bAgain = true;
1527 0 : if ( pAgainObj2 == pAnchoredObj )
1528 : {
1529 : OSL_FAIL( "::CalcCntnt(..) - loop detected, perform attribute changes to avoid the loop" );
1530 : // Prevent oscillation
1531 0 : SwFrmFmt& rFmt = pAnchoredObj->GetFrmFmt();
1532 0 : SwFmtSurround aAttr( rFmt.GetSurround() );
1533 0 : if( SURROUND_THROUGHT != aAttr.GetSurround() )
1534 : {
1535 : // When on auto position, we can only set it to
1536 : // flow through
1537 0 : if ((rFmt.GetAnchor().GetAnchorId() ==
1538 0 : FLY_AT_CHAR) &&
1539 : (SURROUND_PARALLEL ==
1540 0 : aAttr.GetSurround()))
1541 : {
1542 0 : aAttr.SetSurround( SURROUND_THROUGHT );
1543 : }
1544 : else
1545 : {
1546 0 : aAttr.SetSurround( SURROUND_PARALLEL );
1547 : }
1548 0 : rFmt.LockModify();
1549 0 : rFmt.SetFmtAttr( aAttr );
1550 0 : rFmt.UnlockModify();
1551 0 : }
1552 : }
1553 : else
1554 : {
1555 0 : if ( pAgainObj1 == pAnchoredObj )
1556 0 : pAgainObj2 = pAnchoredObj;
1557 0 : pAgainObj1 = pAnchoredObj;
1558 : }
1559 : }
1560 :
1561 60 : if ( !pFrm->GetDrawObjs() )
1562 0 : break;
1563 60 : if ( pFrm->GetDrawObjs()->size() < nCnt )
1564 : {
1565 0 : --nCnt;
1566 : // Do not increment index, in this case
1567 0 : continue;
1568 : }
1569 : }
1570 134 : ++i;
1571 : }
1572 :
1573 : // #i28701# - restart layout process, if
1574 : // requested by floating screen object formatting
1575 156 : if ( bRestartLayoutProcess )
1576 : {
1577 22 : pFrm = pLay->ContainsAny();
1578 22 : pAgainObj1 = 0L;
1579 22 : pAgainObj2 = 0L;
1580 22 : continue;
1581 : }
1582 :
1583 : // OD 2004-05-17 #i28701# - format anchor frame after its objects
1584 : // are formatted, if the wrapping style influence has to be considered.
1585 134 : if ( pLay->GetFmt()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION) )
1586 : {
1587 74 : pFrm->Calc();
1588 : }
1589 :
1590 134 : if ( bAgain )
1591 : {
1592 0 : pFrm = pLay->ContainsCntnt();
1593 0 : if ( pFrm && pFrm->IsInTab() )
1594 0 : pFrm = pFrm->FindTabFrm();
1595 0 : if( pFrm && pFrm->IsInSct() )
1596 : {
1597 0 : SwSectionFrm* pTmp = pFrm->FindSctFrm();
1598 0 : if( pTmp != pLay && pLay->IsAnLower( pTmp ) )
1599 0 : pFrm = pTmp;
1600 : }
1601 :
1602 0 : if ( pFrm == pLoopControlCond )
1603 0 : ++nLoopControlRuns;
1604 : else
1605 : {
1606 0 : nLoopControlRuns = 0;
1607 0 : pLoopControlCond = pFrm;
1608 : }
1609 :
1610 0 : if ( nLoopControlRuns < nLoopControlMax )
1611 0 : continue;
1612 :
1613 : OSL_FAIL( "LoopControl in CalcCntnt" );
1614 : }
1615 : }
1616 9216 : if ( pFrm->IsTabFrm() )
1617 : {
1618 42 : if ( ((SwTabFrm*)pFrm)->IsFollow() )
1619 0 : ((SwTabFrm*)pFrm)->bLockBackMove = false;
1620 : }
1621 :
1622 9216 : pFrm = bPrevInvalid ? pTmpPrev : pFrm->FindNext();
1623 9216 : if( !bPrevInvalid && pFrm && pFrm->IsSctFrm() && pSect )
1624 : {
1625 : // Empty SectionFrms could be present here
1626 5474 : while( pFrm && pFrm->IsSctFrm() && !((SwSectionFrm*)pFrm)->GetSection() )
1627 2166 : pFrm = pFrm->FindNext();
1628 :
1629 : // If FindNext returns the Follow of the original Area, we want to
1630 : // continue with this content as long as it flows back.
1631 2454 : if( pFrm && pFrm->IsSctFrm() && ( pFrm == pSect->GetFollow() ||
1632 800 : ((SwSectionFrm*)pFrm)->IsAnFollow( pSect ) ) )
1633 : {
1634 706 : pFrm = ((SwSectionFrm*)pFrm)->ContainsAny();
1635 706 : if( pFrm )
1636 684 : pFrm->_InvalidatePos();
1637 : }
1638 : }
1639 : // Stay in the pLay
1640 : // Except for SectionFrms with Follow: the first CntntFrm of the Follow
1641 : // will be formatted, so that it get's a chance to load in the pLay.
1642 : // As long as these Frames are loading in pLay, we continue
1643 25752 : } while ( pFrm &&
1644 10914 : ( pLay->IsAnLower( pFrm ) ||
1645 1988 : ( pSect &&
1646 2998 : ( ( pSect->HasFollow() &&
1647 1370 : ( pLay->IsAnLower( pLast ) ||
1648 720 : ( pLast->IsInSct() &&
1649 1010 : pLast->FindSctFrm()->IsAnFollow(pSect) ) ) &&
1650 1988 : pSect->GetFollow()->IsAnLower( pFrm ) ) ||
1651 2336 : ( pFrm->IsInSct() &&
1652 998 : pFrm->FindSctFrm()->IsAnFollow( pSect ) ) ) ) ) );
1653 1650 : if( pSect )
1654 : {
1655 1650 : if( bCollect )
1656 : {
1657 0 : pLay->GetFmt()->GetDoc()->getIDocumentLayoutAccess().GetLayouter()->InsertEndnotes(pSect);
1658 0 : pSect->CalcFtnCntnt();
1659 : }
1660 1650 : if( pSect->HasFollow() )
1661 : {
1662 376 : SwSectionFrm* pNxt = pSect->GetFollow();
1663 752 : while( pNxt && !pNxt->ContainsCntnt() )
1664 0 : pNxt = pNxt->GetFollow();
1665 376 : if( pNxt )
1666 376 : pNxt->CalcFtnCntnt();
1667 : }
1668 1650 : if( bCollect )
1669 : {
1670 0 : pFrm = pLay->ContainsAny();
1671 0 : bCollect = false;
1672 0 : if( pFrm )
1673 0 : continue;
1674 : }
1675 : }
1676 1650 : break;
1677 : }
1678 0 : while( true );
1679 : }
1680 :
1681 : // OD 2004-03-23 #i26791#
1682 162 : void SwFlyFrm::MakeObjPos()
1683 : {
1684 162 : if ( !mbValidPos )
1685 : {
1686 162 : mbValidPos = true;
1687 :
1688 : // OD 29.10.2003 #113049# - use new class to position object
1689 162 : GetAnchorFrm()->Calc();
1690 : objectpositioning::SwToLayoutAnchoredObjectPosition
1691 162 : aObjPositioning( *GetVirtDrawObj() );
1692 162 : aObjPositioning.CalcPosition();
1693 :
1694 : // #i58280#
1695 : // update relative position
1696 162 : SetCurrRelPos( aObjPositioning.GetRelPos() );
1697 :
1698 162 : SWRECTFN( GetAnchorFrm() );
1699 162 : maFrm.Pos( aObjPositioning.GetRelPos() );
1700 162 : maFrm.Pos() += (GetAnchorFrm()->Frm().*fnRect->fnGetPos)();
1701 : // #i69335#
1702 162 : InvalidateObjRectWithSpaces();
1703 : }
1704 162 : }
1705 :
1706 9859 : void SwFlyFrm::MakePrtArea( const SwBorderAttrs &rAttrs )
1707 : {
1708 9859 : if ( !mbValidPrtArea )
1709 : {
1710 9859 : mbValidPrtArea = true;
1711 :
1712 : // OD 31.07.2003 #110978# - consider vertical layout
1713 9859 : SWRECTFN( this )
1714 9859 : (this->*fnRect->fnSetXMargins)( rAttrs.CalcLeftLine(),
1715 19718 : rAttrs.CalcRightLine() );
1716 9859 : (this->*fnRect->fnSetYMargins)( rAttrs.CalcTopLine(),
1717 19718 : rAttrs.CalcBottomLine() );
1718 : }
1719 9859 : }
1720 :
1721 10785 : void SwFlyFrm::MakeContentPos( const SwBorderAttrs &rAttrs )
1722 : {
1723 10785 : if ( !m_bValidContentPos )
1724 : {
1725 10785 : m_bValidContentPos = true;
1726 :
1727 10785 : const SwTwips nUL = rAttrs.CalcTopLine() + rAttrs.CalcBottomLine();
1728 10785 : Size aRelSize( CalcRel( GetFmt()->GetFrmSize() ) );
1729 :
1730 10785 : SWRECTFN( this )
1731 10785 : long nMinHeight = 0;
1732 10785 : if( IsMinHeight() )
1733 366 : nMinHeight = bVert ? aRelSize.Width() : aRelSize.Height();
1734 :
1735 10785 : Point aNewContentPos;
1736 10785 : aNewContentPos = Prt().Pos();
1737 10785 : const SdrTextVertAdjust nAdjust = GetFmt()->GetTextVertAdjust().GetValue();
1738 10785 : if( nAdjust != SDRTEXTVERTADJUST_TOP )
1739 : {
1740 1924 : SwTwips nDiff = (Prt().*fnRect->fnGetHeight)() - CalcContentHeight(&rAttrs, nMinHeight, nUL);
1741 1924 : if( nDiff > 0 )
1742 : {
1743 1864 : if( nAdjust == SDRTEXTVERTADJUST_CENTER )
1744 : {
1745 1758 : if( bVertL2R )
1746 0 : aNewContentPos.setX(aNewContentPos.getX() + nDiff/2);
1747 1758 : else if( bVert )
1748 0 : aNewContentPos.setX(aNewContentPos.getX() - nDiff/2);
1749 : else
1750 1758 : aNewContentPos.setY(aNewContentPos.getY() + nDiff/2);
1751 : }
1752 106 : else if( nAdjust == SDRTEXTVERTADJUST_BOTTOM )
1753 : {
1754 106 : if( bVertL2R )
1755 0 : aNewContentPos.setX(aNewContentPos.getX() + nDiff);
1756 106 : else if( bVert )
1757 0 : aNewContentPos.setX(aNewContentPos.getX() - nDiff);
1758 : else
1759 106 : aNewContentPos.setY(aNewContentPos.getY() + nDiff);
1760 : }
1761 : }
1762 : }
1763 10785 : if( aNewContentPos != ContentPos() )
1764 : {
1765 1754 : ContentPos() = aNewContentPos;
1766 4124 : for( SwFrm *pFrm = Lower(); pFrm; pFrm = pFrm->GetNext())
1767 : {
1768 2370 : pFrm->InvalidatePos();
1769 : }
1770 : }
1771 : }
1772 10785 : }
1773 :
1774 1218 : void SwFlyFrm::InvalidateContentPos()
1775 : {
1776 1218 : m_bValidContentPos = false;
1777 1218 : _Invalidate();
1778 1218 : }
1779 :
1780 1816 : SwTwips SwFlyFrm::_Grow( SwTwips nDist, bool bTst )
1781 : {
1782 1816 : SWRECTFN( this )
1783 1816 : if ( Lower() && !IsColLocked() && !HasFixSize() )
1784 : {
1785 1288 : SwTwips nSize = (Frm().*fnRect->fnGetHeight)();
1786 1288 : if( nSize > 0 && nDist > ( LONG_MAX - nSize ) )
1787 0 : nDist = LONG_MAX - nSize;
1788 :
1789 1288 : if ( nDist <= 0L )
1790 0 : return 0L;
1791 :
1792 1288 : if ( Lower()->IsColumnFrm() )
1793 : { // If it's a Column Frame, the Format takes control of the
1794 : // resizing (due to the adjustment).
1795 0 : if ( !bTst )
1796 : {
1797 : // #i28701# - unlock position of Writer fly frame
1798 0 : UnlockPosition();
1799 0 : _InvalidatePos();
1800 0 : InvalidateSize();
1801 : }
1802 0 : return 0L;
1803 : }
1804 :
1805 1288 : if ( !bTst )
1806 : {
1807 1288 : const SwRect aOld( GetObjRectWithSpaces() );
1808 1288 : _InvalidateSize();
1809 1288 : const bool bOldLock = bLocked;
1810 1288 : Unlock();
1811 1288 : if ( IsFlyFreeFrm() )
1812 : {
1813 : // #i37068# - no format of position here
1814 : // and prevent move in method <CheckClip(..)>.
1815 : // This is needed to prevent layout loop caused by nested
1816 : // Writer fly frames - inner Writer fly frames format its
1817 : // anchor, which grows/shrinks the outer Writer fly frame.
1818 : // Note: position will be invalidated below.
1819 1258 : mbValidPos = true;
1820 : // #i55416#
1821 : // Suppress format of width for autowidth frame, because the
1822 : // format of the width would call <SwTxtFrm::CalcFitToContent()>
1823 : // for the lower frame, which initiated this grow.
1824 1258 : const bool bOldFormatHeightOnly = bFormatHeightOnly;
1825 1258 : const SwFmtFrmSize& rFrmSz = GetFmt()->GetFrmSize();
1826 1258 : if ( rFrmSz.GetWidthSizeType() != ATT_FIX_SIZE )
1827 : {
1828 348 : bFormatHeightOnly = true;
1829 : }
1830 1258 : static_cast<SwFlyFreeFrm*>(this)->SetNoMoveOnCheckClip( true );
1831 1258 : ((SwFlyFreeFrm*)this)->SwFlyFreeFrm::MakeAll();
1832 1258 : static_cast<SwFlyFreeFrm*>(this)->SetNoMoveOnCheckClip( false );
1833 : // #i55416#
1834 1258 : if ( rFrmSz.GetWidthSizeType() != ATT_FIX_SIZE )
1835 : {
1836 348 : bFormatHeightOnly = bOldFormatHeightOnly;
1837 : }
1838 : }
1839 : else
1840 30 : MakeAll();
1841 1288 : _InvalidateSize();
1842 1288 : InvalidatePos();
1843 1288 : if ( bOldLock )
1844 0 : Lock();
1845 1288 : const SwRect aNew( GetObjRectWithSpaces() );
1846 1288 : if ( aOld != aNew )
1847 1000 : ::Notify( this, FindPageFrm(), aOld );
1848 1288 : return (aNew.*fnRect->fnGetHeight)()-(aOld.*fnRect->fnGetHeight)();
1849 : }
1850 0 : return nDist;
1851 : }
1852 528 : return 0L;
1853 : }
1854 :
1855 24 : SwTwips SwFlyFrm::_Shrink( SwTwips nDist, bool bTst )
1856 : {
1857 24 : if( Lower() && !IsColLocked() && !HasFixSize() && !IsNoShrink() )
1858 : {
1859 12 : SWRECTFN( this )
1860 12 : SwTwips nHeight = (Frm().*fnRect->fnGetHeight)();
1861 12 : if ( nDist > nHeight )
1862 0 : nDist = nHeight;
1863 :
1864 12 : SwTwips nVal = nDist;
1865 12 : if ( IsMinHeight() )
1866 : {
1867 2 : const SwFmtFrmSize& rFmtSize = GetFmt()->GetFrmSize();
1868 2 : SwTwips nFmtHeight = bVert ? rFmtSize.GetWidth() : rFmtSize.GetHeight();
1869 :
1870 2 : nVal = std::min( nDist, nHeight - nFmtHeight );
1871 : }
1872 :
1873 12 : if ( nVal <= 0L )
1874 0 : return 0L;
1875 :
1876 12 : if ( Lower()->IsColumnFrm() )
1877 : { // If it's a Column Frame, the Format takes control of the
1878 : // resizing (due to the adjustment).
1879 0 : if ( !bTst )
1880 : {
1881 0 : SwRect aOld( GetObjRectWithSpaces() );
1882 0 : (Frm().*fnRect->fnSetHeight)( nHeight - nVal );
1883 : // #i68520#
1884 0 : if ( nHeight - nVal != 0 )
1885 : {
1886 0 : InvalidateObjRectWithSpaces();
1887 : }
1888 0 : nHeight = (Prt().*fnRect->fnGetHeight)();
1889 0 : (Prt().*fnRect->fnSetHeight)( nHeight - nVal );
1890 0 : _InvalidatePos();
1891 0 : InvalidateSize();
1892 0 : ::Notify( this, FindPageFrm(), aOld );
1893 0 : NotifyDrawObj();
1894 0 : if ( GetAnchorFrm()->IsInFly() )
1895 0 : AnchorFrm()->FindFlyFrm()->Shrink( nDist, bTst );
1896 : }
1897 0 : return 0L;
1898 : }
1899 :
1900 12 : if ( !bTst )
1901 : {
1902 12 : const SwRect aOld( GetObjRectWithSpaces() );
1903 12 : _InvalidateSize();
1904 12 : const bool bOldLocked = bLocked;
1905 12 : Unlock();
1906 12 : if ( IsFlyFreeFrm() )
1907 : {
1908 : // #i37068# - no format of position here
1909 : // and prevent move in method <CheckClip(..)>.
1910 : // This is needed to prevent layout loop caused by nested
1911 : // Writer fly frames - inner Writer fly frames format its
1912 : // anchor, which grows/shrinks the outer Writer fly frame.
1913 : // Note: position will be invalidated below.
1914 12 : mbValidPos = true;
1915 : // #i55416#
1916 : // Suppress format of width for autowidth frame, because the
1917 : // format of the width would call <SwTxtFrm::CalcFitToContent()>
1918 : // for the lower frame, which initiated this shrink.
1919 12 : const bool bOldFormatHeightOnly = bFormatHeightOnly;
1920 12 : const SwFmtFrmSize& rFrmSz = GetFmt()->GetFrmSize();
1921 12 : if ( rFrmSz.GetWidthSizeType() != ATT_FIX_SIZE )
1922 : {
1923 2 : bFormatHeightOnly = true;
1924 : }
1925 12 : static_cast<SwFlyFreeFrm*>(this)->SetNoMoveOnCheckClip( true );
1926 12 : ((SwFlyFreeFrm*)this)->SwFlyFreeFrm::MakeAll();
1927 12 : static_cast<SwFlyFreeFrm*>(this)->SetNoMoveOnCheckClip( false );
1928 : // #i55416#
1929 12 : if ( rFrmSz.GetWidthSizeType() != ATT_FIX_SIZE )
1930 : {
1931 2 : bFormatHeightOnly = bOldFormatHeightOnly;
1932 : }
1933 : }
1934 : else
1935 0 : MakeAll();
1936 12 : _InvalidateSize();
1937 12 : InvalidatePos();
1938 12 : if ( bOldLocked )
1939 0 : Lock();
1940 12 : const SwRect aNew( GetObjRectWithSpaces() );
1941 12 : if ( aOld != aNew )
1942 : {
1943 12 : ::Notify( this, FindPageFrm(), aOld );
1944 12 : if ( GetAnchorFrm()->IsInFly() )
1945 0 : AnchorFrm()->FindFlyFrm()->Shrink( nDist, bTst );
1946 : }
1947 12 : return (aOld.*fnRect->fnGetHeight)() -
1948 12 : (aNew.*fnRect->fnGetHeight)();
1949 : }
1950 0 : return nVal;
1951 : }
1952 12 : return 0L;
1953 : }
1954 :
1955 22 : Size SwFlyFrm::ChgSize( const Size& aNewSize )
1956 : {
1957 : // #i53298#
1958 : // If the fly frame anchored at-paragraph or at-character contains an OLE
1959 : // object, assure that the new size fits into the current clipping area
1960 : // of the fly frame
1961 22 : Size aAdjustedNewSize( aNewSize );
1962 : {
1963 50 : if ( dynamic_cast<SwFlyAtCntFrm*>(this) &&
1964 56 : Lower() && dynamic_cast<SwNoTxtFrm*>(Lower()) &&
1965 6 : static_cast<SwNoTxtFrm*>(Lower())->GetNode()->GetOLENode() )
1966 : {
1967 6 : SwRect aClipRect;
1968 6 : ::CalcClipRect( GetVirtDrawObj(), aClipRect, false );
1969 6 : if ( aAdjustedNewSize.Width() > aClipRect.Width() )
1970 : {
1971 0 : aAdjustedNewSize.setWidth( aClipRect.Width() );
1972 : }
1973 6 : if ( aAdjustedNewSize.Height() > aClipRect.Height() )
1974 : {
1975 0 : aAdjustedNewSize.setWidth( aClipRect.Height() );
1976 : }
1977 : }
1978 : }
1979 22 : if ( aAdjustedNewSize != Frm().SSize() )
1980 : {
1981 22 : SwFrmFmt *pFmt = GetFmt();
1982 22 : SwFmtFrmSize aSz( pFmt->GetFrmSize() );
1983 22 : aSz.SetWidth( aAdjustedNewSize.Width() );
1984 22 : aSz.SetHeight( aAdjustedNewSize.Height() );
1985 : // go via the Doc for UNDO
1986 22 : pFmt->GetDoc()->SetAttr( aSz, *pFmt );
1987 22 : return aSz.GetSize();
1988 : }
1989 : else
1990 0 : return Frm().SSize();
1991 : }
1992 :
1993 13480 : bool SwFlyFrm::IsLowerOf( const SwLayoutFrm* pUpperFrm ) const
1994 : {
1995 : OSL_ENSURE( GetAnchorFrm(), "8-( Fly is lost in Space." );
1996 13480 : const SwFrm* pFrm = GetAnchorFrm();
1997 54882 : do
1998 : {
1999 54944 : if ( pFrm == pUpperFrm )
2000 62 : return true;
2001 54882 : pFrm = pFrm->IsFlyFrm()
2002 2 : ? ((const SwFlyFrm*)pFrm)->GetAnchorFrm()
2003 54884 : : pFrm->GetUpper();
2004 : } while ( pFrm );
2005 13418 : return false;
2006 : }
2007 :
2008 38 : void SwFlyFrm::Cut()
2009 : {
2010 : // TODO: Implement SwFlyFrm::Cut()
2011 38 : }
2012 :
2013 4014 : void SwFrm::AppendFly( SwFlyFrm *pNew )
2014 : {
2015 4014 : if ( !mpDrawObjs )
2016 2168 : mpDrawObjs = new SwSortedObjs();
2017 4014 : mpDrawObjs->Insert( *pNew );
2018 4014 : pNew->ChgAnchorFrm( this );
2019 :
2020 : // Register at the page
2021 : // If there's none present, register via SwPageFrm::PreparePage
2022 4014 : SwPageFrm* pPage = FindPageFrm();
2023 4014 : if ( pPage != NULL )
2024 : {
2025 3238 : pPage->AppendFlyToPage( pNew );
2026 : }
2027 4014 : }
2028 :
2029 4014 : void SwFrm::RemoveFly( SwFlyFrm *pToRemove )
2030 : {
2031 : // Deregister from the page
2032 : // Could already have happened, if the page was already destructed
2033 4014 : SwPageFrm *pPage = pToRemove->FindPageFrm();
2034 4014 : if ( pPage && pPage->GetSortedObjs() )
2035 : {
2036 386 : pPage->RemoveFlyFromPage( pToRemove );
2037 : }
2038 : // #i73201#
2039 : else
2040 : {
2041 10884 : if ( pToRemove->IsAccessibleFrm() &&
2042 7256 : pToRemove->GetFmt() &&
2043 3628 : !pToRemove->IsFlyInCntFrm() )
2044 : {
2045 2090 : SwRootFrm *pRootFrm = getRootFrm();
2046 2090 : if( pRootFrm && pRootFrm->IsAnyShellAccessible() )
2047 : {
2048 0 : SwViewShell *pVSh = pRootFrm->GetCurrShell();
2049 0 : if( pVSh && pVSh->Imp() )
2050 : {
2051 0 : pVSh->Imp()->DisposeAccessibleFrm( pToRemove );
2052 : }
2053 : }
2054 : }
2055 : }
2056 :
2057 4014 : mpDrawObjs->Remove( *pToRemove );
2058 4014 : if ( !mpDrawObjs->size() )
2059 2266 : DELETEZ( mpDrawObjs );
2060 :
2061 4014 : pToRemove->ChgAnchorFrm( 0 );
2062 :
2063 4014 : if ( !pToRemove->IsFlyInCntFrm() && GetUpper() && IsInTab() )//MA_FLY_HEIGHT
2064 32 : GetUpper()->InvalidateSize();
2065 4014 : }
2066 :
2067 4152 : void SwFrm::AppendDrawObj( SwAnchoredObject& _rNewObj )
2068 : {
2069 4152 : if ( !_rNewObj.ISA(SwAnchoredDrawObject) )
2070 : {
2071 : OSL_FAIL( "SwFrm::AppendDrawObj(..) - anchored object of unexpected type -> object not appended" );
2072 4152 : return;
2073 : }
2074 :
2075 11758 : if ( !_rNewObj.GetDrawObj()->ISA(SwDrawVirtObj) &&
2076 4152 : _rNewObj.GetAnchorFrm() && _rNewObj.GetAnchorFrm() != this )
2077 : {
2078 : // perform disconnect from layout, if 'master' drawing object is appended
2079 : // to a new frame.
2080 0 : static_cast<SwDrawContact*>(::GetUserCall( _rNewObj.GetDrawObj() ))->
2081 0 : DisconnectFromLayout( false );
2082 : }
2083 :
2084 4152 : if ( _rNewObj.GetAnchorFrm() != this )
2085 : {
2086 4152 : if ( !mpDrawObjs )
2087 2380 : mpDrawObjs = new SwSortedObjs();
2088 4152 : mpDrawObjs->Insert( _rNewObj );
2089 4152 : _rNewObj.ChgAnchorFrm( this );
2090 : }
2091 :
2092 : // #i113730#
2093 : // Assure the control objects and group objects containing controls are on the control layer
2094 4152 : if ( ::CheckControlLayer( _rNewObj.DrawObj() ) )
2095 : {
2096 544 : const IDocumentDrawModelAccess* pIDDMA = getIDocumentDrawModelAccess();
2097 544 : const SdrLayerID aCurrentLayer(_rNewObj.DrawObj()->GetLayer());
2098 544 : const SdrLayerID aControlLayerID(pIDDMA->GetControlsId());
2099 544 : const SdrLayerID aInvisibleControlLayerID(pIDDMA->GetInvisibleControlsId());
2100 :
2101 544 : if(aCurrentLayer != aControlLayerID && aCurrentLayer != aInvisibleControlLayerID)
2102 : {
2103 0 : if ( aCurrentLayer == pIDDMA->GetInvisibleHellId() ||
2104 0 : aCurrentLayer == pIDDMA->GetInvisibleHeavenId() )
2105 : {
2106 0 : _rNewObj.DrawObj()->SetLayer(aInvisibleControlLayerID);
2107 : }
2108 : else
2109 : {
2110 0 : _rNewObj.DrawObj()->SetLayer(aControlLayerID);
2111 : }
2112 : }
2113 : }
2114 :
2115 : // no direct positioning needed, but invalidate the drawing object position
2116 4152 : _rNewObj.InvalidateObjPos();
2117 :
2118 : // register at page frame
2119 4152 : SwPageFrm* pPage = FindPageFrm();
2120 4152 : if ( pPage )
2121 : {
2122 3452 : pPage->AppendDrawObjToPage( _rNewObj );
2123 : }
2124 :
2125 : // Notify accessible layout.
2126 4152 : SwViewShell* pSh = getRootFrm()->GetCurrShell();
2127 4152 : if( pSh )
2128 : {
2129 3994 : SwRootFrm* pLayout = getRootFrm();
2130 3994 : if( pLayout && pLayout->IsAnyShellAccessible() )
2131 0 : pSh->Imp()->AddAccessibleObj( _rNewObj.GetDrawObj() );
2132 : }
2133 : }
2134 :
2135 4152 : void SwFrm::RemoveDrawObj( SwAnchoredObject& _rToRemoveObj )
2136 : {
2137 : // Notify accessible layout.
2138 4152 : SwViewShell* pSh = getRootFrm()->GetCurrShell();
2139 4152 : if( pSh )
2140 : {
2141 632 : SwRootFrm* pLayout = getRootFrm();
2142 632 : if( pLayout && pLayout->IsAnyShellAccessible() )
2143 0 : pSh->Imp()->DisposeAccessibleObj( _rToRemoveObj.GetDrawObj() );
2144 : }
2145 :
2146 : // deregister from page frame
2147 4152 : SwPageFrm* pPage = _rToRemoveObj.GetPageFrm();
2148 4152 : if ( pPage && pPage->GetSortedObjs() )
2149 732 : pPage->RemoveDrawObjFromPage( _rToRemoveObj );
2150 :
2151 4152 : mpDrawObjs->Remove( _rToRemoveObj );
2152 4152 : if ( !mpDrawObjs->size() )
2153 2282 : DELETEZ( mpDrawObjs );
2154 :
2155 4152 : _rToRemoveObj.ChgAnchorFrm( 0 );
2156 4152 : }
2157 :
2158 80097 : void SwFrm::InvalidateObjs( const bool _bInvaPosOnly,
2159 : const bool _bNoInvaOfAsCharAnchoredObjs )
2160 : {
2161 80097 : if ( GetDrawObjs() )
2162 : {
2163 : // #i26945# - determine page the frame is on,
2164 : // in order to check, if anchored object is registered at the same
2165 : // page.
2166 4600 : const SwPageFrm* pPageFrm = FindPageFrm();
2167 : // #i28701# - re-factoring
2168 12008 : for ( size_t i = 0; i < GetDrawObjs()->size(); ++i )
2169 : {
2170 7408 : SwAnchoredObject* pAnchoredObj = (*GetDrawObjs())[i];
2171 14816 : if ( _bNoInvaOfAsCharAnchoredObjs &&
2172 7408 : (pAnchoredObj->GetFrmFmt().GetAnchor().GetAnchorId()
2173 : == FLY_AS_CHAR) )
2174 : {
2175 2280 : continue;
2176 : }
2177 : // #i26945# - no invalidation, if anchored object
2178 : // isn't registered at the same page and instead is registered at
2179 : // the page, where its anchor character text frame is on.
2180 10256 : if ( pAnchoredObj->GetPageFrm() &&
2181 5128 : pAnchoredObj->GetPageFrm() != pPageFrm )
2182 : {
2183 56 : SwTxtFrm* pAnchorCharFrm = pAnchoredObj->FindAnchorCharFrm();
2184 68 : if ( pAnchorCharFrm &&
2185 12 : pAnchoredObj->GetPageFrm() == pAnchorCharFrm->FindPageFrm() )
2186 : {
2187 0 : continue;
2188 : }
2189 : // #115759# - unlock its position, if anchored
2190 : // object isn't registered at the page, where its anchor
2191 : // character text frame is on, respectively if it has no
2192 : // anchor character text frame.
2193 : else
2194 : {
2195 56 : pAnchoredObj->UnlockPosition();
2196 : }
2197 : }
2198 : // #i51474# - reset flag, that anchored object
2199 : // has cleared environment, and unlock its position, if the anchored
2200 : // object is registered at the same page as the anchor frame is on.
2201 10256 : if ( pAnchoredObj->ClearedEnvironment() &&
2202 5128 : pAnchoredObj->GetPageFrm() &&
2203 0 : pAnchoredObj->GetPageFrm() == pPageFrm )
2204 : {
2205 0 : pAnchoredObj->UnlockPosition();
2206 0 : pAnchoredObj->SetClearedEnvironment( false );
2207 : }
2208 : // distinguish between writer fly frames and drawing objects
2209 5128 : if ( pAnchoredObj->ISA(SwFlyFrm) )
2210 : {
2211 2508 : SwFlyFrm* pFly = static_cast<SwFlyFrm*>(pAnchoredObj);
2212 2508 : pFly->_Invalidate();
2213 2508 : pFly->_InvalidatePos();
2214 2508 : if ( !_bInvaPosOnly )
2215 0 : pFly->_InvalidateSize();
2216 : }
2217 : else
2218 : {
2219 2620 : pAnchoredObj->InvalidateObjPos();
2220 : }
2221 : } // end of loop on objects, which are connected to the frame
2222 : }
2223 80097 : }
2224 :
2225 : // #i26945# - correct check, if anchored object is a lower
2226 : // of the layout frame. E.g., anchor character text frame can be a follow text
2227 : // frame.
2228 : // #i44016# - add parameter <_bUnlockPosOfObjs> to
2229 : // force an unlockposition call for the lower objects.
2230 109536 : void SwLayoutFrm::NotifyLowerObjs( const bool _bUnlockPosOfObjs )
2231 : {
2232 : // invalidate lower floating screen objects
2233 109536 : SwPageFrm* pPageFrm = FindPageFrm();
2234 109536 : if ( pPageFrm && pPageFrm->GetSortedObjs() )
2235 : {
2236 28782 : SwSortedObjs& rObjs = *(pPageFrm->GetSortedObjs());
2237 156310 : for ( size_t i = 0; i < rObjs.size(); ++i )
2238 : {
2239 127528 : SwAnchoredObject* pObj = rObjs[i];
2240 : // #i26945# - check, if anchored object is a lower
2241 : // of the layout frame is changed to check, if its anchor frame
2242 : // is a lower of the layout frame.
2243 : // determine the anchor frame - usually it's the anchor frame,
2244 : // for at-character/as-character anchored objects the anchor character
2245 : // text frame is taken.
2246 127528 : const SwFrm* pAnchorFrm = pObj->GetAnchorFrmContainingAnchPos();
2247 127528 : if ( pObj->ISA(SwFlyFrm) )
2248 : {
2249 61382 : SwFlyFrm* pFly = static_cast<SwFlyFrm*>(pObj);
2250 :
2251 61382 : if ( pFly->Frm().Left() == FAR_AWAY )
2252 19066 : continue;
2253 :
2254 42316 : if ( pFly->IsAnLower( this ) )
2255 6516 : continue;
2256 :
2257 : // #i26945# - use <pAnchorFrm> to check, if
2258 : // fly frame is lower of layout frame resp. if fly frame is
2259 : // at a different page registered as its anchor frame is on.
2260 35800 : const bool bLow = IsAnLower( pAnchorFrm );
2261 35800 : if ( bLow || pAnchorFrm->FindPageFrm() != pPageFrm )
2262 : {
2263 2138 : pFly->_Invalidate( pPageFrm );
2264 2138 : if ( !bLow || pFly->IsFlyAtCntFrm() )
2265 : {
2266 : // #i44016#
2267 2138 : if ( _bUnlockPosOfObjs )
2268 : {
2269 756 : pFly->UnlockPosition();
2270 : }
2271 2138 : pFly->_InvalidatePos();
2272 : }
2273 : else
2274 0 : pFly->_InvalidatePrt();
2275 : }
2276 : }
2277 : else
2278 : {
2279 : OSL_ENSURE( pObj->ISA(SwAnchoredDrawObject),
2280 : "<SwLayoutFrm::NotifyFlys() - anchored object of unexpected type" );
2281 : // #i26945# - use <pAnchorFrm> to check, if
2282 : // fly frame is lower of layout frame resp. if fly frame is
2283 : // at a different page registered as its anchor frame is on.
2284 130214 : if ( IsAnLower( pAnchorFrm ) ||
2285 64068 : pAnchorFrm->FindPageFrm() != pPageFrm )
2286 : {
2287 : // #i44016#
2288 2080 : if ( _bUnlockPosOfObjs )
2289 : {
2290 706 : pObj->UnlockPosition();
2291 : }
2292 2080 : pObj->InvalidateObjPos();
2293 : }
2294 : }
2295 : }
2296 : }
2297 109536 : }
2298 :
2299 9106 : void SwFlyFrm::NotifyDrawObj()
2300 : {
2301 9106 : SwVirtFlyDrawObj* pObj = GetVirtDrawObj();
2302 9106 : pObj->SetRect();
2303 9106 : pObj->SetRectsDirty();
2304 9106 : pObj->SetChanged();
2305 9106 : pObj->BroadcastObjectChange();
2306 9106 : if ( GetFmt()->GetSurround().IsContour() )
2307 21 : ClrContourCache( pObj );
2308 9106 : }
2309 :
2310 20644 : Size SwFlyFrm::CalcRel( const SwFmtFrmSize &rSz ) const
2311 : {
2312 20644 : Size aRet( rSz.GetSize() );
2313 :
2314 20644 : const SwFrm *pRel = IsFlyLayFrm() ? GetAnchorFrm() : GetAnchorFrm()->GetUpper();
2315 20644 : if( pRel ) // LAYER_IMPL
2316 : {
2317 20644 : long nRelWidth = LONG_MAX, nRelHeight = LONG_MAX;
2318 20644 : const SwViewShell *pSh = getRootFrm()->GetCurrShell();
2319 50080 : if ( ( pRel->IsBodyFrm() || pRel->IsPageFrm() ) &&
2320 33312 : pSh && pSh->GetViewOptions()->getBrowseMode() &&
2321 16 : pSh->VisArea().HasArea() )
2322 : {
2323 16 : nRelWidth = pSh->GetBrowseWidth();
2324 16 : nRelHeight = pSh->VisArea().Height();
2325 16 : Size aBorder = pSh->GetOut()->PixelToLogic( pSh->GetBrowseBorder() );
2326 16 : long nDiff = nRelWidth - pRel->Prt().Width();
2327 16 : if ( nDiff > 0 )
2328 0 : nRelWidth -= nDiff;
2329 16 : nRelHeight -= 2*aBorder.Height();
2330 16 : nDiff = nRelHeight - pRel->Prt().Height();
2331 16 : if ( nDiff > 0 )
2332 0 : nRelHeight -= nDiff;
2333 : }
2334 :
2335 : // At the moment only the "== PAGE_FRAME" and "!= PAGE_FRAME" cases are handled.
2336 : // When size is a relative to page size, ignore size of SwBodyFrm.
2337 20644 : if (rSz.GetWidthPercentRelation() != text::RelOrientation::PAGE_FRAME)
2338 20596 : nRelWidth = std::min( nRelWidth, pRel->Prt().Width() );
2339 20644 : if (rSz.GetHeightPercentRelation() != text::RelOrientation::PAGE_FRAME)
2340 20620 : nRelHeight = std::min( nRelHeight, pRel->Prt().Height() );
2341 20644 : if( !pRel->IsPageFrm() )
2342 : {
2343 19844 : const SwPageFrm* pPage = FindPageFrm();
2344 19844 : if( pPage )
2345 : {
2346 19844 : if (rSz.GetWidthPercentRelation() == text::RelOrientation::PAGE_FRAME)
2347 : // Ignore margins of pPage.
2348 48 : nRelWidth = std::min( nRelWidth, pPage->Frm().Width() );
2349 : else
2350 19796 : nRelWidth = std::min( nRelWidth, pPage->Prt().Width() );
2351 19844 : if (rSz.GetHeightPercentRelation() == text::RelOrientation::PAGE_FRAME)
2352 : // Ignore margins of pPage.
2353 24 : nRelHeight = std::min( nRelHeight, pPage->Frm().Height() );
2354 : else
2355 19820 : nRelHeight = std::min( nRelHeight, pPage->Prt().Height() );
2356 : }
2357 : }
2358 :
2359 20644 : if ( rSz.GetWidthPercent() && rSz.GetWidthPercent() != 0xFF )
2360 178 : aRet.Width() = nRelWidth * rSz.GetWidthPercent() / 100;
2361 20644 : if ( rSz.GetHeightPercent() && rSz.GetHeightPercent() != 0xFF )
2362 80 : aRet.Height() = nRelHeight * rSz.GetHeightPercent() / 100;
2363 :
2364 20644 : if ( rSz.GetWidthPercent() == 0xFF )
2365 : {
2366 8 : aRet.Width() *= aRet.Height();
2367 8 : aRet.Width() /= rSz.GetHeight();
2368 : }
2369 20636 : else if ( rSz.GetHeightPercent() == 0xFF )
2370 : {
2371 0 : aRet.Height() *= aRet.Width();
2372 0 : aRet.Height() /= rSz.GetWidth();
2373 : }
2374 : }
2375 20644 : return aRet;
2376 : }
2377 :
2378 912 : static SwTwips lcl_CalcAutoWidth( const SwLayoutFrm& rFrm )
2379 : {
2380 912 : SwTwips nRet = 0;
2381 912 : SwTwips nMin = 0;
2382 912 : const SwFrm* pFrm = rFrm.Lower();
2383 :
2384 : // No autowidth defined for columned frames
2385 912 : if ( !pFrm || pFrm->IsColumnFrm() )
2386 0 : return nRet;
2387 :
2388 2936 : while ( pFrm )
2389 : {
2390 1112 : if ( pFrm->IsSctFrm() )
2391 : {
2392 0 : nMin = lcl_CalcAutoWidth( *(SwSectionFrm*)pFrm );
2393 : }
2394 1112 : if ( pFrm->IsTxtFrm() )
2395 : {
2396 1084 : nMin = ((SwTxtFrm*)pFrm)->CalcFitToContent();
2397 : const SvxLRSpaceItem &rSpace =
2398 1084 : ((SwTxtFrm*)pFrm)->GetTxtNode()->GetSwAttrSet().GetLRSpace();
2399 1084 : if (!((SwTxtFrm*)pFrm)->IsLocked())
2400 1084 : nMin += rSpace.GetRight() + rSpace.GetTxtLeft() + rSpace.GetTxtFirstLineOfst();
2401 : }
2402 28 : else if ( pFrm->IsTabFrm() )
2403 : {
2404 28 : const SwFmtFrmSize& rTblFmtSz = ((SwTabFrm*)pFrm)->GetTable()->GetFrmFmt()->GetFrmSize();
2405 44 : if ( USHRT_MAX == rTblFmtSz.GetSize().Width() ||
2406 16 : text::HoriOrientation::NONE == ((SwTabFrm*)pFrm)->GetFmt()->GetHoriOrient().GetHoriOrient() )
2407 : {
2408 12 : const SwPageFrm* pPage = rFrm.FindPageFrm();
2409 : // auto width table
2410 12 : nMin = pFrm->GetUpper()->IsVertical() ?
2411 0 : pPage->Prt().Height() :
2412 12 : pPage->Prt().Width();
2413 : }
2414 : else
2415 : {
2416 16 : nMin = rTblFmtSz.GetSize().Width();
2417 : }
2418 : }
2419 :
2420 1112 : if ( nMin > nRet )
2421 912 : nRet = nMin;
2422 :
2423 1112 : pFrm = pFrm->GetNext();
2424 : }
2425 :
2426 912 : return nRet;
2427 : }
2428 :
2429 912 : SwTwips SwFlyFrm::CalcAutoWidth() const
2430 : {
2431 912 : return lcl_CalcAutoWidth( *this );
2432 : }
2433 :
2434 : /// OD 16.04.2003 #i13147# - If called for paint and the <SwNoTxtFrm> contains
2435 : /// a graphic, load of intrinsic graphic has to be avoided.
2436 313 : bool SwFlyFrm::GetContour( tools::PolyPolygon& rContour,
2437 : const bool _bForPaint ) const
2438 : {
2439 313 : bool bRet = false;
2440 347 : if( GetFmt()->GetSurround().IsContour() && Lower() &&
2441 34 : Lower()->IsNoTxtFrm() )
2442 : {
2443 34 : SwNoTxtNode *pNd = (SwNoTxtNode*)((SwCntntFrm*)Lower())->GetNode();
2444 : // OD 16.04.2003 #i13147# - determine <GraphicObject> instead of <Graphic>
2445 : // in order to avoid load of graphic, if <SwNoTxtNode> contains a graphic
2446 : // node and method is called for paint.
2447 34 : const GraphicObject* pGrfObj = NULL;
2448 34 : bool bGrfObjCreated = false;
2449 34 : const SwGrfNode* pGrfNd = pNd->GetGrfNode();
2450 34 : if ( pGrfNd && _bForPaint )
2451 : {
2452 16 : pGrfObj = &(pGrfNd->GetGrfObj());
2453 : }
2454 : else
2455 : {
2456 18 : pGrfObj = new GraphicObject( pNd->GetGraphic() );
2457 18 : bGrfObjCreated = true;
2458 : }
2459 : OSL_ENSURE( pGrfObj, "SwFlyFrm::GetContour() - No Graphic/GraphicObject found at <SwNoTxtNode>." );
2460 34 : if ( pGrfObj && pGrfObj->GetType() != GRAPHIC_NONE )
2461 : {
2462 12 : if( !pNd->HasContour() )
2463 : {
2464 : // OD 16.04.2003 #i13147# - no <CreateContour> for a graphic
2465 : // during paint. Thus, return (value of <bRet> should be <sal_False>).
2466 0 : if ( pGrfNd && _bForPaint )
2467 : {
2468 : OSL_FAIL( "SwFlyFrm::GetContour() - No Contour found at <SwNoTxtNode> during paint." );
2469 0 : return bRet;
2470 : }
2471 0 : pNd->CreateContour();
2472 : }
2473 12 : pNd->GetContour( rContour );
2474 : // The Node holds the Polygon matching the original size of the graphic
2475 : // We need to include the scaling here
2476 12 : SwRect aClip;
2477 12 : SwRect aOrig;
2478 12 : Lower()->Calc();
2479 12 : ((SwNoTxtFrm*)Lower())->GetGrfArea( aClip, &aOrig, false );
2480 : // OD 16.04.2003 #i13147# - copy method code <SvxContourDlg::ScaleContour(..)>
2481 : // in order to avoid that graphic has to be loaded for contour scale.
2482 : //SvxContourDlg::ScaleContour( rContour, aGrf, MAP_TWIP, aOrig.SSize() );
2483 : {
2484 12 : OutputDevice* pOutDev = Application::GetDefaultDevice();
2485 12 : const MapMode aDispMap( MAP_TWIP );
2486 24 : const MapMode aGrfMap( pGrfObj->GetPrefMapMode() );
2487 12 : const Size aGrfSize( pGrfObj->GetPrefSize() );
2488 12 : Size aOrgSize;
2489 12 : Point aNewPoint;
2490 12 : bool bPixelMap = aGrfMap.GetMapUnit() == MAP_PIXEL;
2491 :
2492 12 : if ( bPixelMap )
2493 0 : aOrgSize = pOutDev->PixelToLogic( aGrfSize, aDispMap );
2494 : else
2495 12 : aOrgSize = OutputDevice::LogicToLogic( aGrfSize, aGrfMap, aDispMap );
2496 :
2497 12 : if ( aOrgSize.Width() && aOrgSize.Height() )
2498 : {
2499 12 : double fScaleX = (double) aOrig.Width() / aOrgSize.Width();
2500 12 : double fScaleY = (double) aOrig.Height() / aOrgSize.Height();
2501 :
2502 24 : for ( sal_uInt16 j = 0, nPolyCount = rContour.Count(); j < nPolyCount; j++ )
2503 : {
2504 12 : Polygon& rPoly = rContour[ j ];
2505 :
2506 144 : for ( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ )
2507 : {
2508 132 : if ( bPixelMap )
2509 0 : aNewPoint = pOutDev->PixelToLogic( rPoly[ i ], aDispMap );
2510 : else
2511 132 : aNewPoint = OutputDevice::LogicToLogic( rPoly[ i ], aGrfMap, aDispMap );
2512 :
2513 132 : rPoly[ i ] = Point( FRound( aNewPoint.getX() * fScaleX ), FRound( aNewPoint.getY() * fScaleY ) );
2514 : }
2515 : }
2516 12 : }
2517 : }
2518 : // OD 17.04.2003 #i13147# - destroy created <GraphicObject>.
2519 12 : if ( bGrfObjCreated )
2520 : {
2521 12 : delete pGrfObj;
2522 : }
2523 12 : rContour.Move( aOrig.Left(), aOrig.Top() );
2524 12 : if( !aClip.Width() )
2525 0 : aClip.Width( 1 );
2526 12 : if( !aClip.Height() )
2527 0 : aClip.Height( 1 );
2528 12 : rContour.Clip( aClip.SVRect() );
2529 12 : rContour.Optimize(POLY_OPTIMIZE_CLOSE);
2530 12 : bRet = true;
2531 : }
2532 : }
2533 313 : return bRet;
2534 : }
2535 :
2536 : // OD 2004-03-25 #i26791#
2537 4577 : const SwVirtFlyDrawObj* SwFlyFrm::GetVirtDrawObj() const
2538 : {
2539 4577 : return static_cast<const SwVirtFlyDrawObj*>(GetDrawObj());
2540 : }
2541 158783 : SwVirtFlyDrawObj* SwFlyFrm::GetVirtDrawObj()
2542 : {
2543 158783 : return static_cast<SwVirtFlyDrawObj*>(DrawObj());
2544 : }
2545 :
2546 : // OD 2004-03-24 #i26791# - implementation of pure virtual method declared in
2547 : // base class <SwAnchoredObject>
2548 :
2549 1402 : void SwFlyFrm::InvalidateObjPos()
2550 : {
2551 1402 : InvalidatePos();
2552 : // #i68520#
2553 1402 : InvalidateObjRectWithSpaces();
2554 1402 : }
2555 :
2556 310937 : SwFrmFmt& SwFlyFrm::GetFrmFmt()
2557 : {
2558 : OSL_ENSURE( GetFmt(),
2559 : "<SwFlyFrm::GetFrmFmt()> - missing frame format -> crash." );
2560 310937 : return *GetFmt();
2561 : }
2562 660562 : const SwFrmFmt& SwFlyFrm::GetFrmFmt() const
2563 : {
2564 : OSL_ENSURE( GetFmt(),
2565 : "<SwFlyFrm::GetFrmFmt()> - missing frame format -> crash." );
2566 660562 : return *GetFmt();
2567 : }
2568 :
2569 1097181 : const SwRect SwFlyFrm::GetObjRect() const
2570 : {
2571 1097181 : return Frm();
2572 : }
2573 :
2574 : // #i70122#
2575 : // for Writer fly frames the bounding rectangle equals the object rectangles
2576 13471 : const SwRect SwFlyFrm::GetObjBoundRect() const
2577 : {
2578 13471 : return GetObjRect();
2579 : }
2580 :
2581 : // #i68520#
2582 13122 : bool SwFlyFrm::_SetObjTop( const SwTwips _nTop )
2583 : {
2584 13122 : const bool bChanged( Frm().Pos().getY() != _nTop );
2585 :
2586 13122 : Frm().Pos().setY(_nTop);
2587 :
2588 13122 : return bChanged;
2589 : }
2590 4380 : bool SwFlyFrm::_SetObjLeft( const SwTwips _nLeft )
2591 : {
2592 4380 : const bool bChanged( Frm().Pos().getX() != _nLeft );
2593 :
2594 4380 : Frm().Pos().setX(_nLeft);
2595 :
2596 4380 : return bChanged;
2597 : }
2598 :
2599 : /** method to assure that anchored object is registered at the correct
2600 : page frame
2601 :
2602 : OD 2004-07-02 #i28701#
2603 : */
2604 0 : void SwFlyFrm::RegisterAtCorrectPage()
2605 : {
2606 : // default behaviour is to do nothing.
2607 0 : }
2608 :
2609 : /** method to determine, if a <MakeAll()> on the Writer fly frame is possible
2610 :
2611 : OD 2004-05-11 #i28701#
2612 : */
2613 20254 : bool SwFlyFrm::IsFormatPossible() const
2614 : {
2615 40508 : return SwAnchoredObject::IsFormatPossible() &&
2616 40508 : !IsLocked() && !IsColLocked();
2617 : }
2618 :
2619 16 : void SwFlyFrm::GetAnchoredObjects( std::list<SwAnchoredObject*>& aList, const SwFmt& rFmt )
2620 : {
2621 16 : SwIterator<SwFlyFrm,SwFmt> aIter( rFmt );
2622 32 : for( SwFlyFrm* pFlyFrm = aIter.First(); pFlyFrm; pFlyFrm = aIter.Next() )
2623 32 : aList.push_back( pFlyFrm );
2624 16 : }
2625 :
2626 752566 : const SwFlyFrmFmt * SwFlyFrm::GetFmt() const
2627 : {
2628 752566 : return static_cast< const SwFlyFrmFmt * >( GetDep() );
2629 : }
2630 :
2631 556957 : SwFlyFrmFmt * SwFlyFrm::GetFmt()
2632 : {
2633 556957 : return static_cast< SwFlyFrmFmt * >( GetDep() );
2634 : }
2635 :
2636 17023 : void SwFlyFrm::Calc() const
2637 : {
2638 17023 : if ( !m_bValidContentPos )
2639 4582 : ((SwFlyFrm*)this)->PrepareMake();
2640 : else
2641 12441 : SwLayoutFrm::Calc();
2642 17023 : }
2643 :
2644 5345 : SwTwips SwFlyFrm::CalcContentHeight(const SwBorderAttrs *pAttrs, const SwTwips nMinHeight, const SwTwips nUL)
2645 : {
2646 5345 : SWRECTFN( this )
2647 5345 : SwTwips nHeight = 0;
2648 5345 : if ( Lower() )
2649 : {
2650 5341 : if ( Lower()->IsColumnFrm() )
2651 : {
2652 0 : FormatWidthCols( *pAttrs, nUL, nMinHeight );
2653 0 : nHeight = (Lower()->Frm().*fnRect->fnGetHeight)();
2654 : }
2655 : else
2656 : {
2657 5341 : SwFrm *pFrm = Lower();
2658 17555 : while ( pFrm )
2659 : {
2660 6873 : nHeight += (pFrm->Frm().*fnRect->fnGetHeight)();
2661 6873 : if( pFrm->IsTxtFrm() && ((SwTxtFrm*)pFrm)->IsUndersized() )
2662 : // This TxtFrm would like to be a bit larger
2663 530 : nHeight += ((SwTxtFrm*)pFrm)->GetParHeight()
2664 530 : - (pFrm->Prt().*fnRect->fnGetHeight)();
2665 6343 : else if( pFrm->IsSctFrm() && ((SwSectionFrm*)pFrm)->IsUndersized() )
2666 0 : nHeight += ((SwSectionFrm*)pFrm)->Undersize();
2667 6873 : pFrm = pFrm->GetNext();
2668 : }
2669 : }
2670 5341 : if ( GetDrawObjs() )
2671 : {
2672 22 : const size_t nCnt = GetDrawObjs()->size();
2673 22 : SwTwips nTop = (Frm().*fnRect->fnGetTop)();
2674 22 : SwTwips nBorder = (Frm().*fnRect->fnGetHeight)() -
2675 22 : (Prt().*fnRect->fnGetHeight)();
2676 44 : for ( size_t i = 0; i < nCnt; ++i )
2677 : {
2678 22 : SwAnchoredObject* pAnchoredObj = (*GetDrawObjs())[i];
2679 22 : if ( pAnchoredObj->ISA(SwFlyFrm) )
2680 : {
2681 0 : SwFlyFrm* pFly = static_cast<SwFlyFrm*>(pAnchoredObj);
2682 : // OD 06.11.2003 #i22305# - consider
2683 : // only Writer fly frames, which follow the text flow.
2684 0 : if ( pFly->IsFlyLayFrm() &&
2685 0 : pFly->Frm().Top() != FAR_AWAY &&
2686 0 : pFly->GetFmt()->GetFollowTextFlow().GetValue() )
2687 : {
2688 0 : SwTwips nDist = -(pFly->Frm().*fnRect->
2689 0 : fnBottomDist)( nTop );
2690 0 : if( nDist > nBorder + nHeight )
2691 0 : nHeight = nDist - nBorder;
2692 : }
2693 : }
2694 : }
2695 : }
2696 : }
2697 5345 : return nHeight;
2698 270 : }
2699 :
2700 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
