sw/inc/ndtxt.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_NDTXT_HXX
  20 #define INCLUDED_SW_INC_NDTXT_HXX
  21
  22 #include <cppuhelper/weakref.hxx>
  23
  24 #include "doc.hxx"
  25 #include "swdllapi.h"
  26 #include "node.hxx"
  27 #include "hintids.hxx"
  28 #include "ndhints.hxx"
  29 #include "SwNumberTreeTypes.hxx"
  30 #include "IDocumentContentOperations.hxx"
  31 #include "modeltoviewhelper.hxx"
  32
  33 #include <sfx2/Metadatable.hxx>
  34
  35 #include <memory>
  36 #include <vector>
  37 #include <set>
  38 #include <functional>
  39
  40 class SfxHint;
  41 class SwNumRule;
  42 class SwNodeNum;
  43 class SvxLRSpaceItem;
  44
  45 namespace utl {
  46     class TransliterationWrapper;
  47 }
  48 namespace vcl
  49 {
  50 class Font;
  51 }
  52
  53 class SwContentFrame;
  54 class SwTextField;
  55 class SwTextInputField;
  56 class SfxItemSet;
  57 class SwUndoTransliterate;
  58 struct SwSpellArgs;
  59 struct SwConversionArgs;
  60 class SwInterHyphInfo;
  61 class SwWrongList;
  62 class SwGrammarMarkUp;
  63 struct SwDocStat;
  64 struct SwParaIdleData_Impl;
  65 enum class ExpandMode;
  66
  67 namespace sw { namespace mark { enum class RestoreMode; } }
  68
  69 namespace com { namespace sun { namespace star {
  70     namespace uno {
  71         template < class > class Sequence;
  72     }
  73     namespace text { class XTextContent; }
  74 } } }
  75
  76 typedef std::set< sal_Int32 > SwSoftPageBreakList;
  77
  78 /// SwTextNode is a paragraph in the document model.
  79 class SW_DLLPUBLIC SwTextNode
  80     : public SwContentNode
  81     , public ::sfx2::Metadatable
  82 {
  83     friend class SwContentNode;
  84     /// For creating the first TextNode.
  85     friend class SwDoc;         ///< CTOR and AppendTextNode()
  86     friend class SwNodes;
  87     friend class SwTextFrame;
  88     friend class SwScriptInfo;
  89
  90     /** May be 0. It is only then not 0 if it contains hard attributes.
  91        Therefore: never access directly! */
  92     std::unique_ptr<SwpHints> m_pSwpHints;
  93
  94     mutable std::unique_ptr<SwNodeNum> mpNodeNum;  ///< Numbering for this paragraph.
  95     mutable std::unique_ptr<SwNodeNum> mpNodeNumRLHidden; ///< Numbering for this paragraph (hidden redlines)
  96
  97     OUString m_Text;
  98
  99     SwParaIdleData_Impl* m_pParaIdleData_Impl;
 100
 101     /** Some of the chars this para are hidden. Paragraph has to be reformatted
 102        on changing the view to print preview. */
 103     mutable bool m_bContainsHiddenChars : 1;
 104     /// The whole paragraph is hidden because of the hidden text attribute
 105     mutable bool m_bHiddenCharsHidePara : 1;
 106     /// The last two flags have to be recalculated if this flag is set:
 107     mutable bool m_bRecalcHiddenCharFlags : 1;
 108
 109     mutable bool m_bLastOutlineState : 1;
 110     bool m_bNotifiable;
 111
 112     bool mbEmptyListStyleSetDueToSetOutlineLevelAttr;
 113
 114     /** boolean, indicating that a <SetAttr(..)> or <ResetAttr(..)> or
 115        <ResetAllAttr(..)> method is running.
 116        Needed to avoid duplicate handling of attribute change actions. */
 117     bool mbInSetOrResetAttr;
 118
 119     std::unique_ptr< OUString > m_pNumStringCache;
 120
 121     css::uno::WeakReference<css::text::XTextContent> m_wXParagraph;
 122
 123     // DrawingLayer FillAttributes in a preprocessed form for primitive usage
 124     drawinglayer::attribute::SdrAllFillAttributesHelperPtr  maFillAttributes;
 125
 126     SAL_DLLPRIVATE SwTextNode( const SwNodeIndex &rWhere, SwTextFormatColl *pTextColl,
 127                              const SfxItemSet* pAutoAttr = nullptr );
 128
 129     /// Copies the attributes at nStart to pDest.
 130     SAL_DLLPRIVATE void CopyAttr( SwTextNode *pDest, const sal_Int32 nStart, const sal_Int32 nOldPos);
 131
 132     SAL_DLLPRIVATE SwTextNode* MakeNewTextNode( const SwNodeIndex&, bool bNext = true,
 133                                 bool bChgFollow = true );
 134
 135     SAL_DLLPRIVATE void CutImpl(
 136           SwTextNode * const pDest, const SwIndex & rDestStart,
 137           const SwIndex & rStart, /*const*/ sal_Int32 nLen,
 138           const bool bUpdate = true );
 139
 140     /// Move all comprising hard attributes to the AttrSet of the paragraph.
 141     SAL_DLLPRIVATE void MoveTextAttr_To_AttrSet();  // Called by SplitNode.
 142
 143     /// Create the specific AttrSet.
 144     SAL_DLLPRIVATE virtual void NewAttrSet( SwAttrPool& ) override;
 145
 146     /// Optimization: Asking for information about hidden characters at SwScriptInfo
 147     /// updates these flags.
 148     bool IsCalcHiddenCharFlags() const
 149         { return m_bRecalcHiddenCharFlags; }
 150     void SetHiddenCharAttribute( bool bNewHiddenCharsHidePara, bool bNewContainsHiddenChars ) const
 151     {
 152         m_bHiddenCharsHidePara = bNewHiddenCharsHidePara;
 153         m_bContainsHiddenChars = bNewContainsHiddenChars;
 154         m_bRecalcHiddenCharFlags = false;
 155     }
 156
 157     SAL_DLLPRIVATE void CalcHiddenCharFlags() const;
 158
 159     SAL_DLLPRIVATE void SetLanguageAndFont( const SwPaM &rPaM,
 160             LanguageType nLang, sal_uInt16 nLangWhichId,
 161             const vcl::Font *pFont,  sal_uInt16 nFontWhichId );
 162
 163     /// Start: Data collected during idle time
 164
 165     SAL_DLLPRIVATE void InitSwParaStatistics( bool bNew );
 166
 167     inline void TryDeleteSwpHints();
 168
 169     SAL_DLLPRIVATE void impl_FormatToTextAttr(const SfxItemSet& i_rAttrSet);
 170
 171     const SwTextInputField* GetOverlappingInputField( const SwTextAttr& rTextAttr ) const;
 172
 173     void DelFrames_TextNodePart();
 174
 175 public:
 176     enum class WrongState { TODO, PENDING, DONE };
 177
 178     bool IsWordCountDirty() const;
 179     WrongState GetWrongDirty() const;
 180     bool IsWrongDirty() const;
 181     bool IsGrammarCheckDirty() const;
 182     bool IsSmartTagDirty() const;
 183     bool IsAutoCompleteWordDirty() const;
 184     void SetWordCountDirty( bool bNew ) const;
 185     void SetWrongDirty(WrongState eNew) const;
 186     void SetGrammarCheckDirty( bool bNew ) const;
 187     void SetSmartTagDirty( bool bNew ) const;
 188     void SetAutoCompleteWordDirty( bool bNew ) const;
 189     void SetWrong( SwWrongList* pNew, bool bDelete = true );
 190     SwWrongList* GetWrong();
 191     const SwWrongList* GetWrong() const;
 192     void SetGrammarCheck( SwGrammarMarkUp* pNew, bool bDelete = true );
 193     SwGrammarMarkUp* GetGrammarCheck();
 194     // return SwWrongList because *function pointer* return values aren't covariant
 195     SwWrongList const* GetGrammarCheck() const;
 196     void SetSmartTags( SwWrongList* pNew, bool bDelete = true );
 197     SwWrongList* GetSmartTags();
 198     SwWrongList const* GetSmartTags() const;
 199     void TryCharSetExpandToNum(const SfxItemSet& pCharSet);
 200
 201     /// End: Data collected during idle time
 202
 203 protected:
 204     /// for hanging TextFormatCollections somewhere else (Outline-Numbering!)
 205     virtual void SwClientNotify( const SwModify&, const SfxHint& ) override;
 206
 207 public:
 208     using SwContentNode::GetAttr;
 209
 210     const OUString& GetText() const { return m_Text; }
 211
 212     // returns the maximum number of characters that can still be added to the node
 213     inline sal_Int32 GetSpaceLeft() const;
 214
 215     /// getters for SwpHints
 216     inline       SwpHints &GetSwpHints();
 217     inline const SwpHints &GetSwpHints() const;
 218           SwpHints *GetpSwpHints()       { return m_pSwpHints.get(); }
 219     const SwpHints *GetpSwpHints() const { return m_pSwpHints.get(); }
 220     bool   HasHints() const { return m_pSwpHints != nullptr; }
 221     inline       SwpHints &GetOrCreateSwpHints();
 222
 223     virtual ~SwTextNode() override;
 224
 225     virtual sal_Int32 Len() const override;
 226
 227     /// Is in itratr.
 228     void GetMinMaxSize( sal_uLong nIndex, sal_uLong& rMin, sal_uLong &rMax, sal_uLong &rAbs ) const;
 229
 230     /// overriding to handle change of certain paragraph attributes
 231     virtual bool SetAttr( const SfxPoolItem& ) override;
 232     virtual bool SetAttr( const SfxItemSet& rSet ) override;
 233     virtual bool ResetAttr( sal_uInt16 nWhich1, sal_uInt16 nWhich2 = 0 ) override;
 234     virtual bool ResetAttr( const std::vector<sal_uInt16>& rWhichArr ) override;
 235     virtual sal_uInt16 ResetAllAttr() override;
 236
 237     /// insert text content
 238     /// @param rStr text to insert; in case it does not fit into the capacity
 239     ///             of the node, the longest prefix that fits is inserted
 240     /// @return the prefix of rStr that was actually inserted
 241     OUString InsertText( const OUString & rStr, const SwIndex & rIdx,
 242                      const SwInsertFlags nMode
 243                          = SwInsertFlags::DEFAULT );
 244
 245     /** delete text content
 246         ATTENTION: must not be called with a range that overlaps the start of
 247                    an attribute with both extent and dummy char
 248      */
 249     void EraseText ( const SwIndex &rIdx, const sal_Int32 nCount = SAL_MAX_INT32,
 250                      const SwInsertFlags nMode = SwInsertFlags::DEFAULT );
 251
 252     /** delete all attributes.
 253         If neither pSet nor nWhich is given, delete all attributes (except
 254         refmarks, toxmarks, meta) in range.
 255         @param rIdx     start position
 256         @param nLen     range in which attributes will be deleted
 257         @param pSet     if not 0, delete only attributes contained in pSet
 258         @param nWhich   if not 0, delete only attributes with matching which
 259         @param bInclRefToxMark
 260             refmarks, toxmarks, and metas will be ignored unless this is true
 261         ATTENTION: setting bInclRefToxMark is only allowed from UNDO!
 262         @param bExactRange From the attributes included in the range, delete
 263         only the ones which have exactly same range. Don't delete the ones
 264         which are simply included in the range.
 265      */
 266     void RstTextAttr(
 267         const SwIndex &rIdx,
 268         const sal_Int32 nLen,
 269         const sal_uInt16 nWhich = 0,
 270         const SfxItemSet* pSet = nullptr,
 271         const bool bInclRefToxMark = false,
 272         const bool bExactRange = false );
 273     void    GCAttr();
 274
 275     // Delete text attribute (needs to be deregistered at Pool!)
 276     void    DestroyAttr( SwTextAttr* pAttr );
 277
 278     // delete all attributes from SwpHintsArray.
 279     void    ClearSwpHintsArr( bool bDelFields );
 280
 281     /// initialize the hints after file loading (which takes shortcuts)
 282     void    FileLoadedInitHints();
 283
 284     /// Insert pAttr into hints array. @return true iff inserted successfully
 285     bool    InsertHint( SwTextAttr * const pAttr,
 286                   const SetAttrMode nMode = SetAttrMode::DEFAULT );
 287     /// create new text attribute from rAttr and insert it
 288     /// @return     inserted hint; 0 if not sure the hint is inserted
 289     SwTextAttr* InsertItem( SfxPoolItem& rAttr,
 290                   const sal_Int32 nStart, const sal_Int32 nEnd,
 291                   const SetAttrMode nMode = SetAttrMode::DEFAULT );
 292
 293     /** Set these attributes at TextNode. If the whole range is comprised
 294        set them only in AutoAttrSet (SwContentNode::SetAttr). */
 295     bool SetAttr( const SfxItemSet& rSet,
 296                   sal_Int32 nStt, sal_Int32 nEnd,
 297                   const SetAttrMode nMode = SetAttrMode::DEFAULT,
 298                   SwTextAttr **ppNewTextAttr = nullptr);
 299     /** Query the attributes of textnode over the range.
 300        Introduce 4th optional parameter <bMergeIndentValuesOfNumRule>.
 301        If <bMergeIndentValuesOfNumRule> == true, the indent attributes of
 302        the corresponding list level of an applied list style is merged into
 303        the requested item set as a LR-SPACE item, if <bOnlyTextAttr> == false,
 304        corresponding node has not its own indent attributes and the
 305        position-and-space mode of the list level is SvxNumberFormat::LABEL_ALIGNMENT. */
 306     bool GetParaAttr( SfxItemSet& rSet, sal_Int32 nStt, sal_Int32 nEnd,
 307                   const bool bOnlyTextAttr  = false,
 308                   const bool bGetFromChrFormat = true,
 309                   const bool bMergeIndentValuesOfNumRule = false,
 310                   SwRootFrame const* pLayout = nullptr) const;
 311
 312     /// Convey attributes of an AttrSet (AutoFormat) to SwpHintsArray.
 313     void FormatToTextAttr( SwTextNode* pNd );
 314
 315     /// delete all attributes of type nWhich at nStart (opt. end nEnd)
 316     void DeleteAttributes( const sal_uInt16 nWhich,
 317                   const sal_Int32 nStart, const sal_Int32 nEnd = 0 );
 318     /// delete the attribute pTextAttr
 319     void DeleteAttribute ( SwTextAttr * const pTextAttr );
 320
 321     /** Actions on text and attributes.
 322        introduce optional parameter to control, if all attributes have to be copied. */
 323     void CopyText( SwTextNode * const pDest,
 324                const SwIndex &rStart,
 325                const sal_Int32 nLen,
 326                const bool bForceCopyOfAllAttrs );
 327     void CopyText( SwTextNode * const pDest,
 328                const SwIndex &rDestStart,
 329                const SwIndex &rStart,
 330                sal_Int32 nLen,
 331                const bool bForceCopyOfAllAttrs = false );
 332
 333     void        CutText(SwTextNode * const pDest,
 334                     const SwIndex & rStart, const sal_Int32 nLen);
 335     inline void CutText(SwTextNode * const pDest, const SwIndex &rDestStart,
 336                     const SwIndex & rStart, const sal_Int32 nLen);
 337
 338     /// replace nDelLen characters at rStart with rText
 339     /// in case the replacement does not fit, it is partially inserted up to
 340     /// the capacity of the node
 341     void ReplaceText( const SwIndex& rStart, const sal_Int32 nDelLen,
 342             const OUString & rText );
 343     void ReplaceTextOnly( sal_Int32 nPos, sal_Int32 nLen,
 344             const OUString& rText,
 345             const css::uno::Sequence<sal_Int32>& rOffsets );
 346
 347     /// Virtual methods from ContentNode.
 348     virtual SwContentFrame *MakeFrame( SwFrame* ) override;
 349     SwTextNode * SplitContentNode(const SwPosition &,
 350             std::function<void (SwTextNode *, sw::mark::RestoreMode)> const* pContentIndexRestore);
 351     virtual SwContentNode *JoinNext() override;
 352     void JoinPrev();
 353
 354     SwContentNode *AppendNode( const SwPosition & );
 355
 356     /// When appropriate set DontExpand-flag at INet or character styles respectively.
 357     bool DontExpandFormat( const SwIndex& rIdx, bool bFlag = true,
 358                         bool bFormatToTextAttributes = true );
 359
 360     enum GetTextAttrMode {
 361         DEFAULT,    /// DEFAULT: (Start <= nIndex <  End)
 362         EXPAND,     /// EXPAND : (Start <  nIndex <= End)
 363         PARENT,     /// PARENT : (Start <  nIndex <  End)
 364     };
 365
 366     /** get the innermost text attribute covering position nIndex.
 367         @param nWhich   only attribute with this id is returned.
 368         @param eMode    the predicate for matching (@see GetTextAttrMode).
 369
 370         ATTENTION: this function is not well-defined for those
 371         hints of which several may cover a single position, like
 372         RES_TXTATR_CHARFMT, RES_TXTATR_REFMARK, RES_TXTATR_TOXMARK
 373      */
 374     SwTextAttr *GetTextAttrAt(
 375         sal_Int32 const nIndex,
 376         sal_uInt16 const nWhich,
 377         enum GetTextAttrMode const eMode = DEFAULT ) const;
 378
 379     /** get the innermost text attributes covering position nIndex.
 380         @param nWhich   only attributes with this id are returned.
 381         @param eMode    the predicate for matching (@see GetTextAttrMode).
 382      */
 383     std::vector<SwTextAttr *> GetTextAttrsAt(
 384         sal_Int32 const nIndex,
 385         sal_uInt16 const nWhich ) const;
 386
 387     /** get the text attribute at position nIndex which owns
 388         the dummy character CH_TXTATR_* at that position, if one exists.
 389         @param nIndex   the position in the text
 390         @param nWhich   if different from RES_TXTATR_END, return only
 391                         attribute with given which id
 392         @return the text attribute at nIndex of type nWhich, if it exists
 393     */
 394     SwTextAttr *GetTextAttrForCharAt(
 395         const sal_Int32 nIndex,
 396         const sal_uInt16 nWhich = RES_TXTATR_END ) const;
 397
 398     SwTextField* GetFieldTextAttrAt(
 399         const sal_Int32 nIndex,
 400         const bool bIncludeInputFieldAtStart = false ) const;
 401
 402     bool Spell(SwSpellArgs*);
 403     bool Convert( SwConversionArgs & );
 404
 405     inline SwTextFormatColl *GetTextColl() const;
 406     virtual SwFormatColl *ChgFormatColl( SwFormatColl* ) override;
 407     void ChgTextCollUpdateNum( const SwTextFormatColl* pOld,
 408                                 const SwTextFormatColl* pNew );
 409
 410     /** Copy collection with all auto formats to dest-node.
 411         The latter might be in another document!
 412        (Method in ndcopy.cxx!!). */
 413     void CopyCollFormat( SwTextNode& rDestNd );
 414
 415     // BEGIN OF BULLET/NUMBERING/OUTLINE STUFF:
 416
 417     /**
 418        Returns numbering rule of this text node.
 419
 420        @param bInParent     search in parent attributes, too
 421
 422        @return numbering rule of this text node or NULL if none is set
 423      */
 424     SwNumRule *GetNumRule(bool bInParent = true) const;
 425
 426     const SwNodeNum* GetNum(SwRootFrame const* pLayout = nullptr) const;
 427     void DoNum(std::function<void (SwNodeNum &)> const&);
 428
 429     SwNumberTree::tNumberVector GetNumberVector(SwRootFrame const* pLayout = nullptr) const;
 430
 431     /**
 432        Returns if this text node is an outline.
 433
 434        @retval true      this text node is an outline
 435        @retval false     else
 436      */
 437     bool IsOutline() const;
 438
 439     bool IsOutlineStateChanged() const;
 440
 441     void UpdateOutlineState();
 442
 443     /**
 444        Notify this textnode that its numbering rule has changed.
 445      */
 446     void NumRuleChgd();
 447
 448     /** Returns outline of numbering string
 449
 450         Introduce parameter <_bInclPrefixAndSuffixStrings> in order to control,
 451         if the prefix and the suffix strings have to been included or not.
 452
 453         @param _bInclPrefixAndSuffixStrings
 454         optional input parameter - boolean indicating, if the prefix and the
 455         suffix strings have to been included or not. default value = <true>
 456
 457         @param _nRestrictToThisLevel
 458         optional input parameter - unsigned integer indicating the maximum outline
 459         level to which the output string must be restricted to. Default value is
 460         MAXLEVEL
 461     */
 462     OUString GetNumString( const bool _bInclPrefixAndSuffixStrings = true,
 463             const unsigned int _nRestrictToThisLevel = MAXLEVEL,
 464             SwRootFrame const* pLayout = nullptr) const;
 465
 466     /**
 467        Returns the additional indents of this text node and its numbering.
 468
 469        @param bTextLeft  ???
 470
 471        @return additional indents
 472      */
 473      long GetLeftMarginWithNum( bool bTextLeft = false ) const;
 474
 475     /**
 476        Returns the combined first line indent of this text node and
 477        its numbering.
 478
 479        @param the first line indent of this text node taking the
 480                numbering into account (return parameter)
 481
 482        @retval true   this node has SwNodeNum and has numbering rule
 483        @retval false  else
 484      */
 485     bool GetFirstLineOfsWithNum( short& rFirstOffset ) const;
 486
 487     SwTwips GetAdditionalIndentForStartingNewList() const;
 488
 489     void ClearLRSpaceItemDueToListLevelIndents( std::shared_ptr<SvxLRSpaceItem>& o_rLRSpaceItem ) const;
 490
 491     /** return left margin for tab stop position calculation
 492
 493         Needed for text formatting
 494         Method considers new list level attributes, which also can provide a left margin value
 495     */
 496     long GetLeftMarginForTabCalculation() const;
 497
 498     /** Returns if this text node has a number.
 499
 500         This text node has a number if it has a SwNodeNum and a
 501         numbering rule and the numbering format specified for the
 502         level of the SwNodeNum is of an enumeration type.
 503
 504         @retval true    This text node has a number.
 505         @retval false   else
 506      */
 507     bool HasNumber() const;
 508
 509     /** Returns if this text node has a bullet.
 510
 511         This text node has a bullet if it has a SwNodeNum and a
 512         numbering rule and the numbering format specified for the
 513         level of the SwNodeNum is of a bullet type.
 514
 515         @retval true    This text node has a bullet.
 516         @retval false   else
 517      */
 518     bool HasBullet() const;
 519
 520     /** Returns is this text node is numbered.
 521
 522         This node is numbered if it has a SwNodeNum and it has a
 523         numbering rule and has not a hidden SwNodeNum.
 524
 525         ATTENTION: Returns true even if the SwNumFormat has type
 526         SVX_NUM_NUMBER_NONE.
 527
 528         @retval true      This node is numbered.
 529         @retval false     else
 530      */
 531     bool IsNumbered(SwRootFrame const* pLayout = nullptr) const;
 532
 533     /** Returns if this text node has a marked label.
 534
 535         @retval true       This text node has a marked label.
 536         @retval false      else
 537      */
 538     bool HasMarkedLabel() const;
 539
 540     /** Sets the list level of this text node.
 541
 542         Side effect, when the text node is a list item:
 543         The text node's representation in the list tree (<SwNodeNum> instance)
 544         is updated.
 545
 546         @param nLevel level to set
 547     */
 548     void SetAttrListLevel(int nLevel);
 549
 550     bool HasAttrListLevel() const;
 551
 552     int GetAttrListLevel() const;
 553
 554     /** Returns the actual list level of this text node, when it is a list item
 555
 556         @return the actual list level of this text node, if it is a list item,
 557                -1 otherwise
 558     */
 559     int GetActualListLevel() const;
 560
 561     /**
 562        Returns outline level of this text node.
 563
 564        If a text node has an outline number (i.e. it has an SwNodeNum
 565        and an outline numbering rule) the outline level is the level of
 566        this SwNodeNum.
 567
 568        If a text node has no outline number and has a paragraph style
 569        attached the outline level is the outline level of the
 570        paragraph style.
 571
 572        Otherwise the text node has no outline level (NO_NUMBERING).
 573
 574        NOTE: The outline level of text nodes is subject to change. The
 575        plan is to have an SwTextNode::nOutlineLevel member that is
 576        updated from a paragraph style upon appliance of that paragraph
 577        style.
 578
 579        @return outline level or NO_NUMBERING if there is no outline level
 580      */
 581     int GetAttrOutlineLevel() const;
 582
 583     /**
 584        Sets the out line level *at* a text node.
 585
 586        @param nLevel     the level to be set
 587
 588        If the text node has an outline number the level is set at the
 589        outline number.
 590
 591        If the text node has no outline number but has a paragraph
 592        style applied the outline level is set at the paragraph style.
 593
 594        NOTE: This is subject to change, see GetOutlineLevel.
 595      */
 596     void SetAttrOutlineLevel(int nLevel);
 597
 598     bool IsEmptyListStyleDueToSetOutlineLevelAttr() const { return mbEmptyListStyleSetDueToSetOutlineLevelAttr;}
 599     void SetEmptyListStyleDueToSetOutlineLevelAttr();
 600     void ResetEmptyListStyleDueToResetOutlineLevelAttr();
 601
 602     /**
 603        Returns the width of leading tabs/blanks in this paragraph.
 604        This space will be converted into numbering indent if the paragraph
 605        is set to be numbered.
 606
 607        @return     the width of the leading whitespace
 608      */
 609     SwTwips GetWidthOfLeadingTabs() const;
 610
 611     /**
 612        Returns if the paragraph has a visible numbering or bullet.
 613        This includes all kinds of numbering/bullet/outlines.
 614        Note: This function returns false, if the numbering format is
 615        SVX_NUM_NUMBER_NONE or if the numbering/bullet has been deleted.
 616
 617        @return     true if the paragraph has a visible numbering/bullet/outline
 618      */
 619     bool HasVisibleNumberingOrBullet() const;
 620
 621     void SetListId(OUString const& rListId);
 622     OUString GetListId() const;
 623
 624     /** Determines, if the list level indent attributes can be applied to the
 625         paragraph.
 626
 627         The list level indents can be applied to the paragraph under the one
 628         of following conditions:
 629         - the list style is directly applied to the paragraph and the paragraph
 630           has no own indent attributes.
 631         - the list style is applied to the paragraph through one of its paragraph
 632           styles, the paragraph has no own indent attributes and on the paragraph
 633           style hierarchy from the paragraph to the paragraph style with the
 634           list style no indent attributes are found.
 635
 636         @return boolean
 637     */
 638     bool AreListLevelIndentsApplicable() const;
 639
 640     /** Retrieves the list tab stop position, if the paragraph's list level defines
 641         one and this list tab stop has to merged into the tap stops of the paragraph
 642
 643         @param nListTabStopPosition
 644         output parameter - containing the list tab stop position
 645
 646         @return boolean - indicating, if a list tab stop position is provided
 647     */
 648     bool GetListTabStopPosition( long& nListTabStopPosition ) const;
 649
 650     /** Retrieves the character following the list label, if the paragraph's
 651         list level defines one.
 652
 653         @return the list tab stop position as string
 654     */
 655     OUString GetLabelFollowedBy() const;
 656
 657     // END OF BULLET/NUMBERING/OUTLINE STUFF:
 658
 659     void fillSoftPageBreakList( SwSoftPageBreakList& rBreak ) const;
 660
 661     LanguageType GetLang( const sal_Int32 nBegin, const sal_Int32 nLen = 0,
 662                     sal_uInt16 nScript = 0 ) const;
 663
 664     /// in ndcopy.cxx
 665     bool IsSymbolAt(sal_Int32 nBegin) const; // In itratr.cxx.
 666     virtual SwContentNode* MakeCopy(SwDoc*, const SwNodeIndex&, bool bNewFrames) const override;
 667
 668     /// Interactive hyphenation: we find TextFrame and call its CalcHyph.
 669     bool Hyphenate( SwInterHyphInfo &rHyphInf );
 670     void DelSoftHyph( const sal_Int32 nStart, const sal_Int32 nEnd );
 671
 672     /** add 4th optional parameter <bAddSpaceAfterListLabelStr> indicating,
 673        when <bWithNum = true> that a space is inserted after the string for
 674        the list label.
 675        add 5th optional parameter <bWithSpacesForLevel> indicating, if additional
 676        spaces are inserted in front of the expanded text string depending on
 677        the list level. */
 678     OUString GetExpandText( SwRootFrame const* pLayout,
 679                             const sal_Int32 nIdx = 0,
 680                             const sal_Int32 nLen = -1,
 681                             const bool bWithNum = false,
 682                             const bool bAddSpaceAfterListLabelStr = false,
 683                             const bool bWithSpacesForLevel = false,
 684                             const ExpandMode eAdditionalMode = ExpandMode::ExpandFootnote) const;
 685     bool CopyExpandText( SwTextNode& rDestNd, const SwIndex* pDestIdx,
 686                            sal_Int32 nIdx, sal_Int32 nLen,
 687                            SwRootFrame const* pLayout,
 688                            bool bWithNum = false, bool bWithFootnote = true,
 689                            bool bReplaceTabsWithSpaces = false ) const;
 690
 691     OUString GetRedlineText() const;
 692
 693     /** @return actual count of initial chars for initial-function.
 694        If nWishLen == 0 that of first word. */
 695     sal_Int32 GetDropLen(sal_Int32 nWishLen) const;
 696
 697     /// Passes back info needed on the dropcap dimensions
 698     bool GetDropSize(int& rFontHeight, int& rDropHeight, int& rDropDescent) const;
 699
 700     /// Hidden Paragraph Field:
 701     bool CalcHiddenParaField()
 702         { return m_pSwpHints && m_pSwpHints->CalcHiddenParaField(); }
 703     /// set CalcVisible flags
 704     void SetCalcHiddenParaField()
 705         { if (m_pSwpHints) m_pSwpHints->SetCalcHiddenParaField(); }
 706
 707     /// is the paragraph visible?
 708     bool IsHiddenByParaField() const
 709         { return m_pSwpHints && m_pSwpHints->IsHiddenByParaField(); }
 710
 711     int FieldCanHideParaWeight(SwFieldIds eFieldId) const
 712         {
 713             return GetDoc()->FieldCanHideParaWeight(eFieldId);
 714         }
 715     bool FieldHidesPara(const SwField& rField) const
 716         { return GetDoc()->FieldHidesPara(rField); }
 717
 718     /// Hidden Paragraph Field:
 719
 720     bool HasHiddenCharAttribute( bool bWholePara ) const
 721     {
 722         if ( m_bRecalcHiddenCharFlags )
 723             CalcHiddenCharFlags();
 724         return bWholePara ? m_bHiddenCharsHidePara : m_bContainsHiddenChars;
 725     }
 726
 727     void SetCalcHiddenCharFlags() const
 728         { m_bRecalcHiddenCharFlags = true; }
 729
 730     /** @return if the node is hidden due to
 731        1. HiddenParaField
 732        2. HiddenCharAttribute
 733        3. HiddenSection */
 734
 735     bool IsHidden() const;
 736
 737
 738     /// override SwIndexReg
 739     virtual void Update(
 740         SwIndex const & rPos,
 741         const sal_Int32 nChangeLen,
 742         const bool bNegative = false,
 743         const bool bDelete = false ) override;
 744
 745     /// change text to Upper/Lower/Hiragana/Katakana/...
 746     void TransliterateText( utl::TransliterationWrapper& rTrans,
 747                             sal_Int32 nStart, sal_Int32 nEnd,
 748                             SwUndoTransliterate* pUndo );
 749
 750     /// count words in given range - returns true if we refreshed out count
 751     bool CountWords( SwDocStat& rStat, sal_Int32 nStart, sal_Int32 nEnd ) const;
 752
 753     /** Checks some global conditions like loading or destruction of document
 754        to economize notifications */
 755     bool IsNotificationEnabled() const;
 756
 757     /// Checks a temporary notification blocker and the global conditions of IsNotificationEnabled()
 758     bool IsNotifiable() const;
 759
 760     void SetListRestart( bool bRestart );
 761     bool IsListRestart() const;
 762
 763     void SetAttrListRestartValue( SwNumberTree::tSwNumTreeNumber nNum );
 764     bool HasAttrListRestartValue() const;
 765     SwNumberTree::tSwNumTreeNumber GetAttrListRestartValue() const;
 766     SwNumberTree::tSwNumTreeNumber GetActualListStartValue() const;
 767
 768     void SetCountedInList( bool bCounted );
 769     bool IsCountedInList() const;
 770
 771     void AddToList();
 772     void AddToListRLHidden();
 773     void RemoveFromList();
 774     void RemoveFromListRLHidden();
 775     bool IsInList() const;
 776
 777     bool IsFirstOfNumRule(SwRootFrame const& rLayout) const;
 778
 779     SAL_DLLPRIVATE css::uno::WeakReference<css::text::XTextContent> const& GetXParagraph() const
 780             { return m_wXParagraph; }
 781     SAL_DLLPRIVATE void SetXParagraph(css::uno::Reference<css::text::XTextContent> const& xParagraph)
 782             { m_wXParagraph = xParagraph; }
 783
 784     /// sfx2::Metadatable
 785     virtual ::sfx2::IXmlIdRegistry& GetRegistry() override;
 786     virtual bool IsInClipboard() const override;
 787     virtual bool IsInUndo() const override;
 788     virtual bool IsInContent() const override;
 789     virtual css::uno::Reference< css::rdf::XMetadatable > MakeUnoObject() override;
 790
 791     bool IsCollapse() const;
 792
 793     virtual void dumpAsXml(xmlTextWriterPtr pWriter) const override;
 794
 795     sal_uInt32 GetRsid( sal_Int32 nStt, sal_Int32 nEnd ) const;
 796     sal_uInt32 GetParRsid() const;
 797
 798     bool CompareRsid( const SwTextNode &rTextNode, sal_Int32 nStt1, sal_Int32 nStt2 ) const;
 799     bool CompareParRsid( const SwTextNode &rTextNode ) const;
 800
 801     // Access to DrawingLayer FillAttributes in a preprocessed form for primitive usage
 802     virtual drawinglayer::attribute::SdrAllFillAttributesHelperPtr getSdrAllFillAttributesHelper() const override;
 803
 804     /// In MS Word, the font underline setting of the paragraph end position won't affect the formatting of numbering, so we ignore it
 805     static bool IsIgnoredCharFormatForNumbering(const sal_uInt16 nWhich);
 806 };
 807
 808 inline SwpHints & SwTextNode::GetSwpHints()
 809 {
 810     assert( m_pSwpHints );
 811     return *m_pSwpHints;
 812 }
 813 inline const SwpHints &SwTextNode::GetSwpHints() const
 814 {
 815     assert( m_pSwpHints );
 816     return *m_pSwpHints;
 817 }
 818
 819 inline SwpHints& SwTextNode::GetOrCreateSwpHints()
 820 {
 821     if ( !m_pSwpHints )
 822     {
 823         m_pSwpHints.reset(new SwpHints(*this));
 824     }
 825     return *m_pSwpHints;
 826 }
 827
 828 inline void SwTextNode::TryDeleteSwpHints()
 829 {
 830     if ( m_pSwpHints && m_pSwpHints->CanBeDeleted() )
 831     {
 832         m_pSwpHints.reset();
 833     }
 834 }
 835
 836 inline SwTextFormatColl* SwTextNode::GetTextColl() const
 837 {
 838     return static_cast<SwTextFormatColl*>(const_cast<SwModify*>(GetRegisteredIn()));
 839 }
 840
 841 /// Inline methods from Node.hxx
 842 inline SwTextNode *SwNode::GetTextNode()
 843 {
 844      return SwNodeType::Text == m_nNodeType ? static_cast<SwTextNode*>(this) : nullptr;
 845 }
 846
 847 inline const SwTextNode *SwNode::GetTextNode() const
 848 {
 849      return SwNodeType::Text == m_nNodeType ? static_cast<const SwTextNode*>(this) : nullptr;
 850 }
 851
 852 inline void
 853 SwTextNode::CutText(SwTextNode * const pDest, const SwIndex & rDestStart,
 854                     const SwIndex & rStart, const sal_Int32 nLen)
 855 {
 856     CutImpl( pDest, rDestStart, rStart, nLen );
 857 }
 858
 859 inline sal_Int32 SwTextNode::GetSpaceLeft() const
 860 {
 861     // do not fill the String up to the max - need to be able to have a
 862     // SwPosition "behind" the last character, i.e., at index TXTNODE_MAX + 1
 863     const sal_Int32 TXTNODE_MAX = SAL_MAX_INT32 - 2;
 864     return TXTNODE_MAX-m_Text.getLength();
 865 }
 866
 867 #endif
 868
 869 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */