diff options
Diffstat (limited to 'sw/inc/anchoredobject.hxx')
| -rw-r--r-- | sw/inc/anchoredobject.hxx | 514 |
1 files changed, 514 insertions, 0 deletions
diff --git a/sw/inc/anchoredobject.hxx b/sw/inc/anchoredobject.hxx new file mode 100644 index 000000000..2dd945e4c --- /dev/null +++ b/sw/inc/anchoredobject.hxx @@ -0,0 +1,514 @@ +/* -*- 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 <libxml/xmlwriter.h> + +struct SwPosition; +class SdrObject; +class SwFrame; +class SwLayoutFrame; +class SwTextFrame; +class SwFlyFrame; +class SwPageFrame; + +class SwFrameFormat; +class SwFormatAnchor; +enum class RndStdIds; + +/** wrapper class for the positioning of Writer fly frames and drawing objects + + Purpose of this class is to provide a unified interface for the positioning + of Writer fly frames (derived classes of <SwFlyFrame>) and of drawing objects + (derived classes of <SwAnchoredDrawObject>). +*/ +class SW_DLLPUBLIC SwAnchoredObject +{ + private: + // drawing object representing the anchored object in the drawing layer + SdrObject* mpDrawObj; + /// Frame the object is anchored at. + /// For at-char/at-para anchor, this is always the master SwTextFrame. + 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; + + /** method to indicate, that positioning of anchored object is in progress + + note: method is implemented empty + */ + friend class SwObjPositioningInProgress; + void SetPositioningInProgress( const bool _bPosInProgress ) + { + mbPositioningInProgress = _bPosInProgress; + } + + /** check anchor character rectangle + + helper method for method <CheckCharRectAndTopOfLine()> + For to-character anchored Writer fly frames the member <maLastCharRect> + is updated. This is checked for change and depending on the applied + positioning, it's decided, if the Writer fly frame has to be invalidated. + improvement - add second parameter <_rAnchorCharFrame> + + @param _rAnch + input parameter - reference to anchor position + + @param _rAnchorCharFrame + input parameter - reference to the text frame containing the anchor + character. + */ + void CheckCharRect( const SwFormatAnchor& _rAnch, + const SwTextFrame& _rAnchorCharFrame ); + + /** check top of line + + helper method for method <CheckCharRectAndTopOfLine()> + For to-character anchored Writer fly frames the member <mnLastTopOfLine> + is updated. This is checked for change and depending on the applied + positioning, it's decided, if the Writer fly frame has to be invalidated. + + @param _rAnch + input parameter - reference to anchor position + + @param _rAnchorCharFrame + input parameter - reference to the text frame containing the anchor + character. + */ + 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 ); + + /** method to assure that anchored object is registered at the correct + page frame + */ + virtual void RegisterAtCorrectPage() = 0; + + /** method to indicate, that anchored object is attached to an anchor frame */ + virtual void ObjectAttachedToAnchorFrame(); + + /** method to determine, if other anchored objects, also attached at + to the anchor frame, have to consider its wrap influence. + */ + bool ConsiderObjWrapInfluenceOfOtherObjs() const; + + /** method to apply temporary consideration of wrapping style influence + to the anchored objects, which are anchored at the same anchor frame + */ + 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; } + SdrObject* DrawObj() { return mpDrawObj; } + + // accessors to member <mpAnchorFrame> + const SwFrame* GetAnchorFrame() const { return mpAnchorFrame; } + SwFrame* AnchorFrame() { return mpAnchorFrame; } + void ChgAnchorFrame( SwFrame* _pNewAnchorFrame ); + /** determine anchor frame containing the anchor position + + the anchor frame, which is determined, is <mpAnchorFrame> + for an at-page, at-frame or at-paragraph anchored object + and the anchor character frame for an at-character and as-character + anchored object. + */ + SwFrame* GetAnchorFrameContainingAnchPos(); + + SwPageFrame* GetPageFrame() { return mpPageFrame; } + const SwPageFrame* GetPageFrame() const { return mpPageFrame; } + void SetPageFrame( SwPageFrame* _pNewPageFrame ); + + /** method to determine the page frame, on which the 'anchor' of + the given anchored object is. + + Adjust meaning of method and thus its name: If the anchored object + or its anchor isn't correctly inserted in the layout, no page frame + can be found. Thus, the return type changed to be a pointer and can + be NULL. + + @param _rAnchoredObj + input parameter - anchored object, for which the page frame of its + 'anchor' has to be determined. + + @return SwPageFrame& + page frame, the 'anchor' of the given anchored object is on + */ + SwPageFrame* FindPageFrameOfAnchor(); + + /** get frame, which contains the anchor character, if the object + is anchored at-character or as-character. + + @return SwTextFrame* + text frame containing the anchor character. It's NULL, if the object + isn't anchored at-character resp. as-character. + */ + 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(); + + /** check anchor character rectangle and top of line + + For to-character anchored Writer fly frames the members <maLastCharRect> + and <maLastTopOfLine> are updated. These are checked for change and + depending on the applied positioning, it's decided, if the Writer fly + frame has to be invalidated. + + @param _bCheckForParaPorInf + input parameter - boolean indicating, if check on paragraph portion + information has to be done. + */ + 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 ); + + /** reset members <maLastCharRect> and <mnLastTopOfLine> */ + void ClearCharRectAndTopOfLine(); + + /** method to determine position for the object and set the position + at the object + */ + virtual void MakeObjPos() = 0; + + /** is positioning of anchored object in progress */ + bool IsPositioningInProgress() const + { + return mbPositioningInProgress; + } + + /** method to determine, if invalidation of position is allowed */ + bool InvalidationOfPosAllowed() const; + + /** method to invalidate position of the anchored object */ + virtual void InvalidateObjPos() = 0; + + virtual void RegisterAtPage(SwPageFrame &) = 0; + + /** method to perform necessary invalidations for the positioning of + objects, for whose the wrapping style influence has to be considered + on the object positioning. + */ + void InvalidateObjPosForConsiderWrapInfluence(); + + /** method to trigger notification of 'background' */ + 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); + + /** method update layout direction the layout direction, the anchored + object is assigned to + + method has typically to be called, if the anchored object gets its + anchor frame assigned and if the anchor frame changes its layout direction + */ + virtual void UpdateLayoutDir(); + + /** method to determine object area inclusive its spacing */ + const SwRect& GetObjRectWithSpaces() const; + + void InvalidateObjRectWithSpaces() const + { + mbObjRectWithSpacesValid = false; + } + + /** method to determine, if wrapping style influence of the anchored + object has to be considered on the object positioning + + Note: result of this method also decides, if the boolean for the + layout process are of relevance. + */ + 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; + } + + /** method to determine, if due to anchored object size and wrapping + style, its layout environment is cleared. + */ + bool HasClearedEnvironment() const; + + /** method to update anchored object in the <SwSortedObjs> lists + + Method is not proposed to be called during a layout process is + running. It has been used on the change of the anchored object + attributes, which belongs the sort criteria of <SwSortedObjs>. + If document compatibility option 'Consider wrapping style influence + on object positioning' is ON, additionally all anchored objects + at the anchor frame and all following anchored objects on the page + frame are invalidated. + */ + void UpdateObjInSortedList(); + + /** method to determine, if a format on the anchored object is possible + + A format isn't possible, if anchored object is in an invisible layer. + Note: method is virtual to refine the conditions for the sub-classes. + */ + virtual bool IsFormatPossible() const; + + /** method to determine if dragging objects off page is allowed + + Returns true if editor objects can be dragged off page, false otherwise + */ + static bool IsDraggingOffPageAllowed(const SwFrameFormat*); + + // accessors to member <mbTmpConsiderWrapInfluence> + void SetTmpConsiderWrapInfluence( const bool _bTmpConsiderWrapInfluence ); + bool IsTmpConsiderWrapInfluence() const { return mbTmpConsiderWrapInfluence;} + void ClearTmpConsiderWrapInfluence(); + + /** method to determine, if the anchored object is overlapping with a + previous column + + overlapping with a previous column means, that the object overlaps + with a column, which is a previous one of the column its anchor + frame is in. + Only applied for at-paragraph and at-character anchored objects. + */ + bool OverlapsPrevColumn() const; + + /** method to determine position of anchored object relative to + anchor frame + + Usage: Needed layout information for WW8 export + + @return Point - determined relative position + */ + Point GetRelPosToAnchorFrame() const; + + /** method to determine position of anchored object relative to + page frame + + Usage: Needed layout information for WW8 export + + If <_bFollowTextFlow> is set and object is anchored inside table, + the position relative to the table cell is determined. Output + parameter <_obRelToTableCell> reflects this situation + + @param _bFollowTextFlow + input parameter - boolean indicating, if the anchored object has to + follow the text flow. + + @param _obRelToTableCell + output parameter - boolean indicating, the determine position is + relative to the table cell + + @return Point - determined relative position + */ + Point GetRelPosToPageFrame( const bool _bFollowTextFlow, + bool& _obRelToTableCell ) const; + + /** method to determine position of anchored object relative to + anchor character + + Usage: Needed layout information for WW8 export + + @return Point - determined relative position + */ + Point GetRelPosToChar() const; + + /** method to determine position of anchored object relative to + top of line + + Usage: Needed layout information for WW8 export + + @return Point - determined relative position + */ + Point GetRelPosToLine() const; + + /** Dump a bunch of useful data to an XML representation to ease + layout understanding, debugging and testing. + */ + virtual void dumpAsXml( xmlTextWriterPtr pWriter ) const; + + /** The element name to show in the XML dump. */ + virtual const char* getElementName( ) const { return "SwAnchoredObject"; } + + virtual const SwFlyFrame* DynCastFlyFrame() const; + virtual SwFlyFrame* DynCastFlyFrame(); +}; + +/// Helper class for notify that positioning of an anchored object is in progress. +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: */ |