sw/source/core/inc/UndoInsert.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 #ifndef INCLUDED_SW_SOURCE_CORE_INC_UNDOINSERT_HXX
  21 #define INCLUDED_SW_SOURCE_CORE_INC_UNDOINSERT_HXX
  22
  23 #include <memory>
  24
  25 #include <undobj.hxx>
  26 #include <svx/svdtypes.hxx>
  27 #include <rtl/ustring.hxx>
  28 #include <swtypes.hxx>
  29 #include <IDocumentContentOperations.hxx>
  30 #include <optional>
  31
  32 class Graphic;
  33 class SwGrfNode;
  34 class SwUndoDelete;
  35 class SwUndoFormatAttr;
  36 class SwDoc;
  37 namespace sw { class DocumentContentOperationsManager; }
  38 enum class MirrorGraph;
  39
  40 class SwUndoInsert: public SwUndo, private SwUndoSaveContent
  41 {
  42     /// start of Content in UndoNodes for Redo
  43     std::unique_ptr<SwNodeIndex> m_pUndoNodeIndex;
  44     std::optional<OUString> maText;
  45     std::optional<OUString> maUndoText;
  46     std::unique_ptr<SwRedlineData> m_pRedlData;
  47     sal_uLong m_nNode;
  48     sal_Int32 m_nContent, m_nLen;
  49     bool m_bIsWordDelim : 1;
  50     bool m_bIsAppend : 1;
  51     bool m_bWithRsid : 1;
  52
  53     const SwInsertFlags m_nInsertFlags;
  54
  55     friend class ::sw::DocumentContentOperationsManager;     // actually only DocumentContentOperationsManager::InsertString, because it uses CanGrouping
  56     bool CanGrouping( sal_Unicode cIns );
  57     bool CanGrouping( const SwPosition& rPos );
  58
  59     SwDoc * m_pDoc;
  60
  61     void Init(const SwNodeIndex & rNode);
  62     std::optional<OUString> GetTextFromDoc() const;
  63
  64 public:
  65     SwUndoInsert( const SwNodeIndex& rNode, sal_Int32 nContent, sal_Int32 nLen,
  66                   const SwInsertFlags nInsertFlags,
  67                   bool bWDelim = true );
  68     SwUndoInsert( const SwNodeIndex& rNode );
  69     virtual ~SwUndoInsert() override;
  70
  71     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
  72     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
  73     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
  74
  75     /**
  76        Returns rewriter for this undo object.
  77
  78        The returned rewriter has the following rule:
  79
  80            $1 -> '<inserted text>'
  81
  82        <inserted text> is shortened to a length of nUndoStringLength.
  83
  84        @return rewriter for this undo object
  85      */
  86     virtual SwRewriter GetRewriter() const override;
  87
  88     void SetWithRsid() { m_bWithRsid = true; }
  89 };
  90
  91 SwRewriter
  92 MakeUndoReplaceRewriter(sal_uLong const occurrences,
  93     OUString const& sOld, OUString const& sNew);
  94
  95 class SwUndoReplace
  96     : public SwUndo
  97 {
  98 public:
  99     SwUndoReplace(SwPaM const& rPam,
 100             OUString const& rInsert, bool const bRegExp);
 101
 102     virtual ~SwUndoReplace() override;
 103
 104     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 105     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 106
 107     /**
 108        Returns the rewriter of this undo object.
 109
 110        If this undo object represents several replacements the
 111        rewriter contains the following rules:
 112
 113            $1 -> <number of replacements>
 114            $2 -> occurrences of
 115            $3 -> <replaced text>
 116
 117        If this undo object represents one replacement the rewriter
 118        contains these rules:
 119
 120            $1 -> <replaced text>
 121            $2 -> "->"                   (STR_YIELDS)
 122            $3 -> <replacing text>
 123
 124        @return the rewriter of this undo object
 125     */
 126     virtual SwRewriter GetRewriter() const override;
 127
 128     void SetEnd( const SwPaM& rPam );
 129
 130 private:
 131     class Impl;
 132     std::unique_ptr<Impl> m_pImpl;
 133 };
 134
 135 class SwUndoReRead : public SwUndo
 136 {
 137     std::unique_ptr<Graphic> mpGraphic;
 138     std::optional<OUString> maNm;
 139     std::optional<OUString> maFltr;
 140     sal_uLong mnPosition;
 141     MirrorGraph mnMirror;
 142
 143     void SaveGraphicData( const SwGrfNode& );
 144     void SetAndSave( ::sw::UndoRedoContext & );
 145
 146 public:
 147     SwUndoReRead( const SwPaM& rPam, const SwGrfNode& pGrfNd );
 148
 149     virtual ~SwUndoReRead() override;
 150
 151     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 152     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 153 };
 154
 155 class SwUndoInsertLabel : public SwUndo
 156 {
 157     union {
 158         struct {
 159             // for NoTextFrames
 160             SwUndoInsLayFormat* pUndoFly;
 161             SwUndoFormatAttr* pUndoAttr;
 162         } OBJECT;
 163         struct {
 164             // for tables or TextFrames
 165             SwUndoDelete* pUndoInsNd;
 166             sal_uLong nNode;
 167         } NODE;
 168     };
 169
 170     OUString m_sText;
 171     // #i39983# the separator is drawn with a character style
 172     OUString m_sSeparator;
 173     OUString m_sNumberSeparator;
 174     OUString m_sCharacterStyle;
 175     // #i26791# - re-store of drawing object position no longer needed
 176     sal_uInt16 m_nFieldId;
 177     SwLabelType m_eType;
 178     SdrLayerID m_nLayerId;              // for character objects
 179     bool m_bBefore        :1;
 180     bool m_bUndoKeep      :1;
 181     bool m_bCopyBorder        :1;
 182
 183 public:
 184     SwUndoInsertLabel( const SwLabelType eTyp, const OUString &rText,
 185     // #i39983# the separator is drawn with a character style
 186                         const OUString& rSeparator,
 187                         const OUString& rNumberSeparator, //#i61007# order of captions
 188                         const bool bBefore, const sal_uInt16 nId,
 189                         const OUString& rCharacterStyle,
 190                         const bool bCpyBrd,
 191                         const SwDoc* pDoc );
 192     virtual ~SwUndoInsertLabel() override;
 193
 194     virtual void UndoImpl( ::sw::UndoRedoContext & ) override;
 195     virtual void RedoImpl( ::sw::UndoRedoContext & ) override;
 196     virtual void RepeatImpl( ::sw::RepeatContext & ) override;
 197
 198     /**
 199        Returns the rewriter of this undo object.
 200
 201        The rewriter contains this rule:
 202
 203            $1 -> '<text of inserted label>'
 204
 205        <text of inserted label> is shortened to nUndoStringLength
 206        characters.
 207
 208        @return the rewriter of this undo object
 209      */
 210     virtual SwRewriter GetRewriter() const override;
 211     static SwRewriter CreateRewriter(const OUString &rStr);
 212
 213     void SetNodePos( sal_uLong nNd )
 214         { if( SwLabelType::Object != m_eType ) NODE.nNode = nNd; }
 215
 216     void SetUndoKeep()  { m_bUndoKeep = true; }
 217     void SetFlys( SwFrameFormat& rOldFly, SfxItemSet const & rChgSet, SwFrameFormat& rNewFly );
 218     void SetDrawObj( SdrLayerID nLayerId );
 219 };
 220
 221 #endif // INCLUDED_SW_SOURCE_CORE_INC_UNDOINSERT_HXX
 222
 223 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */