sw/source/core/inc/txtfly.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_SOURCE_CORE_INC_TXTFLY_HXX
  20 #define INCLUDED_SW_SOURCE_CORE_INC_TXTFLY_HXX
  21
  22 #include <editeng/txtrange.hxx>
  23 #include <tools/solar.h>
  24 #include <swtypes.hxx>
  25 #include <swrect.hxx>
  26 #include <com/sun/star/text/WrapTextMode.hpp>
  27 #include <memory>
  28 #include <vector>
  29
  30 class OutputDevice;
  31 class SwPageFrame;
  32 class SdrObject;
  33 class SwFormat;
  34 class SwAnchoredObject;
  35 class SwTextFrame;
  36 class SwDrawTextInfo;
  37 class SwContourCache;
  38
  39 typedef std::vector< SwAnchoredObject* > SwAnchoredObjList;
  40
  41 /** Contour-cache global variable, initialized/destroyed in txtinit.cxx
  42     and needed in txtfly.cxx by text wrapping.
  43   */
  44 extern SwContourCache *pContourCache;
  45
  46 #define POLY_CNT 20
  47 #define POLY_MIN 5
  48 #define POLY_MAX 4000
  49
  50 void ClrContourCache( const SdrObject *pObj );
  51
  52 class SwContourCache
  53 {
  54     friend void ClrContourCache();
  55     struct CacheItem
  56     {
  57         const SdrObject *mpSdrObj;
  58         std::unique_ptr<TextRanger> mxTextRanger;
  59     };
  60     std::vector<CacheItem> mvItems;
  61     tools::Long mnPointCount;
  62     SwRect ContourRect( const SwFormat* pFormat, const SdrObject* pObj,
  63         const SwTextFrame* pFrame, const SwRect &rLine, const tools::Long nXPos,
  64         const bool bRight );
  65
  66 public:
  67     SwContourCache();
  68     ~SwContourCache();
  69     const SdrObject* GetObject( sal_uInt16 nPos ) const{ return mvItems[ nPos ].mpSdrObj; }
  70     sal_uInt16 GetCount() const { return mvItems.size(); }
  71     void ClrObject( sal_uInt16 nPos );
  72
  73     /**
  74       Computes the rectangle that will cover the object in the given line.
  75
  76       For _non_ contour-flow objects, this is simply the overlap area of
  77       BoundRect (including spacing), and the line, for contour-flow,
  78       the tools::PolyPolygon of the object gets traversed
  79      */
  80     static SwRect CalcBoundRect( const SwAnchoredObject* pAnchoredObj,
  81                                        const SwRect &rLine,
  82                                        const SwTextFrame* pFrame,
  83                                        const tools::Long nXPos,
  84                                        const bool bRight );
  85 };
  86
  87 /**
  88    The purpose of this class is to be the universal interface between
  89    formatting/text output and the possibly overlapping free-flying frames.
  90    During formatting the formatter gets the information from SwTextFly, whether
  91    a certain area is present by the attributes of an overlapping frame.
  92    Such areas are represented by dummy portions.
  93
  94    The whole text output and touch-up is, again, forwarded to a SwTextFly.
  95    This one decides, whether parts of the text need to be clipped and splits
  96    the areas for e.g. a DrawRect.
  97
  98    Please note that all free-flying frames are located in a PtrArray, sorted
  99    by TopLeft.
 100
 101    Internally we always use document-global values. The IN and OUT parameters
 102    are, however, adjusted to the needs of the LineIter most of the time. That
 103    is: they are converted to frame- and window-local coordinates.
 104    If multiple frames with wrap attributes are located on the same line, we get
 105    the following settings for the text flow:
 106
 107         L/R    P     L     R     N
 108          P   -P-P- -P-L  -P R- -P N
 109          L   -L P- -L L  -L R- -L N
 110          R    R-P-  R-L   R R-  R N
 111          N    N P-  N L   N R-  N N
 112
 113    (P=parallel, L=left, R=right, N=no wrap)
 114
 115    We can describe the behaviour as follows:
 116    Every frame can push away text, with the restriction that it only has influence
 117    until the next frame.
 118  */
 119 class SwTextFly
 120 {
 121     const SwPageFrame                * m_pPage;
 122     const SwAnchoredObject           * mpCurrAnchoredObj;
 123     const SwTextFrame                * m_pCurrFrame;
 124     const SwTextFrame                * m_pMaster;
 125     std::unique_ptr<SwAnchoredObjList> mpAnchoredObjList;
 126
 127     tools::Long m_nMinBottom;
 128     tools::Long m_nNextTop;  /// Stores the upper edge of the "next" frame
 129     sal_uLong m_nCurrFrameNodeIndex;
 130
 131     bool m_bOn : 1;
 132     bool m_bTopRule: 1;
 133     bool mbIgnoreCurrentFrame: 1;
 134     bool mbIgnoreContour: 1;
 135
 136     /** boolean, indicating if objects in page header|footer are considered for
 137         text frames not in page header|footer.
 138      */
 139     bool mbIgnoreObjsInHeaderFooter: 1;
 140
 141     /**
 142         This method will be called during the LineIter formatting
 143             \li to compute the position of the next \c FlyPortion
 144             \li remember new overlappings after a change of the line height.
 145
 146         \param[in] rPortion
 147             Scope: document global.
 148      */
 149     SwRect GetFrame_( const SwRect &rPortion ) const;
 150
 151     SwAnchoredObjList* InitAnchoredObjList();
 152
 153     SwAnchoredObjList* GetAnchoredObjList() const;
 154
 155     /**
 156         Look for the first object which overlaps with the rectangle.
 157         Iterates over the anchored object list mpAnchoredObjList.
 158     */
 159     bool ForEach( const SwRect &rRect, SwRect* pRect, bool bAvoid ) const;
 160
 161     /**
 162       \li There is less than 2cm space on both sides for the text:
 163       no surround (css::text::WrapTextMode_NONE)
 164
 165       \li There is more than 2cm space on only one side:
 166       surround on that side (css::text::WrapTextMode_LEFT or css::text::WrapTextMode_RIGHT)
 167
 168       \li There is more than 2cm space on both sides, the object is
 169       larger than 1.5cm: surround on the wider side
 170       (css::text::WrapTextMode_LEFT or css::text::WrapTextMode_RIGHT)
 171
 172       \li There is more than 2cm space on both sides and the object
 173       width is less than 1.5cm: both sides surround (css::text::WrapTextMode_PARALLEL)
 174      */
 175     css::text::WrapTextMode GetSurroundForTextWrap( const SwAnchoredObject* pAnchoredObj ) const;
 176
 177     /**
 178        The right margin is the right margin or it is determined by the
 179        next object standing on the line.
 180      */
 181     void CalcRightMargin( SwRect &rFly,
 182                           SwAnchoredObjList::size_type nPos,
 183                           const SwRect &rLine ) const;
 184
 185     /**
 186        The left margin is the left margin of the current PrintArea or
 187        it is determined by the last FlyFrame, which stands on the line.
 188      */
 189     void CalcLeftMargin( SwRect &rFly,
 190                          SwAnchoredObjList::size_type nPos,
 191                          const SwRect &rLine ) const;
 192
 193     /**
 194        \return the position in sorted array
 195      */
 196     SwAnchoredObjList::size_type GetPos( const SwAnchoredObject* pAnchoredObj ) const;
 197
 198     bool GetTop( const SwAnchoredObject* _pAnchoredObj,
 199                  const bool bInFootnote,
 200                  const bool bInFooterOrHeader );
 201
 202     SwTwips CalcMinBottom() const;
 203
 204     const SwTextFrame* GetMaster_();
 205
 206 public:
 207
 208     SwTextFly();
 209     SwTextFly( const SwTextFrame *pFrame );
 210     SwTextFly( const SwTextFly& rTextFly );
 211     ~SwTextFly();
 212
 213     void CtorInitTextFly( const SwTextFrame *pFrame );
 214
 215     void SetTopRule();
 216
 217     SwRect GetFrame( const SwRect &rPortion ) const;
 218     bool IsOn() const;
 219
 220     /**
 221         If there is no flying object frame standing in rRect (usually the current row),
 222         then we are turning ourself off.
 223
 224         \param rRect is global to the document!
 225      */
 226     bool Relax( const SwRect &rRect );
 227     bool Relax();
 228
 229     SwTwips GetMinBottom() const;
 230     const SwTextFrame* GetMaster() const;
 231
 232     // This temporary variable needs to be manipulated in const methods
 233     tools::Long GetNextTop() const;
 234     void SetNextTop( tools::Long nNew ) const;
 235
 236     /**
 237       Determines the demanded rectangle for an anchored object,
 238       considering its surround for text wrapping.
 239
 240       \param pAnchoredObj the object for which to get the bounds
 241       \param rLine the bounds of the line to format
 242
 243       \return the flying object bounds
 244       */
 245     SwRect AnchoredObjToRect( const SwAnchoredObject* pAnchoredObj,
 246                               const SwRect& rRect ) const;
 247
 248     /**
 249         This method is called by DrawText().
 250
 251         Ensures that the overlapping frames (except the transparent frames) won't
 252         be scribbled by setting clip regions so that only the portions that are not
 253         in the area of FlyFrames that are opaque and above the current frame will
 254         be output.
 255
 256         DrawText() takes over the on optimization!
 257      */
 258     void DrawTextOpaque( SwDrawTextInfo &rInf );
 259
 260     /**
 261         Two subtleties needs to be mentioned:
 262             \li DrawRect() is allowed over the ClipRects
 263             \li FlyToRect() returns bigger values than the frame data
 264
 265         Ensure that the overlapping frames (except the transparent frames)
 266         won't be scribbled
 267      */
 268     void DrawFlyRect( OutputDevice* pOut, const SwRect &rRect );
 269
 270     /**
 271         Used to switch off the SwTextFly when there is no overlapping object (Relax).
 272
 273         \param[in] the line area
 274         \return whether the line will be overlapped by a frame
 275      */
 276     bool IsAnyFrame( const SwRect &rLine ) const;
 277
 278     /**
 279         Same as IsAnyFrame(const SwRect&), but uses the current frame print
 280         area
 281      */
 282     bool IsAnyFrame() const;
 283
 284     /**
 285         true when a frame or DrawObj must be taken in account. The optimizations
 286         like Paint/FormatEmpty for empty sentences or the virtual OutputDevice can
 287         be used only when false is returned.
 288
 289         \param rRect
 290             The rectangle can be empty, the current frame is then used. The value is
 291             global to the document.
 292       */
 293     bool IsAnyObj( const SwRect& rRect ) const;
 294
 295     void SetIgnoreCurrentFrame( bool bNew );
 296     void SetIgnoreContour( bool bNew );
 297
 298     void SetIgnoreObjsInHeaderFooter( const bool bNew );
 299 };
 300
 301 inline SwAnchoredObjList* SwTextFly::GetAnchoredObjList() const
 302 {
 303     return mpAnchoredObjList
 304            ? mpAnchoredObjList.get()
 305            : const_cast<SwTextFly*>(this)->InitAnchoredObjList();
 306 }
 307
 308 inline void SwTextFly::SetTopRule()
 309 {
 310     m_bTopRule = false;
 311 }
 312
 313 inline bool SwTextFly::IsOn() const
 314 {
 315     return m_bOn;
 316 }
 317
 318 inline bool SwTextFly::Relax( const SwRect &rRect )
 319 {
 320     if (m_bOn)
 321     {
 322         m_bOn = IsAnyFrame( rRect );
 323     }
 324     return m_bOn;
 325 }
 326
 327 inline bool SwTextFly::Relax()
 328 {
 329     if (m_bOn)
 330     {
 331         m_bOn = IsAnyFrame();
 332     }
 333     return m_bOn;
 334 }
 335
 336 inline SwTwips SwTextFly::GetMinBottom() const
 337 {
 338     return mpAnchoredObjList ? m_nMinBottom : CalcMinBottom();
 339 }
 340
 341 inline const SwTextFrame* SwTextFly::GetMaster() const
 342 {
 343     return m_pMaster ? m_pMaster : const_cast<SwTextFly*>(this)->GetMaster_();
 344 }
 345
 346 inline tools::Long SwTextFly::GetNextTop() const
 347 {
 348     return m_nNextTop;
 349 }
 350
 351 inline void SwTextFly::SetNextTop( tools::Long nNew ) const
 352 {
 353     const_cast<SwTextFly*>(this)->m_nNextTop = nNew;
 354 }
 355
 356 inline SwRect SwTextFly::GetFrame( const SwRect &rRect ) const
 357 {
 358     return m_bOn ? GetFrame_( rRect ) : SwRect();
 359 }
 360
 361 inline void SwTextFly::SetIgnoreCurrentFrame( bool bNew )
 362 {
 363     mbIgnoreCurrentFrame = bNew;
 364 }
 365
 366 inline void SwTextFly::SetIgnoreContour( bool bNew )
 367 {
 368     mbIgnoreContour = bNew;
 369 }
 370
 371 inline void SwTextFly::SetIgnoreObjsInHeaderFooter( const bool bNew )
 372 {
 373     mbIgnoreObjsInHeaderFooter = bNew;
 374 }
 375
 376 #endif
 377
 378 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */