anchoredobject.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#include <txtfrm.hxx>
#include <frmatr.hxx>
#include <fmtornt.hxx>
#include <doc.hxx>
#include <IDocumentSettingAccess.hxx>
#include <IDocumentDrawModelAccess.hxx>
#include <fmtsrnd.hxx>
#include <dcontact.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/lrspitem.hxx>
#include <sortedobjs.hxx>
#include <pagefrm.hxx>
#include <layouter.hxx>

using namespace ::com::sun::star;

// --> #i28701# -
// implementation of helper class <SwObjPositioningInProgress>

SwObjPositioningInProgress::SwObjPositioningInProgress( SdrObject& _rSdrObj ) :
    mpAnchoredObj( nullptr ),
    // --> #i52904#
    mbOldObjPositioningInProgress( false )
{
    mpAnchoredObj = ::GetUserCall( &_rSdrObj )->GetAnchoredObj( &_rSdrObj );
    // --> #i52904#
    mbOldObjPositioningInProgress = mpAnchoredObj->IsPositioningInProgress();
    mpAnchoredObj->SetPositioningInProgress( true );
}
SwObjPositioningInProgress::SwObjPositioningInProgress( SwAnchoredObject& _rAnchoredObj ) :
    mpAnchoredObj( &_rAnchoredObj ),
    // --> #i52904#
    mbOldObjPositioningInProgress( false )
{
    // --> #i52904#
    mbOldObjPositioningInProgress = mpAnchoredObj->IsPositioningInProgress();
    mpAnchoredObj->SetPositioningInProgress( true );
}

SwObjPositioningInProgress::~SwObjPositioningInProgress()
{
    if ( mpAnchoredObj )
    {
        // --> #i52904#
        mpAnchoredObj->SetPositioningInProgress( mbOldObjPositioningInProgress );
    }
}


SwAnchoredObject::SwAnchoredObject() :
    mpDrawObj( nullptr ),
    mpAnchorFrame( nullptr ),
    // --> #i28701#
    mpPageFrame( nullptr ),
    maRelPos(),
    maLastCharRect(),
    mnLastTopOfLine( 0 ),
    mpVertPosOrientFrame( nullptr ),
    // --> #i28701#
    mbPositioningInProgress( false ),
    mbConsiderForTextWrap( false ),
    mbPositionLocked( false ),
    // --> #i40147#
    mbKeepPositionLockedForSection( false ),
    mbRestartLayoutProcess( false ),
    // --> #i35911#
    mbClearedEnvironment( false ),
    // --> #i3317#
    mbTmpConsiderWrapInfluence( false ),
    // --> #i68520#
    maObjRectWithSpaces(),
    mbObjRectWithSpacesValid( false ),
    maLastObjRect()
{
}

void SwAnchoredObject::ClearVertPosOrientFrame()
{
    if (mpVertPosOrientFrame)
    {
        const_cast<SwLayoutFrame*>(mpVertPosOrientFrame)->ClearVertPosOrientFrameFor(this);
        mpVertPosOrientFrame = nullptr;
    }
}

SwAnchoredObject::~SwAnchoredObject()
{
    ClearVertPosOrientFrame();
}

void SwAnchoredObject::SetDrawObj( SdrObject& _rDrawObj )
{
    mpDrawObj = &_rDrawObj;
}


void SwAnchoredObject::ChgAnchorFrame( SwFrame* _pNewAnchorFrame )
{
    mpAnchorFrame = _pNewAnchorFrame;

    if ( mpAnchorFrame )
    {
        ObjectAttachedToAnchorFrame();
    }
}

SwFrame* SwAnchoredObject::GetAnchorFrameContainingAnchPos()
{
    SwFrame* pAnchorFrameContainingAnchPos = FindAnchorCharFrame();
    if ( !pAnchorFrameContainingAnchPos )
    {
        pAnchorFrameContainingAnchPos = AnchorFrame();
    }

    return pAnchorFrameContainingAnchPos;
}


void SwAnchoredObject::SetPageFrame( SwPageFrame* _pNewPageFrame )
{
    if ( mpPageFrame == _pNewPageFrame )
        return;

    // clear member, which denotes the layout frame at which the vertical
    // position is oriented at, if it doesn't fit to the new page frame.
    if ( GetVertPosOrientFrame() &&
         ( !_pNewPageFrame ||
           _pNewPageFrame != GetVertPosOrientFrame()->FindPageFrame() ) )
    {
        ClearVertPosOrientFrame();
    }

    // assign new page frame
    mpPageFrame = _pNewPageFrame;
}


SwTwips SwAnchoredObject::GetRelCharX( const SwFrame* pFrame ) const
{
    return maLastCharRect.Left() - pFrame->getFrameArea().Left();
}

SwTwips SwAnchoredObject::GetRelCharY( const SwFrame* pFrame ) const
{
    return maLastCharRect.Bottom() - pFrame->getFrameArea().Top();
}

void SwAnchoredObject::AddLastCharY( tools::Long nDiff )
{
    maLastCharRect.Pos().AdjustY(nDiff );
}

void SwAnchoredObject::ResetLastCharRectHeight()
{
    maLastCharRect.Height( 0 );
}

void SwAnchoredObject::SetVertPosOrientFrame( const SwLayoutFrame& _rVertPosOrientFrame )
{
    ClearVertPosOrientFrame();

    mpVertPosOrientFrame = &_rVertPosOrientFrame;
    const_cast<SwLayoutFrame*>(mpVertPosOrientFrame)->SetVertPosOrientFrameFor(this);

    // #i28701# - take over functionality of deleted method
    // <SwFlyAtContentFrame::AssertPage()>: assure for at-paragraph and at-character
    // an anchored object, that it is registered at the correct page frame
    RegisterAtCorrectPage();
}


// #i28701# - follow-up of #i22341#
void SwAnchoredObject::AddLastTopOfLineY( SwTwips _nDiff )
{
    mnLastTopOfLine += _nDiff;
}

void SwAnchoredObject::CheckCharRectAndTopOfLine(
                                        const bool _bCheckForParaPorInf )
{
    if ( !(GetAnchorFrame() &&
         GetAnchorFrame()->IsTextFrame()) )
        return;

    const SwFormatAnchor& rAnch = GetFrameFormat().GetAnchor();
    if ( !((rAnch.GetAnchorId() == RndStdIds::FLY_AT_CHAR) &&
         rAnch.GetContentAnchor()) )
        return;

    // --> if requested, assure that anchor frame,
    // which contains the anchor character, has a paragraph portion information.
    // The paragraph portion information is needed to determine the
    // anchor character rectangle respectively the top of the line.
    // Thus, a format of this frame is avoided to determine the
    // paragraph portion information.
    // --> #i26945# - use new method <FindAnchorCharFrame()>
    const SwTextFrame& aAnchorCharFrame = *(FindAnchorCharFrame());
    if ( !_bCheckForParaPorInf || aAnchorCharFrame.HasPara() )
    {
        CheckCharRect( rAnch, aAnchorCharFrame );
        CheckTopOfLine( rAnch, aAnchorCharFrame );
    }
}

void SwAnchoredObject::CheckCharRect( const SwFormatAnchor& _rAnch,
                                       const SwTextFrame& _rAnchorCharFrame )
{
    // determine rectangle of anchor character. If not exist, abort operation
    SwRect aCharRect;
    if ( !_rAnchorCharFrame.GetAutoPos( aCharRect, *_rAnch.GetContentAnchor() ) )
    {
        return;
    }
    // check, if anchor character rectangle has changed
    if ( aCharRect == maLastCharRect )
        return;

    // check positioning and alignment for invalidation of position
    {
        SwRectFnSet aRectFnSet(&_rAnchorCharFrame);
        // determine positioning and alignment
        SwFormatVertOrient aVert( GetFrameFormat().GetVertOrient() );
        SwFormatHoriOrient aHori( GetFrameFormat().GetHoriOrient() );
        // check for anchor character rectangle changes for certain
        // positionings and alignments
        // add condition to invalidate position,
        // if vertical aligned at frame/page area and vertical position
        // of anchor character has changed.
        const sal_Int16 eVertRelOrient = aVert.GetRelationOrient();
        if ( ( aHori.GetRelationOrient() == text::RelOrientation::CHAR &&
               aRectFnSet.GetLeft(aCharRect) != aRectFnSet.GetLeft(maLastCharRect) ) ||
             ( eVertRelOrient == text::RelOrientation::CHAR &&
               ( aRectFnSet.GetTop(aCharRect) != aRectFnSet.GetTop(maLastCharRect) ||
                 aRectFnSet.GetHeight(aCharRect) != aRectFnSet.GetHeight(maLastCharRect) ) ) ||
             ( ( ( eVertRelOrient == text::RelOrientation::FRAME ) ||
                 ( eVertRelOrient == text::RelOrientation::PRINT_AREA ) ||
                 ( eVertRelOrient == text::RelOrientation::PAGE_FRAME ) ||
                 ( eVertRelOrient == text::RelOrientation::PAGE_PRINT_AREA ) ) &&
               ( aRectFnSet.GetTop(aCharRect) != aRectFnSet.GetTop(maLastCharRect) ) ) )
        {
            // #i26945#, #i35911# - unlock position of
            // anchored object, if it isn't registered at the page,
            // where its anchor character frame is on.
            if ( GetPageFrame() != _rAnchorCharFrame.FindPageFrame() )
            {
                UnlockPosition();
            }
            InvalidateObjPos();
        }
    }
    // keep new anchor character rectangle
    maLastCharRect = aCharRect;
}

void SwAnchoredObject::CheckTopOfLine( const SwFormatAnchor& _rAnch,
                                        const SwTextFrame& _rAnchorCharFrame )
{
    SwTwips nTopOfLine = 0;
    if ( !_rAnchorCharFrame.GetTopOfLine( nTopOfLine, *_rAnch.GetContentAnchor() ) )
        return;

    if ( nTopOfLine == mnLastTopOfLine )
        return;

    // check alignment for invalidation of position
    if ( GetFrameFormat().GetVertOrient().GetRelationOrient() == text::RelOrientation::TEXT_LINE )
    {
        // #i26945#, #i35911# - unlock position of
        // anchored object, if it isn't registered at the page,
        // where its anchor character frame is on.
        if ( GetPageFrame() != _rAnchorCharFrame.FindPageFrame() )
        {
            UnlockPosition();
        }
        InvalidateObjPos();
    }
    // keep new top of line value
    mnLastTopOfLine = nTopOfLine;
}

void SwAnchoredObject::ClearCharRectAndTopOfLine()
{
    maLastCharRect.Clear();
    mnLastTopOfLine = 0;
}

void SwAnchoredObject::SetCurrRelPos( Point _aRelPos )
{
    maRelPos = _aRelPos;
}

void SwAnchoredObject::ObjectAttachedToAnchorFrame()
{
    // default behaviour:
    // update layout direction, the anchored object is assigned to
    UpdateLayoutDir();
}

void SwAnchoredObject::UpdateLayoutDir()
{
    SwFrameFormat::tLayoutDir nLayoutDir = SwFrameFormat::HORI_L2R;
    const SwFrame* pAnchorFrame = GetAnchorFrame();
    if ( pAnchorFrame )
    {
        const bool bVert = pAnchorFrame->IsVertical();
        const bool bR2L = pAnchorFrame->IsRightToLeft();
        if ( bVert )
        {
            nLayoutDir = SwFrameFormat::VERT_R2L;
        }
        else if ( bR2L )
        {
            nLayoutDir = SwFrameFormat::HORI_R2L;
        }
    }
    GetFrameFormat().SetLayoutDir( nLayoutDir );
}

void SwAnchoredObject::InvalidateObjPosForConsiderWrapInfluence()
{
    if ( ConsiderObjWrapInfluenceOnObjPos() )
    {
        // indicate that object has not to be considered for text wrap
        SetConsiderForTextWrap( false );
        // unlock position
        UnlockPosition();
        // invalidate position
        InvalidateObjPos();
        // invalidate 'background'
        NotifyBackground( GetPageFrame(), GetObjRectWithSpaces(), PrepareHint::FlyFrameLeave );
    }
}

bool SwAnchoredObject::ConsiderObjWrapInfluenceOnObjPos() const
{
    bool bRet( false );

    const SwFrameFormat& rObjFormat = GetFrameFormat();

    // --> #i3317# - add condition <IsTmpConsiderWrapInfluence()>
    // --> #i55204#
    // - correction: wrapping style influence has been considered, if condition
    //   <IsTmpConsiderWrapInfluence()> is hold, regardless of its anchor type
    //   or its wrapping style.
    if ( IsTmpConsiderWrapInfluence() )
    {
        bRet = true;
    }
    else if ( rObjFormat.getIDocumentSettingAccess().get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) )
    {
        const SwFormatAnchor& rAnchor = rObjFormat.GetAnchor();
        if ( ((rAnchor.GetAnchorId() == RndStdIds::FLY_AT_CHAR) ||
              (rAnchor.GetAnchorId() == RndStdIds::FLY_AT_PARA)) &&
             rObjFormat.GetSurround().GetSurround() != css::text::WrapTextMode_THROUGH )
        {
            // --> #i34520# - text also wraps around anchored
            // objects in the layer Hell - see the text formatting.
            // Thus, it hasn't to be checked here.
            bRet = true;
        }
    }

    return bRet;
}

bool SwAnchoredObject::ConsiderObjWrapInfluenceOfOtherObjs() const
{
    bool bRet( false );

    const SwSortedObjs* pObjs = GetAnchorFrame()->GetDrawObjs();
    if ( pObjs->size() > 1 )
    {
        for (SwAnchoredObject* pAnchoredObj : *pObjs)
        {
            if ( pAnchoredObj != this &&
                 pAnchoredObj->ConsiderObjWrapInfluenceOnObjPos() )
            {
                bRet = true;
                break;
            }
        }
    }

    return bRet;
}

bool SwAnchoredObject::ConsiderForTextWrap() const
{
    if ( ConsiderObjWrapInfluenceOnObjPos() )
        return mbConsiderForTextWrap;
    else
        return true;
}

void SwAnchoredObject::SetConsiderForTextWrap( const bool _bConsiderForTextWrap )
{
    mbConsiderForTextWrap = _bConsiderForTextWrap;
}

bool SwAnchoredObject::PositionLocked() const
{
    if ( ConsiderObjWrapInfluenceOnObjPos() )
        return mbPositionLocked;
    else
        return false;
}

bool SwAnchoredObject::RestartLayoutProcess() const
{
    if ( ConsiderObjWrapInfluenceOnObjPos() )
        return mbRestartLayoutProcess;
    else
        return false;
}

void SwAnchoredObject::SetRestartLayoutProcess( const bool _bRestartLayoutProcess )
{
    mbRestartLayoutProcess = _bRestartLayoutProcess;
}

// --> #i35911#
bool SwAnchoredObject::ClearedEnvironment() const
{
    if ( ConsiderObjWrapInfluenceOnObjPos() )
        return mbClearedEnvironment;
    else
        return false;
}
void SwAnchoredObject::SetClearedEnvironment( const bool _bClearedEnvironment )
{
    mbClearedEnvironment = _bClearedEnvironment;
}

