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