sw/inc/frmfmt.hxx

   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 #ifndef INCLUDED_SW_INC_FRMFMT_HXX
  20 #define INCLUDED_SW_INC_FRMFMT_HXX
  21
  22 #include <memory>
  23 #include <com/sun/star/text/PositionLayoutDir.hpp>
  24 #include <cppuhelper/weakref.hxx>
  25 #include <tools/gen.hxx>
  26 namespace sw
  27 {
  28     template<class T> class FrameFormats;
  29     class SpzFrameFormat;
  30 }
  31 #include "format.hxx"
  32 #include "hintids.hxx"
  33 #include "swdllapi.h"
  34 #include <list>
  35 #include "textboxhelper.hxx"
  36
  37 class Graphic;
  38 class IMapObject;
  39 class ImageMap;
  40 class SdrObject;
  41 class SwAnchoredObject;
  42 class SwDrawFrameFormat;
  43 class SwFlyDrawContact;
  44 class SwFlyFrame;
  45 class SwFlyFrameFormat;
  46 class SwRect;
  47 class SwRootFrame;
  48 class SwTableBox;
  49
  50 namespace sw
  51 {
  52     class DocumentLayoutManager;
  53     // This is cheating: we are not really decoupling much with this hint.
  54     // SwDrawFrameFormat should probably bookkeep its SdrObject (and
  55     // SwDrawFrameFormat too) as members
  56     struct SW_DLLPUBLIC FindSdrObjectHint final : SfxHint
  57     {
  58         SdrObject*& m_rpObject;
  59         FindSdrObjectHint(SdrObject*& rpObject)
  60             : SfxHint(SfxHintId::SwFindSdrObject), m_rpObject(rpObject) {};
  61         virtual ~FindSdrObjectHint() override;
  62     };
  63     template<class T> class FrameFormats;
  64     class SpzFrameFormat;
  65 }
  66 class SwFormatsBase;
  67 class SwTableFormat;
  68
  69 /// Style of a layout element.
  70 class SW_DLLPUBLIC SwFrameFormat
  71     : public SwFormat
  72 {
  73     friend class SwDoc;
  74     friend class SwPageDesc;    ///< Is allowed to call protected CTor.
  75     friend class ::sw::DocumentLayoutManager; ///< Is allowed to call protected CTor.
  76     friend class sw::FrameFormats<SwTableFormat*>;     ///< Is allowed to update the list backref.
  77     friend class sw::FrameFormats<sw::SpzFrameFormat*>;     ///< Is allowed to update the list backref.
  78     friend class sw::FrameFormats<SwFrameFormat*>;     ///< Is allowed to update the list backref.
  79     friend class SwTextBoxHelper;
  80     friend class SwUndoFlyBase; ///< calls SetOtherTextBoxFormat
  81
  82     css::uno::WeakReference<css::uno::XInterface> m_wXObject;
  83
  84     // DrawingLayer FillAttributes in a preprocessed form for primitive usage
  85     drawinglayer::attribute::SdrAllFillAttributesHelperPtr  maFillAttributes;
  86
  87     // The assigned SwFrmFmt list.
  88     SwFormatsBase* m_ffList;
  89
  90     std::shared_ptr< SwTextBoxNode > m_pOtherTextBoxFormats;
  91
  92     struct change_name
  93     {
  94         change_name(const OUString &rName) : mName(rName) {}
  95         void operator()(SwFormat *pFormat) { pFormat->m_aFormatName = mName; }
  96         const OUString &mName;
  97     };
  98
  99 protected:
 100     SwFrameFormat(
 101         SwAttrPool& rPool,
 102         const char* pFormatNm,
 103         SwFrameFormat *pDrvdFrame,
 104         sal_uInt16 nFormatWhich = RES_FRMFMT,
 105         const WhichRangesContainer& pWhichRange = aFrameFormatSetRange);
 106
 107     SwFrameFormat(
 108         SwAttrPool& rPool,
 109         const OUString &rFormatNm,
 110         SwFrameFormat *pDrvdFrame,
 111         sal_uInt16 nFormatWhich = RES_FRMFMT,
 112         const WhichRangesContainer& pWhichRange = aFrameFormatSetRange);
 113
 114     virtual void SwClientNotify(const SwModify&, const SfxHint&) override;
 115
 116 public:
 117
 118     const std::shared_ptr< SwTextBoxNode >& GetOtherTextBoxFormats() const { return m_pOtherTextBoxFormats; };
 119     void SetOtherTextBoxFormats(const std::shared_ptr<SwTextBoxNode>& rNew) { m_pOtherTextBoxFormats = rNew; };
 120
 121     virtual ~SwFrameFormat() override;
 122
 123     SwFrameFormat(SwFrameFormat const &) = default;
 124     SwFrameFormat(SwFrameFormat &&) = default;
 125     SwFrameFormat & operator =(SwFrameFormat const &) = default;
 126     SwFrameFormat & operator =(SwFrameFormat &&) = default;
 127
 128     /// Destroys all Frames in aDepend (Frames are identified via dynamic_cast).
 129     virtual void DelFrames();
 130
 131     /// Creates the views.
 132     virtual void MakeFrames();
 133
 134     virtual Graphic MakeGraphic( ImageMap* pMap = nullptr, const sal_uInt32 nMaximumQuadraticPixels = 500000, const std::optional<Size>& rTargetDPI = std::nullopt );
 135
 136     /**  @return the IMapObject defined at format (Fly)
 137         in the ImageMap at position Point.
 138         rPoint - test on DocPosition.
 139         pFly - optional FlyFrame, in case it is already known. */
 140     IMapObject* GetIMapObject( const Point& rPoint,
 141                                 const SwFlyFrame *pFly = nullptr ) const;
 142
 143     /** @return the real size of the frame - or an empty rectangle
 144        if no layout exists.
 145        If pPoint is given, look for the frame closest to it. */
 146     SwRect FindLayoutRect( const bool bPrtArea = false,
 147                            const Point* pPoint = nullptr ) const;
 148
 149     /** @return the SdrObject, that is connected to the ContactObject.
 150        Only DrawFrameFormats are connected to the "real SdrObject". FlyFrameFormats
 151        are connected to a Master and all FlyFrames has the "real SdrObject".
 152        "Real SdrObject" has position and a Z-order. */
 153     SdrObject* FindSdrObject()
 154     {
 155         SdrObject* pObject(nullptr);
 156         CallSwClientNotify(sw::FindSdrObjectHint(pObject));
 157         return pObject;
 158     }
 159     const SdrObject *FindSdrObject() const
 160         { return const_cast<SwFrameFormat*>(this)->FindSdrObject(); }
 161
 162           SdrObject *FindRealSdrObject();
 163     const SdrObject *FindRealSdrObject() const
 164         { return const_cast<SwFrameFormat*>(this)->FindRealSdrObject(); }
 165
 166     bool IsLowerOf( const SwFrameFormat& rFormat ) const;
 167
 168     enum tLayoutDir
 169     {
 170         HORI_L2R,
 171         HORI_R2L,
 172         VERT_R2L
 173     };
 174
 175     virtual SwFrameFormat::tLayoutDir GetLayoutDir() const;
 176     virtual void SetLayoutDir( const SwFrameFormat::tLayoutDir _eLayoutDir );
 177
 178     virtual sal_Int16 GetPositionLayoutDir() const;
 179     virtual void SetPositionLayoutDir( const sal_Int16 _nPositionLayoutDir );
 180
 181     virtual OUString GetDescription() const;
 182
 183     SAL_DLLPRIVATE css::uno::WeakReference<css::uno::XInterface> const& GetXObject() const
 184             { return m_wXObject; }
 185     SAL_DLLPRIVATE void SetXObject(css::uno::Reference<css::uno::XInterface> const& xObject)
 186             { m_wXObject = xObject; }
 187
 188     void RegisterToFormat( SwFormat& rFormat );
 189
 190     // Access to DrawingLayer FillAttributes in a preprocessed form for primitive usage
 191     virtual drawinglayer::attribute::SdrAllFillAttributesHelperPtr getSdrAllFillAttributesHelper() const override;
 192     virtual bool supportsFullDrawingLayerFillAttributeSet() const override;
 193
 194     void dumpAsXml(xmlTextWriterPtr pWriter) const;
 195
 196     virtual void SetFormatName( const OUString& rNewName, bool bBroadcast=false ) override;
 197     void MoveTableBox(SwTableBox& rTableBox, const SwFrameFormat* pOldFormat);
 198     virtual bool IsVisible() const;
 199 };
 200
 201 namespace sw
 202 {
 203     class SW_DLLPUBLIC SpzFrameFormat: public SwFrameFormat {
 204         friend ::SwDrawFrameFormat;
 205         friend ::SwFlyFrameFormat;
 206         SpzFrameFormat(
 207             SwAttrPool& rPool,
 208             const OUString& rFormatName,
 209             SwFrameFormat* pDerivedFrame,
 210             sal_uInt16 nFormatWhich)
 211             : SwFrameFormat(rPool, rFormatName, pDerivedFrame, nFormatWhich)
 212         {
 213             assert(nFormatWhich == RES_DRAWFRMFMT || nFormatWhich == RES_FLYFRMFMT);
 214         };
 215     };
 216 }
 217 // The FlyFrame-Format
 218
 219 class SW_DLLPUBLIC SwFlyFrameFormat final : public sw::SpzFrameFormat
 220 {
 221     friend class SwDoc;
 222     OUString msTitle;
 223     OUString msDesc;
 224     /// A tooltip has priority over an SwFormatURL and is not persisted to files.
 225     OUString msTooltip;
 226
 227     /** Both not existent.
 228        it stores the previous position of Prt rectangle from RequestObjectResize
 229        so it can be used to move frames of non-resizable objects to align them correctly
 230        when they get borders (this is done in SwWrtShell::CalcAndGetScale) */
 231     Point   m_aLastFlyFramePrtRectPos;
 232     std::unique_ptr<SwFlyDrawContact> m_pContact;
 233
 234     SwFlyFrameFormat( const SwFlyFrameFormat &rCpy ) = delete;
 235     SwFlyFrameFormat &operator=( const SwFlyFrameFormat &rCpy ) = delete;
 236
 237     SwFlyFrameFormat( SwAttrPool& rPool, const OUString &rFormatNm, SwFrameFormat *pDrvdFrame );
 238
 239 public:
 240     virtual ~SwFlyFrameFormat() override;
 241
 242     /// Creates the views.
 243     virtual void MakeFrames() override;
 244
 245     SwFlyFrame* GetFrame( const Point* pDocPos = nullptr ) const;
 246
 247     SwAnchoredObject* GetAnchoredObj() const;
 248
 249     virtual Graphic MakeGraphic( ImageMap* pMap = nullptr, const sal_uInt32 nMaximumQuadraticPixels = 500000, const std::optional<Size>& rTargetDPI = std::nullopt ) override;
 250
 251     OUString GetObjTitle() const;
 252     void SetObjTitle( const OUString& rTitle, bool bBroadcast = false );
 253
 254     const OUString & GetObjTooltip() const;
 255     void SetObjTooltip(const OUString& rTooltip);
 256
 257     OUString GetObjDescription() const;
 258     void SetObjDescription( const OUString& rDescription, bool bBroadcast = false );
 259
 260     bool IsDecorative() const;
 261     void SetObjDecorative(bool isDecorative);
 262
 263     /** SwFlyFrameFormat::IsBackgroundTransparent
 264
 265         Override virtual method and its default implementation,
 266         because format of fly frame provides transparent backgrounds.
 267         Method determines, if background of fly frame is transparent.
 268
 269         @return true, if background color is transparent, but not "no fill"
 270         or an existing background graphic is transparent.
 271     */
 272     virtual bool IsBackgroundTransparent() const override;
 273
 274     /** SwFlyFrameFormat::IsBackgroundBrushInherited
 275
 276         Method to determine, if the brush for drawing the
 277         background is "inherited" from its parent/grandparent.
 278         This is the case, if no background graphic is set and the background
 279         color is "no fill"/"auto fill"
 280
 281         @return true, if background brush is "inherited" from parent/grandparent
 282     */
 283     bool IsBackgroundBrushInherited() const;
 284
 285     const Point & GetLastFlyFramePrtRectPos() const       { return m_aLastFlyFramePrtRectPos; }
 286     void SetLastFlyFramePrtRectPos( const Point &rPoint ) { m_aLastFlyFramePrtRectPos = rPoint; }
 287
 288     SwFlyDrawContact* GetOrCreateContact();
 289 };
 290
 291 //The DrawFrame-Format
 292
 293
 294 class SwDrawFrameFormat;
 295 class SwDrawContact;
 296 class SdrTextObj;
 297
 298 namespace sw
 299 {
 300     enum class DrawFrameFormatHintId {
 301         DYING,
 302         PREPPASTING,
 303         PREP_INSERT_FLY,
 304         PREP_DELETE_FLY,
 305         PAGE_OUT_OF_BOUNDS,
 306         MAKE_FRAMES,
 307         DELETE_FRAMES,
 308         POST_RESTORE_FLY_ANCHOR,
 309     };
 310     struct DrawFrameFormatHint final: SfxHint
 311     {
 312         DrawFrameFormatHintId m_eId;
 313         DrawFrameFormatHint(DrawFrameFormatHintId eId)
 314             : SfxHint(SfxHintId::SwDrawFrameFormat), m_eId(eId) {};
 315         virtual ~DrawFrameFormatHint() override;
 316     };
 317     struct CheckDrawFrameFormatLayerHint final: SfxHint
 318     {
 319         bool* m_bCheckControlLayer;
 320         CheckDrawFrameFormatLayerHint(bool* bCheckControlLayer)
 321             : SfxHint(SfxHintId::SwCheckDrawFrameFormatLayer),
 322               m_bCheckControlLayer(bCheckControlLayer) {};
 323         virtual ~CheckDrawFrameFormatLayerHint() override;
 324     };
 325     struct ContactChangedHint final: SfxHint
 326     {
 327         SdrObject** m_ppObject;
 328         ContactChangedHint(SdrObject** ppObject)
 329             : SfxHint(SfxHintId::SwContactChanged),
 330               m_ppObject(ppObject) {};
 331         virtual ~ContactChangedHint() override;
 332     };
 333     struct DrawFormatLayoutCopyHint final : SfxHint
 334     {
 335         SwDrawFrameFormat& m_rDestFormat;
 336         SwDoc& m_rDestDoc;
 337         DrawFormatLayoutCopyHint(SwDrawFrameFormat& rDestFormat, SwDoc& rDestDoc)
 338             : SfxHint(SfxHintId::SwDrawFormatLayoutCopy),
 339               m_rDestFormat(rDestFormat), m_rDestDoc(rDestDoc) {};
 340         virtual ~DrawFormatLayoutCopyHint() override;
 341     };
 342     enum class WW8AnchorConv
 343     {
 344         NO_CONV,
 345         CONV2PG,
 346         CONV2COL_OR_PARA,
 347         CONV2CHAR,
 348         CONV2LINE,
 349         RELTOTABLECELL
 350     };
 351     struct WW8AnchorConvResult final
 352     {
 353         WW8AnchorConv m_eHoriConv;
 354         WW8AnchorConv m_eVertConv;
 355         bool m_bConverted;
 356         Point m_aPos;
 357         WW8AnchorConvResult(WW8AnchorConv eHoriConv, WW8AnchorConv eVertConv) : m_eHoriConv(eHoriConv), m_eVertConv(eVertConv), m_bConverted(false) {};
 358     };
 359     struct SW_DLLPUBLIC WW8AnchorConvHint final : SfxHint
 360     {
 361         WW8AnchorConvResult& m_rResult;
 362         WW8AnchorConvHint(WW8AnchorConvResult& rResult)
 363             : SfxHint(SfxHintId::SwWW8AnchorConv),
 364               m_rResult(rResult) {};
 365         virtual ~WW8AnchorConvHint() override;
 366     };
 367     struct RestoreFlyAnchorHint final : SfxHint
 368     {
 369         const Point m_aPos;
 370         RestoreFlyAnchorHint(Point aPos)
 371             : SfxHint(SfxHintId::SwRestoreFlyAnchor),
 372               m_aPos(aPos) {};
 373         virtual ~RestoreFlyAnchorHint() override;
 374     };
 375     struct CreatePortionHint final : SfxHint
 376     {
 377         SwDrawContact** m_ppContact;
 378         CreatePortionHint(SwDrawContact** ppContact)
 379             : SfxHint(SfxHintId::SwCreatePortion),
 380               m_ppContact(ppContact) {};
 381         virtual ~CreatePortionHint() override;
 382     };
 383     struct CollectTextObjectsHint final : SfxHint
 384     {
 385         std::list<SdrTextObj*>& m_rTextObjects;
 386         CollectTextObjectsHint(std::list<SdrTextObj*>& rTextObjects)
 387             : SfxHint(SfxHintId::SwCollectTextObjects),
 388               m_rTextObjects(rTextObjects) {};
 389         virtual ~CollectTextObjectsHint() override;
 390     };
 391     struct GetZOrderHint final : SfxHint
 392     {
 393         sal_uInt32& m_rnZOrder;
 394         GetZOrderHint(sal_uInt32& rnZOrder)
 395             : SfxHint(SfxHintId::SwGetZOrder),
 396               m_rnZOrder(rnZOrder) {};
 397         virtual ~GetZOrderHint() override;
 398     };
 399     struct GetObjectConnectedHint final : SfxHint
 400     {
 401         bool& m_risConnected;
 402         const SwRootFrame* m_pRoot;
 403         GetObjectConnectedHint(bool& risConnected, const SwRootFrame* pRoot)
 404             : SfxHint(SfxHintId::SwGetObjectConnected),
 405               m_risConnected(risConnected), m_pRoot(pRoot) {};
 406         virtual ~GetObjectConnectedHint() override;
 407     };
 408 }
 409
 410 class SW_DLLPUBLIC SwDrawFrameFormat final : public sw::SpzFrameFormat
 411 {
 412     friend class SwDoc;
 413
 414     mutable const SdrObject * m_pSdrObjectCached;
 415     mutable OUString m_sSdrObjectCachedComment;
 416
 417     SwDrawFrameFormat( const SwDrawFrameFormat &rCpy ) = delete;
 418     SwDrawFrameFormat &operator=( const SwDrawFrameFormat &rCpy ) = delete;
 419
 420     SwFrameFormat::tLayoutDir meLayoutDir;
 421
 422     sal_Int16 mnPositionLayoutDir;
 423
 424     bool mbPosAttrSet;
 425
 426     SwDrawFrameFormat(SwAttrPool& rPool, const OUString& rFormatName, SwFrameFormat* pDerivedFrame)
 427         : sw::SpzFrameFormat(rPool, rFormatName, pDerivedFrame, RES_DRAWFRMFMT),
 428           m_pSdrObjectCached(nullptr),
 429           meLayoutDir(SwFrameFormat::HORI_L2R),
 430           mnPositionLayoutDir(css::text::PositionLayoutDir::PositionInLayoutDirOfAnchor),
 431           mbPosAttrSet(false)
 432     {}
 433
 434 public:
 435     virtual ~SwDrawFrameFormat() override;
 436
 437     /** DrawObjects are removed from the arrays at the layout.
 438      The DrawObjects are marked as deleted. */
 439     virtual void DelFrames() override;
 440
 441     /** Register DrawObjects in the arrays at layout.
 442      Reset delete marks. */
 443     virtual void MakeFrames() override;
 444
 445     virtual Graphic MakeGraphic( ImageMap* pMap = nullptr, const sal_uInt32 nMaximumQuadraticPixels = 500000, const std::optional<Size>& rTargetDPI = std::nullopt ) override;
 446
 447     virtual SwFrameFormat::tLayoutDir GetLayoutDir() const override;
 448     virtual void SetLayoutDir( const SwFrameFormat::tLayoutDir _eLayoutDir ) override;
 449
 450     virtual sal_Int16 GetPositionLayoutDir() const override;
 451     virtual void SetPositionLayoutDir( const sal_Int16 _nPositionLayoutDir ) override;
 452
 453     bool IsPosAttrSet() const { return mbPosAttrSet; }
 454     void PosAttrSet() { mbPosAttrSet = true; }
 455
 456     virtual OUString GetDescription() const override;
 457 };
 458
 459 namespace sw {
 460
 461 SW_DLLPUBLIC bool IsFlyFrameFormatInHeader(const SwFrameFormat& rFormat);
 462
 463 void CheckAnchoredFlyConsistency(SwDoc const& rDoc);
 464
 465 }
 466
 467 #endif
 468
 469 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */