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