sw/source/core/layout/flylay.cxx

   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 <config_wasm_strip.h>
  21
  22 #include <pagefrm.hxx>
  23 #include <rootfrm.hxx>
  24 #include <cntfrm.hxx>
  25 #include <dflyobj.hxx>
  26 #include <dcontact.hxx>
  27 #include <ftnfrm.hxx>
  28 #include <frmatr.hxx>
  29 #include <frmtool.hxx>
  30 #include <sectfrm.hxx>
  31 #include <notxtfrm.hxx>
  32 #include <txtfly.hxx>
  33
  34 #include <svx/svdpage.hxx>
  35 #include <editeng/ulspitem.hxx>
  36 #include <fmtornt.hxx>
  37 #include <fmtfsize.hxx>
  38 #include <ndole.hxx>
  39 #include <tabfrm.hxx>
  40 #include <flyfrms.hxx>
  41 #include <fmtfollowtextflow.hxx>
  42 #include <environmentofanchoredobject.hxx>
  43 #include <sortedobjs.hxx>
  44 #include <viewimp.hxx>
  45 #include <IDocumentSettingAccess.hxx>
  46 #include <IDocumentDrawModelAccess.hxx>
  47 #include <pam.hxx>
  48 #include <ndindex.hxx>
  49 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  50 #include <svx/sdr/attribute/sdrallfillattributeshelper.hxx>
  51 #include <osl/diagnose.h>
  52
  53 using namespace ::com::sun::star;
  54
  55 SwFlyFreeFrame::SwFlyFreeFrame( SwFlyFrameFormat *pFormat, SwFrame* pSib, SwFrame *pAnch, bool bFollow )
  56 :   SwFlyFrame( pFormat, pSib, pAnch, bFollow ),
  57     // #i34753#
  58     mbNoMakePos( false ),
  59     // #i37068#
  60     mbNoMoveOnCheckClip( false )
  61 {
  62 }
  63
  64 void SwFlyFreeFrame::DestroyImpl()
  65 {
  66     // #i28701# - use new method <GetPageFrame()>
  67     if( GetPageFrame() )
  68     {
  69         if( GetFormat()->GetDoc()->IsInDtor() )
  70         {
  71             // #i29879# - remove also to-frame anchored Writer
  72             // fly frame from page.
  73             const bool bRemoveFromPage =
  74                     GetPageFrame()->GetSortedObjs() &&
  75                     ( IsFlyAtContentFrame() ||
  76                       ( GetAnchorFrame() && GetAnchorFrame()->IsFlyFrame() ) );
  77             if ( bRemoveFromPage )
  78             {
  79                 GetPageFrame()->GetSortedObjs()->Remove( *this );
  80             }
  81         }
  82         else
  83         {
  84             SwRect aTmp( GetObjRectWithSpaces() );
  85             SwFlyFreeFrame::NotifyBackground( GetPageFrame(), aTmp, PrepareHint::FlyFrameLeave );
  86         }
  87     }
  88
  89     SwFlyFrame::DestroyImpl();
  90 }
  91
  92 SwFlyFreeFrame::~SwFlyFreeFrame()
  93 {
  94 #if 0
  95     // we are possibly in ContourCache, make sure we vanish
  96     ::ClrContourCache(GetVirtDrawObj());
  97 #endif
  98 }
  99
 100 // #i28701#
 101 /** Notifies the background (all ContentFrames that currently are overlapping).
 102  *
 103  * Additionally, the window is also directly invalidated (especially where
 104  * there are no overlapping ContentFrames).
 105  * This also takes ContentFrames within other Flys into account.
 106  */
 107 void SwFlyFreeFrame::NotifyBackground( SwPageFrame *pPageFrame,
 108                                      const SwRect& rRect, PrepareHint eHint )
 109 {
 110     ::Notify_Background( GetVirtDrawObj(), pPageFrame, rRect, eHint, true );
 111 }
 112
 113 void SwFlyFreeFrame::MakeAll(vcl::RenderContext* /*pRenderContext*/)
 114 {
 115     if ( !GetFormat()->GetDoc()->getIDocumentDrawModelAccess().IsVisibleLayerId( GetVirtDrawObj()->GetLayer() ) )
 116     {
 117         return;
 118     }
 119
 120     if ( !GetAnchorFrame() || IsLocked() || IsColLocked() )
 121     {
 122         return;
 123     }
 124
 125     // #i28701# - use new method <GetPageFrame()>
 126     if( !GetPageFrame() && GetAnchorFrame()->IsInFly() )
 127     {
 128         SwFlyFrame* pFly = AnchorFrame()->FindFlyFrame();
 129         SwPageFrame *pPageFrame = pFly ? pFly->FindPageFrame() : nullptr;
 130         if( pPageFrame )
 131             pPageFrame->AppendFlyToPage( this );
 132     }
 133
 134     if( !GetPageFrame() )
 135     {
 136         return;
 137     }
 138
 139     Lock(); // The curtain drops
 140
 141     // takes care of the notification in the dtor
 142     const SwFlyNotify aNotify( this );
 143
 144     if ( IsClipped() )
 145     {
 146         setFrameAreaSizeValid(false);
 147         m_bHeightClipped = m_bWidthClipped = false;
 148         // no invalidation of position,
 149         // if anchored object is anchored inside a Writer fly frame,
 150         // its position is already locked, and it follows the text flow.
 151         // #i34753# - add condition:
 152         // no invalidation of position, if no direct move is requested in <CheckClip(..)>
 153         if ( !IsNoMoveOnCheckClip() &&
 154              !( PositionLocked() &&
 155                 GetAnchorFrame()->IsInFly() &&
 156                 GetFrameFormat().GetFollowTextFlow().GetValue() ) )
 157         {
 158             setFrameAreaPositionValid(false);
 159         }
 160     }
 161
 162     // #i81146# new loop control
 163     int nLoopControlRuns = 0;
 164     const int nLoopControlMax = 10;
 165
 166     // RotateFlyFrame3 - outer frame
 167     const double fRotation(getLocalFrameRotation());
 168     const bool bRotated(!basegfx::fTools::equalZero(fRotation));
 169
 170     if(bRotated)
 171     {
 172         // Re-layout may be partially (see all isFrameAreaDefinitionValid() flags),
 173         // so resetting the local SwFrame(s) in the local SwFrameAreaDefinition is
 174         // needed. Reset to BoundAreas will be done below automatically
 175         if(isTransformableSwFrame())
 176         {
 177             getTransformableSwFrame()->restoreFrameAreas();
 178         }
 179     }
 180
 181     while ( !isFrameAreaPositionValid() || !isFrameAreaSizeValid() || !isFramePrintAreaValid() || m_bFormatHeightOnly || !m_bValidContentPos )
 182     {
 183         SwRectFnSet aRectFnSet(this);
 184         const SwFormatFrameSize *pSz;
 185         {   // Additional scope, so aAccess will be destroyed before the check!
 186
 187             SwBorderAttrAccess aAccess( SwFrame::GetCache(), this );
 188             const SwBorderAttrs &rAttrs = *aAccess.Get();
 189             pSz = &rAttrs.GetAttrSet().GetFrameSize();
 190
 191             // Only set when the flag is set!
 192             if ( !isFrameAreaSizeValid() )
 193             {
 194                 setFramePrintAreaValid(false);
 195             }
 196
 197             if ( !isFramePrintAreaValid() )
 198             {
 199                 MakePrtArea( rAttrs );
 200                 m_bValidContentPos = false;
 201             }
 202
 203             if ( !isFrameAreaSizeValid() || m_bFormatHeightOnly )
 204             {
 205                 setFrameAreaSizeValid(false);
 206                 Format( getRootFrame()->GetCurrShell()->GetOut(), &rAttrs );
 207                 m_bFormatHeightOnly = false;
 208             }
 209         }
 210
 211         if ( !isFrameAreaPositionValid() )
 212         {
 213             const Point aOldPos( aRectFnSet.GetPos(getFrameArea()) );
 214             // #i26791# - use new method <MakeObjPos()>
 215             // #i34753# - no positioning, if requested.
 216             if ( IsNoMakePos() )
 217             {
 218                 setFrameAreaPositionValid(true);
 219             }
 220             else
 221                 // #i26791# - use new method <MakeObjPos()>
 222                 MakeObjPos();
 223             if (!IsForceNotifyNewBackground() && aOldPos == aRectFnSet.GetPos(getFrameArea()))
 224             {
 225                 if( !isFrameAreaPositionValid() && GetAnchorFrame()->IsInSct() &&
 226                     !GetAnchorFrame()->FindSctFrame()->isFrameAreaDefinitionValid() )
 227                 {
 228                     setFrameAreaPositionValid(true);
 229                 }
 230             }
 231             else
 232             {
 233                 setFrameAreaSizeValid(false);
 234             }
 235         }
 236
 237         if ( !m_bValidContentPos )
 238         {
 239             SwBorderAttrAccess aAccess( SwFrame::GetCache(), this );
 240             const SwBorderAttrs &rAttrs = *aAccess.Get();
 241             MakeContentPos( rAttrs );
 242         }
 243
 244         if ( isFrameAreaPositionValid() && isFrameAreaSizeValid() )
 245         {
 246             ++nLoopControlRuns;
 247
 248             OSL_ENSURE( nLoopControlRuns < nLoopControlMax, "LoopControl in SwFlyFreeFrame::MakeAll" );
 249
 250             if ( nLoopControlRuns < nLoopControlMax )
 251                 CheckClip( *pSz );
 252         }
 253         else
 254             nLoopControlRuns = 0;
 255     }
 256
 257     // RotateFlyFrame3 - outer frame
 258     // Do not refresh transforms/Areas self here, this will be done
 259     // when inner and outer frame are layouted, in SwNoTextFrame::MakeAll
 260     if(bRotated)
 261     {
 262         // RotateFlyFrame3: Safe changes locally
 263         // get center from outer frame (layout frame) to be on the safe side
 264         const Point aCenter(getFrameArea().Center());
 265         const basegfx::B2DPoint aB2DCenter(aCenter.X(), aCenter.Y());
 266
 267         if(!mpTransformableSwFrame)
 268         {
 269             mpTransformableSwFrame.reset(new TransformableSwFrame(*this));
 270         }
 271
 272         getTransformableSwFrame()->createFrameAreaTransformations(
 273             fRotation,
 274             aB2DCenter);
 275         getTransformableSwFrame()->adaptFrameAreasToTransformations();
 276     }
 277     else
 278     {
 279         // RotateFlyFrame3: Also need to clear ContourCache (if used),
 280         // usually done in SwFlyFrame::NotifyDrawObj, but there relies on
 281         // being in transform mode which is already reset then
 282         if(isTransformableSwFrame())
 283         {
 284             ::ClrContourCache(GetVirtDrawObj());
 285         }
 286
 287         // reset transformations to show that they are not used
 288         mpTransformableSwFrame.reset();
 289     }
 290
 291     Unlock();
 292
 293 #if OSL_DEBUG_LEVEL > 0
 294     SwRectFnSet aRectFnSet(this);
 295     OSL_ENSURE( m_bHeightClipped || ( aRectFnSet.GetHeight(getFrameArea()) > 0 &&
 296             aRectFnSet.GetHeight(getFramePrintArea()) > 0),
 297             "SwFlyFreeFrame::Format(), flipping Fly." );
 298
 299 #endif
 300 }
 301
 302 bool SwFlyFreeFrame::supportsAutoContour() const
 303 {
 304     static bool bOverrideHandleContourToAlwaysOff(true); // loplugin:constvars:ignore
 305
 306     // RotateFlyFrameFix: For LO6.0 we need to deactivate the AutoContour feature again, it is simply
 307     // not clear how/if to use and save/load it in ODF. This has to be discussed.
 308     // The reason not to remove is that this may be used as-is now, using a new switch.
 309     // Even when not, the detection if it is possible will be needed in any case later.
 310     if(bOverrideHandleContourToAlwaysOff)
 311     {
 312         return false;
 313     }
 314
 315     if(!isTransformableSwFrame())
 316     {
 317         // support only when transformed, else there is no free space
 318         return false;
 319     }
 320
 321     // Check for Borders. If we have Borders, do (currently) not support,
 322     // since borders do not transform with the object.
 323     // (Will need to be enhanced to take into account if we have Borders and if these
 324     // transform with the object)
 325     SwBorderAttrAccess aAccess(SwFrame::GetCache(), this);
 326     const SwBorderAttrs &rAttrs(*aAccess.Get());
 327
 328     if(rAttrs.IsLine())
 329     {
 330         return false;
 331     }
 332
 333     // Check for Padding. Do not support when padding is used, this will
 334     // produce a covered space around the object (filled with fill defines)
 335     const SvxBoxItem* pBoxItem(nullptr);
 336
 337     if(GetFormat() && (pBoxItem = GetFormat()->GetItemIfSet(RES_BOX, false)))
 338     {
 339         if(pBoxItem->HasBorder(/*bTreatPaddingAsBorder*/true))
 340         {
 341             return false;
 342         }
 343     }
 344
 345     // check for Fill - if we have fill, it will fill the gaps and we will not
 346     // support AutoContour
 347     if(GetFormat() && GetFormat()->supportsFullDrawingLayerFillAttributeSet())
 348     {
 349         const drawinglayer::attribute::SdrAllFillAttributesHelperPtr aFillAttributes(GetFormat()->getSdrAllFillAttributesHelper());
 350
 351         if(aFillAttributes && aFillAttributes->isUsed())
 352         {
 353             return false;
 354         }
 355     }
 356     else
 357     {
 358         const std::unique_ptr<SvxBrushItem> aBack(GetFormat()->makeBackgroundBrushItem());
 359
 360         if(aBack->isUsed())
 361         {
 362             return false;
 363         }
 364     }
 365
 366     // else, support
 367     return true;
 368 }
 369
 370 // RotateFlyFrame3 - Support for Transformations - outer frame
 371 basegfx::B2DHomMatrix SwFlyFreeFrame::getFrameAreaTransformation() const
 372 {
 373     if(isTransformableSwFrame())
 374     {
 375         // use pre-created transformation
 376         return getTransformableSwFrame()->getLocalFrameAreaTransformation();
 377     }
 378
 379     // call parent
 380     return SwFlyFrame::getFrameAreaTransformation();
 381 }
 382
 383 basegfx::B2DHomMatrix SwFlyFreeFrame::getFramePrintAreaTransformation() const
 384 {
 385     if(isTransformableSwFrame())
 386     {
 387         // use pre-created transformation
 388         return getTransformableSwFrame()->getLocalFramePrintAreaTransformation();
 389     }
 390
 391     // call parent
 392     return SwFlyFrame::getFramePrintAreaTransformation();
 393 }
 394
 395 // RotateFlyFrame3 - Support for Transformations
 396 void SwFlyFreeFrame::transform_translate(const Point& rOffset)
 397 {
 398     // call parent - this will do the basic transform for SwRect(s)
 399     // in the SwFrameAreaDefinition
 400     SwFlyFrame::transform_translate(rOffset);
 401
 402     // check if the Transformations need to be adapted
 403     if(isTransformableSwFrame())
 404     {
 405         const basegfx::B2DHomMatrix aTransform(
 406             basegfx::utils::createTranslateB2DHomMatrix(
 407                 rOffset.X(), rOffset.Y()));
 408
 409         // transform using TransformableSwFrame
 410         getTransformableSwFrame()->transform(aTransform);
 411     }
 412 }
 413
 414 // RotateFlyFrame3 - outer frame
 415 double getLocalFrameRotation_from_SwNoTextFrame(const SwNoTextFrame& rNoTextFrame)
 416 {
 417     return rNoTextFrame.getLocalFrameRotation();
 418 }
 419
 420 double SwFlyFreeFrame::getLocalFrameRotation() const
 421 {
 422     // SwLayoutFrame::Lower() != SwFrame::GetLower(), but SwFrame::GetLower()
 423     // calls SwLayoutFrame::Lower() when it's a SwLayoutFrame - so use GetLower()
 424     const SwNoTextFrame* pSwNoTextFrame(dynamic_cast< const SwNoTextFrame* >(GetLower()));
 425
 426     if(nullptr != pSwNoTextFrame)
 427     {
 428         return getLocalFrameRotation_from_SwNoTextFrame(*pSwNoTextFrame);
 429     }
 430
 431     // no rotation
 432     return 0.0;
 433 }
 434
 435 /** determines, if direct environment of fly frame has 'auto' size
 436
 437     #i17297#
 438     start with anchor frame and search via <GetUpper()> for a header, footer,
 439     row or fly frame stopping at page frame.
 440     return <true>, if such a frame is found and it has 'auto' size.
 441     otherwise <false> is returned.
 442
 443     @return boolean indicating, that direct environment has 'auto' size
 444 */
 445 bool SwFlyFreeFrame::HasEnvironmentAutoSize() const
 446 {
 447     bool bRetVal = false;
 448
 449     const SwFrame* pToBeCheckedFrame = GetAnchorFrame();
 450     while ( pToBeCheckedFrame &&
 451             !pToBeCheckedFrame->IsPageFrame() )
 452     {
 453         if ( pToBeCheckedFrame->IsHeaderFrame() ||
 454              pToBeCheckedFrame->IsFooterFrame() ||
 455              pToBeCheckedFrame->IsRowFrame() ||
 456              pToBeCheckedFrame->IsFlyFrame() )
 457         {
 458             bRetVal = SwFrameSize::Fixed !=
 459                       pToBeCheckedFrame->GetAttrSet()->GetFrameSize().GetHeightSizeType();
 460             break;
 461         }
 462         else
 463         {
 464             pToBeCheckedFrame = pToBeCheckedFrame->GetUpper();
 465         }
 466     }
 467
 468     return bRetVal;
 469 }
 470
 471 void SwFlyFreeFrame::CheckClip( const SwFormatFrameSize &rSz )
 472 {
 473     // It's probably time now to take appropriate measures, if the Fly
 474     // doesn't fit into its surrounding.
 475     // First, the Fly gives up its position, then it's formatted.
 476     // Only if it still doesn't fit after giving up its position, the
 477     // width or height are given up as well. The frame will be squeezed
 478     // as much as needed.
 479
 480     const SwVirtFlyDrawObj *pObj = GetVirtDrawObj();
 481     SwRect aClip, aTmpStretch;
 482     ::CalcClipRect( pObj, aClip );
 483     ::CalcClipRect( pObj, aTmpStretch, false );
 484     aClip.Intersection_( aTmpStretch );
 485
 486     const tools::Long nBot = getFrameArea().Top() + getFrameArea().Height();
 487     const tools::Long nRig = getFrameArea().Left() + getFrameArea().Width();
 488     const tools::Long nClipBot = aClip.Top() + aClip.Height();
 489     const tools::Long nClipRig = aClip.Left() + aClip.Width();
 490
 491     const bool bBot = nBot > nClipBot;
 492     const bool bRig = nRig > nClipRig;
 493     if (( bBot || bRig ) && !IsDraggingOffPageAllowed(FindFrameFormat(GetDrawObj())))
 494     {
 495         bool bAgain = false;
 496         // #i37068# - no move, if it's requested
 497         if ( bBot && !IsNoMoveOnCheckClip() &&
 498              !GetDrawObjs() && !GetAnchorFrame()->IsInTab() )
 499         {
 500             SwFrame* pHeader = FindFooterOrHeader();
 501             // In a header, correction of the position is no good idea.
 502             // If the fly moves, some paragraphs have to be formatted, this
 503             // could cause a change of the height of the headerframe,
 504             // now the flyframe can change its position and so on ...
 505             if ( !pHeader || !pHeader->IsHeaderFrame() )
 506             {
 507                 const tools::Long nOld = getFrameArea().Top();
 508
 509                 // tdf#112443 disable positioning if content is completely off page
 510                 bool bDisableOffPagePositioning = GetFormat()->getIDocumentSettingAccess().get(DocumentSettingId::DISABLE_OFF_PAGE_POSITIONING);
 511                 if ( !bDisableOffPagePositioning || nOld <= nClipBot)
 512                 {
 513                     SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
 514                     aFrm.Pos().setY( std::max( aClip.Top(), nClipBot - aFrm.Height() ) );
 515                 }
 516
 517                 if ( getFrameArea().Top() != nOld )
 518                 {
 519                     bAgain = true;
 520                 }
 521
 522                 m_bHeightClipped = true;
 523             }
 524         }
 525         if ( bRig )
 526         {
 527             const tools::Long nOld = getFrameArea().Left();
 528
 529             // tdf#112443 disable positioning if content is completely off page
 530             bool bDisableOffPagePositioning = GetFormat()->getIDocumentSettingAccess().get(DocumentSettingId::DISABLE_OFF_PAGE_POSITIONING);
 531             if ( !bDisableOffPagePositioning || nOld <= nClipRig )
 532             {
 533                 SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
 534                 aFrm.Pos().setX( std::max( aClip.Left(), nClipRig - aFrm.Width() ) );
 535             }
 536
 537             if ( getFrameArea().Left() != nOld )
 538             {
 539                 const SwFormatHoriOrient &rH = GetFormat()->GetHoriOrient();
 540                 // Left-aligned ones may not be moved to the left when they
 541                 // are avoiding another one.
 542                 if( rH.GetHoriOrient() == text::HoriOrientation::LEFT )
 543                 {
 544                     SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
 545                     aFrm.Pos().setX( nOld );
 546                 }
 547                 else
 548                 {
 549                     bAgain = true;
 550                 }
 551             }
 552             m_bWidthClipped = true;
 553         }
 554         if ( bAgain )
 555         {
 556             setFrameAreaSizeValid(false);
 557         }
 558         else
 559         {
 560             // If we reach this branch, the Frame protrudes into forbidden
 561             // areas, and correcting the position is not allowed or not
 562             // possible or not required.
 563
 564             // For Flys with OLE objects as lower, we make sure that
 565             // we always resize proportionally
 566             Size aOldSize( getFrameArea().SSize() );
 567
 568             // First, setup the FrameRect, then transfer it to the Frame.
 569             SwRect aFrameRect( getFrameArea() );
 570
 571             if ( bBot )
 572             {
 573                 tools::Long nDiff = nClipBot;
 574                 nDiff -= aFrameRect.Top(); // nDiff represents the available distance
 575                 nDiff = aFrameRect.Height() - nDiff;
 576                 aFrameRect.Height( aFrameRect.Height() - nDiff );
 577                 m_bHeightClipped = true;
 578             }
 579             if ( bRig )
 580             {
 581                 tools::Long nDiff = nClipRig;
 582                 nDiff -= aFrameRect.Left();// nDiff represents the available distance
 583                 nDiff = aFrameRect.Width() - nDiff;
 584                 aFrameRect.Width( aFrameRect.Width() - nDiff );
 585                 m_bWidthClipped = true;
 586             }
 587
 588             // #i17297# - no proportional
 589             // scaling of graphics in environments, which determines its size
 590             // by its content ('auto' size). Otherwise layout loops can occur and
 591             // layout sizes of the environment can be incorrect.
 592             // Such environment are:
 593             // (1) header and footer frames with 'auto' size
 594             // (2) table row frames with 'auto' size
 595             // (3) fly frames with 'auto' size
 596             // Note: section frames seems to be not critical - didn't found
 597             //       any critical layout situation so far.
 598             if ( Lower() && Lower()->IsNoTextFrame() &&
 599                  (static_cast<SwNoTextFrame*>(Lower())->GetNode()->GetOLENode() ||
 600                    !HasEnvironmentAutoSize() ) )
 601             {
 602                 // If width and height got adjusted, then the bigger
 603                 // change is relevant.
 604                 if ( aFrameRect.Width() != aOldSize.Width() &&
 605                      aFrameRect.Height()!= aOldSize.Height() )
 606                 {
 607                     if ( (aOldSize.Width() - aFrameRect.Width()) >
 608                          (aOldSize.Height()- aFrameRect.Height()) )
 609                         aFrameRect.Height( aOldSize.Height() );
 610                     else
 611                         aFrameRect.Width( aOldSize.Width() );
 612                 }
 613
 614                 // Adjusted the width? change height proportionally
 615                 if( aFrameRect.Width() != aOldSize.Width() )
 616                 {
 617                     aFrameRect.Height( aFrameRect.Width() * aOldSize.Height() /
 618                                      aOldSize.Width() );
 619                     m_bHeightClipped = true;
 620                 }
 621                 // Adjusted the height? change width proportionally
 622                 else if( aFrameRect.Height() != aOldSize.Height() )
 623                 {
 624                     aFrameRect.Width( aFrameRect.Height() * aOldSize.Width() /
 625                                     aOldSize.Height() );
 626                     m_bWidthClipped = true;
 627                 }
 628
 629                 // #i17297# - reactivate change
 630                 // of size attribute for fly frames containing an ole object.
 631
 632                 // Added the aFrameRect.HasArea() hack, because
 633                 // the environment of the ole object does not have to be valid
 634                 // at this moment, or even worse, it does not have to have a
 635                 // reasonable size. In this case we do not want to change to
 636                 // attributes permanently. Maybe one day somebody dares to remove
 637                 // this code.
 638                 if ( aFrameRect.HasArea() &&
 639                      static_cast<SwNoTextFrame*>(Lower())->GetNode()->GetOLENode() &&
 640                      ( m_bWidthClipped || m_bHeightClipped ) )
 641                 {
 642                     SwFlyFrameFormat *pFormat = GetFormat();
 643                     pFormat->LockModify();
 644                     SwFormatFrameSize aFrameSize( rSz );
 645                     aFrameSize.SetWidth( aFrameRect.Width() );
 646                     aFrameSize.SetHeight( aFrameRect.Height() );
 647                     pFormat->SetFormatAttr( aFrameSize );
 648                     pFormat->UnlockModify();
 649                 }
 650             }
 651
 652             // Now change the Frame; for columns, we put the new values into the attributes,
 653             // otherwise we'll end up with unwanted side-effects/oscillations
 654             const tools::Long nPrtHeightDiff = getFrameArea().Height() - getFramePrintArea().Height();
 655             const tools::Long nPrtWidthDiff  = getFrameArea().Width()  - getFramePrintArea().Width();
 656             maUnclippedFrame = getFrameArea();
 657
 658             {
 659                 SwFrameAreaDefinition::FrameAreaWriteAccess aFrm(*this);
 660                 aFrm.Height( aFrameRect.Height() );
 661                 aFrm.Width ( std::max( tools::Long(MINLAY), aFrameRect.Width() ) );
 662             }
 663
 664             if ( Lower() && Lower()->IsColumnFrame() )
 665             {
 666                 ColLock();  //lock grow/shrink
 667                 const Size aTmpOldSize( getFramePrintArea().SSize() );
 668
 669                 {
 670                     SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this);
 671                     aPrt.Height( getFrameArea().Height() - nPrtHeightDiff );
 672                     aPrt.Width ( getFrameArea().Width()  - nPrtWidthDiff );
 673                 }
 674
 675                 ChgLowersProp( aTmpOldSize );
 676                 SwFrame *pLow = Lower();
 677                 do
 678                 {
 679                     pLow->Calc(getRootFrame()->GetCurrShell()->GetOut());
 680                     // also calculate the (Column)BodyFrame
 681                     static_cast<SwLayoutFrame*>(pLow)->Lower()->Calc(getRootFrame()->GetCurrShell()->GetOut());
 682                     pLow = pLow->GetNext();
 683                 } while ( pLow );
 684                 ::CalcContent( this );
 685                 ColUnlock();
 686
 687                 if ( !isFrameAreaSizeValid() && !m_bWidthClipped )
 688                 {
 689                     setFrameAreaSizeValid(true);
 690                     m_bFormatHeightOnly = true;
 691                 }
 692             }
 693             else
 694             {
 695                 SwFrameAreaDefinition::FramePrintAreaWriteAccess aPrt(*this);
 696                 aPrt.Height( getFrameArea().Height() - nPrtHeightDiff );
 697                 aPrt.Width ( getFrameArea().Width()  - nPrtWidthDiff );
 698             }
 699         }
 700     }
 701
 702     // #i26945#
 703     OSL_ENSURE( getFrameArea().Height() >= 0,
 704             "<SwFlyFreeFrame::CheckClip(..)> - fly frame has negative height now." );
 705 }
 706
 707 /** method to determine, if a <MakeAll()> on the Writer fly frame is possible
 708     #i43771#
 709 */
 710 bool SwFlyFreeFrame::IsFormatPossible() const
 711 {
 712     return SwFlyFrame::IsFormatPossible() &&
 713            ( GetPageFrame() ||
 714              ( GetAnchorFrame() && GetAnchorFrame()->IsInFly() ) );
 715 }
 716
 717 SwFlyLayFrame::SwFlyLayFrame( SwFlyFrameFormat *pFormat, SwFrame* pSib, SwFrame *pAnch ) :
 718     SwFlyFreeFrame( pFormat, pSib, pAnch )
 719 {
 720     m_bLayout = true;
 721 }
 722
 723 void SwFlyLayFrame::RegisterAtPage(SwPageFrame & rPageFrame)
 724 {
 725     assert(GetPageFrame() != &rPageFrame);
 726     if (GetPageFrame())
 727     {
 728         GetPageFrame()->MoveFly( this, &rPageFrame );
 729     }
 730     else
 731     {
 732         rPageFrame.AppendFlyToPage( this );
 733     }
 734 }
 735
 736 // #i28701#
 737
 738 void SwFlyLayFrame::SwClientNotify(const SwModify& rMod, const SfxHint& rHint)
 739 {
 740     if (rHint.GetId() != SfxHintId::SwLegacyModify)
 741         return;
 742     auto pLegacy = static_cast<const sw::LegacyModifyHint*>(&rHint);
 743     if(!pLegacy->m_pNew)
 744         return;
 745     const auto pAnch = GetAnchorFromPoolItem(*pLegacy->m_pNew);
 746
 747     if(!pAnch)
 748     {
 749         SwFlyFrame::SwClientNotify(rMod, rHint);
 750         return;
 751     }
 752     SAL_WARN_IF(pAnch->GetAnchorId() == GetFormat()->GetAnchor().GetAnchorId(), "sw.core", "Invalid change of anchor type.");
 753
 754     // Unregister, get hold of the page, attach to the corresponding LayoutFrame.
 755     SwRect aOld(GetObjRectWithSpaces());
 756     // #i28701# - use new method <GetPageFrame()>
 757     SwPageFrame* pOldPage = GetPageFrame();
 758     AnchorFrame()->RemoveFly(this);
 759
 760     if(RndStdIds::FLY_AT_PAGE == pAnch->GetAnchorId())
 761     {
 762         SwRootFrame* pRoot = getRootFrame();
 763         SwPageFrame* pTmpPage = static_cast<SwPageFrame*>(pRoot->Lower());
 764         sal_uInt16 nPagesToFlip = pAnch->GetPageNum()-1;
 765         while(pTmpPage && nPagesToFlip)
 766         {
 767             pTmpPage = static_cast<SwPageFrame*>(pTmpPage->GetNext());
 768             --nPagesToFlip;
 769         }
 770         if(pTmpPage && !nPagesToFlip)
 771         {
 772             // #i50432# - adjust synopsis of <PlaceFly(..)>
 773             pTmpPage->PlaceFly(this, nullptr);
 774         }
 775         if(!pTmpPage)
 776         {
 777             pRoot->SetAssertFlyPages();
 778             pRoot->AssertFlyPages();
 779         }
 780     }
 781     else
 782     {
 783         SwNodeIndex aIdx(*pAnch->GetAnchorNode());
 784         SwContentFrame* pContent = GetFormat()->GetDoc()->GetNodes().GoNext(&aIdx)->
 785                 GetContentNode()->getLayoutFrame(getRootFrame(), nullptr, nullptr);
 786         if(pContent)
 787         {
 788             SwFlyFrame *pTmp = pContent->FindFlyFrame();
 789             if(pTmp)
 790                 pTmp->AppendFly(this);
 791         }
 792     }
 793     // #i28701# - use new method <GetPageFrame()>
 794     if ( pOldPage && pOldPage != GetPageFrame() )
 795         NotifyBackground( pOldPage, aOld, PrepareHint::FlyFrameLeave );
 796     SetCompletePaint();
 797     InvalidateAll();
 798     SetNotifyBack();
 799 }
 800
 801 void SwPageFrame::AppendFlyToPage( SwFlyFrame *pNew )
 802 {
 803     if ( !pNew->GetVirtDrawObj()->IsInserted() )
 804         getRootFrame()->GetDrawPage()->InsertObject(
 805                 static_cast<SdrObject*>(pNew->GetVirtDrawObj()),
 806                 pNew->GetVirtDrawObj()->GetReferencedObj().GetOrdNumDirect() );
 807
 808     InvalidateSpelling();
 809     InvalidateSmartTags();
 810     InvalidateAutoCompleteWords();
 811     InvalidateWordCount();
 812
 813     if ( GetUpper() )
 814     {
 815         static_cast<SwRootFrame*>(GetUpper())->SetIdleFlags();
 816         static_cast<SwRootFrame*>(GetUpper())->InvalidateBrowseWidth();
 817     }
 818
 819     SdrObject* pObj = pNew->GetVirtDrawObj();
 820     OSL_ENSURE( pNew->GetAnchorFrame(), "Fly without Anchor" );
 821     SwFlyFrame* pFly = const_cast<SwFlyFrame*>(pNew->GetAnchorFrame()->FindFlyFrame());
 822     if ( pFly && pObj->GetOrdNum() < pFly->GetVirtDrawObj()->GetOrdNum() )
 823     {
 824         //#i119945# set pFly's OrdNum to _rNewObj's. So when pFly is removed by Undo, the original OrdNum will not be changed.
 825         sal_uInt32 nNewNum = pObj->GetOrdNumDirect();
 826         SdrObject* pDrawObj = nullptr;
 827         if (auto pFormat = pFly->GetFormat())
 828             if (auto pShapeFormat = SwTextBoxHelper::getOtherTextBoxFormat(pFormat, RES_FLYFRMFMT))
 829                 pDrawObj = pShapeFormat->FindRealSdrObject();
 830
 831         if (pDrawObj)
 832         {
 833             if (auto pPage = pDrawObj->getSdrPageFromSdrObject())
 834                 pPage->SetObjectOrdNum(pDrawObj->GetOrdNumDirect(), nNewNum);
 835             else
 836                 pDrawObj->SetOrdNum(nNewNum);
 837         }
 838
 839         if ( pObj->getSdrPageFromSdrObject() )
 840             pObj->getSdrPageFromSdrObject()->SetObjectOrdNum( pFly->GetVirtDrawObj()->GetOrdNumDirect(), nNewNum + (pDrawObj ? 1 : 0) );
 841         else
 842             pFly->GetVirtDrawObj()->SetOrdNum( nNewNum + (pDrawObj ? 1 : 0));
 843     }
 844
 845     // Don't look further at Flys that sit inside the Content.
 846     if ( pNew->IsFlyInContentFrame() )
 847         InvalidateFlyInCnt();
 848     else
 849     {
 850         InvalidateFlyContent();
 851
 852         if ( !m_pSortedObjs )
 853         {
 854             m_pSortedObjs.reset(new SwSortedObjs());
 855         }
 856
 857         const bool bSuccessInserted = m_pSortedObjs->Insert( *pNew );
 858         OSL_ENSURE( bSuccessInserted, "Fly not inserted in Sorted." );
 859
 860         // #i87493#
 861         OSL_ENSURE( pNew->GetPageFrame() == nullptr || pNew->GetPageFrame() == this,
 862                 "<SwPageFrame::AppendFlyToPage(..)> - anchored fly frame seems to be registered at another page frame. Serious defect." );
 863         // #i28701# - use new method <SetPageFrame(..)>
 864         pNew->SetPageFrame( this );
 865         pNew->InvalidatePage( this );
 866         // #i28701#
 867         pNew->UnlockPosition();
 868         // needed to reposition at-page anchored flys moved from different page
 869         pNew->InvalidateObjPos();
 870
 871         // Notify accessible layout. That's required at this place for
 872         // frames only where the anchor is moved. Creation of new frames
 873         // is additionally handled by the SwFrameNotify class.
 874 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 875         if( GetUpper() &&
 876             static_cast< SwRootFrame * >( GetUpper() )->IsAnyShellAccessible() &&
 877              static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell() )
 878         {
 879             static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell()->Imp()
 880                                       ->AddAccessibleFrame( pNew );
 881         }
 882 #endif
 883     }
 884
 885     // #i28701# - correction: consider also drawing objects
 886     if ( !pNew->GetDrawObjs() )
 887         return;
 888
 889     SwSortedObjs &rObjs = *pNew->GetDrawObjs();
 890     for (SwAnchoredObject* pTmpObj : rObjs)
 891     {
 892         if ( auto pTmpFly = pTmpObj->DynCastFlyFrame() )
 893         {
 894             // #i28701# - use new method <GetPageFrame()>
 895             if ( pTmpFly->IsFlyFreeFrame() && !pTmpFly->GetPageFrame() )
 896                 AppendFlyToPage( pTmpFly );
 897         }
 898         else if ( dynamic_cast<const SwAnchoredDrawObject*>( pTmpObj) !=  nullptr )
 899         {
 900             // #i87493#
 901             if ( pTmpObj->GetPageFrame() != this )
 902             {
 903                 if ( pTmpObj->GetPageFrame() != nullptr )
 904                 {
 905                     pTmpObj->GetPageFrame()->RemoveDrawObjFromPage( *pTmpObj );
 906                 }
 907                 AppendDrawObjToPage( *pTmpObj );
 908             }
 909         }
 910     }
 911 }
 912
 913 void SwPageFrame::RemoveFlyFromPage( SwFlyFrame *pToRemove )
 914 {
 915     const sal_uInt32 nOrdNum = pToRemove->GetVirtDrawObj()->GetOrdNum();
 916     getRootFrame()->GetDrawPage()->RemoveObject( nOrdNum );
 917     pToRemove->GetVirtDrawObj()->ReferencedObj().SetOrdNum( nOrdNum );
 918
 919     if ( GetUpper() )
 920     {
 921         if ( !pToRemove->IsFlyInContentFrame() )
 922             static_cast<SwRootFrame*>(GetUpper())->SetSuperfluous();
 923         static_cast<SwRootFrame*>(GetUpper())->InvalidateBrowseWidth();
 924     }
 925
 926     // Don't look further at Flys that sit inside the Content.
 927     if ( pToRemove->IsFlyInContentFrame() )
 928         return;
 929
 930     // Don't delete collections just yet. This will happen at the end of the
 931     // action in the RemoveSuperfluous of the page, kicked off by a method of
 932     // the same name in the root.
 933     // The FlyColl might be gone already, because the page's dtor is being
 934     // executed.
 935     // Remove it _before_ disposing accessible frames to avoid accesses to
 936     // the Frame from event handlers.
 937     if (m_pSortedObjs)
 938     {
 939         m_pSortedObjs->Remove(*pToRemove);
 940         if (!m_pSortedObjs->size())
 941         {
 942             m_pSortedObjs.reset();
 943         }
 944     }
 945
 946     // Notify accessible layout. That's required at this place for
 947     // frames only where the anchor is moved. Creation of new frames
 948     // is additionally handled by the SwFrameNotify class.
 949 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 950     if( GetUpper() &&
 951         static_cast< SwRootFrame * >( GetUpper() )->IsAnyShellAccessible() &&
 952         static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell() )
 953     {
 954         static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell()->Imp()
 955                                   ->DisposeAccessibleFrame( pToRemove, true );
 956     }
 957 #endif
 958
 959     // #i28701# - use new method <SetPageFrame(..)>
 960     pToRemove->SetPageFrame( nullptr );
 961 }
 962
 963 void SwPageFrame::MoveFly( SwFlyFrame *pToMove, SwPageFrame *pDest )
 964 {
 965     // Invalidations
 966     if ( GetUpper() )
 967     {
 968         static_cast<SwRootFrame*>(GetUpper())->SetIdleFlags();
 969         if ( !pToMove->IsFlyInContentFrame() && pDest->GetPhyPageNum() < GetPhyPageNum() )
 970             static_cast<SwRootFrame*>(GetUpper())->SetSuperfluous();
 971     }
 972
 973     pDest->InvalidateSpelling();
 974     pDest->InvalidateSmartTags();
 975     pDest->InvalidateAutoCompleteWords();
 976     pDest->InvalidateWordCount();
 977
 978     if ( pToMove->IsFlyInContentFrame() )
 979     {
 980         pDest->InvalidateFlyInCnt();
 981         return;
 982     }
 983
 984     // Notify accessible layout. That's required at this place for
 985     // frames only where the anchor is moved. Creation of new frames
 986     // is additionally handled by the SwFrameNotify class.
 987 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
 988     if( GetUpper() &&
 989         static_cast< SwRootFrame * >( GetUpper() )->IsAnyShellAccessible() &&
 990         static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell() )
 991     {
 992         static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell()->Imp()
 993                                   ->DisposeAccessibleFrame( pToMove, true );
 994     }
 995 #endif
 996
 997     // The FlyColl might be gone already, because the page's dtor is being executed.
 998     if ( m_pSortedObjs )
 999     {
1000         m_pSortedObjs->Remove( *pToMove );
1001         if ( !m_pSortedObjs->size() )
1002         {
1003             m_pSortedObjs.reset();
1004         }
1005
1006         // Removing a fly from the page affects the margin of tables, so update the frame print area
1007         // of the lowers of my body frame.
1008         SwFrame* pBodyFrame = FindBodyCont();
1009         if (pBodyFrame)
1010         {
1011             for (SwFrame* pFrame = pBodyFrame->GetLower(); pFrame; pFrame = pFrame->GetNext())
1012             {
1013                 if (!pFrame->IsTabFrame())
1014                 {
1015                     // This is meant to match SwTabFrame::CalcFlyOffsets(), so not relevant for
1016                     // other frame types.
1017                     continue;
1018                 }
1019
1020                 pFrame->InvalidatePrt();
1021             }
1022         }
1023     }
1024
1025     // Register
1026     if ( !pDest->GetSortedObjs() )
1027         pDest->m_pSortedObjs.reset(new SwSortedObjs());
1028
1029     const bool bSuccessInserted = pDest->GetSortedObjs()->Insert( *pToMove );
1030     OSL_ENSURE( bSuccessInserted, "Fly not inserted in Sorted." );
1031
1032     // #i28701# - use new method <SetPageFrame(..)>
1033     pToMove->SetPageFrame( pDest );
1034     pToMove->InvalidatePage( pDest );
1035     pToMove->SetNotifyBack();
1036     pDest->InvalidateFlyContent();
1037     // #i28701#
1038     pToMove->UnlockPosition();
1039
1040     // Notify accessible layout. That's required at this place for
1041     // frames only where the anchor is moved. Creation of new frames
1042     // is additionally handled by the SwFrameNotify class.
1043 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1044     if( GetUpper() &&
1045         static_cast< SwRootFrame * >( GetUpper() )->IsAnyShellAccessible() &&
1046         static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell() )
1047     {
1048         static_cast< SwRootFrame * >( GetUpper() )->GetCurrShell()->Imp()
1049                                   ->AddAccessibleFrame( pToMove );
1050     }
1051 #endif
1052
1053     // #i28701# - correction: move lowers of Writer fly frame
1054     if ( !pToMove->GetDrawObjs() )
1055         return;
1056
1057     SwSortedObjs &rObjs = *pToMove->GetDrawObjs();
1058     for (SwAnchoredObject* pObj : rObjs)
1059     {
1060         if ( auto pFly = pObj->DynCastFlyFrame() )
1061         {
1062             if ( pFly->IsFlyFreeFrame() )
1063             {
1064                 // #i28701# - use new method <GetPageFrame()>
1065                 SwPageFrame* pPageFrame = pFly->GetPageFrame();
1066                 if ( pPageFrame )
1067                     pPageFrame->MoveFly( pFly, pDest );
1068                 else
1069                     pDest->AppendFlyToPage( pFly );
1070             }
1071         }
1072         else if ( dynamic_cast<const SwAnchoredDrawObject*>( pObj) !=  nullptr )
1073         {
1074             RemoveDrawObjFromPage( *pObj );
1075             pDest->AppendDrawObjToPage( *pObj );
1076         }
1077     }
1078 }
1079
1080 void SwPageFrame::AppendDrawObjToPage( SwAnchoredObject& _rNewObj )
1081 {
1082     if ( dynamic_cast<const SwAnchoredDrawObject*>( &_rNewObj) ==  nullptr )
1083     {
1084         OSL_FAIL( "SwPageFrame::AppendDrawObjToPage(..) - anchored object of unexpected type -> object not appended" );
1085         return;
1086     }
1087
1088     if ( GetUpper() )
1089     {
1090         static_cast<SwRootFrame*>(GetUpper())->InvalidateBrowseWidth();
1091     }
1092
1093     assert(_rNewObj.GetAnchorFrame());
1094     SwFlyFrame* pFlyFrame = const_cast<SwFlyFrame*>(_rNewObj.GetAnchorFrame()->FindFlyFrame());
1095     if ( pFlyFrame &&
1096          _rNewObj.GetDrawObj()->GetOrdNum() < pFlyFrame->GetVirtDrawObj()->GetOrdNum() )
1097     {
1098         //#i119945# set pFly's OrdNum to _rNewObj's. So when pFly is removed by Undo, the original OrdNum will not be changed.
1099         sal_uInt32 nNewNum = _rNewObj.GetDrawObj()->GetOrdNumDirect();
1100         if ( _rNewObj.GetDrawObj()->getSdrPageFromSdrObject() )
1101             _rNewObj.DrawObj()->getSdrPageFromSdrObject()->SetObjectOrdNum( pFlyFrame->GetVirtDrawObj()->GetOrdNumDirect(), nNewNum );
1102         else
1103             pFlyFrame->GetVirtDrawObj()->SetOrdNum( nNewNum );
1104     }
1105
1106     if ( RndStdIds::FLY_AS_CHAR == _rNewObj.GetFrameFormat().GetAnchor().GetAnchorId() )
1107     {
1108         return;
1109     }
1110
1111     if ( !m_pSortedObjs )
1112     {
1113         m_pSortedObjs.reset(new SwSortedObjs());
1114     }
1115     if ( !m_pSortedObjs->Insert( _rNewObj ) )
1116     {
1117         OSL_ENSURE( m_pSortedObjs->Contains( _rNewObj ),
1118                 "Drawing object not appended into list <pSortedObjs>." );
1119     }
1120     // #i87493#
1121     OSL_ENSURE( _rNewObj.GetPageFrame() == nullptr || _rNewObj.GetPageFrame() == this,
1122             "<SwPageFrame::AppendDrawObjToPage(..)> - anchored draw object seems to be registered at another page frame. Serious defect." );
1123     _rNewObj.SetPageFrame( this );
1124
1125     // invalidate page in order to force a reformat of object layout of the page.
1126     InvalidateFlyLayout();
1127 }
1128
1129 void SwPageFrame::RemoveDrawObjFromPage( SwAnchoredObject& _rToRemoveObj )
1130 {
1131     if ( dynamic_cast<const SwAnchoredDrawObject*>( &_rToRemoveObj) ==  nullptr )
1132     {
1133         OSL_FAIL( "SwPageFrame::RemoveDrawObjFromPage(..) - anchored object of unexpected type -> object not removed" );
1134         return;
1135     }
1136
1137     if ( m_pSortedObjs )
1138     {
1139         m_pSortedObjs->Remove( _rToRemoveObj );
1140         if ( !m_pSortedObjs->size() )
1141         {
1142             m_pSortedObjs.reset();
1143         }
1144         if ( GetUpper() )
1145         {
1146             if (RndStdIds::FLY_AS_CHAR !=
1147                     _rToRemoveObj.GetFrameFormat().GetAnchor().GetAnchorId())
1148             {
1149                 static_cast<SwRootFrame*>(GetUpper())->SetSuperfluous();
1150                 InvalidatePage();
1151             }
1152             static_cast<SwRootFrame*>(GetUpper())->InvalidateBrowseWidth();
1153         }
1154     }
1155     _rToRemoveObj.SetPageFrame( nullptr );
1156 }
1157
1158 // #i50432# - adjust method description and synopsis.
1159 void SwPageFrame::PlaceFly( SwFlyFrame* pFly, SwFlyFrameFormat* pFormat )
1160 {
1161     // #i50432# - consider the case that page is an empty page:
1162     // In this case append the fly frame at the next page
1163     OSL_ENSURE( !IsEmptyPage() || GetNext(),
1164             "<SwPageFrame::PlaceFly(..)> - empty page with no next page! -> fly frame appended at empty page" );
1165     if ( IsEmptyPage() && GetNext() )
1166     {
1167         static_cast<SwPageFrame*>(GetNext())->PlaceFly( pFly, pFormat );
1168     }
1169     else
1170     {
1171         // If we received a Fly, we use that one. Otherwise, create a new
1172         // one using the Format.
1173         if ( pFly )
1174             AppendFly( pFly );
1175         else
1176         {
1177             OSL_ENSURE( pFormat, ":-( No Format given for Fly." );
1178             pFly = new SwFlyLayFrame( pFormat, this, this );
1179             AppendFly( pFly );
1180             ::RegistFlys( this, pFly );
1181         }
1182     }
1183 }
1184
1185 // #i18732# - adjustments for following text flow or not
1186 // AND alignment at 'page areas' for to paragraph/to character anchored objects
1187 // #i22305# - adjustment for following text flow for to frame anchored objects
1188 // #i29778# - Because calculating the floating screen object's position
1189 // (Writer fly frame or drawing object) doesn't perform a calculation on its
1190 // upper frames and its anchor frame, a calculation of the upper frames in this
1191 // method is no longer sensible.
1192 // #i28701# - if document compatibility option 'Consider wrapping style influence
1193 // on object positioning' is ON, the clip area corresponds to the one as the
1194 // object doesn't follow the text flow.
1195 bool CalcClipRect( const SdrObject *pSdrObj, SwRect &rRect, bool bMove )
1196 {
1197     bool bRet = true;
1198     if ( auto pVirtFlyDrawObj = dynamic_cast<const SwVirtFlyDrawObj*>(pSdrObj) )
1199     {
1200         const SwFlyFrame* pFly = pVirtFlyDrawObj->GetFlyFrame();
1201         const bool bFollowTextFlow = pFly->GetFormat()->GetFollowTextFlow().GetValue();
1202         // #i28701#
1203         const bool bConsiderWrapOnObjPos =
1204                                 pFly->GetFormat()->getIDocumentSettingAccess().get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION);
1205         const SwFormatVertOrient &rV = pFly->GetFormat()->GetVertOrient();
1206         if( pFly->IsFlyLayFrame() )
1207         {
1208             const SwFrame* pClip;
1209             // #i22305#
1210             // #i28701#
1211             if ( !bFollowTextFlow || bConsiderWrapOnObjPos )
1212             {
1213                 pClip = pFly->GetAnchorFrame()->FindPageFrame();
1214             }
1215             else
1216             {
1217                 pClip = pFly->GetAnchorFrame();
1218             }
1219
1220             rRect = pClip->getFrameArea();
1221             SwRectFnSet aRectFnSet(pClip);
1222
1223             // vertical clipping: Top and Bottom, also to PrtArea if necessary
1224             if( rV.GetVertOrient() != text::VertOrientation::NONE &&
1225                 rV.GetRelationOrient() == text::RelOrientation::PRINT_AREA )
1226             {
1227                 aRectFnSet.SetTop( rRect, aRectFnSet.GetPrtTop(*pClip) );
1228                 aRectFnSet.SetBottom( rRect, aRectFnSet.GetPrtBottom(*pClip) );
1229             }
1230             // horizontal clipping: Top and Bottom, also to PrtArea if necessary
1231             const SwFormatHoriOrient &rH = pFly->GetFormat()->GetHoriOrient();
1232             if( rH.GetHoriOrient() != text::HoriOrientation::NONE &&
1233                 rH.GetRelationOrient() == text::RelOrientation::PRINT_AREA )
1234             {
1235                 aRectFnSet.SetLeft( rRect, aRectFnSet.GetPrtLeft(*pClip) );
1236                 aRectFnSet.SetRight(rRect, aRectFnSet.GetPrtRight(*pClip));
1237             }
1238         }
1239         else if( pFly->IsFlyAtContentFrame() )
1240         {
1241             // #i18732# - consider following text flow or not
1242             // AND alignment at 'page areas'
1243             const SwFrame* pVertPosOrientFrame = pFly->GetVertPosOrientFrame();
1244             if ( !pVertPosOrientFrame )
1245             {
1246                 OSL_FAIL( "::CalcClipRect(..) - frame, vertical position is oriented at, is missing .");
1247                 pVertPosOrientFrame = pFly->GetAnchorFrame();
1248             }
1249
1250             if ( !bFollowTextFlow || bConsiderWrapOnObjPos )
1251             {
1252                 const SwLayoutFrame* pClipFrame = pVertPosOrientFrame->FindPageFrame();
1253                 if (!pClipFrame)
1254                 {
1255                     OSL_FAIL("!pClipFrame: "
1256                             "if you can reproduce this please file a bug");
1257                     return false;
1258                 }
1259                 rRect = bMove ? pClipFrame->GetUpper()->getFrameArea()
1260                               : pClipFrame->getFrameArea();
1261                 // #i26945# - consider that a table, during
1262                 // its format, can exceed its upper printing area bottom.
1263                 // Thus, enlarge the clip rectangle, if such a case occurred
1264                 if ( pFly->GetAnchorFrame()->IsInTab() )
1265                 {
1266                     const SwTabFrame* pTabFrame = const_cast<SwFlyFrame*>(pFly)
1267                                 ->GetAnchorFrameContainingAnchPos()->FindTabFrame();
1268                     SwRect aTmp( pTabFrame->getFramePrintArea() );
1269                     aTmp += pTabFrame->getFrameArea().Pos();
1270                     rRect.Union( aTmp );
1271                     // #i43913# - consider also the cell frame
1272                     const SwFrame* pCellFrame = const_cast<SwFlyFrame*>(pFly)
1273                                 ->GetAnchorFrameContainingAnchPos()->GetUpper();
1274                     while ( pCellFrame && !pCellFrame->IsCellFrame() )
1275                     {
1276                         pCellFrame = pCellFrame->GetUpper();
1277                     }
1278                     if ( pCellFrame )
1279                     {
1280                         aTmp = pCellFrame->getFramePrintArea();
1281                         aTmp += pCellFrame->getFrameArea().Pos();
1282                         rRect.Union( aTmp );
1283                     }
1284                 }
1285             }
1286             else if ( rV.GetRelationOrient() == text::RelOrientation::PAGE_FRAME ||
1287                       rV.GetRelationOrient() == text::RelOrientation::PAGE_PRINT_AREA )
1288             {
1289                 // new class <SwEnvironmentOfAnchoredObject>
1290                 objectpositioning::SwEnvironmentOfAnchoredObject
1291                                                 aEnvOfObj( bFollowTextFlow );
1292                 const SwLayoutFrame& rVertClipFrame =
1293                     aEnvOfObj.GetVertEnvironmentLayoutFrame( *pVertPosOrientFrame );
1294                 if ( rV.GetRelationOrient() == text::RelOrientation::PAGE_FRAME )
1295                 {
1296                     rRect = rVertClipFrame.getFrameArea();
1297                 }
1298                 else if ( rV.GetRelationOrient() == text::RelOrientation::PAGE_PRINT_AREA )
1299                 {
1300                     if ( rVertClipFrame.IsPageFrame() )
1301                     {
1302                         rRect = static_cast<const SwPageFrame&>(rVertClipFrame).PrtWithoutHeaderAndFooter();
1303                     }
1304                     else
1305                     {
1306                         rRect = rVertClipFrame.getFrameArea();
1307                     }
1308                 }
1309                 const SwLayoutFrame* pHoriClipFrame =
1310                         pFly->GetAnchorFrame()->FindPageFrame()->GetUpper();
1311                 SwRectFnSet aRectFnSet(pFly->GetAnchorFrame());
1312                 aRectFnSet.SetLeft( rRect, aRectFnSet.GetLeft(pHoriClipFrame->getFrameArea()) );
1313                 aRectFnSet.SetRight(rRect, aRectFnSet.GetRight(pHoriClipFrame->getFrameArea()));
1314             }
1315             else
1316             {
1317                 // #i26945#
1318                 const SwFrame *pClip =
1319                         const_cast<SwFlyFrame*>(pFly)->GetAnchorFrameContainingAnchPos();
1320                 SwRectFnSet aRectFnSet(pClip);
1321                 const SwLayoutFrame *pUp = pClip->GetUpper();
1322                 const SwFrame *pCell = pUp->IsCellFrame() ? pUp : nullptr;
1323                 const SwFrameType nType = bMove
1324                                      ? SwFrameType::Root   | SwFrameType::Fly | SwFrameType::Header |
1325                                        SwFrameType::Footer | SwFrameType::Ftn
1326                                      : SwFrameType::Body   | SwFrameType::Fly | SwFrameType::Header |
1327                                        SwFrameType::Footer | SwFrameType::Cell| SwFrameType::Ftn;
1328
1329                 while ( !(pUp->GetType() & nType) || pUp->IsColBodyFrame() )
1330                 {
1331                     pUp = pUp->GetUpper();
1332                     if ( !pCell && pUp->IsCellFrame() )
1333                         pCell = pUp;
1334                 }
1335                 if ( bMove && pUp->IsRootFrame() )
1336                 {
1337                     rRect  = pUp->getFramePrintArea();
1338                     rRect += pUp->getFrameArea().Pos();
1339                     pUp = nullptr;
1340                 }
1341                 if ( pUp )
1342                 {
1343                     if ( pUp->GetType() & SwFrameType::Body )
1344                     {
1345                         const SwPageFrame *pPg;
1346                         if ( pUp->GetUpper() != (pPg = pFly->FindPageFrame()) )
1347                             pUp = pPg->FindBodyCont();
1348                         if (pUp)
1349                         {
1350                             rRect = pUp->GetUpper()->getFrameArea();
1351                             aRectFnSet.SetTop( rRect, aRectFnSet.GetPrtTop(*pUp) );
1352                             aRectFnSet.SetBottom(rRect, aRectFnSet.GetPrtBottom(*pUp));
1353                         }
1354                     }
1355                     else
1356                     {
1357                         if( ( pUp->GetType() & (SwFrameType::Fly | SwFrameType::Ftn ) ) &&
1358                             !pUp->getFrameArea().Contains( pFly->getFrameArea().Pos() ) )
1359                         {
1360                             if( pUp->IsFlyFrame() )
1361                             {
1362                                 const SwFlyFrame *pTmpFly = static_cast<const SwFlyFrame*>(pUp);
1363                                 while( pTmpFly->GetNextLink() )
1364                                 {
1365                                     pTmpFly = pTmpFly->GetNextLink();
1366                                     if( pTmpFly->getFrameArea().Contains( pFly->getFrameArea().Pos() ) )
1367                                         break;
1368                                 }
1369                                 pUp = pTmpFly;
1370                             }
1371                             else if( pUp->IsInFootnote() )
1372                             {
1373                                 const SwFootnoteFrame *pTmp = pUp->FindFootnoteFrame();
1374                                 while( pTmp->GetFollow() )
1375                                 {
1376                                     pTmp = pTmp->GetFollow();
1377                                     if( pTmp->getFrameArea().Contains( pFly->getFrameArea().Pos() ) )
1378                                         break;
1379                                 }
1380                                 pUp = pTmp;
1381                             }
1382                         }
1383                         rRect = pUp->getFramePrintArea();
1384                         rRect.Pos() += pUp->getFrameArea().Pos();
1385                         if ( pUp->GetType() & (SwFrameType::Header | SwFrameType::Footer) )
1386                         {
1387                             rRect.Left ( pUp->GetUpper()->getFrameArea().Left() );
1388                             rRect.Width( pUp->GetUpper()->getFrameArea().Width());
1389                         }
1390                         else if ( pUp->IsCellFrame() )                //MA_FLY_HEIGHT
1391                         {
1392                             const SwFrame *pTab = pUp->FindTabFrame();
1393                             aRectFnSet.SetBottom( rRect, aRectFnSet.GetPrtBottom(*pTab->GetUpper()) );
1394                             // expand to left and right cell border
1395                             rRect.Left ( pUp->getFrameArea().Left() );
1396                             rRect.Width( pUp->getFrameArea().Width() );
1397                         }
1398                     }
1399                 }
1400                 if ( pCell )
1401                 {
1402                     // CellFrames might also sit in unallowed areas. In this case,
1403                     // the Fly is allowed to do so as well
1404                     SwRect aTmp( pCell->getFramePrintArea() );
1405                     aTmp += pCell->getFrameArea().Pos();
1406                     rRect.Union( aTmp );
1407                 }
1408             }
1409         }
1410         else
1411         {
1412             const SwFrame *pUp = pFly->GetAnchorFrame()->GetUpper();
1413             SwRectFnSet aRectFnSet(pFly->GetAnchorFrame());
1414             while( pUp->IsColumnFrame() || pUp->IsSctFrame() || pUp->IsColBodyFrame())
1415                 pUp = pUp->GetUpper();
1416             rRect = pUp->getFrameArea();
1417             if( !pUp->IsBodyFrame() )
1418             {
1419                 rRect += pUp->getFramePrintArea().Pos();
1420                 rRect.SSize( pUp->getFramePrintArea().SSize() );
1421                 if ( pUp->IsCellFrame() )
1422                 {
1423                     const SwFrame *pTab = pUp->FindTabFrame();
1424                     aRectFnSet.SetBottom( rRect, aRectFnSet.GetPrtBottom(*pTab->GetUpper()) );
1425                 }
1426             }
1427             else if ( pUp->GetUpper()->IsPageFrame() )
1428             {
1429                 // Objects anchored as character may exceed right margin
1430                 // of body frame:
1431                 aRectFnSet.SetRight( rRect, aRectFnSet.GetRight(pUp->GetUpper()->getFrameArea()) );
1432             }
1433             tools::Long nHeight = (9*aRectFnSet.GetHeight(rRect))/10;
1434             tools::Long nTop;
1435             const SwFormat *pFormat = GetUserCall(pSdrObj)->GetFormat();
1436             const SvxULSpaceItem &rUL = pFormat->GetULSpace();
1437             if( bMove )
1438             {
1439                 nTop = aRectFnSet.IsVert() ? static_cast<const SwFlyInContentFrame*>(pFly)->GetRefPoint().X() :
1440                                static_cast<const SwFlyInContentFrame*>(pFly)->GetRefPoint().Y();
1441                 nTop = aRectFnSet.YInc( nTop, -nHeight );
1442                 tools::Long nWidth = aRectFnSet.GetWidth(pFly->getFrameArea());
1443                 aRectFnSet.SetLeftAndWidth( rRect, aRectFnSet.IsVert() ?
1444                             static_cast<const SwFlyInContentFrame*>(pFly)->GetRefPoint().Y() :
1445                             static_cast<const SwFlyInContentFrame*>(pFly)->GetRefPoint().X(), nWidth );
1446                 nHeight = 2*nHeight - rUL.GetLower() - rUL.GetUpper();
1447             }
1448             else
1449             {
1450                 nTop = aRectFnSet.YInc( aRectFnSet.GetBottom(pFly->getFrameArea()),
1451                                            rUL.GetLower() - nHeight );
1452                 nHeight = 2*nHeight - aRectFnSet.GetHeight(pFly->getFrameArea())
1453                           - rUL.GetLower() - rUL.GetUpper();
1454             }
1455             aRectFnSet.SetTopAndHeight( rRect, nTop, nHeight );
1456         }
1457     }
1458     else
1459     {
1460         const SwDrawContact *pC = static_cast<const SwDrawContact*>(GetUserCall(pSdrObj));
1461         const SwFrameFormat  *pFormat = pC->GetFormat();
1462         const SwFormatAnchor &rAnch = pFormat->GetAnchor();
1463         if ( RndStdIds::FLY_AS_CHAR == rAnch.GetAnchorId() )
1464         {
1465             const SwFrame* pAnchorFrame = pC->GetAnchorFrame( pSdrObj );
1466             if( !pAnchorFrame )
1467             {
1468                 OSL_FAIL( "<::CalcClipRect(..)> - missing anchor frame." );
1469                 const_cast<SwDrawContact*>(pC)->ConnectToLayout();
1470                 pAnchorFrame = pC->GetAnchorFrame();
1471             }
1472             const SwFrame* pUp = pAnchorFrame->GetUpper();
1473             rRect = pUp->getFramePrintArea();
1474             rRect += pUp->getFrameArea().Pos();
1475             SwRectFnSet aRectFnSet(pAnchorFrame);
1476             tools::Long nHeight = (9*aRectFnSet.GetHeight(rRect))/10;
1477             tools::Long nTop;
1478             const SvxULSpaceItem &rUL = pFormat->GetULSpace();
1479             SwRect aSnapRect( pSdrObj->GetSnapRect() );
1480             tools::Long nTmpH = 0;
1481             if( bMove )
1482             {
1483                 nTop = aRectFnSet.YInc( aRectFnSet.IsVert() ? pSdrObj->GetAnchorPos().X() :
1484                                        pSdrObj->GetAnchorPos().Y(), -nHeight );
1485                 tools::Long nWidth = aRectFnSet.GetWidth(aSnapRect);
1486                 aRectFnSet.SetLeftAndWidth( rRect, aRectFnSet.IsVert() ?
1487                             pSdrObj->GetAnchorPos().Y() :
1488                             pSdrObj->GetAnchorPos().X(), nWidth );
1489             }
1490             else
1491             {
1492                 // #i26791# - value of <nTmpH> is needed to
1493                 // calculate value of <nTop>.
1494                 nTmpH = aRectFnSet.IsVert() ? pSdrObj->GetCurrentBoundRect().GetWidth() :
1495                                        pSdrObj->GetCurrentBoundRect().GetHeight();
1496                 nTop = aRectFnSet.YInc( aRectFnSet.GetTop(aSnapRect),
1497                                           rUL.GetLower() + nTmpH - nHeight );
1498             }
1499             nHeight = 2*nHeight - nTmpH - rUL.GetLower() - rUL.GetUpper();
1500             aRectFnSet.SetTopAndHeight( rRect, nTop, nHeight );
1501         }
1502         else
1503         {
1504             // restrict clip rectangle for drawing
1505             // objects in header/footer to the page frame.
1506             // #i26791#
1507             const SwFrame* pAnchorFrame = pC->GetAnchorFrame( pSdrObj );
1508             if ( pAnchorFrame && pAnchorFrame->FindFooterOrHeader() )
1509             {
1510                 // clip frame is the page frame the header/footer is on.
1511                 const SwFrame* pClipFrame = pAnchorFrame->FindPageFrame();
1512                 rRect = pClipFrame->getFrameArea();
1513             }
1514             else
1515             {
1516                 bRet = false;
1517             }
1518         }
1519     }
1520     return bRet;
1521 }
1522
1523 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */