LibreOffice Module sw (master)  1
unovwr.cxx
Go to the documentation of this file.
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 #include <UndoOverwrite.hxx>
21 #include <unotools/charclass.hxx>
24 #include <doc.hxx>
25 #include <IDocumentUndoRedo.hxx>
27 #include <IShellCursorSupplier.hxx>
28 #include <swundo.hxx>
29 #include <pam.hxx>
30 #include <ndtxt.hxx>
31 #include <UndoCore.hxx>
32 #include <rolbck.hxx>
33 #include <acorrect.hxx>
34 #include <docary.hxx>
35 #include <strings.hrc>
36 
37 using namespace ::com::sun::star;
38 using namespace ::com::sun::star::i18n;
39 using namespace ::com::sun::star::uno;
40 
42  sal_Unicode cIns )
43  : SwUndo(SwUndoId::OVERWRITE, pDoc),
44  bGroup( false )
45 {
46  SwTextNode *const pTextNd = rPos.nNode.GetNode().GetTextNode();
47  assert(pTextNd);
48  sal_Int32 const nTextNdLen = pTextNd->GetText().getLength();
49 
50  nSttNode = rPos.nNode.GetIndex();
51  nSttContent = rPos.nContent.GetIndex();
52 
54  {
55  SwPaM aPam( rPos.nNode, rPos.nContent.GetIndex(),
56  rPos.nNode, rPos.nContent.GetIndex()+1 );
57  pRedlSaveData.reset( new SwRedlineSaveDatas );
58  if( !FillSaveData( aPam, *pRedlSaveData, false ))
59  {
60  pRedlSaveData.reset();
61  }
62  if (nSttContent < nTextNdLen)
63  {
65  }
66  }
67 
68  bInsChar = true;
69  if( nSttContent < nTextNdLen ) // no pure insert?
70  {
71  aDelStr += OUStringLiteral1( pTextNd->GetText()[nSttContent] );
72  if( !pHistory )
73  pHistory.reset( new SwHistory );
74  SwRegHistory aRHst( *pTextNd, pHistory.get() );
75  pHistory->CopyAttr( pTextNd->GetpSwpHints(), nSttNode, 0,
76  nTextNdLen, false );
77  ++rPos.nContent;
78  bInsChar = false;
79  }
80 
81  bool bOldExpFlg = pTextNd->IsIgnoreDontExpand();
82  pTextNd->SetIgnoreDontExpand( true );
83 
84  pTextNd->InsertText( OUString(cIns), rPos.nContent,
86  aInsStr += OUStringLiteral1( cIns );
87 
88  if( !bInsChar )
89  {
90  const SwIndex aTmpIndex( rPos.nContent, -2 );
91  pTextNd->EraseText( aTmpIndex, 1 );
92  }
93  pTextNd->SetIgnoreDontExpand( bOldExpFlg );
94 
95  bCacheComment = false;
96 }
97 
99 {
100 }
101 
103  sal_Unicode cIns )
104 {
105 // What is with only inserted characters?
106 
107  // Only deletion of single chars can be combined.
108  if( rPos.nNode != nSttNode || aInsStr.isEmpty() ||
109  ( !bGroup && aInsStr.getLength() != 1 ))
110  return false;
111 
112  // Is the node a TextNode at all?
113  SwTextNode * pDelTextNd = rPos.nNode.GetNode().GetTextNode();
114  if( !pDelTextNd ||
115  (pDelTextNd->GetText().getLength() != rPos.nContent.GetIndex() &&
116  rPos.nContent.GetIndex() != ( nSttContent + aInsStr.getLength() )))
117  return false;
118 
119  CharClass& rCC = GetAppCharClass();
120 
121  // ask the char that should be inserted
122  if (( CH_TXTATR_BREAKWORD == cIns || CH_TXTATR_INWORD == cIns ) ||
123  rCC.isLetterNumeric( OUString( cIns ), 0 ) !=
124  rCC.isLetterNumeric( aInsStr, aInsStr.getLength()-1 ) )
125  return false;
126 
127  if (!bInsChar && rPos.nContent.GetIndex() < pDelTextNd->GetText().getLength())
128  {
129  SwRedlineSaveDatas aTmpSav;
130  SwPaM aPam( rPos.nNode, rPos.nContent.GetIndex(),
131  rPos.nNode, rPos.nContent.GetIndex()+1 );
132 
133  const bool bSaved = FillSaveData( aPam, aTmpSav, false );
134 
135  bool bOk = ( !pRedlSaveData && !bSaved ) ||
136  ( pRedlSaveData && bSaved &&
138  nSttContent > rPos.nContent.GetIndex() ));
139  // aTmpSav.DeleteAndDestroyAll();
140  if( !bOk )
141  return false;
142 
143  pDoc->getIDocumentRedlineAccess().DeleteRedline( aPam, false, USHRT_MAX );
144  }
145 
146  // both 'overwrites' can be combined so 'move' the corresponding character
147  if( !bInsChar )
148  {
149  if (rPos.nContent.GetIndex() < pDelTextNd->GetText().getLength())
150  {
151  aDelStr += OUStringLiteral1( pDelTextNd->GetText()[rPos.nContent.GetIndex()] );
152  ++rPos.nContent;
153  }
154  else
155  bInsChar = true;
156  }
157 
158  bool bOldExpFlg = pDelTextNd->IsIgnoreDontExpand();
159  pDelTextNd->SetIgnoreDontExpand( true );
160 
161  OUString const ins( pDelTextNd->InsertText(OUString(cIns), rPos.nContent,
163  assert(ins.getLength() == 1); // check in SwDoc::Overwrite => cannot fail
164  (void) ins;
165  aInsStr += OUStringLiteral1( cIns );
166 
167  if( !bInsChar )
168  {
169  const SwIndex aTmpIndex( rPos.nContent, -2 );
170  pDelTextNd->EraseText( aTmpIndex, 1 );
171  }
172  pDelTextNd->SetIgnoreDontExpand( bOldExpFlg );
173 
174  bGroup = true;
175  return true;
176 }
177 
179 {
180  SwDoc *const pDoc = & rContext.GetDoc();
181  SwPaM *const pCurrentPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
182 
183  pCurrentPam->DeleteMark();
184  pCurrentPam->GetPoint()->nNode = nSttNode;
185  SwTextNode* pTextNd = pCurrentPam->GetNode().GetTextNode();
186  assert(pTextNd);
187  SwIndex& rIdx = pCurrentPam->GetPoint()->nContent;
188  rIdx.Assign( pTextNd, nSttContent );
189 
190  SwAutoCorrExceptWord* pACEWord = pDoc->GetAutoCorrExceptWord();
191  if( pACEWord )
192  {
193  if( 1 == aInsStr.getLength() && 1 == aDelStr.getLength() )
194  pACEWord->CheckChar( *pCurrentPam->GetPoint(), aDelStr[0] );
195  pDoc->SetAutoCorrExceptWord( nullptr );
196  }
197 
198  // If there was not only a overwrite but also an insert, delete the surplus
199  if( aInsStr.getLength() > aDelStr.getLength() )
200  {
201  rIdx += aDelStr.getLength();
202  pTextNd->EraseText( rIdx, aInsStr.getLength() - aDelStr.getLength() );
203  rIdx = nSttContent;
204  }
205 
206  if( !aDelStr.isEmpty() )
207  {
208  bool bOldExpFlg = pTextNd->IsIgnoreDontExpand();
209  pTextNd->SetIgnoreDontExpand( true );
210 
211  ++rIdx;
212  for( sal_Int32 n = 0; n < aDelStr.getLength(); n++ )
213  {
214  // do it individually, to keep the attributes!
215  OUString aTmpStr(aDelStr[n]);
216  OUString const ins( pTextNd->InsertText(aTmpStr, rIdx) );
217  assert(ins.getLength() == 1); // cannot fail
218  (void) ins;
219  rIdx -= 2;
220  pTextNd->EraseText( rIdx, 1 );
221  rIdx += 2;
222  }
223  pTextNd->SetIgnoreDontExpand( bOldExpFlg );
224  --rIdx;
225  }
226 
227  if( pHistory )
228  {
229  if( pTextNd->GetpSwpHints() )
230  pTextNd->ClearSwpHintsArr( false );
231  pHistory->TmpRollback( pDoc, 0, false );
232  }
233 
234  if( pCurrentPam->GetMark()->nContent.GetIndex() != nSttContent )
235  {
236  pCurrentPam->SetMark();
237  pCurrentPam->GetMark()->nContent = nSttContent;
238  }
239 
240  if( pRedlSaveData )
241  SetSaveData( *pDoc, *pRedlSaveData );
242 }
243 
245 {
246  SwPaM *const pCurrentPam = & rContext.GetRepeatPaM();
247  if( aInsStr.isEmpty() || pCurrentPam->HasMark() )
248  return;
249 
250  SwDoc & rDoc = rContext.GetDoc();
251 
252  {
253  ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
254  rDoc.getIDocumentContentOperations().Overwrite(*pCurrentPam, OUString(aInsStr[0]));
255  }
256  for( sal_Int32 n = 1; n < aInsStr.getLength(); ++n )
257  rDoc.getIDocumentContentOperations().Overwrite( *pCurrentPam, OUString(aInsStr[n]) );
258 }
259 
261 {
262  SwDoc *const pDoc = & rContext.GetDoc();
263  SwPaM *const pCurrentPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
264 
265  pCurrentPam->DeleteMark();
266  pCurrentPam->GetPoint()->nNode = nSttNode;
267  SwTextNode* pTextNd = pCurrentPam->GetNode().GetTextNode();
268  assert(pTextNd);
269  SwIndex& rIdx = pCurrentPam->GetPoint()->nContent;
270 
271  if( pRedlSaveData )
272  {
273  rIdx.Assign( pTextNd, nSttContent );
274  pCurrentPam->SetMark();
275  pCurrentPam->GetMark()->nContent += aDelStr.getLength();
276  pDoc->getIDocumentRedlineAccess().DeleteRedline( *pCurrentPam, false, USHRT_MAX );
277  pCurrentPam->DeleteMark();
278  }
279  rIdx.Assign( pTextNd, !aDelStr.isEmpty() ? nSttContent+1 : nSttContent );
280 
281  bool bOldExpFlg = pTextNd->IsIgnoreDontExpand();
282  pTextNd->SetIgnoreDontExpand( true );
283 
284  for( sal_Int32 n = 0; n < aInsStr.getLength(); n++ )
285  {
286  // do it individually, to keep the attributes!
287  OUString const ins(
288  pTextNd->InsertText( OUString(aInsStr[n]), rIdx,
290  assert(ins.getLength() == 1); // cannot fail
291  (void) ins;
292  if( n < aDelStr.getLength() )
293  {
294  rIdx -= 2;
295  pTextNd->EraseText( rIdx, 1 );
296  rIdx += n+1 < aDelStr.getLength() ? 2 : 1;
297  }
298  }
299  pTextNd->SetIgnoreDontExpand( bOldExpFlg );
300 
301  // get back old start position from UndoNodes array
302  if( pHistory )
303  pHistory->SetTmpEnd( pHistory->Count() );
304  if( pCurrentPam->GetMark()->nContent.GetIndex() != nSttContent )
305  {
306  pCurrentPam->SetMark();
307  pCurrentPam->GetMark()->nContent = nSttContent;
308  }
309 }
310 
312 {
313  SwRewriter aResult;
314 
315  OUString aString;
316 
317  aString += SwResId(STR_START_QUOTE);
319  SwResId(STR_LDOTS));
320  aString += SwResId(STR_END_QUOTE);
321 
322  aResult.AddRule(UndoArg1, aString);
323 
324  return aResult;
325 }
326 
328 {
329  OUString const sText;
330  std::unique_ptr<SwHistory> pHistory;
331  std::unique_ptr<Sequence< sal_Int32 >> pOffsets;
333  sal_Int32 nStart, nLen;
334 
335  UndoTransliterate_Data( sal_uLong nNd, sal_Int32 nStt, sal_Int32 nStrLen, const OUString& rText )
336  : sText( rText ),
337  nNdIdx( nNd ), nStart( nStt ), nLen( nStrLen )
338  {}
339 
340  void SetChangeAtNode( SwDoc& rDoc );
341 };
342 
344  const SwPaM& rPam,
345  const utl::TransliterationWrapper& rTrans )
346  : SwUndo( SwUndoId::TRANSLITERATE, rPam.GetDoc() ), SwUndRng( rPam ), nType( rTrans.getType() )
347 {
348 }
349 
351 {
352 }
353 
355 {
356  SwDoc & rDoc = rContext.GetDoc();
357 
358  // since the changes were added to the vector from the end of the string/node towards
359  // the start, we need to revert them from the start towards the end now to keep the
360  // offset information of the undo data in sync with the changing text.
361  // Thus we need to iterate from the end of the vector to the start
362  for (sal_Int32 i = aChanges.size() - 1; i >= 0; --i)
363  aChanges[i]->SetChangeAtNode( rDoc );
364 
365  AddUndoRedoPaM(rContext, true);
366 }
367 
369 {
370  SwPaM & rPam( AddUndoRedoPaM(rContext) );
371  DoTransliterate(rContext.GetDoc(), rPam);
372 }
373 
375 {
376  DoTransliterate(rContext.GetDoc(), rContext.GetRepeatPaM());
377 }
378 
380 {
382  rDoc.getIDocumentContentOperations().TransliterateText( rPam, aTrans );
383 }
384 
386  sal_Int32 nStart, sal_Int32 nLen,
387  uno::Sequence <sal_Int32> const & rOffsets )
388 {
389  long nOffsLen = rOffsets.getLength();
391  rTNd.GetIndex(), nStart, static_cast<sal_Int32>(nOffsLen),
392  rTNd.GetText().copy(nStart, nLen));
393 
394  aChanges.push_back( std::unique_ptr<UndoTransliterate_Data>(pNew) );
395 
396  const sal_Int32* pOffsets = rOffsets.getConstArray();
397  // where did we need less memory ?
398  const sal_Int32* p = pOffsets;
399  for( long n = 0; n < nOffsLen; ++n, ++p )
400  if( *p != ( nStart + n ))
401  {
402  // create the Offset array
403  pNew->pOffsets.reset( new Sequence <sal_Int32> ( nLen ) );
404  sal_Int32* pIdx = pNew->pOffsets->getArray();
405  p = pOffsets;
406  long nMyOff, nNewVal = nStart;
407  for( n = 0, nMyOff = nStart; n < nOffsLen; ++p, ++n, ++nMyOff )
408  {
409  if( *p < nMyOff )
410  {
411  // something is deleted
412  nMyOff = *p;
413  *(pIdx-1) = nNewVal++;
414  }
415  else if( *p > nMyOff )
416  {
417  for( ; *p > nMyOff; ++nMyOff )
418  *pIdx++ = nNewVal;
419  --nMyOff;
420  --n;
421  --p;
422  }
423  else
424  *pIdx++ = nNewVal++;
425  }
426 
427  // and then we need to save the attributes/bookmarks
428  // but this data must moved every time to the last in the chain!
429  for (size_t i = 0; i + 1 < aChanges.size(); ++i) // check all changes but not the current one
430  {
431  UndoTransliterate_Data* pD = aChanges[i].get();
432  if( pD->nNdIdx == pNew->nNdIdx && pD->pHistory )
433  {
434  // same node and have a history?
435  pNew->pHistory = std::move(pD->pHistory);
436  break; // more can't exist
437  }
438  }
439 
440  if( !pNew->pHistory )
441  {
442  pNew->pHistory.reset( new SwHistory );
443  SwRegHistory aRHst( rTNd, pNew->pHistory.get() );
444  pNew->pHistory->CopyAttr( rTNd.GetpSwpHints(),
445  pNew->nNdIdx, 0, rTNd.GetText().getLength(), false );
446  }
447  break;
448  }
449 }
450 
452 {
453  SwTextNode* pTNd = rDoc.GetNodes()[ nNdIdx ]->GetTextNode();
454  if( pTNd )
455  {
456  Sequence <sal_Int32> aOffsets( pOffsets ? pOffsets->getLength() : nLen );
457  if( pOffsets )
458  aOffsets = *pOffsets;
459  else
460  {
461  sal_Int32* p = aOffsets.getArray();
462  for( sal_Int32 n = 0; n < nLen; ++n, ++p )
463  *p = n + nStart;
464  }
465  pTNd->ReplaceTextOnly( nStart, nLen, sText, aOffsets );
466 
467  if( pHistory )
468  {
469  if( pTNd->GetpSwpHints() )
470  pTNd->ClearSwpHintsArr( false );
471  pHistory->TmpRollback( &rDoc, 0, false );
472  pHistory->SetTmpEnd( pHistory->Count() );
473  }
474  }
475 }
476 
477 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
void SetChangeAtNode(SwDoc &rDoc)
Definition: unovwr.cxx:451
SwPaM & AddUndoRedoPaM(::sw::UndoRedoContext &, bool const bCorrToContent=false) const
Definition: undobj.cxx:106
void DeleteMark()
Definition: pam.hxx:177
sal_uLong GetIndex() const
Definition: node.hxx:282
SwAutoCorrExceptWord * GetAutoCorrExceptWord()
Definition: doc.hxx:1380
SwUndoOverwrite(SwDoc *, SwPosition &, sal_Unicode cIns)
Definition: unovwr.cxx:41
std::unique_ptr< SwHistory > pHistory
Definition: undobj.hxx:154
Marks a position in the document model.
Definition: pam.hxx:35
virtual ~SwUndoOverwrite() override
Definition: unovwr.cxx:98
const OUString & GetText() const
Definition: ndtxt.hxx:211
bool getType(BSTR name, Type &type)
SwUndoId
Definition: swundo.hxx:29
SwpHints * GetpSwpHints()
Definition: ndtxt.hxx:219
virtual SwPaM & CreateNewShellCursor()=0
OVERWRITE
SwNodeIndex nNode
Definition: pam.hxx:37
SwUndoTransliterate(const SwPaM &rPam, const utl::TransliterationWrapper &rTrans)
Definition: unovwr.cxx:343
sal_uIntPtr sal_uLong
SwPaM & GetRepeatPaM()
Definition: UndoCore.hxx:128
Definition: doc.hxx:185
bool bCacheComment
Definition: undobj.hxx:59
SwNode & GetNode() const
Definition: ndindex.hxx:118
IDocumentUndoRedo & GetIDocumentUndoRedo()
Definition: doc.cxx:176
virtual bool DeleteRedline(const SwPaM &rPam, bool bSaveInUndo, sal_uInt16 nDelType)=0
IDocumentContentOperations const & getIDocumentContentOperations() const
Definition: doc.cxx:347
virtual void TransliterateText(const SwPaM &rPaM, utl::TransliterationWrapper &)=0
change text to Upper/Lower/Hiragana/Katakana/...
void DoTransliterate(SwDoc &rDoc, SwPaM const &rPam)
Definition: unovwr.cxx:379
IShellCursorSupplier & GetCursorSupplier()
Definition: UndoCore.hxx:96
#define CH_TXTATR_BREAKWORD
Definition: hintids.hxx:43
bool isLetterNumeric(const OUString &rStr, sal_Int32 nPos) const
sal_uInt16 sal_Unicode
#define CH_TXTATR_INWORD
Definition: hintids.hxx:44
FUNC_TYPE const nType
virtual void RepeatImpl(::sw::RepeatContext &) override
Definition: unovwr.cxx:374
SwIndex nContent
Definition: pam.hxx:38
bool empty() const
Definition: docary.hxx:369
TransliterationFlags const nType
SwDoc & GetDoc() const
Definition: UndoCore.hxx:126
sal_uLong GetIndex() const
Definition: ndindex.hxx:151
virtual void RedoImpl(::sw::UndoRedoContext &) override
Definition: unovwr.cxx:260
static bool CanRedlineGroup(SwRedlineSaveDatas &rCurr, const SwRedlineSaveDatas &rCheck, bool bCurrIsEnd)
Definition: undobj.cxx:1473
SwDoc & GetDoc() const
Definition: UndoCore.hxx:94
virtual SwRewriter GetRewriter() const override
Returns the rewriter of this undo object.
Definition: unovwr.cxx:311
std::vector< std::unique_ptr< UndoTransliterate_Data > > aChanges
virtual void RepeatImpl(::sw::RepeatContext &) override
Definition: unovwr.cxx:244
std::unique_ptr< Sequence< sal_Int32 > > pOffsets
Definition: unovwr.cxx:331
virtual void UndoImpl(::sw::UndoRedoContext &) override
Definition: unovwr.cxx:178
void SetIgnoreDontExpand(bool bNew)
Definition: node.hxx:142
PaM is Point and Mark: a selection of the document model.
Definition: pam.hxx:136
virtual bool Overwrite(const SwPaM &rRg, const OUString &rStr)=0
Overwrite string in an existing text node.
sal_Int32 nSttContent
std::unique_ptr< SwRedlineSaveDatas > pRedlSaveData
SwIndex & Assign(SwIndexReg *, sal_Int32)
Definition: index.cxx:198
static void SetSaveData(SwDoc &rDoc, SwRedlineSaveDatas &rSData)
Definition: undobj.cxx:1446
int i
bool HasMark() const
A PaM marks a selection if Point and Mark are distinct positions.
Definition: pam.hxx:205
std::unique_ptr< SwHistory > pHistory
Definition: unovwr.cxx:330
Marks a character position inside a document model node.
Definition: index.hxx:37
void AddRule(SwUndoArg eWhat, const OUString &rWith)
Definition: SwRewriter.cxx:29
bool IsIgnoreDontExpand() const
Definition: node.hxx:141
OUString SwResId(const char *pId)
Definition: swmodule.cxx:191
void CheckChar(const SwPosition &rPos, sal_Unicode cChar)
Definition: acorrect.cxx:527
virtual ~SwUndoTransliterate() override
Definition: unovwr.cxx:350
void SetMark(const sw::mark::IMark *pMark)
Definition: index.cxx:214
virtual bool IsIgnoreRedline() const =0
OUString const sText
Definition: unovwr.cxx:329
void ReplaceTextOnly(sal_Int32 nPos, sal_Int32 nLen, const OUString &rText, const css::uno::Sequence< sal_Int32 > &rOffsets)
Definition: txtedt.cxx:1930
void EraseText(const SwIndex &rIdx, const sal_Int32 nCount=SAL_MAX_INT32, const SwInsertFlags nMode=SwInsertFlags::DEFAULT)
delete text content ATTENTION: must not be called with a range that overlaps the start of an attribut...
Definition: ndtxt.cxx:2669
virtual void RedoImpl(::sw::UndoRedoContext &) override
Definition: unovwr.cxx:368
OUString InsertText(const OUString &rStr, const SwIndex &rIdx, const SwInsertFlags nMode=SwInsertFlags::DEFAULT)
insert text content
Definition: ndtxt.cxx:2285
bool CanGrouping(SwDoc *, SwPosition &, sal_Unicode cIns)
Definition: unovwr.cxx:102
void SetAutoCorrExceptWord(std::unique_ptr< SwAutoCorrExceptWord > pNew)
Definition: docedt.cxx:810
void ClearSwpHintsArr(bool bDelFields)
Definition: thints.cxx:3324
SwTextNode is a paragraph in the document model.
Definition: ndtxt.hxx:79
sal_uLong nSttNode
IDocumentRedlineAccess const & getIDocumentRedlineAccess() const
Definition: doc.cxx:367
virtual void UndoImpl(::sw::UndoRedoContext &) override
Definition: unovwr.cxx:354
OUString ShortenString(const OUString &rStr, sal_Int32 nLength, const OUString &rFillStr)
Shortens a string to a maximum length.
Definition: undobj.cxx:1505
const o3tl::enumarray< SvxAdjust, unsigned short > aSvxToUnoAdjust USHRT_MAX
Definition: unosett.cxx:259
sal_Int32 GetIndex() const
Definition: index.hxx:95
SwNodes & GetNodes()
Definition: doc.hxx:403
Reference< XComponentContext > getProcessComponentContext()
UndoTransliterate_Data(sal_uLong nNd, sal_Int32 nStt, sal_Int32 nStrLen, const OUString &rText)
Definition: unovwr.cxx:335
static bool FillSaveData(const SwPaM &rRange, SwRedlineSaveDatas &rSData, bool bDelRange=true, bool bCopyNext=true)
Definition: undobj.cxx:1381
virtual const SwRedlineTable & GetRedlineTable() const =0
CharClass & GetAppCharClass()
Definition: init.cxx:740
const int nUndoStringLength
Definition: UndoCore.hxx:225
SwTextNode * GetTextNode()
Inline methods from Node.hxx.
Definition: ndtxt.hxx:842
void AddChanges(SwTextNode &rTNd, sal_Int32 nStart, sal_Int32 nLen, css::uno::Sequence< sal_Int32 > const &rOffsets)
Definition: unovwr.cxx:385
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo