xref: /aoo4110/main/sw/source/core/undo/unovwr.cxx (revision b1cdbd2c)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 #include <UndoOverwrite.hxx>
28 
29 #include <tools/resid.hxx>
30 
31 #include <unotools/charclass.hxx>
32 #include <unotools/transliterationwrapper.hxx>
33 
34 #include <comphelper/processfactory.hxx>
35 
36 #include <doc.hxx>
37 #include <IDocumentUndoRedo.hxx>
38 #include <IShellCursorSupplier.hxx>
39 #include <swundo.hxx>			// fuer die UndoIds
40 #include <pam.hxx>
41 #include <ndtxt.hxx>
42 #include <UndoCore.hxx>
43 #include <rolbck.hxx>
44 #include <acorrect.hxx>
45 #include <docary.hxx>
46 
47 #include <comcore.hrc> // #111827#
48 #include <undo.hrc>
49 
50 using namespace ::com::sun::star;
51 using namespace ::com::sun::star::i18n;
52 using namespace ::com::sun::star::uno;
53 
54 
55 //------------------------------------------------------------
56 
57 // OVERWRITE
58 
59 
SwUndoOverwrite(SwDoc * pDoc,SwPosition & rPos,sal_Unicode cIns)60 SwUndoOverwrite::SwUndoOverwrite( SwDoc* pDoc, SwPosition& rPos,
61 									sal_Unicode cIns )
62 	: SwUndo(UNDO_OVERWRITE),
63       pRedlSaveData( 0 ), bGroup( sal_False )
64 {
65     if( !pDoc->IsIgnoreRedline() && pDoc->GetRedlineTbl().Count() )
66 	{
67 		SwPaM aPam( rPos.nNode, rPos.nContent.GetIndex(),
68 					rPos.nNode, rPos.nContent.GetIndex()+1 );
69 		pRedlSaveData = new SwRedlineSaveDatas;
70 		if( !FillSaveData( aPam, *pRedlSaveData, sal_False ))
71 			delete pRedlSaveData, pRedlSaveData = 0;
72 	}
73 
74 	nSttNode = rPos.nNode.GetIndex();
75 	nSttCntnt = rPos.nContent.GetIndex();
76 
77 	SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
78 	ASSERT( pTxtNd, "Overwrite nicht im TextNode?" );
79 
80 	bInsChar = sal_True;
81 	xub_StrLen nTxtNdLen = pTxtNd->GetTxt().Len();
82 	if( nSttCntnt < nTxtNdLen )		// kein reines Einfuegen ?
83 	{
84 		aDelStr.Insert( pTxtNd->GetTxt().GetChar( nSttCntnt ) );
85 		if( !pHistory )
86 			pHistory = new SwHistory;
87 		SwRegHistory aRHst( *pTxtNd, pHistory );
88         pHistory->CopyAttr( pTxtNd->GetpSwpHints(), nSttNode, 0,
89                             nTxtNdLen, false );
90 		rPos.nContent++;
91 		bInsChar = sal_False;
92 	}
93 
94 	sal_Bool bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
95 	pTxtNd->SetIgnoreDontExpand( sal_True );
96 
97     pTxtNd->InsertText( cIns, rPos.nContent,
98             IDocumentContentOperations::INS_EMPTYEXPAND );
99 	aInsStr.Insert( cIns );
100 
101 	if( !bInsChar )
102 	{
103 		const SwIndex aTmpIndex( rPos.nContent, -2 );
104         pTxtNd->EraseText( aTmpIndex, 1 );
105     }
106 	pTxtNd->SetIgnoreDontExpand( bOldExpFlg );
107 
108     bCacheComment = false;
109 }
110 
~SwUndoOverwrite()111 SwUndoOverwrite::~SwUndoOverwrite()
112 {
113 	delete pRedlSaveData;
114 }
115 
CanGrouping(SwDoc * pDoc,SwPosition & rPos,sal_Unicode cIns)116 sal_Bool SwUndoOverwrite::CanGrouping( SwDoc* pDoc, SwPosition& rPos,
117 									sal_Unicode cIns )
118 {
119 ///  ?? was ist mit nur eingefuegten Charaktern ???
120 
121 	// es kann nur das Loeschen von einzelnen char's zusammengefasst werden
122 	if( rPos.nNode != nSttNode || !aInsStr.Len()  ||
123 		( !bGroup && aInsStr.Len() != 1 ))
124 		return sal_False;
125 
126 	// ist der Node ueberhaupt ein TextNode?
127 	SwTxtNode * pDelTxtNd = rPos.nNode.GetNode().GetTxtNode();
128 	if( !pDelTxtNd ||
129 		( pDelTxtNd->GetTxt().Len() != rPos.nContent.GetIndex() &&
130 			rPos.nContent.GetIndex() != ( nSttCntnt + aInsStr.Len() )))
131 		return sal_False;
132 
133 	CharClass& rCC = GetAppCharClass();
134 
135 	// befrage das einzufuegende Charakter
136     if (( CH_TXTATR_BREAKWORD == cIns || CH_TXTATR_INWORD == cIns ) ||
137 		rCC.isLetterNumeric( String( cIns ), 0 ) !=
138 		rCC.isLetterNumeric( aInsStr, aInsStr.Len()-1 ) )
139 		return sal_False;
140 
141 	{
142 		SwRedlineSaveDatas* pTmpSav = new SwRedlineSaveDatas;
143 		SwPaM aPam( rPos.nNode, rPos.nContent.GetIndex(),
144 					rPos.nNode, rPos.nContent.GetIndex()+1 );
145 
146 		if( !FillSaveData( aPam, *pTmpSav, sal_False ))
147 			delete pTmpSav, pTmpSav = 0;
148 
149 		sal_Bool bOk = ( !pRedlSaveData && !pTmpSav ) ||
150 				   ( pRedlSaveData && pTmpSav &&
151 						SwUndo::CanRedlineGroup( *pRedlSaveData, *pTmpSav,
152 							nSttCntnt > rPos.nContent.GetIndex() ));
153 		delete pTmpSav;
154 		if( !bOk )
155 			return sal_False;
156 
157 		pDoc->DeleteRedline( aPam, false, USHRT_MAX );
158 	}
159 
160 	// Ok, die beiden 'Overwrites' koennen zusammen gefasst werden, also
161 	// 'verschiebe' das enstprechende Zeichen
162 	if( !bInsChar )
163 	{
164 		if( rPos.nContent.GetIndex() < pDelTxtNd->GetTxt().Len() )
165 		{
166 			aDelStr.Insert( pDelTxtNd->GetTxt().GetChar(rPos.nContent.GetIndex()) );
167 			rPos.nContent++;
168 		}
169 		else
170 			bInsChar = sal_True;
171 	}
172 
173 	sal_Bool bOldExpFlg = pDelTxtNd->IsIgnoreDontExpand();
174 	pDelTxtNd->SetIgnoreDontExpand( sal_True );
175 
176     pDelTxtNd->InsertText( cIns, rPos.nContent,
177             IDocumentContentOperations::INS_EMPTYEXPAND );
178 	aInsStr.Insert( cIns );
179 
180 	if( !bInsChar )
181 	{
182 		const SwIndex aTmpIndex( rPos.nContent, -2 );
183         pDelTxtNd->EraseText( aTmpIndex, 1 );
184     }
185 	pDelTxtNd->SetIgnoreDontExpand( bOldExpFlg );
186 
187 	bGroup = sal_True;
188 	return sal_True;
189 }
190 
191 
192 
193 
194 
UndoImpl(::sw::UndoRedoContext & rContext)195 void SwUndoOverwrite::UndoImpl(::sw::UndoRedoContext & rContext)
196 {
197     SwDoc *const pDoc = & rContext.GetDoc();
198     SwPaM *const pAktPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
199 
200 	pAktPam->DeleteMark();
201 	pAktPam->GetPoint()->nNode = nSttNode;
202 	SwTxtNode* pTxtNd = pAktPam->GetNode()->GetTxtNode();
203 	ASSERT( pTxtNd, "Overwrite nicht im TextNode?" );
204 	SwIndex& rIdx = pAktPam->GetPoint()->nContent;
205 	rIdx.Assign( pTxtNd, nSttCntnt );
206 
207 	SwAutoCorrExceptWord* pACEWord = pDoc->GetAutoCorrExceptWord();
208 	if( pACEWord )
209 	{
210 		if( 1 == aInsStr.Len() && 1 == aDelStr.Len() )
211 			pACEWord->CheckChar( *pAktPam->GetPoint(), aDelStr.GetChar( 0 ) );
212 		pDoc->SetAutoCorrExceptWord( 0 );
213 	}
214 
215 	// wurde nicht nur ueberschieben sondern auch geinsertet, so loesche
216 	// den Ueberhang
217 	if( aInsStr.Len() > aDelStr.Len() )
218 	{
219 		rIdx += aDelStr.Len();
220         pTxtNd->EraseText( rIdx, aInsStr.Len() - aDelStr.Len() );
221 		rIdx = nSttCntnt;
222 	}
223 
224 	if( aDelStr.Len() )
225 	{
226 		String aTmpStr( '1' );
227 		sal_Unicode* pTmpStr = aTmpStr.GetBufferAccess();
228 
229 		sal_Bool bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
230 		pTxtNd->SetIgnoreDontExpand( sal_True );
231 
232 		rIdx++;
233 		for( xub_StrLen n = 0; n < aDelStr.Len(); n++  )
234 		{
235 			// einzeln, damit die Attribute stehen bleiben !!!
236 			*pTmpStr = aDelStr.GetChar( n );
237             pTxtNd->InsertText( aTmpStr, rIdx /*???, SETATTR_NOTXTATRCHR*/ );
238 			rIdx -= 2;
239             pTxtNd->EraseText( rIdx, 1 );
240 			rIdx += 2;
241 		}
242 		pTxtNd->SetIgnoreDontExpand( bOldExpFlg );
243 		rIdx--;
244 	}
245 	if( pHistory )
246 	{
247 		if( pTxtNd->GetpSwpHints() )
248             pTxtNd->ClearSwpHintsArr( false );
249         pHistory->TmpRollback( pDoc, 0, false );
250     }
251 
252 	if( pAktPam->GetMark()->nContent.GetIndex() != nSttCntnt )
253 	{
254 		pAktPam->SetMark();
255 		pAktPam->GetMark()->nContent = nSttCntnt;
256 	}
257 
258 	if( pRedlSaveData )
259 		SetSaveData( *pDoc, *pRedlSaveData );
260 }
261 
RepeatImpl(::sw::RepeatContext & rContext)262 void SwUndoOverwrite::RepeatImpl(::sw::RepeatContext & rContext)
263 {
264     SwPaM *const pAktPam = & rContext.GetRepeatPaM();
265 	if( !aInsStr.Len() || pAktPam->HasMark() )
266 		return;
267 
268     SwDoc & rDoc = rContext.GetDoc();
269 
270     {
271         ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
272         rDoc.Overwrite(*pAktPam, aInsStr.GetChar(0));
273     }
274 	for( xub_StrLen n = 1; n < aInsStr.Len(); ++n )
275 		rDoc.Overwrite( *pAktPam, aInsStr.GetChar( n ) );
276 }
277 
RedoImpl(::sw::UndoRedoContext & rContext)278 void SwUndoOverwrite::RedoImpl(::sw::UndoRedoContext & rContext)
279 {
280     SwDoc *const pDoc = & rContext.GetDoc();
281     SwPaM *const pAktPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
282 
283 	pAktPam->DeleteMark();
284 	pAktPam->GetPoint()->nNode = nSttNode;
285 	SwTxtNode* pTxtNd = pAktPam->GetNode()->GetTxtNode();
286 	ASSERT( pTxtNd, "Overwrite nicht im TextNode?" );
287 	SwIndex& rIdx = pAktPam->GetPoint()->nContent;
288 
289 	if( pRedlSaveData )
290 	{
291 		rIdx.Assign( pTxtNd, nSttCntnt );
292 		pAktPam->SetMark();
293 		pAktPam->GetMark()->nContent += aInsStr.Len();
294 		pDoc->DeleteRedline( *pAktPam, false, USHRT_MAX );
295 		pAktPam->DeleteMark();
296 	}
297 	rIdx.Assign( pTxtNd, aDelStr.Len() ? nSttCntnt+1 : nSttCntnt );
298 
299 	sal_Bool bOldExpFlg = pTxtNd->IsIgnoreDontExpand();
300 	pTxtNd->SetIgnoreDontExpand( sal_True );
301 
302 	for( xub_StrLen n = 0; n < aInsStr.Len(); n++  )
303 	{
304 		// einzeln, damit die Attribute stehen bleiben !!!
305         pTxtNd->InsertText( aInsStr.GetChar( n ), rIdx,
306                 IDocumentContentOperations::INS_EMPTYEXPAND );
307 		if( n < aDelStr.Len() )
308 		{
309 			rIdx -= 2;
310             pTxtNd->EraseText( rIdx, 1 );
311 			rIdx += n+1 < aDelStr.Len() ? 2 : 1;
312 		}
313 	}
314 	pTxtNd->SetIgnoreDontExpand( bOldExpFlg );
315 
316 	// alte Anfangs-Position vom UndoNodes-Array zurueckholen
317 	if( pHistory )
318 		pHistory->SetTmpEnd( pHistory->Count() );
319 	if( pAktPam->GetMark()->nContent.GetIndex() != nSttCntnt )
320 	{
321 		pAktPam->SetMark();
322 		pAktPam->GetMark()->nContent = nSttCntnt;
323 	}
324 }
325 
GetRewriter() const326 SwRewriter SwUndoOverwrite::GetRewriter() const
327 {
328     SwRewriter aResult;
329 
330     String aString;
331 
332     aString += String(SW_RES(STR_START_QUOTE));
333     aString += ShortenString(aInsStr, nUndoStringLength,
334                              String(SW_RES(STR_LDOTS)));
335     aString += String(SW_RES(STR_END_QUOTE));
336 
337     aResult.AddRule(UNDO_ARG1, aString);
338 
339     return aResult;
340 }
341 
342 //------------------------------------------------------------
343 
344 struct _UndoTransliterate_Data
345 {
346 	String          sText;
347 	SwHistory*      pHistory;
348 	Sequence< sal_Int32 >*  pOffsets;
349 	sal_uLong           nNdIdx;
350 	xub_StrLen      nStart, nLen;
351 
_UndoTransliterate_Data_UndoTransliterate_Data352 	_UndoTransliterate_Data( sal_uLong nNd, xub_StrLen nStt, xub_StrLen nStrLen, const String& rTxt )
353 		: sText( rTxt ), pHistory( 0 ), pOffsets( 0 ),
354 		nNdIdx( nNd ), nStart( nStt ), nLen( nStrLen )
355 	{}
~_UndoTransliterate_Data_UndoTransliterate_Data356 	~_UndoTransliterate_Data() { delete pOffsets; delete pHistory; }
357 
358 	void SetChangeAtNode( SwDoc& rDoc );
359 };
360 
SwUndoTransliterate(const SwPaM & rPam,const utl::TransliterationWrapper & rTrans)361 SwUndoTransliterate::SwUndoTransliterate(
362     const SwPaM& rPam,
363 	const utl::TransliterationWrapper& rTrans )
364 	: SwUndo( UNDO_TRANSLITERATE ), SwUndRng( rPam ), nType( rTrans.getType() )
365 {
366 }
367 
~SwUndoTransliterate()368 SwUndoTransliterate::~SwUndoTransliterate()
369 {
370     for (size_t i = 0; i < aChanges.size();  ++i)
371         delete aChanges[i];
372 }
373 
UndoImpl(::sw::UndoRedoContext & rContext)374 void SwUndoTransliterate::UndoImpl(::sw::UndoRedoContext & rContext)
375 {
376     SwDoc & rDoc = rContext.GetDoc();
377 
378     // since the changes were added to the vector from the end of the string/node towards
379     // the start, we need to revert them from the start towards the end now to keep the
380     // offset information of the undo data in sync with the changing text.
381     // Thus we need to iterate from the end of the vector to the start
382 	for (sal_Int32 i = aChanges.size() - 1; i >= 0;  --i)
383 		aChanges[i]->SetChangeAtNode( rDoc );
384 
385     AddUndoRedoPaM(rContext, true);
386 }
387 
RedoImpl(::sw::UndoRedoContext & rContext)388 void SwUndoTransliterate::RedoImpl(::sw::UndoRedoContext & rContext)
389 {
390     SwPaM & rPam( AddUndoRedoPaM(rContext) );
391     DoTransliterate(rContext.GetDoc(), rPam);
392 }
393 
RepeatImpl(::sw::RepeatContext & rContext)394 void SwUndoTransliterate::RepeatImpl(::sw::RepeatContext & rContext)
395 {
396     DoTransliterate(rContext.GetDoc(), rContext.GetRepeatPaM());
397 }
398 
DoTransliterate(SwDoc & rDoc,SwPaM & rPam)399 void SwUndoTransliterate::DoTransliterate(SwDoc & rDoc, SwPaM & rPam)
400 {
401 	utl::TransliterationWrapper aTrans( ::comphelper::getProcessServiceFactory(), nType );
402 	rDoc.TransliterateText( rPam, aTrans );
403 }
404 
AddChanges(SwTxtNode & rTNd,xub_StrLen nStart,xub_StrLen nLen,uno::Sequence<sal_Int32> & rOffsets)405 void SwUndoTransliterate::AddChanges( SwTxtNode& rTNd,
406                     xub_StrLen nStart, xub_StrLen nLen,
407                     uno::Sequence <sal_Int32>& rOffsets )
408 {
409 	long nOffsLen = rOffsets.getLength();
410 	_UndoTransliterate_Data* pNew = new _UndoTransliterate_Data(
411 						rTNd.GetIndex(), nStart, (xub_StrLen)nOffsLen,
412 						rTNd.GetTxt().Copy( nStart, nLen ));
413 
414     aChanges.push_back( pNew );
415 
416 	const sal_Int32* pOffsets = rOffsets.getConstArray();
417 	// where did we need less memory ?
418 	const sal_Int32* p = pOffsets;
419 	for( long n = 0; n < nOffsLen; ++n, ++p )
420 	if( *p != ( nStart + n ))
421 	{
422 		// create the Offset array
423 		pNew->pOffsets = new Sequence <sal_Int32> ( nLen );
424 		sal_Int32* pIdx = pNew->pOffsets->getArray();
425 		p = pOffsets;
426 		long nMyOff, nNewVal = nStart;
427 		for( n = 0, nMyOff = nStart; n < nOffsLen; ++p, ++n, ++nMyOff )
428 		{
429 			if( *p < nMyOff )
430 			{
431 				// something is deleted
432 				nMyOff = *p;
433 				*(pIdx-1) = nNewVal++;
434 			}
435 			else if( *p > nMyOff )
436 			{
437 				for( ; *p > nMyOff; ++nMyOff )
438 					*pIdx++ = nNewVal;
439 				--nMyOff;
440 				--n;
441 				--p;
442 			}
443 			else
444 				*pIdx++ = nNewVal++;
445 		}
446 
447 		// and then we need to save the attributes/bookmarks
448 		// but this data must moved every time to the last in the chain!
449         for (size_t i = 0; i + 1 < aChanges.size(); ++i)    // check all changes but not the current one
450         {
451 		    _UndoTransliterate_Data* pD = aChanges[i];
452 			if( pD->nNdIdx == pNew->nNdIdx && pD->pHistory )
453 			{
454 				// same node and have a history?
455 				pNew->pHistory = pD->pHistory;
456 				pD->pHistory = 0;
457 				break;		    // more can't exist
458 			}
459         }
460 
461 		if( !pNew->pHistory )
462 		{
463 			pNew->pHistory = new SwHistory;
464 			SwRegHistory aRHst( rTNd, pNew->pHistory );
465             pNew->pHistory->CopyAttr( rTNd.GetpSwpHints(),
466                     pNew->nNdIdx, 0, rTNd.GetTxt().Len(), false );
467         }
468 		break;
469 	}
470 }
471 
SetChangeAtNode(SwDoc & rDoc)472 void _UndoTransliterate_Data::SetChangeAtNode( SwDoc& rDoc )
473 {
474 	SwTxtNode* pTNd = rDoc.GetNodes()[ nNdIdx ]->GetTxtNode();
475 	if( pTNd )
476 	{
477 		Sequence <sal_Int32> aOffsets( pOffsets ? pOffsets->getLength() : nLen );
478 		if( pOffsets )
479 			aOffsets = *pOffsets;
480 		else
481 		{
482 			sal_Int32* p = aOffsets.getArray();
483 			for( xub_StrLen n = 0; n < nLen; ++n, ++p )
484 				*p = n + nStart;
485 		}
486 		pTNd->ReplaceTextOnly( nStart, nLen, sText, aOffsets );
487 
488 		if( pHistory )
489 		{
490 			if( pTNd->GetpSwpHints() )
491                 pTNd->ClearSwpHintsArr( false );
492             pHistory->TmpRollback( &rDoc, 0, false );
493 			pHistory->SetTmpEnd( pHistory->Count() );
494 		}
495 	}
496 }
497 
498 
499