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