sw/source/core/layout/anchoredobject.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 <txtfrm.hxx>
  21 #include <frmatr.hxx>
  22 #include <fmtornt.hxx>
  23 #include <doc.hxx>
  24 #include <IDocumentSettingAccess.hxx>
  25 #include <IDocumentDrawModelAccess.hxx>
  26 #include <fmtsrnd.hxx>
  27 #include <dcontact.hxx>
  28 #include <editeng/ulspitem.hxx>
  29 #include <editeng/lrspitem.hxx>
  30 #include <sortedobjs.hxx>
  31 #include <pagefrm.hxx>
  32 #include <layouter.hxx>
  33 #include <osl/diagnose.h>
  34 #include <flyfrms.hxx>
  35
  36 using namespace ::com::sun::star;
  37
  38 // --> #i28701# -
  39 // implementation of helper class <SwObjPositioningInProgress>
  40
  41 SwObjPositioningInProgress::SwObjPositioningInProgress( SdrObject& _rSdrObj ) :
  42     mpAnchoredObj( nullptr ),
  43     // --> #i52904#
  44     mbOldObjPositioningInProgress( false )
  45 {
  46     mpAnchoredObj = ::GetUserCall( &_rSdrObj )->GetAnchoredObj( &_rSdrObj );
  47     // --> #i52904#
  48     mbOldObjPositioningInProgress = mpAnchoredObj->IsPositioningInProgress();
  49     mpAnchoredObj->SetPositioningInProgress( true );
  50 }
  51 SwObjPositioningInProgress::SwObjPositioningInProgress( SwAnchoredObject& _rAnchoredObj ) :
  52     mpAnchoredObj( &_rAnchoredObj ),
  53     // --> #i52904#
  54     mbOldObjPositioningInProgress( false )
  55 {
  56     // --> #i52904#
  57     mbOldObjPositioningInProgress = mpAnchoredObj->IsPositioningInProgress();
  58     mpAnchoredObj->SetPositioningInProgress( true );
  59 }
  60
  61 SwObjPositioningInProgress::~SwObjPositioningInProgress()
  62 {
  63     if ( mpAnchoredObj )
  64     {
  65         // --> #i52904#
  66         mpAnchoredObj->SetPositioningInProgress( mbOldObjPositioningInProgress );
  67     }
  68 }
  69
  70
  71 SwAnchoredObject::SwAnchoredObject() :
  72     mpAnchorFrame( nullptr ),
  73     // --> #i28701#
  74     mpPageFrame( nullptr ),
  75     mnLastTopOfLine( 0 ),
  76     mpVertPosOrientFrame( nullptr ),
  77     // --> #i28701#
  78     mbPositioningInProgress( false ),
  79     mbConsiderForTextWrap( false ),
  80     mbPositionLocked( false ),
  81     // --> #i40147#
  82     mbKeepPositionLockedForSection( false ),
  83     mbRestartLayoutProcess( false ),
  84     // --> #i35911#
  85     mbClearedEnvironment( false ),
  86     // --> #i3317#
  87     mbTmpConsiderWrapInfluence( false ),
  88     mbObjRectWithSpacesValid( false )
  89 {
  90 }
  91
  92 void SwAnchoredObject::ClearVertPosOrientFrame()
  93 {
  94     if (mpVertPosOrientFrame)
  95     {
  96         const_cast<SwLayoutFrame*>(mpVertPosOrientFrame)->ClearVertPosOrientFrameFor(this);
  97         mpVertPosOrientFrame = nullptr;
  98     }
  99 }
 100
 101 SwAnchoredObject::~SwAnchoredObject()
 102 {
 103     ClearVertPosOrientFrame();
 104 }
 105
 106 void SwAnchoredObject::SetDrawObj( SdrObject& _rDrawObj )
 107 {
 108     mpDrawObj = &_rDrawObj;
 109 }
 110
 111
 112 void SwAnchoredObject::ChgAnchorFrame( SwFrame* _pNewAnchorFrame )
 113 {
 114     mpAnchorFrame = _pNewAnchorFrame;
 115
 116     if ( mpAnchorFrame )
 117     {
 118         ObjectAttachedToAnchorFrame();
 119     }
 120 }
 121
 122 /** determine anchor frame containing the anchor position
 123
 124     #i26945#
 125     the anchor frame, which is determined, is <mpAnchorFrame>
 126     for an at-page, at-frame or at-paragraph anchored object
 127     and the anchor character frame for an at-character and as-character
 128     anchored object.
 129 */
 130 SwFrame* SwAnchoredObject::GetAnchorFrameContainingAnchPos()
 131 {
 132     SwFrame* pAnchorFrameContainingAnchPos = FindAnchorCharFrame();
 133     if ( !pAnchorFrameContainingAnchPos )
 134     {
 135         pAnchorFrameContainingAnchPos = AnchorFrame();
 136     }
 137
 138     return pAnchorFrameContainingAnchPos;
 139 }
 140
 141
 142 void SwAnchoredObject::SetPageFrame( SwPageFrame* _pNewPageFrame )
 143 {
 144     if ( mpPageFrame == _pNewPageFrame )
 145         return;
 146
 147     // clear member, which denotes the layout frame at which the vertical
 148     // position is oriented at, if it doesn't fit to the new page frame.
 149     if ( GetVertPosOrientFrame() &&
 150          ( !_pNewPageFrame ||
 151            _pNewPageFrame != GetVertPosOrientFrame()->FindPageFrame() ) )
 152     {
 153         ClearVertPosOrientFrame();
 154     }
 155
 156     // assign new page frame
 157     mpPageFrame = _pNewPageFrame;
 158 }
 159
 160
 161 SwTwips SwAnchoredObject::GetRelCharX( const SwFrame* pFrame ) const
 162 {
 163     return maLastCharRect.Left() - pFrame->getFrameArea().Left();
 164 }
 165
 166 SwTwips SwAnchoredObject::GetRelCharY( const SwFrame* pFrame ) const
 167 {
 168     return maLastCharRect.Bottom() - pFrame->getFrameArea().Top();
 169 }
 170
 171 void SwAnchoredObject::AddLastCharY( tools::Long nDiff )
 172 {
 173     maLastCharRect.Pos().AdjustY(nDiff );
 174 }
 175
 176 void SwAnchoredObject::ResetLastCharRectHeight()
 177 {
 178     maLastCharRect.Height( 0 );
 179 }
 180
 181 void SwAnchoredObject::SetVertPosOrientFrame( const SwLayoutFrame& _rVertPosOrientFrame )
 182 {
 183     ClearVertPosOrientFrame();
 184
 185     mpVertPosOrientFrame = &_rVertPosOrientFrame;
 186     const_cast<SwLayoutFrame*>(mpVertPosOrientFrame)->SetVertPosOrientFrameFor(this);
 187
 188     // #i28701# - take over functionality of deleted method
 189     // <SwFlyAtContentFrame::AssertPage()>: assure for at-paragraph and at-character
 190     // an anchored object, that it is registered at the correct page frame
 191     RegisterAtCorrectPage();
 192 }
 193
 194
 195 // #i28701# - follow-up of #i22341#
 196 void SwAnchoredObject::AddLastTopOfLineY( SwTwips _nDiff )
 197 {
 198     mnLastTopOfLine += _nDiff;
 199 }
 200
 201 /** check anchor character rectangle and top of line
 202
 203     #i26791
 204     For to-character anchored Writer fly frames the members <maLastCharRect>
 205     and <maLastTopOfLine> are updated. These are checked for change and
 206     depending on the applied positioning, it's decided, if the Writer fly
 207     frame has to be invalidated.
 208
 209     add parameter <_bCheckForParaPorInf>, default value <true>
 210 */
 211 void SwAnchoredObject::CheckCharRectAndTopOfLine(
 212                                         const bool _bCheckForParaPorInf )
 213 {
 214     if ( !(GetAnchorFrame() &&
 215          GetAnchorFrame()->IsTextFrame()) )
 216         return;
 217
 218     const SwFormatAnchor& rAnch = GetFrameFormat().GetAnchor();
 219     if ( !((rAnch.GetAnchorId() == RndStdIds::FLY_AT_CHAR) &&
 220          rAnch.GetAnchorNode()) )
 221         return;
 222
 223     // --> if requested, assure that anchor frame,
 224     // which contains the anchor character, has a paragraph portion information.
 225     // The paragraph portion information is needed to determine the
 226     // anchor character rectangle respectively the top of the line.
 227     // Thus, a format of this frame is avoided to determine the
 228     // paragraph portion information.
 229     // --> #i26945# - use new method <FindAnchorCharFrame()>
 230     const SwTextFrame& aAnchorCharFrame = *(FindAnchorCharFrame());
 231     if ( !_bCheckForParaPorInf || aAnchorCharFrame.HasPara() )
 232     {
 233         CheckCharRect( rAnch, aAnchorCharFrame );
 234         CheckTopOfLine( rAnch, aAnchorCharFrame );
 235     }
 236 }
 237
 238 /** check anchor character rectangle
 239
 240     #i22341#
 241     helper method for method <CheckCharRectAndTopOfLine()>
 242     For to-character anchored Writer fly frames the member <maLastCharRect>
 243     is updated. This is checked for change and depending on the applied
 244     positioning, it's decided, if the Writer fly frame has to be invalidated.
 245
 246     improvement - add second parameter <_rAnchorCharFrame>
 247 */
 248 void SwAnchoredObject::CheckCharRect( const SwFormatAnchor& _rAnch,
 249                                        const SwTextFrame& _rAnchorCharFrame )
 250 {
 251     // determine rectangle of anchor character. If not exist, abort operation
 252     SwRect aCharRect;
 253     if ( !_rAnchorCharFrame.GetAutoPos( aCharRect, *_rAnch.GetContentAnchor() ) )
 254     {
 255         return;
 256     }
 257     // check, if anchor character rectangle has changed
 258     if ( aCharRect == maLastCharRect )
 259         return;
 260
 261     // check positioning and alignment for invalidation of position
 262     {
 263         SwRectFnSet aRectFnSet(&_rAnchorCharFrame);
 264         // determine positioning and alignment
 265         SwFormatVertOrient aVert( GetFrameFormat().GetVertOrient() );
 266         SwFormatHoriOrient aHori( GetFrameFormat().GetHoriOrient() );
 267         // check for anchor character rectangle changes for certain
 268         // positionings and alignments
 269         // add condition to invalidate position,
 270         // if vertical aligned at frame/page area and vertical position
 271         // of anchor character has changed.
 272         const sal_Int16 eVertRelOrient = aVert.GetRelationOrient();
 273         if ( ( aHori.GetRelationOrient() == text::RelOrientation::CHAR &&
 274                aRectFnSet.GetLeft(aCharRect) != aRectFnSet.GetLeft(maLastCharRect) ) ||
 275              ( eVertRelOrient == text::RelOrientation::CHAR &&
 276                ( aRectFnSet.GetTop(aCharRect) != aRectFnSet.GetTop(maLastCharRect) ||
 277                  aRectFnSet.GetHeight(aCharRect) != aRectFnSet.GetHeight(maLastCharRect) ) ) ||
 278              ( ( ( eVertRelOrient == text::RelOrientation::FRAME ) ||
 279                  ( eVertRelOrient == text::RelOrientation::PRINT_AREA ) ||
 280                  ( eVertRelOrient == text::RelOrientation::PAGE_FRAME ) ||
 281                  ( eVertRelOrient == text::RelOrientation::PAGE_PRINT_AREA ) ) &&
 282                ( aRectFnSet.GetTop(aCharRect) != aRectFnSet.GetTop(maLastCharRect) ) ) )
 283         {
 284             // #i26945#, #i35911# - unlock position of
 285             // anchored object, if it isn't registered at the page,
 286             // where its anchor character frame is on.
 287             if ( GetPageFrame() != _rAnchorCharFrame.FindPageFrame() )
 288             {
 289                 UnlockPosition();
 290             }
 291             InvalidateObjPos();
 292         }
 293     }
 294     // keep new anchor character rectangle
 295     maLastCharRect = aCharRect;
 296 }
 297
 298 /** check top of line
 299
 300     #i22341#
 301     helper method for method <CheckCharRectAndTopOfLine()>
 302     For to-character anchored Writer fly frames the member <mnLastTopOfLine>
 303     is updated. This is checked for change and depending on the applied
 304     positioning, it's decided, if the Writer fly frame has to be invalidated.
 305
 306     improvement - add second parameter <_rAnchorCharFrame>
 307 */
 308 void SwAnchoredObject::CheckTopOfLine( const SwFormatAnchor& _rAnch,
 309                                         const SwTextFrame& _rAnchorCharFrame )
 310 {
 311     SwTwips nTopOfLine = 0;
 312     if ( !_rAnchorCharFrame.GetTopOfLine( nTopOfLine, *_rAnch.GetContentAnchor() ) )
 313         return;
 314
 315     if ( nTopOfLine == mnLastTopOfLine )
 316         return;
 317
 318     // check alignment for invalidation of position
 319     if ( GetFrameFormat().GetVertOrient().GetRelationOrient() == text::RelOrientation::TEXT_LINE )
 320     {
 321         // #i26945#, #i35911# - unlock position of
 322         // anchored object, if it isn't registered at the page,
 323         // where its anchor character frame is on.
 324         if ( GetPageFrame() != _rAnchorCharFrame.FindPageFrame() )
 325         {
 326             UnlockPosition();
 327         }
 328         InvalidateObjPos();
 329     }
 330     // keep new top of line value
 331     mnLastTopOfLine = nTopOfLine;
 332 }
 333
 334 void SwAnchoredObject::ClearCharRectAndTopOfLine()
 335 {
 336     maLastCharRect.Clear();
 337     mnLastTopOfLine = 0;
 338 }
 339
 340 void SwAnchoredObject::SetCurrRelPos( Point _aRelPos )
 341 {
 342     maRelPos = _aRelPos;
 343 }
 344
 345 void SwAnchoredObject::ObjectAttachedToAnchorFrame()
 346 {
 347     // default behaviour:
 348     // update layout direction, the anchored object is assigned to
 349     UpdateLayoutDir();
 350 }
 351
 352 /** method update layout direction the layout direction, the anchored
 353     object is in
 354
 355     #i31698#
 356     method has typically to be called, if the anchored object gets its
 357     anchor frame assigned.
 358 */
 359 void SwAnchoredObject::UpdateLayoutDir()
 360 {
 361     SwFrameFormat::tLayoutDir nLayoutDir = SwFrameFormat::HORI_L2R;
 362     const SwFrame* pAnchorFrame = GetAnchorFrame();
 363     if ( pAnchorFrame )
 364     {
 365         const bool bVert = pAnchorFrame->IsVertical();
 366         const bool bR2L = pAnchorFrame->IsRightToLeft();
 367         if ( bVert )
 368         {
 369             nLayoutDir = SwFrameFormat::VERT_R2L;
 370         }
 371         else if ( bR2L )
 372         {
 373             nLayoutDir = SwFrameFormat::HORI_R2L;
 374         }
 375     }
 376     GetFrameFormat().SetLayoutDir( nLayoutDir );
 377 }
 378
 379 /** method to perform necessary invalidations for the positioning of
 380     objects, for whose the wrapping style influence has to be considered
 381     on the object positioning.
 382
 383     #i28701#
 384 */
 385 void SwAnchoredObject::InvalidateObjPosForConsiderWrapInfluence()
 386 {
 387     if ( ConsiderObjWrapInfluenceOnObjPos() )
 388     {
 389         // indicate that object has not to be considered for text wrap
 390         SetConsiderForTextWrap( false );
 391         // unlock position
 392         UnlockPosition();
 393         // invalidate position
 394         InvalidateObjPos();
 395         // invalidate 'background'
 396         NotifyBackground( GetPageFrame(), GetObjRectWithSpaces(), PrepareHint::FlyFrameLeave );
 397     }
 398 }
 399
 400 /** method to determine, if wrapping style influence of the anchored
 401     object has to be considered on the object positioning
 402
 403     #i28701#
 404     Note: result of this method also decides, if the booleans for the
 405     layout process are of relevance.
 406 */
 407 bool SwAnchoredObject::ConsiderObjWrapInfluenceOnObjPos() const
 408 {
 409     bool bRet( false );
 410
 411     const SwFrameFormat& rObjFormat = GetFrameFormat();
 412
 413     // --> #i3317# - add condition <IsTmpConsiderWrapInfluence()>
 414     // --> #i55204#
 415     // - correction: wrapping style influence has been considered, if condition
 416     //   <IsTmpConsiderWrapInfluence()> is hold, regardless of its anchor type
 417     //   or its wrapping style.
 418     if ( IsTmpConsiderWrapInfluence() )
 419     {
 420         bRet = true;
 421     }
 422     else if ( rObjFormat.getIDocumentSettingAccess().get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) )
 423     {
 424         const SwFormatAnchor& rAnchor = rObjFormat.GetAnchor();
 425         if ( ((rAnchor.GetAnchorId() == RndStdIds::FLY_AT_CHAR) ||
 426               (rAnchor.GetAnchorId() == RndStdIds::FLY_AT_PARA)) &&
 427              rObjFormat.GetSurround().GetSurround() != css::text::WrapTextMode_THROUGH )
 428         {
 429             // --> #i34520# - text also wraps around anchored
 430             // objects in the layer Hell - see the text formatting.
 431             // Thus, it hasn't to be checked here.
 432             bRet = true;
 433         }
 434     }
 435
 436     return bRet;
 437 }
 438
 439 /** method to determine, if other anchored objects, also attached at
 440     to the anchor frame, have to consider its wrap influence.
 441
 442     // --> #i43255#
 443 */
 444 bool SwAnchoredObject::ConsiderObjWrapInfluenceOfOtherObjs() const
 445 {
 446     bool bRet( false );
 447
 448     const SwSortedObjs* pObjs = GetAnchorFrame()->GetDrawObjs();
 449     if ( pObjs->size() > 1 )
 450     {
 451         for (SwAnchoredObject* pAnchoredObj : *pObjs)
 452         {
 453             if ( pAnchoredObj != this &&
 454                  pAnchoredObj->ConsiderObjWrapInfluenceOnObjPos() )
 455             {
 456                 bRet = true;
 457                 break;
 458             }
 459         }
 460     }
 461
 462     return bRet;
 463 }
 464
 465 bool SwAnchoredObject::ConsiderForTextWrap() const
 466 {
 467     if ( ConsiderObjWrapInfluenceOnObjPos() )
 468         return mbConsiderForTextWrap;
 469     else
 470         return true;
 471 }
 472
 473 void SwAnchoredObject::SetConsiderForTextWrap( const bool _bConsiderForTextWrap )
 474 {
 475     mbConsiderForTextWrap = _bConsiderForTextWrap;
 476 }
 477
 478 bool SwAnchoredObject::PositionLocked() const
 479 {
 480     if ( ConsiderObjWrapInfluenceOnObjPos() )
 481         return mbPositionLocked;
 482     else
 483         return false;
 484 }
 485
 486 bool SwAnchoredObject::RestartLayoutProcess() const
 487 {
 488     if ( ConsiderObjWrapInfluenceOnObjPos() )
 489         return mbRestartLayoutProcess;
 490     else
 491         return false;
 492 }
 493
 494 void SwAnchoredObject::SetRestartLayoutProcess( const bool _bRestartLayoutProcess )
 495 {
 496     mbRestartLayoutProcess = _bRestartLayoutProcess;
 497 }
 498
 499 // --> #i35911#
 500 bool SwAnchoredObject::ClearedEnvironment() const
 501 {
 502     if ( ConsiderObjWrapInfluenceOnObjPos() )
 503         return mbClearedEnvironment;
 504     else
 505         return false;
 506 }
 507 void SwAnchoredObject::SetClearedEnvironment( const bool _bClearedEnvironment )
 508 {
 509     mbClearedEnvironment = _bClearedEnvironment;
 510 }
 511
 512 /** method to determine, if due to anchored object size and wrapping
 513     style, its layout environment is cleared.
 514
 515     #i35911#
 516 */
 517 bool SwAnchoredObject::HasClearedEnvironment() const
 518 {
 519     bool bHasClearedEnvironment( false );
 520
 521     // --> #i43913# - layout frame, vertical position is orient at, has to be set.
 522     OSL_ENSURE( GetVertPosOrientFrame(),
 523             "<SwAnchoredObject::HasClearedEnvironment()> - layout frame missing, at which the vertical position is oriented at." );
 524     if ( GetVertPosOrientFrame() &&
 525          GetAnchorFrame()->IsTextFrame() &&
 526          !static_cast<const SwTextFrame*>(GetAnchorFrame())->IsFollow() &&
 527          static_cast<const SwTextFrame*>(GetAnchorFrame())->FindPageFrame()->GetPhyPageNum() >=
 528                 GetPageFrame()->GetPhyPageNum() )
 529     {
 530         const SwFrame* pTmpFrame = GetVertPosOrientFrame()->Lower();
 531         while ( pTmpFrame && pTmpFrame->IsLayoutFrame() && !pTmpFrame->IsTabFrame() )
 532         {
 533             pTmpFrame = static_cast<const SwLayoutFrame*>(pTmpFrame)->Lower();
 534         }
 535         if ( !pTmpFrame )
 536         {
 537             bHasClearedEnvironment = true;
 538         }
 539         else if ( pTmpFrame->IsTextFrame() && !pTmpFrame->GetNext() )
 540         {
 541             const SwTextFrame* pTmpTextFrame = static_cast<const SwTextFrame*>(pTmpFrame);
 542             if ( pTmpTextFrame->IsUndersized() ||
 543                  ( pTmpTextFrame->GetFollow() &&
 544                    pTmpTextFrame->GetFollow()->GetOffset() == TextFrameIndex(0)))
 545             {
 546                 bHasClearedEnvironment = true;
 547             }
 548         }
 549     }
 550
 551     return bHasClearedEnvironment;
 552 }
 553
 554 /** method to add spacing to object area
 555
 556     #i28701#
 557     #i68520# - return constant reference and use cache
 558 */
 559 const SwRect& SwAnchoredObject::GetObjRectWithSpaces() const
 560 {
 561     if ( mbObjRectWithSpacesValid &&
 562          maLastObjRect != GetObjRect() )
 563     {
 564         OSL_FAIL( "<SwAnchoredObject::GetObjRectWithSpaces> - cache for object rectangle inclusive spaces marked as valid, but it couldn't be. Missing invalidation of cache." );
 565         InvalidateObjRectWithSpaces();
 566     }
 567     if ( !mbObjRectWithSpacesValid )
 568     {
 569         maObjRectWithSpaces = GetObjBoundRect();
 570         const SwFrameFormat& rFormat = GetFrameFormat();
 571         const SvxULSpaceItem& rUL = rFormat.GetULSpace();
 572         const SvxLRSpaceItem& rLR = rFormat.GetLRSpace();
 573         {
 574             maObjRectWithSpaces.Top ( std::max( maObjRectWithSpaces.Top() - tools::Long(rUL.GetUpper()), tools::Long(0) ));
 575             maObjRectWithSpaces.Left( std::max( maObjRectWithSpaces.Left()- rLR.GetLeft(),  tools::Long(0) ));
 576             maObjRectWithSpaces.AddHeight(rUL.GetLower() );
 577             maObjRectWithSpaces.AddWidth(rLR.GetRight() );
 578         }
 579
 580         mbObjRectWithSpacesValid = true;
 581         maLastObjRect = GetObjRect();
 582     }
 583
 584     return maObjRectWithSpaces;
 585 }
 586
 587 // --> #i68520#
 588 void SwAnchoredObject::SetObjTop( const SwTwips _nTop)
 589 {
 590     const bool bTopChanged( SetObjTop_( _nTop ) );
 591     if ( bTopChanged )
 592     {
 593         mbObjRectWithSpacesValid = false;
 594     }
 595 }
 596
 597 void SwAnchoredObject::SetObjLeft( const SwTwips _nLeft)
 598 {
 599     const bool bLeftChanged( SetObjLeft_( _nLeft ) );
 600     if ( bLeftChanged )
 601     {
 602         mbObjRectWithSpacesValid = false;
 603     }
 604 }
 605
 606 /** method to update anchored object in the <SwSortedObjs> lists
 607
 608     #i28701#
 609     If document compatibility option 'Consider wrapping style influence
 610     on object positioning' is ON, additionally all anchored objects
 611     at the anchor frame and all following anchored objects on the page
 612     frame are invalidated.
 613 */
 614
 615 void SwAnchoredObject::UpdateObjInSortedList()
 616 {
 617     if(!GetAnchorFrame())
 618         return;
 619
 620     if ( GetFrameFormat().getIDocumentSettingAccess().get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) )
 621     {
 622         // invalidate position of all anchored objects at anchor frame
 623         if ( GetAnchorFrame()->GetDrawObjs() )
 624         {
 625             const SwSortedObjs* pObjs = GetAnchorFrame()->GetDrawObjs();
 626             for(auto it = pObjs->begin(); it != pObjs->end(); ++it)
 627             {
 628                 SwAnchoredObject* pAnchoredObj = *it;
 629                 if(pAnchoredObj->ConsiderObjWrapInfluenceOnObjPos())
 630                     pAnchoredObj->InvalidateObjPosForConsiderWrapInfluence();
 631                 else
 632                     pAnchoredObj->InvalidateObjPos();
 633             }
 634         }
 635         // invalidate all following anchored objects on the page frame
 636         if ( GetPageFrame() && GetPageFrame()->GetSortedObjs() )
 637         {
 638             const SwSortedObjs* pObjs = GetPageFrame()->GetSortedObjs();
 639             // determine start index
 640             for ( size_t i = pObjs->ListPosOf( *this ) + 1; i < pObjs->size(); ++i )
 641             {
 642                 SwAnchoredObject* pAnchoredObj = (*pObjs)[i];
 643                 if ( pAnchoredObj->ConsiderObjWrapInfluenceOnObjPos() )
 644                     pAnchoredObj->InvalidateObjPosForConsiderWrapInfluence();
 645                 else
 646                     pAnchoredObj->InvalidateObjPos();
 647             }
 648         }
 649     }
 650     // update its position in the sorted object list of its anchor frame
 651     AnchorFrame()->GetDrawObjs()->Update( *this );
 652     // update its position in the sorted object list of its page frame
 653     // note: as-character anchored object aren't registered at a page frame
 654     if ( GetPageFrame() && GetPageFrame()->GetSortedObjs() &&
 655         GetFrameFormat().GetAnchor().GetAnchorId() != RndStdIds::FLY_AS_CHAR )
 656     {
 657         GetPageFrame()->GetSortedObjs()->Update( *this );
 658     }
 659 }
 660
 661 /** method to determine, if invalidation of position is allowed
 662
 663     #i28701#
 664 */
 665 bool SwAnchoredObject::InvalidationOfPosAllowed() const
 666 {
 667     // --> Check, if page frame layout is in progress,
 668     // isn't needed, because of anchored object, whose are moved forward.
 669     return !PositionLocked();
 670 }
 671
 672 /** method to determine the page frame, on which the 'anchor' of
 673     the given anchored object is.
 674
 675     #i28701#
 676     #i33751#, #i34060#
 677     Adjust meaning of method and thus its name: If the anchored object
 678     or its anchor isn't correctly inserted in the layout, no page frame
 679     can be found. Thus, the return type changed to be a pointer and can
 680     be NULL.
 681 */
 682 SwPageFrame* SwAnchoredObject::FindPageFrameOfAnchor()
 683 {
 684     SwPageFrame* pRetPageFrame = nullptr;
 685
 686     // --> #i44339# - check, if anchor frame exists.
 687     if ( mpAnchorFrame )
 688     {
 689         // --> #i26945# - use new method <GetAnchorFrameContainingAnchPos()>
 690         pRetPageFrame = GetAnchorFrameContainingAnchPos()->FindPageFrame();
 691     }
 692
 693     return pRetPageFrame;
 694 }
 695
 696 /** get frame, which contains the anchor character, if the object
 697     is anchored at-character or as-character.
 698
 699     #i26945#
 700
 701     @return SwTextFrame*
 702     text frame containing the anchor character. It's NULL, if the object
 703     isn't anchored at-character resp. as-character.
 704 */
 705 SwTextFrame* SwAnchoredObject::FindAnchorCharFrame()
 706 {
 707     SwTextFrame* pAnchorCharFrame( nullptr );
 708
 709     // --> #i44339# - check, if anchor frame exists.
 710     if ( mpAnchorFrame )
 711     {
 712         const SwFormatAnchor& rAnch = GetFrameFormat().GetAnchor();
 713         if ((rAnch.GetAnchorId() == RndStdIds::FLY_AT_CHAR) ||
 714             (rAnch.GetAnchorId() == RndStdIds::FLY_AS_CHAR))
 715         {
 716             SwTextFrame *const pFrame(static_cast<SwTextFrame*>(AnchorFrame()));
 717             TextFrameIndex const nOffset(pFrame->MapModelToViewPos(*rAnch.GetContentAnchor()));
 718             pAnchorCharFrame = &pFrame->GetFrameAtOfst(nOffset);
 719         }
 720         else if (SwFlyFrame* pFlyFrame = DynCastFlyFrame())
 721         {
 722             // See if this fly is split. If so, then the anchor is also split. All anchors are
 723             // empty, except the last follow.
 724             if (pFlyFrame->IsFlySplitAllowed())
 725             {
 726                 auto pFlyAtContentFrame = static_cast<SwFlyAtContentFrame*>(pFlyFrame);
 727                 SwFlyAtContentFrame* pFly = pFlyAtContentFrame;
 728                 SwTextFrame* pAnchor = static_cast<SwTextFrame*>(AnchorFrame());
 729                 // If we have to jump back N frames to find the master fly, then we have to step N
 730                 // frames from the master anchor to reach the correct follow anchor.
 731                 while (pFly->GetPrecede())
 732                 {
 733                     pFly = pFly->GetPrecede();
 734                     if (!pAnchor)
 735                     {
 736                         SAL_WARN("sw.layout", "SwAnchoredObject::FindAnchorCharFrame: fly chain "
 737                                               "length is longer then anchor chain length");
 738                         break;
 739                     }
 740                     pAnchor = pAnchor->GetFollow();
 741                 }
 742                 if (pAnchor)
 743                 {
 744                     pAnchorCharFrame = pAnchor;
 745                 }
 746             }
 747         }
 748     }
 749
 750     return pAnchorCharFrame;
 751 }
 752
 753 /** method to determine, if a format on the anchored object is possible
 754
 755     #i28701#
 756     A format is possible, if anchored object is in an invisible layer.
 757     Note: method is virtual to refine the conditions for the sub-classes.
 758 */
 759 bool SwAnchoredObject::IsFormatPossible() const
 760 {
 761     return GetFrameFormat().GetDoc()->getIDocumentDrawModelAccess().IsVisibleLayerId( GetDrawObj()->GetLayer() );
 762 }
 763
 764 bool SwAnchoredObject::IsDraggingOffPageAllowed(const SwFrameFormat* pFrameFormat)
 765 {
 766     OSL_ASSERT(pFrameFormat);
 767     const bool bDisablePositioning = pFrameFormat->getIDocumentSettingAccess().get(DocumentSettingId::DISABLE_OFF_PAGE_POSITIONING);
 768     const bool bIsWrapThrough = pFrameFormat->GetSurround().GetSurround() == text::WrapTextMode::WrapTextMode_THROUGH;
 769
 770     return bDisablePositioning && bIsWrapThrough;
 771 }
 772
 773 // --> #i3317#
 774 void SwAnchoredObject::SetTmpConsiderWrapInfluence( const bool _bTmpConsiderWrapInfluence )
 775 {
 776     mbTmpConsiderWrapInfluence = _bTmpConsiderWrapInfluence;
 777     // --> #i35911#
 778     if ( mbTmpConsiderWrapInfluence )
 779     {
 780         SwLayouter::InsertObjForTmpConsiderWrapInfluence( *(GetFrameFormat().GetDoc()),
 781                                                           *this );
 782     }
 783 }
 784
 785 void SwAnchoredObject::ClearTmpConsiderWrapInfluence()
 786 {
 787     mbTmpConsiderWrapInfluence = false;
 788     mbClearedEnvironment = false;
 789     SetClearedEnvironment( false );
 790     SwLayouter::RemoveObjForTmpConsiderWrapInfluence( *(GetFrameFormat().GetDoc()),
 791                                                       *this );
 792 }
 793 void SwAnchoredObject::SetTmpConsiderWrapInfluenceOfOtherObjs()
 794 {
 795     const SwSortedObjs* pObjs = GetAnchorFrame()->GetDrawObjs();
 796     if ( pObjs->size() > 1 )
 797     {
 798         for (SwAnchoredObject* pAnchoredObj : *pObjs)
 799         {
 800             if ( pAnchoredObj != this )
 801             {
 802                 pAnchoredObj->SetTmpConsiderWrapInfluence( true/*bTmpConsiderWrapInfluence*/ );
 803             }
 804         }
 805     }
 806 }
 807
 808 /** method to determine, if the anchored object is overlapping with a
 809     previous column
 810
 811     #i3317#
 812     overlapping with a previous column means, that the object overlaps
 813     with a column, which is a previous one of the column its anchor
 814     frame is in.
 815     Only applied for at-paragraph and at-character anchored objects.
 816 */
 817 bool SwAnchoredObject::OverlapsPrevColumn() const
 818 {
 819     bool bOverlapsPrevColumn( false );
 820
 821     if ( mpAnchorFrame && mpAnchorFrame->IsTextFrame() )
 822     {
 823         const SwFrame* pColFrame = mpAnchorFrame->FindColFrame();
 824         if ( pColFrame && pColFrame->GetPrev() )
 825         {
 826             const SwFrame* pTmpColFrame = pColFrame->GetPrev();
 827             SwRect aChkRect;
 828             while ( pTmpColFrame )
 829             {
 830                 aChkRect.Union( pTmpColFrame->getFrameArea() );
 831                 pTmpColFrame = pTmpColFrame->GetPrev();
 832             }
 833             bOverlapsPrevColumn = GetObjRect().Overlaps( aChkRect );
 834         }
 835     }
 836
 837     return bOverlapsPrevColumn;
 838 }
 839
 840 /** method to determine position of anchored object relative to
 841     anchor frame
 842
 843     #i30669#
 844     Usage: Needed layout information for WW8 export
 845 */
 846 Point SwAnchoredObject::GetRelPosToAnchorFrame() const
 847 {
 848     Point aRelPos;
 849
 850     assert(GetAnchorFrame());
 851     aRelPos = GetObjRect().Pos();
 852     aRelPos -= GetAnchorFrame()->getFrameArea().Pos();
 853
 854     return aRelPos;
 855 }
 856
 857 /** method to determine position of anchored object relative to
 858     page frame
 859
 860     #i30669#
 861     Usage: Needed layout information for WW8 export
 862     #i33818# - add parameters <_bFollowTextFlow> and
 863     <_obRelToTableCell>
 864     If <_bFollowTextFlow> is set and object is anchored inside table,
 865     the position relative to the table cell is determined. Output
 866     parameter <_obRelToTableCell> reflects this situation
 867 */
 868 Point SwAnchoredObject::GetRelPosToPageFrame( const bool _bFollowTextFlow,
 869                                             bool& _obRelToTableCell ) const
 870 {
 871     Point aRelPos;
 872     _obRelToTableCell = false;
 873
 874     assert(GetAnchorFrame());
 875     assert(GetAnchorFrame()->FindPageFrame());
 876
 877     aRelPos = GetObjRect().Pos();
 878     // --> #i33818# - search for cell frame, if object has to
 879     // follow the text flow.
 880     const SwFrame* pFrame( nullptr );
 881     if ( _bFollowTextFlow && !GetAnchorFrame()->IsPageFrame() )
 882     {
 883         pFrame = GetAnchorFrame()->GetUpper();
 884         while ( !pFrame->IsCellFrame() && !pFrame->IsPageFrame() )
 885         {
 886             pFrame = pFrame->GetUpper();
 887         }
 888     }
 889     else
 890     {
 891         pFrame = GetAnchorFrame()->FindPageFrame();
 892     }
 893     if ( pFrame->IsCellFrame() )
 894     {
 895         aRelPos -= pFrame->getFrameArea().Pos() + pFrame->getFramePrintArea().Pos();
 896         _obRelToTableCell = true;
 897     }
 898     else
 899     {
 900         aRelPos -= pFrame->getFrameArea().Pos();
 901     }
 902
 903     return aRelPos;
 904 }
 905
 906 /** method to determine position of anchored object relative to
 907     anchor character
 908
 909     #i30669#
 910     Usage: Needed layout information for WW8 export
 911 */
 912 Point SwAnchoredObject::GetRelPosToChar() const
 913 {
 914     Point aRelPos = GetObjRect().Pos();
 915     aRelPos -= GetLastCharRect().Pos();
 916
 917     return aRelPos;
 918 }
 919
 920 /** method to determine position of anchored object relative to
 921     top of line
 922
 923     #i30669#
 924     Usage: Needed layout information for WW8 export
 925 */
 926 Point SwAnchoredObject::GetRelPosToLine() const
 927 {
 928     Point aRelPos = GetObjRect().Pos();
 929     aRelPos.AdjustY( -(GetLastTopOfLine()) );
 930
 931     return aRelPos;
 932 }
 933
 934 const SwFlyFrame* SwAnchoredObject::DynCastFlyFrame() const
 935 {
 936     return nullptr;
 937 }
 938
 939 SwFlyFrame* SwAnchoredObject::DynCastFlyFrame()
 940 {
 941     return nullptr;
 942 }
 943
 944 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */