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