bool SwAnchoredObject::HasClearedEnvironment() const
{
    bool bHasClearedEnvironment( false );

    // --> #i43913# - layout frame, vertical position is orient at, has to be set.
    OSL_ENSURE( GetVertPosOrientFrame(),
            "<SwAnchoredObject::HasClearedEnvironment()> - layout frame missing, at which the vertical position is oriented at." );
    if ( GetVertPosOrientFrame() &&
         GetAnchorFrame()->IsTextFrame() &&
         !static_cast<const SwTextFrame*>(GetAnchorFrame())->IsFollow() &&
         static_cast<const SwTextFrame*>(GetAnchorFrame())->FindPageFrame()->GetPhyPageNum() >=
                GetPageFrame()->GetPhyPageNum() )
    {
        const SwFrame* pTmpFrame = GetVertPosOrientFrame()->Lower();
        while ( pTmpFrame && pTmpFrame->IsLayoutFrame() && !pTmpFrame->IsTabFrame() )
        {
            pTmpFrame = static_cast<const SwLayoutFrame*>(pTmpFrame)->Lower();
        }
        if ( !pTmpFrame )
        {
            bHasClearedEnvironment = true;
        }
        else if ( pTmpFrame->IsTextFrame() && !pTmpFrame->GetNext() )
        {
            const SwTextFrame* pTmpTextFrame = static_cast<const SwTextFrame*>(pTmpFrame);
            if ( pTmpTextFrame->IsUndersized() ||
                 ( pTmpTextFrame->GetFollow() &&
                   pTmpTextFrame->GetFollow()->GetOffset() == TextFrameIndex(0)))
            {
                bHasClearedEnvironment = true;
            }
        }
    }

    return bHasClearedEnvironment;
}

const SwRect& SwAnchoredObject::GetObjRectWithSpaces() const
{
    if ( mbObjRectWithSpacesValid &&
         maLastObjRect != GetObjRect() )
    {
        OSL_FAIL( "<SwAnchoredObject::GetObjRectWithSpaces> - cache for object rectangle inclusive spaces marked as valid, but it couldn't be. Missing invalidation of cache." );
        InvalidateObjRectWithSpaces();
    }
    if ( !mbObjRectWithSpacesValid )
    {
        maObjRectWithSpaces = GetObjBoundRect();
        const SwFrameFormat& rFormat = GetFrameFormat();
        const SvxULSpaceItem& rUL = rFormat.GetULSpace();
        const SvxLRSpaceItem& rLR = rFormat.GetLRSpace();
        {
            maObjRectWithSpaces.Top ( std::max( maObjRectWithSpaces.Top() - tools::Long(rUL.GetUpper()), 0L ));
            maObjRectWithSpaces.Left( std::max( maObjRectWithSpaces.Left()- rLR.GetLeft(),  0L ));
            maObjRectWithSpaces.AddHeight(rUL.GetLower() );
            maObjRectWithSpaces.AddWidth(rLR.GetRight() );
        }

        mbObjRectWithSpacesValid = true;
        maLastObjRect = GetObjRect();
    }

    return maObjRectWithSpaces;
}

// --> #i68520#
void SwAnchoredObject::SetObjTop( const SwTwips _nTop)
{
    const bool bTopChanged( SetObjTop_( _nTop ) );
    if ( bTopChanged )
    {
        mbObjRectWithSpacesValid = false;
    }
}

void SwAnchoredObject::SetObjLeft( const SwTwips _nLeft)
{
    const bool bLeftChanged( SetObjLeft_( _nLeft ) );
    if ( bLeftChanged )
    {
        mbObjRectWithSpacesValid = false;
    }
}

void SwAnchoredObject::UpdateObjInSortedList()
{
    if ( !GetAnchorFrame() )
        return;

    if ( GetFrameFormat().getIDocumentSettingAccess().get(DocumentSettingId::CONSIDER_WRAP_ON_OBJECT_POSITION) )
    {
        // invalidate position of all anchored objects at anchor frame
        if ( GetAnchorFrame()->GetDrawObjs() )
        {
            const SwSortedObjs* pObjs = GetAnchorFrame()->GetDrawObjs();
            // determine start index
            for (auto it = pObjs->begin(); it != pObjs->end(); ++it)
            {
                SwAnchoredObject* pAnchoredObj = *it;
                if ( pAnchoredObj->ConsiderObjWrapInfluenceOnObjPos() )
                    pAnchoredObj->InvalidateObjPosForConsiderWrapInfluence();
                else
                    pAnchoredObj->InvalidateObjPos();
            }
        }
        // invalidate all following anchored objects on the page frame
        if ( GetPageFrame() && GetPageFrame()->GetSortedObjs() )
        {
            const SwSortedObjs* pObjs = GetPageFrame()->GetSortedObjs();
            // determine start index
            for ( size_t i = pObjs->ListPosOf( *this ) + 1; i < pObjs->size(); ++i )
            {
                SwAnchoredObject* pAnchoredObj = (*pObjs)[i];
                if ( pAnchoredObj->ConsiderObjWrapInfluenceOnObjPos() )
                    pAnchoredObj->InvalidateObjPosForConsiderWrapInfluence();
                else
                    pAnchoredObj->InvalidateObjPos();
            }
        }
    }
    // update its position in the sorted object list of its anchor frame
    AnchorFrame()->GetDrawObjs()->Update( *this );
    // update its position in the sorted object list of its page frame
    // note: as-character anchored object aren't registered at a page frame
    if ( GetFrameFormat().GetAnchor().GetAnchorId() != RndStdIds::FLY_AS_CHAR )
    {
        GetPageFrame()->GetSortedObjs()->Update( *this );
    }
}

bool SwAnchoredObject::InvalidationOfPosAllowed() const
{
    // --> Check, if page frame layout is in progress,
    // isn't needed, because of anchored object, whose are moved forward.
    return !PositionLocked();
}

SwPageFrame* SwAnchoredObject::FindPageFrameOfAnchor()
{
    SwPageFrame* pRetPageFrame = nullptr;

    // --> #i44339# - check, if anchor frame exists.
    if ( mpAnchorFrame )
    {
        // --> #i26945# - use new method <GetAnchorFrameContainingAnchPos()>
        pRetPageFrame = GetAnchorFrameContainingAnchPos()->FindPageFrame();
    }

    return pRetPageFrame;
}

SwTextFrame* SwAnchoredObject::FindAnchorCharFrame()
{
    SwTextFrame* pAnchorCharFrame( nullptr );

    // --> #i44339# - check, if anchor frame exists.
    if ( mpAnchorFrame )
    {
        const SwFormatAnchor& rAnch = GetFrameFormat().GetAnchor();
        if ((rAnch.GetAnchorId() == RndStdIds::FLY_AT_CHAR) ||
            (rAnch.GetAnchorId() == RndStdIds::FLY_AS_CHAR))
        {
            SwTextFrame *const pFrame(static_cast<SwTextFrame*>(AnchorFrame()));
            TextFrameIndex const nOffset(pFrame->MapModelToViewPos(*rAnch.GetContentAnchor()));
            pAnchorCharFrame = &pFrame->GetFrameAtOfst(nOffset);
        }
    }

    return pAnchorCharFrame;
}

bool SwAnchoredObject::IsFormatPossible() const
{
    return GetFrameFormat().GetDoc()->getIDocumentDrawModelAccess().IsVisibleLayerId( GetDrawObj()->GetLayer() );
}

bool SwAnchoredObject::IsDraggingOffPageAllowed(const SwFrameFormat* pFrameFormat)
{
    OSL_ASSERT(pFrameFormat);
    const bool bDisablePositioning = pFrameFormat->getIDocumentSettingAccess().get(DocumentSettingId::DISABLE_OFF_PAGE_POSITIONING);
    const bool bIsWrapThrough = pFrameFormat->GetSurround().GetSurround() == text::WrapTextMode::WrapTextMode_THROUGH;

    return bDisablePositioning && bIsWrapThrough;
}

// --> #i3317#
void SwAnchoredObject::SetTmpConsiderWrapInfluence( const bool _bTmpConsiderWrapInfluence )
{
    mbTmpConsiderWrapInfluence = _bTmpConsiderWrapInfluence;
    // --> #i35911#
    if ( mbTmpConsiderWrapInfluence )
    {
        SwLayouter::InsertObjForTmpConsiderWrapInfluence( *(GetFrameFormat().GetDoc()),
                                                          *this );
    }
}

void SwAnchoredObject::ClearTmpConsiderWrapInfluence()
{
    mbTmpConsiderWrapInfluence = false;
    mbClearedEnvironment = false;
    SetClearedEnvironment( false );
    SwLayouter::RemoveObjForTmpConsiderWrapInfluence( *(GetFrameFormat().GetDoc()),
                                                      *this );
}
void SwAnchoredObject::SetTmpConsiderWrapInfluenceOfOtherObjs()
{
    const SwSortedObjs* pObjs = GetAnchorFrame()->GetDrawObjs();
    if ( pObjs->size() > 1 )
    {
        for (SwAnchoredObject* pAnchoredObj : *pObjs)
        {
            if ( pAnchoredObj != this )
            {
                pAnchoredObj->SetTmpConsiderWrapInfluence( true/*bTmpConsiderWrapInfluence*/ );
            }
        }
    }
}

bool SwAnchoredObject::OverlapsPrevColumn() const
{
    bool bOverlapsPrevColumn( false );

    if ( mpAnchorFrame && mpAnchorFrame->IsTextFrame() )
    {
        const SwFrame* pColFrame = mpAnchorFrame->FindColFrame();
        if ( pColFrame && pColFrame->GetPrev() )
        {
            const SwFrame* pTmpColFrame = pColFrame->GetPrev();
            SwRect aChkRect;
            while ( pTmpColFrame )
            {
                aChkRect.Union( pTmpColFrame->getFrameArea() );
                pTmpColFrame = pTmpColFrame->GetPrev();
            }
            bOverlapsPrevColumn = GetObjRect().IsOver( aChkRect );
        }
    }

    return bOverlapsPrevColumn;
}

Point SwAnchoredObject::GetRelPosToAnchorFrame() const
{
    Point aRelPos;

    assert(GetAnchorFrame());
    aRelPos = GetObjRect().Pos();
    aRelPos -= GetAnchorFrame()->getFrameArea().Pos();

    return aRelPos;
}

Point SwAnchoredObject::GetRelPosToPageFrame( const bool _bFollowTextFlow,
                                            bool& _obRelToTableCell ) const
{
    Point aRelPos;
    _obRelToTableCell = false;

    assert(GetAnchorFrame());
    assert(GetAnchorFrame()->FindPageFrame());

    aRelPos = GetObjRect().Pos();
    // --> #i33818# - search for cell frame, if object has to
    // follow the text flow.
    const SwFrame* pFrame( nullptr );
    if ( _bFollowTextFlow && !GetAnchorFrame()->IsPageFrame() )
    {
        pFrame = GetAnchorFrame()->GetUpper();
        while ( !pFrame->IsCellFrame() && !pFrame->IsPageFrame() )
        {
            pFrame = pFrame->GetUpper();
        }
    }
    else
    {
        pFrame = GetAnchorFrame()->FindPageFrame();
    }
    if ( pFrame->IsCellFrame() )
    {
        aRelPos -= pFrame->getFrameArea().Pos() + pFrame->getFramePrintArea().Pos();
        _obRelToTableCell = true;
    }
    else
    {
        aRelPos -= pFrame->getFrameArea().Pos();
    }

    return aRelPos;
}

Point SwAnchoredObject::GetRelPosToChar() const
{
    Point aRelPos = GetObjRect().Pos();
    aRelPos -= GetLastCharRect().Pos();

    return aRelPos;
}

Point SwAnchoredObject::GetRelPosToLine() const
{
    Point aRelPos = GetObjRect().Pos();
    aRelPos.AdjustY( -(GetLastTopOfLine()) );

    return aRelPos;
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */