anchoredobject.hxx

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 .
 */
#ifndef INCLUDED_SW_INC_ANCHOREDOBJECT_HXX
#define INCLUDED_SW_INC_ANCHOREDOBJECT_HXX
 
#include "swtypes.hxx"
#include "swrect.hxx"
#include <svx/svdobj.hxx>
#include <libxml/xmlwriter.h>
 
struct SwPosition;
class SwFrame;
class SwLayoutFrame;
class SwTextFrame;
class SwFlyFrame;
class SwPageFrame;
 
class SwFrameFormat;
class SwFormatAnchor;
enum class RndStdIds;
 
class SW_DLLPUBLIC SwAnchoredObject
{
    private:
        // drawing object representing the anchored object in the drawing layer
        rtl::Reference<SdrObject> mpDrawObj;
        SwFrame* mpAnchorFrame;
        // #i28701 - page frame the object is registered at
        // note: no page frame for as-character anchored objects
        SwPageFrame* mpPageFrame;
        // current relative position (relative to anchor position of anchor frame)
        Point maRelPos;
 
        // for to-character anchored objects:
        // Last known anchor character rectangle.
        // Used to decide, if invalidation has to been performed, if anchor position
        // has changed, and used to position object.
        SwRect maLastCharRect;
 
        // for to-character anchored objects:
        // Last known top of line, in which the anchor character is in.
        // Used to decide, if invalidation has to been performed, if anchor position
        // has changed, and used to position object.
        SwTwips mnLastTopOfLine;
 
        // for to-paragraph and to-character anchored objects:
        // Layout frame vertical position is orient at - typically it's the upper
        // of the anchor frame, but it could also by the upper of a follow or
        // a following layout frame in the text flow.
        const SwLayoutFrame* mpVertPosOrientFrame;
 
        // i#i28701 boolean, indicating that the object
        // positioning algorithm is in progress.
        bool mbPositioningInProgress;
 
        // Booleans needed for the layout process.
        // Values only of relevance for to-paragraph and to-character anchored
        // floating screen object, for whose the 'straight-forward positioning
        // process are applied
        // Otherwise value of <mbConsiderForTextWrap> is treated as <true>,
        // value of <mbPositionLocked> is treated as <false> and
        // value of <mbRestartLayoutProcess> is treated as <false>.
        // i#35911 - add boolean <mbClearEnvironment>
        // Indicates that due to its position and wrapping style its layout
        // environment is cleared - all content is moved forward.
        // Treated as <false>, if not the 'straight-forward positioning process"
        // is applied.
        bool mbConsiderForTextWrap;
        bool mbPositionLocked;
        // boolean needed to keep position of
        // anchored object locked due to special object positioning for sections.
        bool mbKeepPositionLockedForSection;
 
        bool mbRestartLayoutProcess;
        bool mbClearedEnvironment;
 
        // i#i3317 - boolean, indicating that temporarily
        // the wrapping style influence of the anchored object has to be
        // considered during its positioning.
        // This boolean is used, if compatibility option 'Consider wrapping style
        // influence on object positioning' is OFF and a positioning loop is
        // detected in method <SwFlyAtContentFrame::MakeAll()> or method
        // <SwAnchoredDrawObject::MakeObjPosAnchoredAtPara()>.
        // The boolean is reset to <false>, when the layout process for a
        // page frame starts.
        bool mbTmpConsiderWrapInfluence;
 
        mutable SwRect maObjRectWithSpaces;
        mutable bool mbObjRectWithSpacesValid;
        mutable SwRect maLastObjRect;
 
        friend class SwObjPositioningInProgress;
        void SetPositioningInProgress( const bool _bPosInProgress )
        {
            mbPositioningInProgress = _bPosInProgress;
        }
 
        void CheckCharRect( const SwFormatAnchor& _rAnch,
                             const SwTextFrame& _rAnchorCharFrame );
 
        void CheckTopOfLine( const SwFormatAnchor& _rAnch,
                              const SwTextFrame& _rAnchorCharFrame );
 
        // method <sw_HideObj(..)> sets needed data structure values for the
        // object positioning
        friend bool sw_HideObj( const SwTextFrame& _rFrame,
                                 const RndStdIds _eAnchorType,
                                 SwPosition const& rAnchorPos,
                                 SwAnchoredObject* _pAnchoredObj );
    protected:
        SwAnchoredObject();
 
        void SetVertPosOrientFrame( const SwLayoutFrame& _rVertPosOrientFrame );
 
        virtual void RegisterAtCorrectPage() = 0;
 
        virtual void ObjectAttachedToAnchorFrame();
 
        bool ConsiderObjWrapInfluenceOfOtherObjs() const;
 
        void SetTmpConsiderWrapInfluenceOfOtherObjs();
 
        virtual bool SetObjTop_( const SwTwips _nTop) = 0;
        virtual bool SetObjLeft_( const SwTwips _nLeft) = 0;
 
        virtual SwRect GetObjBoundRect() const = 0;
    public:
 
        virtual ~SwAnchoredObject();
 
        // accessors to member <mpDrawObj>
        void SetDrawObj( SdrObject& _rDrawObj );
        const SdrObject* GetDrawObj() const { return mpDrawObj.get(); }
        SdrObject* DrawObj() { return mpDrawObj.get(); }
        void ClearDrawObj() { mpDrawObj.clear(); }
 
        // accessors to member <mpAnchorFrame>
        const SwFrame* GetAnchorFrame() const { return mpAnchorFrame; }
        SwFrame* AnchorFrame() { return mpAnchorFrame; }
        void ChgAnchorFrame( SwFrame* _pNewAnchorFrame );
        SwFrame* GetAnchorFrameContainingAnchPos();
 
        SwPageFrame* GetPageFrame() { return mpPageFrame; }
        const SwPageFrame* GetPageFrame() const { return mpPageFrame; }
        void SetPageFrame( SwPageFrame* _pNewPageFrame );
 
        SwPageFrame* FindPageFrameOfAnchor();
 
        SwTextFrame* FindAnchorCharFrame();
 
        // accessors to data of position calculation:
        // frame vertical position is orient at
        const SwLayoutFrame* GetVertPosOrientFrame() const
        {
            return mpVertPosOrientFrame;
        }
        // method to clear member <mpVertPosOrientFrame>
        void ClearVertPosOrientFrame();
 
        void CheckCharRectAndTopOfLine( const bool _bCheckForParaPorInf );
 
        // accessors to member <maLastCharRect>
        const SwRect& GetLastCharRect() const { return maLastCharRect;}
        SwTwips GetRelCharX( const SwFrame* pFrame ) const;
        SwTwips GetRelCharY( const SwFrame* pFrame ) const;
        void AddLastCharY( tools::Long nDiff );
        void ResetLastCharRectHeight();
 
        // accessor to member <nmLastTopOfLine>
        SwTwips GetLastTopOfLine() const { return mnLastTopOfLine;}
        void AddLastTopOfLineY( SwTwips _nDiff );
 
        void ClearCharRectAndTopOfLine();
 
        virtual void MakeObjPos() = 0;
 
        bool IsPositioningInProgress() const
        {
            return mbPositioningInProgress;
        }
 
        bool InvalidationOfPosAllowed() const;
 
        virtual void InvalidateObjPos() = 0;
 
        virtual void RegisterAtPage(SwPageFrame &) = 0;
 
        void InvalidateObjPosForConsiderWrapInfluence();
 
        virtual void NotifyBackground( SwPageFrame* _pPageFrame,
                                       const SwRect& _rRect,
                                       PrepareHint _eHint ) = 0;
 
        // accessors to the current relative position (relative to anchor
        // position of anchor frame)
        const Point& GetCurrRelPos() const { return maRelPos;}
        void SetCurrRelPos( Point _aRelPos );
 
        // accessors to the format
        virtual SwFrameFormat& GetFrameFormat() = 0;
        virtual const SwFrameFormat& GetFrameFormat() const = 0;
 
        // accessors to the object area and its position
        virtual SwRect GetObjRect() const = 0;
 
        void SetObjTop( const SwTwips _nTop);
        void SetObjLeft( const SwTwips _nLeft);
 
        virtual void UpdateLayoutDir();
 
        const SwRect& GetObjRectWithSpaces() const;
 
        void InvalidateObjRectWithSpaces() const
        {
            mbObjRectWithSpacesValid = false;
        }
 
        bool ConsiderObjWrapInfluenceOnObjPos() const;
 
        // accessors to booleans for layout process
        bool ConsiderForTextWrap() const;
        void SetConsiderForTextWrap( const bool _bConsiderForTextWrap );
        bool PositionLocked() const;
        void LockPosition()
        {
            mbPositionLocked = true;
        }
        void UnlockPosition()
        {
            if ( !mbKeepPositionLockedForSection )
            {
                mbPositionLocked = false;
            }
        }
 
        void SetKeepPosLocked( const bool _bKeepPosLocked )
        {
            mbKeepPositionLockedForSection = _bKeepPosLocked;
        }
 
        bool RestartLayoutProcess() const;
        void SetRestartLayoutProcess( const bool _bRestartLayoutProcess );
        // accessors for <mbClearedEnvironment>
        bool ClearedEnvironment() const;
        void SetClearedEnvironment( const bool _bClearedEnvironment );
 
        // reset booleans for layout process
        void ResetLayoutProcessBools()
        {
            mbPositioningInProgress = false;
            mbConsiderForTextWrap = false;
            mbPositionLocked = false;
            mbKeepPositionLockedForSection = false;
            mbRestartLayoutProcess = false;
            mbClearedEnvironment = false;
            mbTmpConsiderWrapInfluence = false;
        }
 
        bool HasClearedEnvironment() const;
 
        void UpdateObjInSortedList();
 
        virtual bool IsFormatPossible() const;
 
        static bool IsDraggingOffPageAllowed(const SwFrameFormat*);
 
        // accessors to member <mbTmpConsiderWrapInfluence>
        void SetTmpConsiderWrapInfluence( const bool _bTmpConsiderWrapInfluence );
        bool IsTmpConsiderWrapInfluence() const { return mbTmpConsiderWrapInfluence;}
        void ClearTmpConsiderWrapInfluence();
 
        bool OverlapsPrevColumn() const;
 
        Point GetRelPosToAnchorFrame() const;
 
        Point GetRelPosToPageFrame( const bool _bFollowTextFlow,
                                  bool& _obRelToTableCell ) const;
 
        Point GetRelPosToChar() const;
 
        Point GetRelPosToLine() const;
 
        virtual void dumpAsXml( xmlTextWriterPtr pWriter ) const;
 
        virtual const char* getElementName( ) const { return "SwAnchoredObject"; }
 
        virtual const SwFlyFrame* DynCastFlyFrame() const;
        virtual SwFlyFrame* DynCastFlyFrame();
};
 
class SwObjPositioningInProgress
{
    private:
        SwAnchoredObject* mpAnchoredObj;
        // boolean indicating old state
        // of anchored object regarding positioning in progress in order to
        // consider nested usage of class <SwObjPositioningInProgress>
        bool mbOldObjPositioningInProgress;
 
    public:
        SwObjPositioningInProgress( SdrObject& _rSdrObj );
        SwObjPositioningInProgress( SwAnchoredObject& _rAnchoredObj );
        ~SwObjPositioningInProgress();
};
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */