xref: /aoo41x/main/sw/source/core/txtnode/txtedt.cxx (revision 69a74367)
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 // So kann man die Linguistik-Statistik ( (Tmp-Path)\swlingu.stk ) aktivieren:
28 //#define LINGU_STATISTIK
29 #ifdef LINGU_STATISTIK
30 	#include <stdio.h>			// in SwLinguStatistik::DTOR
31 	#include <stdlib.h> 		// getenv()
32 	#include <time.h> 			// clock()
33     #include <tools/stream.hxx>
34 #endif
35 
36 #include <hintids.hxx>
37 #include <vcl/svapp.hxx>
38 #include <svl/itemiter.hxx>
39 #include <editeng/splwrap.hxx>
40 #include <editeng/langitem.hxx>
41 #include <editeng/fontitem.hxx>
42 #include <editeng/scripttypeitem.hxx>
43 #include <editeng/hangulhanja.hxx>
44 #include <SwSmartTagMgr.hxx>
45 #include <linguistic/lngprops.hxx>
46 #include <unotools/transliterationwrapper.hxx>
47 #include <unotools/charclass.hxx>
48 #include <dlelstnr.hxx>
49 #include <swmodule.hxx>
50 #include <splargs.hxx>
51 #include <viewopt.hxx>
52 #include <acmplwrd.hxx>
53 #include <doc.hxx>		// GetDoc()
54 #include <docsh.hxx>
55 #include <txtfld.hxx>
56 #include <fmtfld.hxx>
57 #include <txatbase.hxx>
58 #include <charatr.hxx>
59 #include <fldbas.hxx>
60 #include <pam.hxx>
61 #include <hints.hxx>
62 #include <ndtxt.hxx>
63 #include <txtfrm.hxx>
64 #include <SwGrammarMarkUp.hxx>
65 
66 #include <txttypes.hxx>
67 #include <breakit.hxx>
68 #include <crstate.hxx>
69 #include <UndoOverwrite.hxx>
70 #include <txatritr.hxx>
71 #include <redline.hxx>		// SwRedline
72 #include <docary.hxx>		// SwRedlineTbl
73 #include <scriptinfo.hxx>
74 #include <docstat.hxx>
75 #include <editsh.hxx>
76 #include <unotextmarkup.hxx>
77 #include <txtatr.hxx>
78 #include <fmtautofmt.hxx>
79 #include <istyleaccess.hxx>
80 
81 #include <unomid.h>
82 
83 #include <com/sun/star/beans/XPropertySet.hpp>
84 #include <com/sun/star/i18n/WordType.hdl>
85 #include <com/sun/star/i18n/ScriptType.hdl>
86 #include <com/sun/star/i18n/TransliterationModules.hpp>
87 #include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
88 
89 #include <vector>
90 
91 #include <unotextrange.hxx>
92 
93 using rtl::OUString;
94 using namespace ::com::sun::star;
95 using namespace ::com::sun::star::frame;
96 using namespace ::com::sun::star::i18n;
97 using namespace ::com::sun::star::beans;
98 using namespace ::com::sun::star::uno;
99 using namespace ::com::sun::star::linguistic2;
100 using namespace ::com::sun::star::smarttags;
101 
102 // Wir ersparen uns in Hyphenate ein GetFrm()
103 // Achtung: in edlingu.cxx stehen die Variablen!
104 extern const SwTxtNode *pLinguNode;
105 extern       SwTxtFrm  *pLinguFrm;
106 
107 bool lcl_IsSkippableWhiteSpace( xub_Unicode cCh )
108 {
109     return 0x3000 == cCh ||
110            ' ' == cCh ||
111            '\t' == cCh ||
112            0x0a == cCh;
113 }
114 
115 /*
116  * This has basically the same function as SwScriptInfo::MaskHiddenRanges,
117  * only for deleted redlines
118  */
119 
120 sal_uInt16 lcl_MaskRedlines( const SwTxtNode& rNode, XubString& rText,
121                          const xub_StrLen nStt, const xub_StrLen nEnd,
122                          const xub_Unicode cChar )
123 {
124     sal_uInt16 nNumOfMaskedRedlines = 0;
125 
126     const SwDoc& rDoc = *rNode.GetDoc();
127     sal_uInt16 nAct = rDoc.GetRedlinePos( rNode, USHRT_MAX );
128 
129     for ( ; nAct < rDoc.GetRedlineTbl().Count(); nAct++ )
130     {
131         const SwRedline* pRed = rDoc.GetRedlineTbl()[ nAct ];
132 
133         if ( pRed->Start()->nNode > rNode.GetIndex() )
134             break;
135 
136         if( nsRedlineType_t::REDLINE_DELETE == pRed->GetType() )
137         {
138             xub_StrLen nRedlineEnd;
139             xub_StrLen nRedlineStart;
140 
141             pRed->CalcStartEnd( rNode.GetIndex(), nRedlineStart, nRedlineEnd );
142 
143             if ( nRedlineEnd < nStt || nRedlineStart > nEnd )
144                 continue;
145 
146             while ( nRedlineStart < nRedlineEnd && nRedlineStart < nEnd )
147             {
148                 if ( nRedlineStart >= nStt && nRedlineStart < nEnd )
149                 {
150                     rText.SetChar( nRedlineStart, cChar );
151                     ++nNumOfMaskedRedlines;
152                 }
153                 ++nRedlineStart;
154             }
155         }
156     }
157 
158     return nNumOfMaskedRedlines;
159 }
160 
161 /*
162  * Used for spell checking. Deleted redlines and hidden characters are masked
163  */
164 
165 sal_uInt16 lcl_MaskRedlinesAndHiddenText( const SwTxtNode& rNode, XubString& rText,
166                                       const xub_StrLen nStt, const xub_StrLen nEnd,
167                                       const xub_Unicode cChar = CH_TXTATR_INWORD,
168                                       bool bCheckShowHiddenChar = true )
169 {
170     sal_uInt16 nRedlinesMasked = 0;
171     sal_uInt16 nHiddenCharsMasked = 0;
172 
173     const SwDoc& rDoc = *rNode.GetDoc();
174     const bool bShowChg = 0 != IDocumentRedlineAccess::IsShowChanges( rDoc.GetRedlineMode() );
175 
176     // If called from word count or from spell checking, deleted redlines
177     // should be masked:
178     if ( bShowChg )
179     {
180         nRedlinesMasked = lcl_MaskRedlines( rNode, rText, nStt, nEnd, cChar );
181     }
182 
183     const bool bHideHidden = !SW_MOD()->GetViewOption(rDoc.get(IDocumentSettingAccess::HTML_MODE))->IsShowHiddenChar();
184 
185     // If called from word count, we want to mask the hidden ranges even
186     // if they are visible:
187     if ( !bCheckShowHiddenChar || bHideHidden )
188     {
189         nHiddenCharsMasked =
190             SwScriptInfo::MaskHiddenRanges( rNode, rText, nStt, nEnd, cChar );
191     }
192 
193     return nRedlinesMasked + nHiddenCharsMasked;
194 }
195 
196 /*
197  * Used for spell checking. Calculates a rectangle for repaint.
198  */
199 
200 static SwRect lcl_CalculateRepaintRect( SwTxtFrm& rTxtFrm, xub_StrLen nChgStart, xub_StrLen nChgEnd )
201 {
202     SwRect aRect;
203 
204     SwTxtNode *pNode = rTxtFrm.GetTxtNode();
205 
206     SwNodeIndex aNdIdx( *pNode );
207     SwPosition aPos( aNdIdx, SwIndex( pNode, nChgEnd ) );
208     SwCrsrMoveState aTmpState( MV_NONE );
209     aTmpState.b2Lines = sal_True;
210     rTxtFrm.GetCharRect( aRect, aPos, &aTmpState );
211     // information about end of repaint area
212     Sw2LinesPos* pEnd2Pos = aTmpState.p2Lines;
213 
214     const SwTxtFrm *pEndFrm = &rTxtFrm;
215 
216     while( pEndFrm->HasFollow() &&
217            nChgEnd >= pEndFrm->GetFollow()->GetOfst() )
218         pEndFrm = pEndFrm->GetFollow();
219 
220     if ( pEnd2Pos )
221     {
222         // we are inside a special portion, take left border
223         SWRECTFN( pEndFrm )
224         (aRect.*fnRect->fnSetTop)( (pEnd2Pos->aLine.*fnRect->fnGetTop)() );
225         if ( pEndFrm->IsRightToLeft() )
226             (aRect.*fnRect->fnSetLeft)( (pEnd2Pos->aPortion.*fnRect->fnGetLeft)() );
227         else
228             (aRect.*fnRect->fnSetLeft)( (pEnd2Pos->aPortion.*fnRect->fnGetRight)() );
229         (aRect.*fnRect->fnSetWidth)( 1 );
230         (aRect.*fnRect->fnSetHeight)( (pEnd2Pos->aLine.*fnRect->fnGetHeight)() );
231         delete pEnd2Pos;
232     }
233 
234     aTmpState.p2Lines = NULL;
235     SwRect aTmp;
236     aPos = SwPosition( aNdIdx, SwIndex( pNode, nChgStart ) );
237     rTxtFrm.GetCharRect( aTmp, aPos, &aTmpState );
238 
239     // i63141: GetCharRect(..) could cause a formatting,
240     // during the formatting SwTxtFrms could be joined, deleted, created...
241     // => we have to reinit pStartFrm and pEndFrm after the formatting
242     const SwTxtFrm* pStartFrm = &rTxtFrm;
243     while( pStartFrm->HasFollow() &&
244            nChgStart >= pStartFrm->GetFollow()->GetOfst() )
245         pStartFrm = pStartFrm->GetFollow();
246     pEndFrm = pStartFrm;
247     while( pEndFrm->HasFollow() &&
248            nChgEnd >= pEndFrm->GetFollow()->GetOfst() )
249         pEndFrm = pEndFrm->GetFollow();
250 
251     // information about start of repaint area
252     Sw2LinesPos* pSt2Pos = aTmpState.p2Lines;
253     if ( pSt2Pos )
254     {
255         // we are inside a special portion, take right border
256         SWRECTFN( pStartFrm )
257         (aTmp.*fnRect->fnSetTop)( (pSt2Pos->aLine.*fnRect->fnGetTop)() );
258         if ( pStartFrm->IsRightToLeft() )
259             (aTmp.*fnRect->fnSetLeft)( (pSt2Pos->aPortion.*fnRect->fnGetRight)() );
260         else
261             (aTmp.*fnRect->fnSetLeft)( (pSt2Pos->aPortion.*fnRect->fnGetLeft)() );
262         (aTmp.*fnRect->fnSetWidth)( 1 );
263         (aTmp.*fnRect->fnSetHeight)( (pSt2Pos->aLine.*fnRect->fnGetHeight)() );
264         delete pSt2Pos;
265     }
266 
267     sal_Bool bSameFrame = sal_True;
268 
269     if( rTxtFrm.HasFollow() )
270     {
271         if( pEndFrm != pStartFrm )
272         {
273             bSameFrame = sal_False;
274             SwRect aStFrm( pStartFrm->PaintArea() );
275             {
276                 SWRECTFN( pStartFrm )
277                 (aTmp.*fnRect->fnSetLeft)( (aStFrm.*fnRect->fnGetLeft)() );
278                 (aTmp.*fnRect->fnSetRight)( (aStFrm.*fnRect->fnGetRight)() );
279                 (aTmp.*fnRect->fnSetBottom)( (aStFrm.*fnRect->fnGetBottom)() );
280             }
281             aStFrm = pEndFrm->PaintArea();
282             {
283                 SWRECTFN( pEndFrm )
284                 (aRect.*fnRect->fnSetTop)( (aStFrm.*fnRect->fnGetTop)() );
285                 (aRect.*fnRect->fnSetLeft)( (aStFrm.*fnRect->fnGetLeft)() );
286                 (aRect.*fnRect->fnSetRight)( (aStFrm.*fnRect->fnGetRight)() );
287             }
288             aRect.Union( aTmp );
289             while( sal_True )
290             {
291                 pStartFrm = pStartFrm->GetFollow();
292                 if( pStartFrm == pEndFrm )
293                     break;
294                 aRect.Union( pStartFrm->PaintArea() );
295             }
296         }
297     }
298     if( bSameFrame )
299     {
300         SWRECTFN( pStartFrm )
301         if( (aTmp.*fnRect->fnGetTop)() == (aRect.*fnRect->fnGetTop)() )
302             (aRect.*fnRect->fnSetLeft)( (aTmp.*fnRect->fnGetLeft)() );
303         else
304         {
305             SwRect aStFrm( pStartFrm->PaintArea() );
306             (aRect.*fnRect->fnSetLeft)( (aStFrm.*fnRect->fnGetLeft)() );
307             (aRect.*fnRect->fnSetRight)( (aStFrm.*fnRect->fnGetRight)() );
308             (aRect.*fnRect->fnSetTop)( (aTmp.*fnRect->fnGetTop)() );
309         }
310 
311         if( aTmp.Height() > aRect.Height() )
312             aRect.Height( aTmp.Height() );
313     }
314 
315     return aRect;
316 }
317 
318 /*
319  * Used for automatic styles. Used during RstAttr.
320  */
321 
322 static bool lcl_HaveCommonAttributes( IStyleAccess& rStyleAccess,
323                                       const SfxItemSet* pSet1,
324                                       sal_uInt16 nWhichId,
325                                       const SfxItemSet& rSet2,
326                                       boost::shared_ptr<SfxItemSet>& pStyleHandle )
327 {
328     bool bRet = false;
329 
330     SfxItemSet* pNewSet = 0;
331 
332     if ( !pSet1 )
333     {
334         ASSERT( nWhichId, "lcl_HaveCommonAttributes not used correctly" )
335         if ( SFX_ITEM_SET == rSet2.GetItemState( nWhichId, sal_False ) )
336         {
337             pNewSet = rSet2.Clone( sal_True );
338             pNewSet->ClearItem( nWhichId );
339         }
340     }
341     else if ( pSet1->Count() )
342     {
343         SfxItemIter aIter( *pSet1 );
344         const SfxPoolItem* pItem = aIter.GetCurItem();
345         while( sal_True )
346         {
347             if ( SFX_ITEM_SET == rSet2.GetItemState( pItem->Which(), sal_False ) )
348             {
349                 if ( !pNewSet )
350                     pNewSet = rSet2.Clone( sal_True );
351                 pNewSet->ClearItem( pItem->Which() );
352             }
353 
354             if( aIter.IsAtEnd() )
355                 break;
356 
357             pItem = aIter.NextItem();
358         }
359     }
360 
361     if ( pNewSet )
362     {
363         if ( pNewSet->Count() )
364             pStyleHandle = rStyleAccess.getAutomaticStyle( *pNewSet, IStyleAccess::AUTO_STYLE_CHAR );
365         delete pNewSet;
366         bRet = true;
367     }
368 
369     return bRet;
370 }
371 
372 inline sal_Bool InRange(xub_StrLen nIdx, xub_StrLen nStart, xub_StrLen nEnd) {
373 	return ((nIdx >=nStart) && (nIdx <= nEnd));
374 }
375 
376 /*
377  * void SwTxtNode::RstAttr(const SwIndex &rIdx, sal_uInt16 nLen)
378  *
379  * Deletes all attributes, starting at position rIdx, for length nLen.
380  */
381 
382 /* 5 cases:
383  * 1) The attribute is completely in the deletion range:
384  *    -> delete it
385  * 2) The end of the attribute is in the deletion range:
386  *    -> delete it, then re-insert it with new end
387  * 3) The start of the attribute is in the deletion range:
388  *    -> delete it, then re-insert it with new start
389  * 4) The attribute contains the deletion range:
390  *       Split, i.e.,
391  *    -> Delete, re-insert from old start to start of deletion range
392  *    -> insert new attribute from end of deletion range to old end
393  * 5) The attribute is outside the deletion range
394  *    -> nothing to do
395  */
396 
397 void SwTxtNode::RstTxtAttr(
398     const SwIndex &rIdx,
399     const xub_StrLen nLen,
400     const sal_uInt16 nWhich,
401     const SfxItemSet* pSet,
402     const sal_Bool bInclRefToxMark )
403 {
404     if ( !GetpSwpHints() )
405         return;
406 
407     xub_StrLen nStt = rIdx.GetIndex();
408     xub_StrLen nEnd = nStt + nLen;
409     {
410         // enlarge range for the reset of text attributes in case of an overlapping input field
411         const SwTxtInputFld* pTxtInputFld = dynamic_cast<const SwTxtInputFld*>(GetTxtAttrAt( nStt, RES_TXTATR_INPUTFIELD, PARENT ));
412         if ( pTxtInputFld == NULL )
413         {
414             pTxtInputFld = dynamic_cast<const SwTxtInputFld*>(GetTxtAttrAt(nEnd, RES_TXTATR_INPUTFIELD, PARENT ));
415         }
416         if ( pTxtInputFld != NULL )
417         {
418             if ( nStt > *(pTxtInputFld->GetStart()) )
419             {
420                 nStt = *(pTxtInputFld->GetStart());
421             }
422             if ( nEnd < *(pTxtInputFld->End()) )
423             {
424                 nEnd = *(pTxtInputFld->End());
425             }
426         }
427     }
428 
429     bool bChanged = false;
430 
431     // nMin and nMax initialized to maximum / minimum (inverse)
432     xub_StrLen nMin = m_Text.Len();
433     xub_StrLen nMax = nStt;
434     const bool bNoLen = nMin == 0;
435 
436     // We have to remember the "new" attributes, which have
437     // been introduced by splitting surrounding attributes (case 4).
438     // They may not be forgotten inside the "Forget" function
439     //std::vector< const SwTxtAttr* > aNewAttributes;
440 
441     // iterate over attribute array until start of attribute is behind deletion range
442     sal_uInt16 i = 0;
443     xub_StrLen nAttrStart;
444     SwTxtAttr *pHt = NULL;
445     while ( (i < m_pSwpHints->Count())
446             && ( ( ( nAttrStart = *(*m_pSwpHints)[i]->GetStart()) < nEnd )
447                  || nLen==0 ) )
448     {
449         pHt = m_pSwpHints->GetTextHint(i);
450 
451         // attributes without end stay in!
452         // but consider <bInclRefToxMark> used by Undo
453         xub_StrLen* const pAttrEnd = pHt->GetEnd();
454         const bool bKeepAttrWithoutEnd =
455             pAttrEnd == NULL
456             && ( !bInclRefToxMark
457                  || ( RES_TXTATR_REFMARK != pHt->Which()
458                       && RES_TXTATR_TOXMARK != pHt->Which()
459                       && RES_TXTATR_META != pHt->Which()
460                       && RES_TXTATR_METAFIELD != pHt->Which() ) );
461         if ( bKeepAttrWithoutEnd )
462         {
463 
464             i++;
465             continue;
466         }
467         // attributes with content stay in
468         if ( pHt->HasContent() )
469         {
470             ++i;
471             continue;
472         }
473 
474         // Default behavior is to process all attributes:
475         bool bSkipAttr = false;;
476         boost::shared_ptr<SfxItemSet> pStyleHandle;
477 
478         // 1. case: We want to reset only the attributes listed in pSet:
479         if ( pSet )
480         {
481             bSkipAttr = SFX_ITEM_SET != pSet->GetItemState( pHt->Which(), sal_False );
482             if ( bSkipAttr && RES_TXTATR_AUTOFMT == pHt->Which() )
483             {
484                 // if the current attribute is an autostyle, we have to check if the autostyle
485                 // and pSet have any attributes in common. If so, pStyleHandle will contain
486                 // a handle to AutoStyle / pSet:
487                 bSkipAttr = !lcl_HaveCommonAttributes( getIDocumentStyleAccess(), pSet, 0, *static_cast<const SwFmtAutoFmt&>(pHt->GetAttr()).GetStyleHandle(), pStyleHandle );
488             }
489         }
490         else if ( nWhich )
491         {
492             // 2. case: We want to reset only the attributes with WhichId nWhich:
493             bSkipAttr = nWhich != pHt->Which();
494             if ( bSkipAttr && RES_TXTATR_AUTOFMT == pHt->Which() )
495             {
496                 bSkipAttr = !lcl_HaveCommonAttributes( getIDocumentStyleAccess(), 0, nWhich, *static_cast<const SwFmtAutoFmt&>(pHt->GetAttr()).GetStyleHandle(), pStyleHandle );
497             }
498         }
499         else if ( !bInclRefToxMark )
500         {
501             // 3. case: Reset all attributes except from ref/toxmarks:
502             // skip hints with CH_TXTATR here
503             // (deleting those is ONLY allowed for UNDO!)
504             bSkipAttr = RES_TXTATR_REFMARK   == pHt->Which()
505                      || RES_TXTATR_TOXMARK   == pHt->Which()
506                      || RES_TXTATR_META      == pHt->Which()
507                      || RES_TXTATR_METAFIELD == pHt->Which();
508         }
509 
510         if ( bSkipAttr )
511         {
512             i++;
513             continue;
514         }
515 
516 
517         if( nStt <= nAttrStart )          // Faelle: 1,3,5
518         {
519             const xub_StrLen nAttrEnd = pAttrEnd != NULL
520                                         ? *pAttrEnd
521                                         : nAttrStart;
522             if( nEnd > nAttrStart
523                 || ( nEnd == nAttrEnd && nEnd == nAttrStart ) )
524             {
525                 // Faelle: 1,3
526                 if ( nMin > nAttrStart )
527                     nMin = nAttrStart;
528                 if ( nMax < nAttrEnd )
529                     nMax = nAttrEnd;
530                 // Falls wir nur ein nichtaufgespanntes Attribut entfernen,
531                 // tun wir mal so, als ob sich nichts geaendert hat.
532                 bChanged = bChanged || nEnd > nAttrStart || bNoLen;
533                 if( nAttrEnd <= nEnd ) // Fall: 1
534                 {
535                     m_pSwpHints->DeleteAtPos(i);
536                     DestroyAttr( pHt );
537 
538                     if ( pStyleHandle.get() )
539                     {
540                         SwTxtAttr* pNew = MakeTxtAttr( *GetDoc(),
541                                 *pStyleHandle, nAttrStart, nAttrEnd );
542                         InsertHint( pNew, nsSetAttrMode::SETATTR_NOHINTADJUST );
543                     }
544 
545                     // if the last attribute is a Field, the HintsArray is deleted!
546                     if ( !m_pSwpHints )
547                         break;
548 
549                     //JP 26.11.96:
550                     // beim DeleteAtPos wird ein Resort ausgefuehrt!!
551                     // darum muessen wir wieder bei 0 anfangen!!!
552                     // ueber den Fall 3 koennen Attribute nach hinten
553                     // verschoben worden sein; damit stimmt jetzt das i
554                     // nicht mehr!!!
555                     i = 0;
556 
557                     continue;
558                 }
559                 else // Fall: 3
560                 {
561                     m_pSwpHints->NoteInHistory( pHt );
562                     *pHt->GetStart() = nEnd;
563                     m_pSwpHints->NoteInHistory( pHt, sal_True );
564 
565                     if ( pStyleHandle.get() && nAttrStart < nEnd )
566                     {
567                         SwTxtAttr* pNew = MakeTxtAttr( *GetDoc(),
568                                 *pStyleHandle, nAttrStart, nEnd );
569                         InsertHint( pNew, nsSetAttrMode::SETATTR_NOHINTADJUST );
570                     }
571 
572                     bChanged = true;
573                 }
574             }
575         }
576         else if ( pAttrEnd != NULL )    // Faelle: 2,4,5
577         {
578             if( *pAttrEnd > nStt )     // Faelle: 2,4
579             {
580                 if( *pAttrEnd < nEnd )  // Fall: 2
581                 {
582                     if ( nMin > nAttrStart )
583                         nMin = nAttrStart;
584                     if ( nMax < *pAttrEnd )
585                         nMax = *pAttrEnd;
586                     bChanged = true;
587 
588                     const xub_StrLen nAttrEnd = *pAttrEnd;
589 
590                     m_pSwpHints->NoteInHistory( pHt );
591                     *pAttrEnd = nStt;
592                     m_pSwpHints->NoteInHistory( pHt, sal_True );
593 
594                     if ( pStyleHandle.get() )
595                     {
596                         SwTxtAttr* pNew = MakeTxtAttr( *GetDoc(),
597                             *pStyleHandle, nStt, nAttrEnd );
598                         InsertHint( pNew, nsSetAttrMode::SETATTR_NOHINTADJUST );
599                     }
600                 }
601                 else if( nLen ) // Fall: 4
602                 {
603                     // bei Lange 0 werden beide Hints vom Insert(Ht)
604                     // wieder zu einem zusammengezogen !!!!
605                     if ( nMin > nAttrStart )
606                         nMin = nAttrStart;
607                     if ( nMax < *pAttrEnd )
608                         nMax = *pAttrEnd;
609                     bChanged = true;
610                     xub_StrLen nTmpEnd = *pAttrEnd;
611                     m_pSwpHints->NoteInHistory( pHt );
612                     *pAttrEnd = nStt;
613                     m_pSwpHints->NoteInHistory( pHt, sal_True );
614 
615                     if ( pStyleHandle.get() && nStt < nEnd )
616                     {
617                         SwTxtAttr* pNew = MakeTxtAttr( *GetDoc(),
618                             *pStyleHandle, nStt, nEnd );
619                         InsertHint( pNew, nsSetAttrMode::SETATTR_NOHINTADJUST );
620                     }
621 
622                     if( nEnd < nTmpEnd )
623                     {
624                         SwTxtAttr* pNew = MakeTxtAttr( *GetDoc(),
625                             pHt->GetAttr(), nEnd, nTmpEnd );
626                         if ( pNew )
627                         {
628                             SwTxtCharFmt* pCharFmt = dynamic_cast<SwTxtCharFmt*>(pHt);
629                             if ( pCharFmt )
630                                 static_cast<SwTxtCharFmt*>(pNew)->SetSortNumber( pCharFmt->GetSortNumber() );
631 
632                             InsertHint( pNew,
633                                 nsSetAttrMode::SETATTR_NOHINTADJUST );
634                         }
635 
636 
637                         // jetzt kein i+1, weil das eingefuegte Attribut
638                         // ein anderes auf die Position geschoben hat !
639                         continue;
640                     }
641                 }
642             }
643             ++i;
644         }
645     }
646 
647     TryDeleteSwpHints();
648     if (bChanged)
649     {
650         if ( HasHints() )
651         {
652             m_pSwpHints->Resort();
653         }
654         //TxtFrm's reagieren auf aHint, andere auf aNew
655         SwUpdateAttr aHint( nMin, nMax, 0 );
656         NotifyClients( 0, &aHint );
657         SwFmtChg aNew( GetFmtColl() );
658         NotifyClients( 0, &aNew );
659     }
660 }
661 
662 
663 
664 /*************************************************************************
665  *				  SwTxtNode::GetCurWord()
666  *
667  * Aktuelles Wort zurueckliefern:
668  * Wir suchen immer von links nach rechts, es wird also das Wort
669  * vor nPos gesucht. Es sei denn, wir befinden uns am Anfang des
670  * Absatzes, dann wird das erste Wort zurueckgeliefert.
671  * Wenn dieses erste Wort nur aus Whitespaces besteht, returnen wir
672  * einen leeren String.
673  *************************************************************************/
674 
675 XubString SwTxtNode::GetCurWord( xub_StrLen nPos ) const
676 {
677     ASSERT( nPos <= m_Text.Len(), "SwTxtNode::GetCurWord: invalid index." );
678 
679     if (!m_Text.Len())
680         return m_Text;
681 
682 	Boundary aBndry;
683 	const uno::Reference< XBreakIterator > &rxBreak = pBreakIt->GetBreakIter();
684     if (rxBreak.is())
685     {
686         sal_Int16 nWordType = WordType::DICTIONARY_WORD;
687         lang::Locale aLocale( pBreakIt->GetLocale( GetLang( nPos ) ) );
688 #ifdef DEBUG
689         sal_Bool bBegin = rxBreak->isBeginWord( m_Text, nPos, aLocale, nWordType );
690         sal_Bool bEnd   = rxBreak->isEndWord  ( m_Text, nPos, aLocale, nWordType );
691         (void)bBegin;
692         (void)bEnd;
693 #endif
694         aBndry =
695             rxBreak->getWordBoundary( m_Text, nPos, aLocale, nWordType, sal_True );
696 
697         // if no word was found use previous word (if any)
698         if (aBndry.startPos == aBndry.endPos)
699         {
700             aBndry = rxBreak->previousWord( m_Text, nPos, aLocale, nWordType );
701         }
702     }
703 
704     // check if word was found and if it uses a symbol font, if so
705     // enforce returning an empty string
706     if (aBndry.endPos != aBndry.startPos && IsSymbol( (xub_StrLen)aBndry.startPos ))
707 		aBndry.endPos = aBndry.startPos;
708 
709     return m_Text.Copy( static_cast<xub_StrLen>(aBndry.startPos),
710                        static_cast<xub_StrLen>(aBndry.endPos - aBndry.startPos) );
711 }
712 
713 SwScanner::SwScanner( const SwTxtNode& rNd, const String& rTxt, const LanguageType* pLang,
714                       const ModelToViewHelper::ConversionMap* pConvMap,
715                       sal_uInt16 nType, xub_StrLen nStart, xub_StrLen nEnde, sal_Bool bClp )
716     : rNode( rNd ), rText( rTxt), pLanguage( pLang ), pConversionMap( pConvMap ), nLen( 0 ), nWordType( nType ), bClip( bClp )
717 {
718     ASSERT( rText.Len(), "SwScanner: EmptyString" );
719     nStartPos = nBegin = nStart;
720     nEndPos = nEnde;
721 
722     if ( pLanguage )
723     {
724         aCurrLang = *pLanguage;
725     }
726     else
727     {
728         ModelToViewHelper::ModelPosition aModelBeginPos = ModelToViewHelper::ConvertToModelPosition( pConversionMap, nBegin );
729         const xub_StrLen nModelBeginPos = (xub_StrLen)aModelBeginPos.mnPos;
730         aCurrLang = rNd.GetLang( nModelBeginPos );
731     }
732 }
733 
734 sal_Bool SwScanner::NextWord()
735 {
736     nBegin = nBegin + nLen;
737     Boundary aBound;
738 
739     CharClass& rCC = GetAppCharClass();
740     lang::Locale aOldLocale = rCC.getLocale();
741 
742 	while ( true )
743 	{
744         // skip non-letter characters:
745         while ( nBegin < rText.Len() )
746         {
747             if ( !lcl_IsSkippableWhiteSpace( rText.GetChar( nBegin ) ) )
748             {
749                 if ( !pLanguage )
750                 {
751                     const sal_uInt16 nNextScriptType = pBreakIt->GetBreakIter()->getScriptType( rText, nBegin );
752                     ModelToViewHelper::ModelPosition aModelBeginPos = ModelToViewHelper::ConvertToModelPosition( pConversionMap, nBegin );
753                     const xub_StrLen nBeginModelPos = (xub_StrLen)aModelBeginPos.mnPos;
754                     aCurrLang = rNode.GetLang( nBeginModelPos, 1, nNextScriptType );
755                 }
756 
757                 if ( nWordType != i18n::WordType::WORD_COUNT )
758                 {
759                     rCC.setLocale( pBreakIt->GetLocale( aCurrLang ) );
760                     if ( rCC.isLetterNumeric( rText.GetChar( nBegin ) ) )
761                         break;
762                 }
763                 else
764                     break;
765             }
766             ++nBegin;
767         }
768 
769 		if ( nBegin >= rText.Len() || nBegin >= nEndPos )
770 			return sal_False;
771 
772         // get the word boundaries
773         aBound = pBreakIt->GetBreakIter()->getWordBoundary( rText, nBegin,
774 				pBreakIt->GetLocale( aCurrLang ), nWordType, sal_True );
775         ASSERT( aBound.endPos >= aBound.startPos, "broken aBound result" );
776 
777         //no word boundaries could be found
778         if(aBound.endPos == aBound.startPos)
779             return sal_False;
780 
781         //if a word before is found it has to be searched for the next
782 		if(aBound.endPos == nBegin)
783             ++nBegin;
784         else
785 			break;
786     } // end while( true )
787 
788     rCC.setLocale( aOldLocale );
789 
790     // #i89042, as discussed with HDU: don't evaluate script changes for word count. Use whole word.
791     if ( nWordType == i18n::WordType::WORD_COUNT )
792     {
793         nBegin = Max( static_cast< xub_StrLen >(aBound.startPos), nBegin );
794         nLen   = 0;
795         if (static_cast< xub_StrLen >(aBound.endPos) > nBegin)
796             nLen = static_cast< xub_StrLen >(aBound.endPos) - nBegin;
797     }
798     else
799     {
800         // we have to differenciate between these cases:
801         if ( aBound.startPos <= nBegin )
802         {
803             ASSERT( aBound.endPos >= nBegin, "Unexpected aBound result" )
804 
805             // restrict boundaries to script boundaries and nEndPos
806             const sal_uInt16 nCurrScript = pBreakIt->GetBreakIter()->getScriptType( rText, nBegin );
807             XubString aTmpWord = rText.Copy( nBegin, static_cast<xub_StrLen>(aBound.endPos - nBegin) );
808             const sal_Int32 nScriptEnd = nBegin +
809                 pBreakIt->GetBreakIter()->endOfScript( aTmpWord, 0, nCurrScript );
810             const sal_Int32 nEnd = Min( aBound.endPos, nScriptEnd );
811 
812             // restrict word start to last script change position
813             sal_Int32 nScriptBegin = 0;
814             if ( aBound.startPos < nBegin )
815             {
816                 // search from nBegin backwards until the next script change
817                 aTmpWord = rText.Copy( static_cast<xub_StrLen>(aBound.startPos),
818                                        static_cast<xub_StrLen>(nBegin - aBound.startPos + 1) );
819                 nScriptBegin = aBound.startPos +
820                     pBreakIt->GetBreakIter()->beginOfScript( aTmpWord, nBegin - aBound.startPos,
821                                                     nCurrScript );
822             }
823 
824             nBegin = (xub_StrLen)Max( aBound.startPos, nScriptBegin );
825 	        nLen = (xub_StrLen)(nEnd - nBegin);
826         }
827         else
828         {
829             const sal_uInt16 nCurrScript = pBreakIt->GetBreakIter()->getScriptType( rText, aBound.startPos );
830             XubString aTmpWord = rText.Copy( static_cast<xub_StrLen>(aBound.startPos),
831                                              static_cast<xub_StrLen>(aBound.endPos - aBound.startPos) );
832             const sal_Int32 nScriptEnd = aBound.startPos +
833                 pBreakIt->GetBreakIter()->endOfScript( aTmpWord, 0, nCurrScript );
834             const sal_Int32 nEnd = Min( aBound.endPos, nScriptEnd );
835             nBegin = (xub_StrLen)aBound.startPos;
836 	        nLen = (xub_StrLen)(nEnd - nBegin);
837         }
838     }
839 
840 	// optionally clip the result of getWordBoundaries:
841 	if ( bClip )
842 	{
843 		aBound.startPos = Max( (xub_StrLen)aBound.startPos, nStartPos );
844 		aBound.endPos = Min( (xub_StrLen)aBound.endPos, nEndPos );
845         nBegin = (xub_StrLen)aBound.startPos;
846 	    nLen = (xub_StrLen)(aBound.endPos - nBegin);
847 	}
848 
849     if( ! nLen )
850         return sal_False;
851 
852     aWord = rText.Copy( nBegin, nLen );
853 
854     return sal_True;
855 }
856 
857 
858 sal_uInt16 SwTxtNode::Spell(SwSpellArgs* pArgs)
859 {
860 	// Die Aehnlichkeiten zu SwTxtFrm::_AutoSpell sind beabsichtigt ...
861 	// ACHTUNG: Ev. Bugs in beiden Routinen fixen!
862 
863 	uno::Reference<beans::XPropertySet> xProp( GetLinguPropertySet() );
864 
865 	xub_StrLen nBegin, nEnd;
866 
867     // modify string according to redline information and hidden text
868     const XubString aOldTxt( m_Text );
869     const bool bRestoreString =
870         lcl_MaskRedlinesAndHiddenText( *this, m_Text, 0, m_Text.Len() ) > 0;
871 
872     if ( pArgs->pStartNode != this )
873 		nBegin = 0;
874 	else
875         nBegin = pArgs->pStartIdx->GetIndex();
876 
877     nEnd = ( pArgs->pEndNode != this )
878             ? m_Text.Len()
879             : pArgs->pEndIdx->GetIndex();
880 
881 	pArgs->xSpellAlt = NULL;
882 
883     // 4 cases:
884     //
885     // 1. IsWrongDirty = 0 and GetWrong = 0
886     //      Everything is checked and correct
887     // 2. IsWrongDirty = 0 and GetWrong = 1
888     //      Everything is checked and errors are identified in the wrong list
889     // 3. IsWrongDirty = 1 and GetWrong = 0
890     //      Nothing has been checked
891     // 4. IsWrongDirty = 1 and GetWrong = 1
892     //      Text has been checked but there is an invalid range in the wrong list
893     //
894     // Nothing has to be done for case 1.
895     if ( ( IsWrongDirty() || GetWrong() ) && m_Text.Len() )
896     {
897         if ( nBegin > m_Text.Len() )
898         {
899             nBegin = m_Text.Len();
900         }
901         if ( nEnd > m_Text.Len() )
902         {
903             nEnd = m_Text.Len();
904         }
905         //
906         if(!IsWrongDirty())
907         {
908             xub_StrLen nTemp = GetWrong()->NextWrong( nBegin );
909             if(nTemp > nEnd)
910             {
911                 // reset original text
912                 if ( bRestoreString )
913                 {
914                     m_Text = aOldTxt;
915                 }
916                 return 0;
917             }
918             if(nTemp > nBegin)
919                 nBegin = nTemp;
920 
921         }
922 
923         // In case 2. we pass the wrong list to the scanned, because only
924         // the words in the wrong list have to be checked
925         SwScanner aScanner( *this, m_Text, 0, 0,
926                             WordType::DICTIONARY_WORD,
927                             nBegin, nEnd );
928         while( !pArgs->xSpellAlt.is() && aScanner.NextWord() )
929 		{
930 			const XubString& rWord = aScanner.GetWord();
931 
932             // get next language for next word, consider language attributes
933             // within the word
934             LanguageType eActLang = aScanner.GetCurrentLanguage();
935 
936             if( rWord.Len() > 0 && LANGUAGE_NONE != eActLang )
937 			{
938 				if (pArgs->xSpeller.is())
939 				{
940 					SvxSpellWrapper::CheckSpellLang( pArgs->xSpeller, eActLang );
941 					pArgs->xSpellAlt = pArgs->xSpeller->spell( rWord, eActLang,
942 											Sequence< PropertyValue >() );
943 				}
944 				if( (pArgs->xSpellAlt).is() )
945 				{
946 					if( IsSymbol( aScanner.GetBegin() ) )
947 					{
948 						pArgs->xSpellAlt = NULL;
949 					}
950 					else
951 					{
952 						// make sure the selection build later from the
953 						// data below does not include footnotes and other
954 						// "in word" character to the left and right in order
955 						// to preserve those. Therefore count those "in words"
956 						// in order to modify the selection accordingly.
957 						const sal_Unicode* pChar = rWord.GetBuffer();
958 						xub_StrLen nLeft = 0;
959 						while (pChar && *pChar++ == CH_TXTATR_INWORD)
960 							++nLeft;
961 						pChar = rWord.Len() ? rWord.GetBuffer() + rWord.Len() - 1 : 0;
962 						xub_StrLen nRight = 0;
963 						while (pChar && *pChar-- == CH_TXTATR_INWORD)
964 							++nRight;
965 
966 						pArgs->pStartNode = this;
967 						pArgs->pEndNode = this;
968                         pArgs->pStartIdx->Assign(this, aScanner.GetEnd() - nRight );
969                         pArgs->pEndIdx->Assign(this, aScanner.GetBegin() + nLeft );
970 					}
971 				}
972 			}
973         }
974 	}
975 
976     // reset original text
977     if ( bRestoreString )
978     {
979         m_Text = aOldTxt;
980     }
981 
982     return pArgs->xSpellAlt.is() ? 1 : 0;
983 }
984 
985 
986 void SwTxtNode::SetLanguageAndFont( const SwPaM &rPaM,
987     LanguageType nLang, sal_uInt16 nLangWhichId,
988     const Font *pFont,  sal_uInt16 nFontWhichId )
989 {
990     sal_uInt16 aRanges[] = {
991             nLangWhichId, nLangWhichId,
992             nFontWhichId, nFontWhichId,
993             0, 0, 0 };
994     if (!pFont)
995         aRanges[2] = aRanges[3] = 0;    // clear entries with font WhichId
996 
997     SwEditShell *pEditShell = GetDoc()->GetEditShell();
998     SfxItemSet aSet( pEditShell->GetAttrPool(), aRanges );
999     aSet.Put( SvxLanguageItem( nLang, nLangWhichId ) );
1000 
1001     DBG_ASSERT( pFont, "target font missing?" );
1002     if (pFont)
1003     {
1004         SvxFontItem aFontItem = (SvxFontItem&) aSet.Get( nFontWhichId );
1005         aFontItem.SetFamilyName(   pFont->GetName());
1006         aFontItem.SetFamily(       pFont->GetFamily());
1007         aFontItem.SetStyleName(    pFont->GetStyleName());
1008         aFontItem.SetPitch(        pFont->GetPitch());
1009         aFontItem.SetCharSet( pFont->GetCharSet() );
1010         aSet.Put( aFontItem );
1011     }
1012 
1013     GetDoc()->InsertItemSet( rPaM, aSet, 0 );
1014     // SetAttr( aSet );    <- Does not set language attribute of empty paragraphs correctly,
1015     //                     <- because since there is no selection the flag to garbage
1016     //                     <- collect all attributes is set, and therefore attributes spanned
1017     //                     <- over empty selection are removed.
1018 
1019 }
1020 
1021 
1022 sal_uInt16 SwTxtNode::Convert( SwConversionArgs &rArgs )
1023 {
1024     // get range of text within node to be converted
1025     // (either all the text or the the text within the selection
1026     // when the conversion was started)
1027     xub_StrLen nTextBegin, nTextEnd;
1028     //
1029     if ( rArgs.pStartNode != this )
1030 	{
1031         nTextBegin = 0;
1032 	}
1033     else
1034         nTextBegin = rArgs.pStartIdx->GetIndex();
1035     if (nTextBegin > m_Text.Len())
1036     {
1037         nTextBegin = m_Text.Len();
1038     }
1039 
1040     nTextEnd = ( rArgs.pEndNode != this )
1041         ?  m_Text.Len()
1042         :  ::std::min( rArgs.pEndIdx->GetIndex(), m_Text.Len() );
1043 
1044     rArgs.aConvText = rtl::OUString();
1045 
1046     // modify string according to redline information and hidden text
1047     const XubString aOldTxt( m_Text );
1048     const bool bRestoreString =
1049         lcl_MaskRedlinesAndHiddenText( *this, m_Text, 0, m_Text.Len() ) > 0;
1050 
1051     sal_Bool    bFound  = sal_False;
1052     xub_StrLen  nBegin  = nTextBegin;
1053     xub_StrLen  nLen = 0;
1054 	LanguageType nLangFound = LANGUAGE_NONE;
1055     if (!m_Text.Len())
1056     {
1057         if (rArgs.bAllowImplicitChangesForNotConvertibleText)
1058         {
1059             // create SwPaM with mark & point spanning empty paragraph
1060             //SwPaM aCurPaM( *this, *this, nBegin, nBegin + nLen ); <-- wrong c-tor, does sth different
1061             SwPaM aCurPaM( *this, 0 );
1062 
1063             SetLanguageAndFont( aCurPaM,
1064                     rArgs.nConvTargetLang, RES_CHRATR_CJK_LANGUAGE,
1065                     rArgs.pTargetFont, RES_CHRATR_CJK_FONT );
1066         }
1067     }
1068     else
1069     {
1070         SwLanguageIterator aIter( *this, nBegin );
1071 
1072         // find non zero length text portion of appropriate language
1073         do {
1074 			nLangFound = aIter.GetLanguage();
1075             sal_Bool bLangOk =  (nLangFound == rArgs.nConvSrcLang) ||
1076                                 (editeng::HangulHanjaConversion::IsChinese( nLangFound ) &&
1077                                  editeng::HangulHanjaConversion::IsChinese( rArgs.nConvSrcLang ));
1078 
1079 			xub_StrLen nChPos = aIter.GetChgPos();
1080 			// the position at the end of the paragraph returns -1
1081 			// which becomes 65535 when converted to xub_StrLen,
1082 			// and thus must be cut to the end of the actual string.
1083 			if (nChPos == (xub_StrLen) -1)
1084             {
1085                 nChPos = m_Text.Len();
1086             }
1087 
1088 			nLen = nChPos - nBegin;
1089 			bFound = bLangOk && nLen > 0;
1090 			if (!bFound)
1091             {
1092                 // create SwPaM with mark & point spanning the attributed text
1093                 //SwPaM aCurPaM( *this, *this, nBegin, nBegin + nLen ); <-- wrong c-tor, does sth different
1094                 SwPaM aCurPaM( *this, nBegin );
1095                 aCurPaM.SetMark();
1096                 aCurPaM.GetPoint()->nContent = nBegin + nLen;
1097 
1098                 // check script type of selected text
1099                 SwEditShell *pEditShell = GetDoc()->GetEditShell();
1100                 pEditShell->Push();             // save current cursor on stack
1101                 pEditShell->SetSelection( aCurPaM );
1102                 sal_Bool bIsAsianScript = (SCRIPTTYPE_ASIAN == pEditShell->GetScriptType());
1103                 pEditShell->Pop( sal_False );   // restore cursor from stack
1104 
1105                 if (!bIsAsianScript && rArgs.bAllowImplicitChangesForNotConvertibleText)
1106                 {
1107                     SetLanguageAndFont( aCurPaM,
1108                             rArgs.nConvTargetLang, RES_CHRATR_CJK_LANGUAGE,
1109                             rArgs.pTargetFont, RES_CHRATR_CJK_FONT );
1110                 }
1111 				nBegin = nChPos;    // start of next language portion
1112             }
1113         } while (!bFound && aIter.Next());	/* loop while nothing was found and still sth is left to be searched */
1114     }
1115 
1116     // keep resulting text within selection / range of text to be converted
1117     if (nBegin < nTextBegin)
1118         nBegin = nTextBegin;
1119     if (nBegin + nLen > nTextEnd)
1120         nLen = nTextEnd - nBegin;
1121     sal_Bool bInSelection = nBegin < nTextEnd;
1122 
1123     if (bFound && bInSelection)     // convertible text found within selection/range?
1124     {
1125         const XubString aTxtPortion = m_Text.Copy( nBegin, nLen );
1126         DBG_ASSERT( m_Text.Len() > 0, "convertible text portion missing!" );
1127         rArgs.aConvText     = m_Text.Copy( nBegin, nLen );
1128 		rArgs.nConvTextLang = nLangFound;
1129 
1130         // position where to start looking in next iteration (after current ends)
1131 		rArgs.pStartNode = this;
1132         rArgs.pStartIdx->Assign(this, nBegin + nLen );
1133         // end position (when we have travelled over the whole document)
1134         rArgs.pEndNode = this;
1135         rArgs.pEndIdx->Assign(this, nBegin );
1136 	}
1137 
1138     // restore original text
1139     if ( bRestoreString )
1140     {
1141         m_Text = aOldTxt;
1142     }
1143 
1144     return rArgs.aConvText.getLength() ? 1 : 0;
1145 }
1146 
1147 // Die Aehnlichkeiten zu SwTxtNode::Spell sind beabsichtigt ...
1148 // ACHTUNG: Ev. Bugs in beiden Routinen fixen!
1149 SwRect SwTxtFrm::_AutoSpell( const SwCntntNode* pActNode, const SwViewOption& rViewOpt, xub_StrLen nActPos )
1150 {
1151     SwRect aRect;
1152 #if OSL_DEBUG_LEVEL > 1
1153     static sal_Bool bStop = sal_False;
1154     if ( bStop )
1155         return aRect;
1156 #endif
1157     // Die Aehnlichkeiten zu SwTxtNode::Spell sind beabsichtigt ...
1158     // ACHTUNG: Ev. Bugs in beiden Routinen fixen!
1159     SwTxtNode *pNode = GetTxtNode();
1160     if( pNode != pActNode || !nActPos )
1161         nActPos = STRING_LEN;
1162 
1163     SwAutoCompleteWord& rACW = SwDoc::GetAutoCompleteWords();
1164 
1165     // modify string according to redline information and hidden text
1166     const XubString aOldTxt( pNode->GetTxt() );
1167     const bool bRestoreString =
1168             lcl_MaskRedlinesAndHiddenText( *pNode, pNode->m_Text,
1169                 0, pNode->GetTxt().Len() )     > 0;
1170 
1171     // a change of data indicates that at least one word has been modified
1172     const sal_Bool bRedlineChg =
1173         ( pNode->GetTxt().GetBuffer() != aOldTxt.GetBuffer() );
1174 
1175     xub_StrLen nBegin = 0;
1176     xub_StrLen nEnd = pNode->GetTxt().Len();
1177     xub_StrLen nInsertPos = 0;
1178     xub_StrLen nChgStart = STRING_LEN;
1179     xub_StrLen nChgEnd = 0;
1180     xub_StrLen nInvStart = STRING_LEN;
1181     xub_StrLen nInvEnd = 0;
1182 
1183     const sal_Bool bAddAutoCmpl = pNode->IsAutoCompleteWordDirty() &&
1184                                   rViewOpt.IsAutoCompleteWords();
1185 
1186     if( pNode->GetWrong() )
1187     {
1188         nBegin = pNode->GetWrong()->GetBeginInv();
1189         if( STRING_LEN != nBegin )
1190         {
1191             nEnd = pNode->GetWrong()->GetEndInv();
1192             if ( nEnd > pNode->GetTxt().Len() )
1193             {
1194                 nEnd = pNode->GetTxt().Len();
1195             }
1196         }
1197 
1198         // get word around nBegin, we start at nBegin - 1
1199         if ( STRING_LEN != nBegin )
1200         {
1201             if ( nBegin )
1202                 --nBegin;
1203 
1204             LanguageType eActLang = pNode->GetLang( nBegin );
1205             Boundary aBound =
1206                 pBreakIt->GetBreakIter()->getWordBoundary( pNode->GetTxt(), nBegin,
1207                     pBreakIt->GetLocale( eActLang ),
1208                     WordType::DICTIONARY_WORD, sal_True );
1209             nBegin = xub_StrLen(aBound.startPos);
1210         }
1211 
1212         // get the position in the wrong list
1213         nInsertPos = pNode->GetWrong()->GetWrongPos( nBegin );
1214 
1215         // sometimes we have to skip one entry
1216         if( nInsertPos < pNode->GetWrong()->Count() &&
1217             nBegin == pNode->GetWrong()->Pos( nInsertPos ) +
1218                       pNode->GetWrong()->Len( nInsertPos ) )
1219                 nInsertPos++;
1220     }
1221 
1222     sal_Bool bFresh = nBegin < nEnd;
1223 
1224     if( nBegin < nEnd )
1225     {
1226         //! register listener to LinguServiceEvents now in order to get
1227         //! notified about relevant changes in the future
1228         SwModule *pModule = SW_MOD();
1229         if (!pModule->GetLngSvcEvtListener().is())
1230             pModule->CreateLngSvcEvtListener();
1231 
1232 		uno::Reference< XSpellChecker1 > xSpell( ::GetSpellChecker() );
1233         SwDoc* pDoc = pNode->GetDoc();
1234 
1235         SwScanner aScanner( *pNode, pNode->GetTxt(), 0, 0,
1236                             WordType::DICTIONARY_WORD, nBegin, nEnd);
1237 
1238         while( aScanner.NextWord() )
1239         {
1240             const XubString& rWord = aScanner.GetWord();
1241             nBegin = aScanner.GetBegin();
1242             xub_StrLen nLen = aScanner.GetLen();
1243 
1244             // get next language for next word, consider language attributes
1245             // within the word
1246             LanguageType eActLang = aScanner.GetCurrentLanguage();
1247 
1248             sal_Bool bSpell = sal_True;
1249             bSpell = xSpell.is() ? xSpell->hasLanguage( eActLang ) : sal_False;
1250             if( bSpell && rWord.Len() > 0 )
1251             {
1252                 // check for: bAlter => xHyphWord.is()
1253                 DBG_ASSERT(!bSpell || xSpell.is(), "NULL pointer");
1254 
1255                 if( !xSpell->isValid( rWord, eActLang, Sequence< PropertyValue >() ) )
1256                 {
1257                     xub_StrLen nSmartTagStt = nBegin;
1258                     xub_StrLen nDummy = 1;
1259                     if ( !pNode->GetSmartTags() || !pNode->GetSmartTags()->InWrongWord( nSmartTagStt, nDummy ) )
1260                     {
1261                         if( !pNode->GetWrong() )
1262                         {
1263                             pNode->SetWrong( new SwWrongList( WRONGLIST_SPELL ) );
1264                             pNode->GetWrong()->SetInvalid( 0, nEnd );
1265                         }
1266                         if( pNode->GetWrong()->Fresh( nChgStart, nChgEnd,
1267                             nBegin, nLen, nInsertPos, nActPos ) )
1268                             pNode->GetWrong()->Insert( rtl::OUString(), 0, nBegin, nLen, nInsertPos++ );
1269                         else
1270                         {
1271                             nInvStart = nBegin;
1272                             nInvEnd = nBegin + nLen;
1273                         }
1274                     }
1275                 }
1276                 else if( bAddAutoCmpl && rACW.GetMinWordLen() <= rWord.Len() )
1277                 {
1278                     if ( bRedlineChg )
1279                     {
1280                         XubString rNewWord( rWord );
1281                         rACW.InsertWord( rNewWord, *pDoc );
1282                     }
1283                     else
1284                         rACW.InsertWord( rWord, *pDoc );
1285                 }
1286             }
1287         }
1288     }
1289 
1290     // reset original text
1291     // i63141 before calling GetCharRect(..) with formatting!
1292     if ( bRestoreString )
1293     {
1294         pNode->m_Text = aOldTxt;
1295     }
1296     if( pNode->GetWrong() )
1297     {
1298         if( bFresh )
1299             pNode->GetWrong()->Fresh( nChgStart, nChgEnd,
1300                                       nEnd, 0, nInsertPos, nActPos );
1301 
1302         //
1303         // Calculate repaint area:
1304         //
1305         if( nChgStart < nChgEnd )
1306         {
1307             aRect = lcl_CalculateRepaintRect( *this, nChgStart, nChgEnd );
1308         }
1309 
1310         pNode->GetWrong()->SetInvalid( nInvStart, nInvEnd );
1311         pNode->SetWrongDirty( STRING_LEN != pNode->GetWrong()->GetBeginInv() );
1312         if( !pNode->GetWrong()->Count() && ! pNode->IsWrongDirty() )
1313             pNode->SetWrong( NULL );
1314     }
1315     else
1316         pNode->SetWrongDirty( false );
1317 
1318     if( bAddAutoCmpl )
1319         pNode->SetAutoCompleteWordDirty( false );
1320 
1321     return aRect;
1322 }
1323 
1324 /** Function: SmartTagScan
1325 
1326     Function scans words in current text and checks them in the
1327     smarttag libraries. If the check returns true to bounds of the
1328     recognized words are stored into a list which is used later for drawing
1329     the underline.
1330 
1331     @param SwCntntNode* pActNode
1332 
1333     @param xub_StrLen nActPos
1334 
1335     @return SwRect: Repaint area
1336 */
1337 SwRect SwTxtFrm::SmartTagScan( SwCntntNode* /*pActNode*/, xub_StrLen /*nActPos*/ )
1338 {
1339     SwRect aRet;
1340     SwTxtNode *pNode = GetTxtNode();
1341     const rtl::OUString& rText = pNode->GetTxt();
1342 
1343     // Iterate over language portions
1344     SmartTagMgr& rSmartTagMgr = SwSmartTagMgr::Get();
1345 
1346     SwWrongList* pSmartTagList = pNode->GetSmartTags();
1347 
1348     xub_StrLen nBegin = 0;
1349     xub_StrLen nEnd = static_cast< xub_StrLen >(rText.getLength());
1350 
1351     if ( pSmartTagList )
1352     {
1353         if ( pSmartTagList->GetBeginInv() != STRING_LEN )
1354         {
1355             nBegin = pSmartTagList->GetBeginInv();
1356             nEnd = Min( pSmartTagList->GetEndInv(), (xub_StrLen)rText.getLength() );
1357 
1358             if ( nBegin < nEnd )
1359             {
1360                 const LanguageType aCurrLang = pNode->GetLang( nBegin );
1361                 const com::sun::star::lang::Locale aCurrLocale = pBreakIt->GetLocale( aCurrLang );
1362                 nBegin = static_cast< xub_StrLen >(pBreakIt->GetBreakIter()->beginOfSentence( rText, nBegin, aCurrLocale ));
1363                 nEnd = static_cast< xub_StrLen >(Min( rText.getLength(), pBreakIt->GetBreakIter()->endOfSentence( rText, nEnd, aCurrLocale ) ));
1364             }
1365         }
1366     }
1367 
1368     const sal_uInt16 nNumberOfEntries = pSmartTagList ? pSmartTagList->Count() : 0;
1369     sal_uInt16 nNumberOfRemovedEntries = 0;
1370     sal_uInt16 nNumberOfInsertedEntries = 0;
1371 
1372     // clear smart tag list between nBegin and nEnd:
1373     if ( 0 != nNumberOfEntries )
1374     {
1375         xub_StrLen nChgStart = STRING_LEN;
1376         xub_StrLen nChgEnd = 0;
1377         const sal_uInt16 nCurrentIndex = pSmartTagList->GetWrongPos( nBegin );
1378         pSmartTagList->Fresh( nChgStart, nChgEnd, nBegin, nEnd - nBegin, nCurrentIndex, STRING_LEN );
1379         nNumberOfRemovedEntries = nNumberOfEntries - pSmartTagList->Count();
1380     }
1381 
1382     if ( nBegin < nEnd )
1383     {
1384         // Expand the string:
1385         rtl::OUString aExpandText;
1386         const ModelToViewHelper::ConversionMap* pConversionMap =
1387                 pNode->BuildConversionMap( aExpandText );
1388 
1389         // Ownership ov ConversionMap is passed to SwXTextMarkup object!
1390         Reference< com::sun::star::text::XTextMarkup > xTextMarkup =
1391              new SwXTextMarkup( *pNode, pConversionMap );
1392 
1393         Reference< ::com::sun::star::frame::XController > xController = pNode->GetDoc()->GetDocShell()->GetController();
1394 
1395 	SwPosition start(*pNode, nBegin);
1396 	SwPosition end  (*pNode, nEnd);
1397         Reference< ::com::sun::star::text::XTextRange > xRange = SwXTextRange::CreateXTextRange(*pNode->GetDoc(), start, &end);
1398 
1399 	rSmartTagMgr.RecognizeTextRange(xRange, xTextMarkup, xController);
1400 
1401 
1402 	xub_StrLen nLangBegin = nBegin;
1403         xub_StrLen nLangEnd = nEnd;
1404 
1405         // smart tag recognization has to be done for each language portion:
1406         SwLanguageIterator aIter( *pNode, nLangBegin );
1407 
1408         do
1409         {
1410             const LanguageType nLang = aIter.GetLanguage();
1411             const com::sun::star::lang::Locale aLocale = pBreakIt->GetLocale( nLang );
1412             nLangEnd = Min( nEnd, aIter.GetChgPos() );
1413 
1414             const sal_uInt32 nExpandBegin = ModelToViewHelper::ConvertToViewPosition( pConversionMap, nLangBegin );
1415             const sal_uInt32 nExpandEnd   = ModelToViewHelper::ConvertToViewPosition( pConversionMap, nLangEnd );
1416 
1417             rSmartTagMgr.RecognizeString(aExpandText, xTextMarkup, xController, aLocale, nExpandBegin, nExpandEnd - nExpandBegin );
1418 
1419             nLangBegin = nLangEnd;
1420         }
1421         while ( aIter.Next() && nLangEnd < nEnd );
1422 
1423         pSmartTagList = pNode->GetSmartTags();
1424 
1425         const sal_uInt16 nNumberOfEntriesAfterRecognize = pSmartTagList ? pSmartTagList->Count() : 0;
1426         nNumberOfInsertedEntries = nNumberOfEntriesAfterRecognize - ( nNumberOfEntries - nNumberOfRemovedEntries );
1427     }
1428 
1429     if( pSmartTagList )
1430 	{
1431         //
1432         // Update WrongList stuff
1433         //
1434         pSmartTagList->SetInvalid( STRING_LEN, 0 );
1435         pNode->SetSmartTagDirty( STRING_LEN != pSmartTagList->GetBeginInv() );
1436 
1437         if( !pSmartTagList->Count() && !pNode->IsSmartTagDirty() )
1438             pNode->SetSmartTags( NULL );
1439 
1440         //
1441         // Calculate repaint area:
1442         //
1443 #if OSL_DEBUG_LEVEL > 1
1444         const sal_uInt16 nNumberOfEntriesAfterRecognize2 = pSmartTagList->Count();
1445 		(void) nNumberOfEntriesAfterRecognize2;
1446 #endif
1447         if ( nBegin < nEnd && ( 0 != nNumberOfRemovedEntries ||
1448                                 0 != nNumberOfInsertedEntries ) )
1449 		{
1450             aRet = lcl_CalculateRepaintRect( *this, nBegin, nEnd );
1451         }
1452     }
1453 	else
1454         pNode->SetSmartTagDirty( false );
1455 
1456     return aRet;
1457 }
1458 
1459 
1460 // Wird vom CollectAutoCmplWords gerufen
1461 void SwTxtFrm::CollectAutoCmplWrds( SwCntntNode* pActNode, xub_StrLen nActPos )
1462 {
1463 	SwTxtNode *pNode = GetTxtNode();
1464 	if( pNode != pActNode || !nActPos )
1465 		nActPos = STRING_LEN;
1466 
1467     SwDoc* pDoc = pNode->GetDoc();
1468     SwAutoCompleteWord& rACW = SwDoc::GetAutoCompleteWords();
1469 
1470 	xub_StrLen nBegin = 0;
1471     xub_StrLen nEnd = pNode->GetTxt().Len();
1472 	xub_StrLen nLen;
1473 	sal_Bool bACWDirty = sal_False, bAnyWrd = sal_False;
1474 
1475 
1476 	if( nBegin < nEnd )
1477 	{
1478         sal_uInt16 nCnt = 200;
1479         SwScanner aScanner( *pNode, pNode->GetTxt(), 0, 0,
1480                             WordType::DICTIONARY_WORD, nBegin, nEnd );
1481         while( aScanner.NextWord() )
1482 		{
1483 			nBegin = aScanner.GetBegin();
1484 			nLen = aScanner.GetLen();
1485 			if( rACW.GetMinWordLen() <= nLen )
1486 			{
1487 				const XubString& rWord = aScanner.GetWord();
1488 
1489 				if( nActPos < nBegin || ( nBegin + nLen ) < nActPos )
1490 				{
1491                     if( rACW.GetMinWordLen() <= rWord.Len() )
1492                         rACW.InsertWord( rWord, *pDoc );
1493                     bAnyWrd = sal_True;
1494 				}
1495 				else
1496 					bACWDirty = sal_True;
1497 			}
1498             if( !--nCnt )
1499             {
1500                 if ( Application::AnyInput( INPUT_ANY ) )
1501                     return;
1502                 nCnt = 100;
1503             }
1504 		}
1505 	}
1506 
1507 	if( bAnyWrd && !bACWDirty )
1508 		pNode->SetAutoCompleteWordDirty( sal_False );
1509 }
1510 
1511 
1512 /*************************************************************************
1513  *						SwTxtNode::Hyphenate
1514  *************************************************************************/
1515 // Findet den TxtFrm und sucht dessen CalcHyph
1516 
1517 sal_Bool SwTxtNode::Hyphenate( SwInterHyphInfo &rHyphInf )
1518 {
1519 	// Abkuerzung: am Absatz ist keine Sprache eingestellt:
1520     if ( LANGUAGE_NONE == sal_uInt16( GetSwAttrSet().GetLanguage().GetLanguage() )
1521          && USHRT_MAX == GetLang( 0, m_Text.Len() ) )
1522     {
1523 		if( !rHyphInf.IsCheck() )
1524 			rHyphInf.SetNoLang( sal_True );
1525 		return sal_False;
1526 	}
1527 
1528 	if( pLinguNode != this )
1529 	{
1530 		pLinguNode = this;
1531 		pLinguFrm = (SwTxtFrm*)getLayoutFrm( GetDoc()->GetCurrentLayout(), (Point*)(rHyphInf.GetCrsrPos()) );
1532 	}
1533 	SwTxtFrm *pFrm = pLinguFrm;
1534 	if( pFrm )
1535         pFrm = &(pFrm->GetFrmAtOfst( rHyphInf.nStart ));
1536 	else
1537 	{
1538 		// 4935: Seit der Trennung ueber Sonderbereiche sind Faelle
1539 		// moeglich, in denen kein Frame zum Node vorliegt.
1540 		// Also kein ASSERT!
1541 #if OSL_DEBUG_LEVEL > 1
1542 		ASSERT( pFrm, "!SwTxtNode::Hyphenate: can't find any frame" );
1543 #endif
1544 		return sal_False;
1545 	}
1546 
1547 	while( pFrm )
1548 	{
1549 		if( pFrm->Hyphenate( rHyphInf ) )
1550 		{
1551 			// Das Layout ist nicht robust gegen "Direktformatierung"
1552 			// (7821, 7662, 7408); vgl. layact.cxx,
1553 			// SwLayAction::_TurboAction(), if( !pCnt->IsValid() ...
1554 			pFrm->SetCompletePaint();
1555 			return sal_True;
1556 		}
1557 		pFrm = (SwTxtFrm*)(pFrm->GetFollow());
1558 		if( pFrm )
1559 		{
1560 			rHyphInf.nLen = rHyphInf.nLen - (pFrm->GetOfst() - rHyphInf.nStart);
1561 			rHyphInf.nStart = pFrm->GetOfst();
1562 		}
1563 	}
1564 	return sal_False;
1565 }
1566 
1567 #ifdef LINGU_STATISTIK
1568 
1569 // globale Variable
1570 SwLinguStatistik aSwLinguStat;
1571 
1572 
1573 void SwLinguStatistik::Flush()
1574 {
1575 	if ( !nWords )
1576 		return ;
1577 
1578 	static char *pLogName = 0;
1579 	const sal_Bool bFirstOpen = pLogName ? sal_False : sal_True;
1580 	if( bFirstOpen )
1581 	{
1582 		char *pPath = getenv( "TEMP" );
1583 		char *pName = "swlingu.stk";
1584 		if( !pPath )
1585 			pLogName = pName;
1586 		else
1587 		{
1588 			const int nLen = strlen(pPath);
1589 			// fuer dieses new wird es kein delete geben.
1590 			pLogName = new char[nLen + strlen(pName) + 3];
1591 			if(nLen && (pPath[nLen-1] == '\\') || (pPath[nLen-1] == '/'))
1592 				snprintf( pLogName, sizeof(pLogName), "%s%s", pPath, pName );
1593 			else
1594 				snprintf( pLogName, sizeof(pLogName), "%s/%s", pPath, pName );
1595 		}
1596 	}
1597 	SvFileStream aStream( String::CreateFromAscii(pLogName), (bFirstOpen
1598 										? STREAM_WRITE | STREAM_TRUNC
1599 										: STREAM_WRITE ));
1600 
1601 	if( !aStream.GetError() )
1602 	{
1603 		if ( bFirstOpen )
1604 			aStream << "\nLinguistik-Statistik\n";
1605 		aStream << endl << ++nFlushCnt << ". Messung\n";
1606 		aStream << "Rechtschreibung\n";
1607 		aStream << "gepruefte Worte: \t" << nWords << endl;
1608 		aStream << "als fehlerhaft erkannt:\t" << nWrong << endl;
1609 		aStream << "Alternativvorschlaege:\t" << nAlter << endl;
1610 		if ( nWrong )
1611 			aStream << "Durchschnitt:\t\t" << nAlter*1.0 / nWrong << endl;
1612 		aStream << "Dauer (msec):\t\t" << nSpellTime << endl;
1613 		aStream << "\nThesaurus\n";
1614 		aStream << "Synonyme gesamt:\t" << nSynonym << endl;
1615 		if ( nSynonym )
1616 			aStream << "Synonym-Durchschnitt:\t" <<
1617 							nSynonym*1.0 / ( nWords - nNoSynonym ) << endl;
1618 		aStream << "ohne Synonyme:\t\t" << nNoSynonym << endl;
1619 		aStream << "Bedeutungen gesamt:\t" << nSynonym << endl;
1620 		aStream << "keine Bedeutungen:\t"<< nNoSynonym << endl;
1621 		aStream << "Dauer (msec):\t\t" << nTheTime << endl;
1622 		aStream << "\nHyphenator\n";
1623 		aStream << "Trennstellen gesamt:\t" << nHyphens << endl;
1624 		if ( nHyphens )
1625 			aStream << "Hyphen-Durchschnitt:\t" <<
1626 					nHyphens*1.0 / ( nWords - nNoHyph - nHyphErr ) << endl;
1627 		aStream << "keine Trennstellen:\t" << nNoHyph << endl;
1628 		aStream << "Trennung verweigert:\t" << nHyphErr << endl;
1629 		aStream << "Dauer (msec):\t\t" << nHyphTime << endl;
1630 		aStream << "---------------------------------------------\n";
1631 	}
1632 	nWords = nWrong = nAlter = nSynonym = nNoSynonym =
1633 	nHyphens = nNoHyph = nHyphErr = nSpellTime = nTheTime =
1634 	nHyphTime = 0;
1635 	//pThes = NULL;
1636 }
1637 
1638 #endif
1639 
1640 namespace sw // #i120045# namespace to avoid XCode template-misoptimization
1641 {
1642 struct TransliterationChgData
1643 {
1644     xub_StrLen              nStart;
1645     xub_StrLen              nLen;
1646     String                  sChanged;
1647     Sequence< sal_Int32 >   aOffsets;
1648 };
1649 }
1650 using sw::TransliterationChgData;
1651 
1652 // change text to Upper/Lower/Hiragana/Katagana/...
1653 void SwTxtNode::TransliterateText(
1654     utl::TransliterationWrapper& rTrans,
1655     xub_StrLen nStt, xub_StrLen nEnd,
1656     SwUndoTransliterate* pUndo )
1657 {
1658     if (nStt < nEnd && pBreakIt->GetBreakIter().is())
1659 	{
1660         // since we don't use Hiragana/Katakana or half-width/full-width transliterations here
1661         // it is fine to use ANYWORD_IGNOREWHITESPACES. (ANY_WORD btw is broken and will
1662         // occasionaly miss words in consecutive sentences). Also with ANYWORD_IGNOREWHITESPACES
1663         // text like 'just-in-time' will be converted to 'Just-In-Time' which seems to be the
1664         // proper thing to do.
1665         const sal_Int16 nWordType = WordType::ANYWORD_IGNOREWHITESPACES;
1666 
1667         //! In order to have less trouble with changing text size, e.g. because
1668         //! of ligatures or � (German small sz) being resolved, we need to process
1669         //! the text replacements from end to start.
1670         //! This way the offsets for the yet to be changed words will be
1671         //! left unchanged by the already replaced text.
1672         //! For this we temporarily save the changes to be done in this vector
1673         std::vector< TransliterationChgData >   aChanges;
1674         TransliterationChgData                  aChgData;
1675 
1676         if (rTrans.getType() == (sal_uInt32)TransliterationModulesExtra::TITLE_CASE)
1677         {
1678             // for 'capitalize every word' we need to iterate over each word
1679 
1680             Boundary aSttBndry;
1681             Boundary aEndBndry;
1682             aSttBndry = pBreakIt->GetBreakIter()->getWordBoundary(
1683                         GetTxt(), nStt,
1684                         pBreakIt->GetLocale( GetLang( nStt ) ),
1685                         nWordType,
1686                         sal_True /*prefer forward direction*/);
1687             aEndBndry = pBreakIt->GetBreakIter()->getWordBoundary(
1688                         GetTxt(), nEnd,
1689                         pBreakIt->GetLocale( GetLang( nEnd ) ),
1690                         nWordType,
1691                         sal_False /*prefer backward direction*/);
1692 
1693             // prevent backtracking to the previous word if selection is at word boundary
1694             if (aSttBndry.endPos <= nStt)
1695             {
1696                 aSttBndry = pBreakIt->GetBreakIter()->nextWord(
1697                         GetTxt(), aSttBndry.endPos,
1698                         pBreakIt->GetLocale( GetLang( aSttBndry.endPos ) ),
1699                         nWordType);
1700             }
1701             // prevent advancing to the next word if selection is at word boundary
1702             if (aEndBndry.startPos >= nEnd)
1703             {
1704                 aEndBndry = pBreakIt->GetBreakIter()->previousWord(
1705                         GetTxt(), aEndBndry.startPos,
1706                         pBreakIt->GetLocale( GetLang( aEndBndry.startPos ) ),
1707                         nWordType);
1708             }
1709 
1710             Boundary aCurWordBndry( aSttBndry );
1711             while (aCurWordBndry.startPos <= aEndBndry.startPos)
1712             {
1713                 nStt = (xub_StrLen)aCurWordBndry.startPos;
1714                 nEnd = (xub_StrLen)aCurWordBndry.endPos;
1715                 sal_Int32 nLen = nEnd - nStt;
1716                 DBG_ASSERT( nLen > 0, "invalid word length of 0" );
1717 #if OSL_DEBUG_LEVEL > 1
1718                 String aText( GetTxt().Copy( nStt, nLen ) );
1719 #endif
1720 
1721 		        Sequence <sal_Int32> aOffsets;
1722                 String sChgd( rTrans.transliterate( GetTxt(), GetLang( nStt ), nStt, nLen, &aOffsets ));
1723 
1724                 if (!m_Text.Equals( sChgd, nStt, nLen ))
1725                 {
1726                     aChgData.nStart     = nStt;
1727                     aChgData.nLen       = nLen;
1728                     aChgData.sChanged   = sChgd;
1729                     aChgData.aOffsets   = aOffsets;
1730                     aChanges.push_back( aChgData );
1731                 }
1732 
1733                 aCurWordBndry = pBreakIt->GetBreakIter()->nextWord(
1734                         GetTxt(), nEnd,
1735                         pBreakIt->GetLocale( GetLang( nEnd ) ),
1736                         nWordType);
1737             }
1738         }
1739         else if (rTrans.getType() == (sal_uInt32)TransliterationModulesExtra::SENTENCE_CASE)
1740         {
1741             // for 'sentence case' we need to iterate sentence by sentence
1742 
1743             sal_Int32 nLastStart = pBreakIt->GetBreakIter()->beginOfSentence(
1744                     GetTxt(), nEnd,
1745                     pBreakIt->GetLocale( GetLang( nEnd ) ) );
1746             sal_Int32 nLastEnd = pBreakIt->GetBreakIter()->endOfSentence(
1747                     GetTxt(), nLastStart,
1748                     pBreakIt->GetLocale( GetLang( nLastStart ) ) );
1749 
1750             // extend nStt, nEnd to the current sentence boundaries
1751             sal_Int32 nCurrentStart = pBreakIt->GetBreakIter()->beginOfSentence(
1752                     GetTxt(), nStt,
1753                     pBreakIt->GetLocale( GetLang( nStt ) ) );
1754             sal_Int32 nCurrentEnd = pBreakIt->GetBreakIter()->endOfSentence(
1755                     GetTxt(), nCurrentStart,
1756                     pBreakIt->GetLocale( GetLang( nCurrentStart ) ) );
1757 
1758             // prevent backtracking to the previous sentence if selection starts at end of a sentence
1759             if (nCurrentEnd <= nStt)
1760             {
1761                 // now nCurrentStart is probably located on a non-letter word. (unless we
1762                 // are in Asian text with no spaces...)
1763                 // Thus to get the real sentence start we should locate the next real word,
1764                 // that is one found by DICTIONARY_WORD
1765                 i18n::Boundary aBndry = pBreakIt->GetBreakIter()->nextWord(
1766                         GetTxt(), nCurrentEnd,
1767                         pBreakIt->GetLocale( GetLang( nCurrentEnd ) ),
1768                         i18n::WordType::DICTIONARY_WORD);
1769 
1770                 // now get new current sentence boundaries
1771                 nCurrentStart = pBreakIt->GetBreakIter()->beginOfSentence(
1772                         GetTxt(), aBndry.startPos,
1773                         pBreakIt->GetLocale( GetLang( aBndry.startPos) ) );
1774                 nCurrentEnd = pBreakIt->GetBreakIter()->endOfSentence(
1775                         GetTxt(), nCurrentStart,
1776                         pBreakIt->GetLocale( GetLang( nCurrentStart) ) );
1777             }
1778             // prevent advancing to the next sentence if selection ends at start of a sentence
1779             if (nLastStart >= nEnd)
1780             {
1781                 // now nCurrentStart is probably located on a non-letter word. (unless we
1782                 // are in Asian text with no spaces...)
1783                 // Thus to get the real sentence start we should locate the previous real word,
1784                 // that is one found by DICTIONARY_WORD
1785                 i18n::Boundary aBndry = pBreakIt->GetBreakIter()->previousWord(
1786                         GetTxt(), nLastStart,
1787                         pBreakIt->GetLocale( GetLang( nLastStart) ),
1788                         i18n::WordType::DICTIONARY_WORD);
1789                 nLastEnd = pBreakIt->GetBreakIter()->endOfSentence(
1790                         GetTxt(), aBndry.startPos,
1791                         pBreakIt->GetLocale( GetLang( aBndry.startPos) ) );
1792                 if (nCurrentEnd > nLastEnd)
1793                     nCurrentEnd = nLastEnd;
1794             }
1795 
1796             while (nCurrentStart < nLastEnd)
1797             {
1798                 sal_Int32 nLen = nCurrentEnd - nCurrentStart;
1799                 DBG_ASSERT( nLen > 0, "invalid word length of 0" );
1800 #if OSL_DEBUG_LEVEL > 1
1801                 String aText( GetTxt().Copy( nCurrentStart, nLen ) );
1802 #endif
1803 
1804 		        Sequence <sal_Int32> aOffsets;
1805                 String sChgd( rTrans.transliterate( GetTxt(),
1806                         GetLang( nCurrentStart ), nCurrentStart, nLen, &aOffsets ));
1807 
1808                 if (!m_Text.Equals( sChgd, nStt, nLen ))
1809                 {
1810                     aChgData.nStart     = nCurrentStart;
1811                     aChgData.nLen       = nLen;
1812                     aChgData.sChanged   = sChgd;
1813                     aChgData.aOffsets   = aOffsets;
1814                     aChanges.push_back( aChgData );
1815                 }
1816 
1817                 Boundary aFirstWordBndry;
1818                 aFirstWordBndry = pBreakIt->GetBreakIter()->nextWord(
1819                         GetTxt(), nCurrentEnd,
1820                         pBreakIt->GetLocale( GetLang( nCurrentEnd ) ),
1821                         nWordType);
1822                 nCurrentStart = aFirstWordBndry.startPos;
1823                 nCurrentEnd = pBreakIt->GetBreakIter()->endOfSentence(
1824                         GetTxt(), nCurrentStart,
1825                         pBreakIt->GetLocale( GetLang( nCurrentStart ) ) );
1826             }
1827         }
1828         else
1829         {
1830             // here we may transliterate over complete language portions...
1831 
1832 		    SwLanguageIterator* pIter;
1833 		    if( rTrans.needLanguageForTheMode() )
1834                 pIter = new SwLanguageIterator( *this, nStt );
1835 		    else
1836 			    pIter = 0;
1837 
1838 		    xub_StrLen nEndPos;
1839 		    sal_uInt16 nLang;
1840 		    do {
1841 			    if( pIter )
1842 			    {
1843 				    nLang = pIter->GetLanguage();
1844 				    nEndPos = pIter->GetChgPos();
1845 				    if( nEndPos > nEnd )
1846 					    nEndPos = nEnd;
1847 			    }
1848 			    else
1849 			    {
1850 				    nLang = LANGUAGE_SYSTEM;
1851 				    nEndPos = nEnd;
1852 			    }
1853                 xub_StrLen nLen = nEndPos - nStt;
1854 
1855 			    Sequence <sal_Int32> aOffsets;
1856                 String sChgd( rTrans.transliterate( m_Text, nLang, nStt, nLen, &aOffsets ));
1857 
1858                 if (!m_Text.Equals( sChgd, nStt, nLen ))
1859                 {
1860                     aChgData.nStart     = nStt;
1861                     aChgData.nLen       = nLen;
1862                     aChgData.sChanged   = sChgd;
1863                     aChgData.aOffsets   = aOffsets;
1864                     aChanges.push_back( aChgData );
1865                 }
1866 
1867                 nStt = nEndPos;
1868 		    } while( nEndPos < nEnd && pIter && pIter->Next() );
1869 		    delete pIter;
1870         }
1871 
1872         if (aChanges.size() > 0)
1873         {
1874             // now apply the changes from end to start to leave the offsets of the
1875             // yet unchanged text parts remain the same.
1876             for (size_t i = 0; i < aChanges.size(); ++i)
1877             {
1878                 TransliterationChgData &rData = aChanges[ aChanges.size() - 1 - i ];
1879                 if (pUndo)
1880                     pUndo->AddChanges( *this, rData.nStart, rData.nLen, rData.aOffsets );
1881                 ReplaceTextOnly( rData.nStart, rData.nLen, rData.sChanged, rData.aOffsets );
1882             }
1883         }
1884     }
1885 }
1886 
1887 
1888 void SwTxtNode::ReplaceTextOnly( xub_StrLen nPos, xub_StrLen nLen,
1889 								const XubString& rText,
1890 								const Sequence<sal_Int32>& rOffsets )
1891 {
1892     m_Text.Replace( nPos, nLen, rText );
1893 
1894 	xub_StrLen nTLen = rText.Len();
1895 	const sal_Int32* pOffsets = rOffsets.getConstArray();
1896 	// now look for no 1-1 mapping -> move the indizies!
1897 	xub_StrLen nI, nMyOff;
1898 	for( nI = 0, nMyOff = nPos; nI < nTLen; ++nI, ++nMyOff )
1899 	{
1900 		xub_StrLen nOff = (xub_StrLen)pOffsets[ nI ];
1901 		if( nOff < nMyOff )
1902 		{
1903 			// something is inserted
1904 			xub_StrLen nCnt = 1;
1905 			while( nI + nCnt < nTLen && nOff == pOffsets[ nI + nCnt ] )
1906 				++nCnt;
1907 
1908 			Update( SwIndex( this, nMyOff ), nCnt, sal_False );
1909 			nMyOff = nOff;
1910 			//nMyOff -= nCnt;
1911 			nI += nCnt - 1;
1912 		}
1913 		else if( nOff > nMyOff )
1914 		{
1915 			// something is deleted
1916 			Update( SwIndex( this, nMyOff+1 ), nOff - nMyOff, sal_True );
1917 			nMyOff = nOff;
1918 		}
1919 	}
1920 	if( nMyOff < nLen )
1921 		// something is deleted at the end
1922 		Update( SwIndex( this, nMyOff ), nLen - nMyOff, sal_True );
1923 
1924 	// notify the layout!
1925 	SwDelTxt aDelHint( nPos, nTLen );
1926 	NotifyClients( 0, &aDelHint );
1927 
1928 	SwInsTxt aHint( nPos, nTLen );
1929 	NotifyClients( 0, &aHint );
1930 }
1931 
1932 void SwTxtNode::CountWords( SwDocStat& rStat,
1933                             xub_StrLen nStt, xub_StrLen nEnd ) const
1934 {
1935     ++rStat.nAllPara; // #i93174#: count _all_ paragraphs
1936     if( nStt < nEnd )
1937     {
1938         if ( !IsHidden() )
1939         {
1940             ++rStat.nPara;
1941             sal_uLong nTmpWords = 0;
1942             sal_uLong nTmpChars = 0;
1943 
1944             // Shortcut: Whole paragraph should be considered and cached values
1945             // are valid:
1946             if ( 0 == nStt && GetTxt().Len() == nEnd && !IsWordCountDirty() )
1947             {
1948                 nTmpWords = GetParaNumberOfWords();
1949                 nTmpChars = GetParaNumberOfChars();
1950             }
1951             else
1952             {
1953                 String aOldStr( m_Text );
1954                 String& rCastStr = const_cast<String&>(m_Text);
1955 
1956                 // fills the deleted redlines and hidden ranges with cChar:
1957                 const xub_Unicode cChar(' ');
1958                 const sal_uInt16 nNumOfMaskedChars =
1959                         lcl_MaskRedlinesAndHiddenText( *this, rCastStr, nStt, nEnd, cChar, false );
1960 
1961                 // expand fields
1962                 rtl::OUString aExpandText;
1963                 const ModelToViewHelper::ConversionMap* pConversionMap =
1964                         BuildConversionMap( aExpandText );
1965 
1966                 const sal_uInt32 nExpandBegin = ModelToViewHelper::ConvertToViewPosition( pConversionMap, nStt );
1967                 const sal_uInt32 nExpandEnd   = ModelToViewHelper::ConvertToViewPosition( pConversionMap, nEnd );
1968                 aExpandText = aExpandText.copy( nExpandBegin, nExpandEnd - nExpandBegin );
1969 
1970                 const bool bCount = aExpandText.getLength() > 0;
1971 
1972                 // count words in 'regular' text:
1973                 if( bCount && pBreakIt->GetBreakIter().is() )
1974                 {
1975                     // split into different script languages
1976                     sal_Int32 nScriptBegin = 0;
1977                     while ( nScriptBegin < aExpandText.getLength() )
1978                     {
1979                         const sal_Int16 nCurrScript = pBreakIt->GetBreakIter()->getScriptType( aExpandText, nScriptBegin );
1980                         const sal_Int32 nScriptEnd = pBreakIt->GetBreakIter()->endOfScript( aExpandText, nScriptBegin, nCurrScript );
1981                         rtl::OUString aScriptText = aExpandText.copy( nScriptBegin, nScriptEnd - nScriptBegin );
1982 
1983                         // Asian languages count words as characters
1984                         if ( nCurrScript == ::com::sun::star::i18n::ScriptType::ASIAN )
1985                         {
1986                             // substract white spaces
1987                             sal_Int32 nSpaceCount = 0;
1988                             sal_Int32 nSpacePos = 0;
1989 
1990                             // substract normal white spaces
1991                             nSpacePos = -1;
1992                             while ( ( nSpacePos = aScriptText.indexOf( ' ', nSpacePos + 1 ) ) != -1 )
1993                             {
1994                                 nSpaceCount++;
1995                             }
1996                             // substract Asian full-width white spaces
1997                             nSpacePos = -1;
1998                             while ( ( nSpacePos = aScriptText.indexOf( 12288, nSpacePos + 1 ) ) != -1 )
1999                             {
2000                                 nSpaceCount++;
2001                             }
2002                             nTmpWords += nScriptEnd - nScriptBegin - nSpaceCount;
2003                         }
2004                         else
2005                         {
2006                             const String aScannerText( aScriptText );
2007                             SwScanner aScanner( *this, aScannerText, 0, pConversionMap,
2008                                                 i18n::WordType::WORD_COUNT,
2009                                                 (xub_StrLen)0, (xub_StrLen)aScriptText.getLength() );
2010 
2011                             const rtl::OUString aBreakWord( CH_TXTATR_BREAKWORD );
2012 
2013                             while ( aScanner.NextWord() )
2014                             {
2015                                 if ( aScanner.GetLen() > 1 ||
2016                                      CH_TXTATR_BREAKWORD != aScriptText.match(aBreakWord, aScanner.GetBegin() ) )
2017                                     ++nTmpWords;
2018                             }
2019                         }
2020                         nScriptBegin = nScriptEnd;
2021                     }
2022                 }
2023 
2024                 ASSERT( aExpandText.getLength() >= nNumOfMaskedChars,
2025                         "More characters hidden that characters in string!" )
2026                 nTmpChars = nExpandEnd - nExpandBegin - nNumOfMaskedChars;
2027 
2028                 // count words in numbering string:
2029                 if ( nStt == 0 && bCount )
2030                 {
2031                     // add numbering label
2032                     const String aNumString = GetNumString();
2033                     const xub_StrLen nNumStringLen = aNumString.Len();
2034                     if ( nNumStringLen > 0 )
2035                     {
2036                         LanguageType aLanguage = GetLang( 0 );
2037 
2038                         SwScanner aScanner( *this, aNumString, &aLanguage, 0,
2039                                             i18n::WordType::WORD_COUNT,
2040                                             0, nNumStringLen );
2041 
2042                         while ( aScanner.NextWord() )
2043                             ++nTmpWords;
2044 
2045                         nTmpChars += nNumStringLen;
2046                     }
2047                     else if ( HasBullet() )
2048                     {
2049                         ++nTmpWords;
2050                         ++nTmpChars;
2051                     }
2052                 }
2053 
2054                 delete pConversionMap;
2055 
2056                 rCastStr = aOldStr;
2057 
2058                 // If the whole paragraph has been calculated, update cached
2059                 // values:
2060                 if ( 0 == nStt && GetTxt().Len() == nEnd )
2061                 {
2062                     SetParaNumberOfWords( nTmpWords );
2063                     SetParaNumberOfChars( nTmpChars );
2064                     SetWordCountDirty( false );
2065                 }
2066             }
2067 
2068             rStat.nWord += nTmpWords;
2069             rStat.nChar += nTmpChars;
2070         }
2071     }
2072 }
2073 
2074 //
2075 // Paragraph statistics start
2076 //
2077 struct SwParaIdleData_Impl
2078 {
2079     SwWrongList* pWrong;            // for spell checking
2080     SwGrammarMarkUp* pGrammarCheck;     // for grammar checking /  proof reading
2081     SwWrongList* pSmartTags;
2082     sal_uLong nNumberOfWords;
2083     sal_uLong nNumberOfChars;
2084     bool bWordCountDirty        : 1;
2085     bool bWrongDirty            : 1;    // Ist das Wrong-Feld auf invalid?
2086     bool bGrammarCheckDirty     : 1;
2087     bool bSmartTagDirty         : 1;
2088     bool bAutoComplDirty        : 1;    // die ACompl-Liste muss angepasst werden
2089 
2090     SwParaIdleData_Impl() :
2091         pWrong              ( 0 ),
2092         pGrammarCheck       ( 0 ),
2093         pSmartTags          ( 0 ),
2094         nNumberOfWords      ( 0 ),
2095         nNumberOfChars      ( 0 ),
2096         bWordCountDirty     ( true ),
2097         bWrongDirty         ( true ),
2098         bGrammarCheckDirty  ( true ),
2099         bSmartTagDirty      ( true ),
2100         bAutoComplDirty     ( true ) {};
2101 };
2102 
2103 void SwTxtNode::InitSwParaStatistics( bool bNew )
2104 {
2105     if ( bNew )
2106     {
2107         m_pParaIdleData_Impl = new SwParaIdleData_Impl;
2108     }
2109     else if ( m_pParaIdleData_Impl )
2110     {
2111         delete m_pParaIdleData_Impl->pWrong;
2112         delete m_pParaIdleData_Impl->pGrammarCheck;
2113         delete m_pParaIdleData_Impl->pSmartTags;
2114         delete m_pParaIdleData_Impl;
2115         m_pParaIdleData_Impl = 0;
2116     }
2117 }
2118 
2119 void SwTxtNode::SetWrong( SwWrongList* pNew, bool bDelete )
2120 {
2121     if ( m_pParaIdleData_Impl )
2122     {
2123         if ( bDelete )
2124         {
2125             delete m_pParaIdleData_Impl->pWrong;
2126         }
2127         m_pParaIdleData_Impl->pWrong = pNew;
2128     }
2129 }
2130 
2131 SwWrongList* SwTxtNode::GetWrong()
2132 {
2133     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->pWrong : 0;
2134 }
2135 
2136 // --> OD 2008-05-27 #i71360#
2137 const SwWrongList* SwTxtNode::GetWrong() const
2138 {
2139     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->pWrong : 0;
2140 }
2141 // <--
2142 
2143 
2144 void SwTxtNode::SetGrammarCheck( SwGrammarMarkUp* pNew, bool bDelete )
2145 {
2146     if ( m_pParaIdleData_Impl )
2147     {
2148         if ( bDelete )
2149         {
2150             delete m_pParaIdleData_Impl->pGrammarCheck;
2151         }
2152         m_pParaIdleData_Impl->pGrammarCheck = pNew;
2153     }
2154 }
2155 
2156 SwGrammarMarkUp* SwTxtNode::GetGrammarCheck()
2157 {
2158     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->pGrammarCheck : 0;
2159 }
2160 
2161 void SwTxtNode::SetSmartTags( SwWrongList* pNew, bool bDelete )
2162 {
2163     ASSERT( !pNew || SwSmartTagMgr::Get().IsSmartTagsEnabled(),
2164             "Weird - we have a smart tag list without any recognizers?" )
2165 
2166     if ( m_pParaIdleData_Impl )
2167     {
2168         if ( bDelete )
2169         {
2170             delete m_pParaIdleData_Impl->pSmartTags;
2171         }
2172         m_pParaIdleData_Impl->pSmartTags = pNew;
2173     }
2174 }
2175 
2176 SwWrongList* SwTxtNode::GetSmartTags()
2177 {
2178     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->pSmartTags : 0;
2179 }
2180 
2181 void SwTxtNode::SetParaNumberOfWords( sal_uLong nNew ) const
2182 {
2183     if ( m_pParaIdleData_Impl )
2184     {
2185         m_pParaIdleData_Impl->nNumberOfWords = nNew;
2186     }
2187 }
2188 sal_uLong SwTxtNode::GetParaNumberOfWords() const
2189 {
2190     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->nNumberOfWords : 0;
2191 }
2192 void SwTxtNode::SetParaNumberOfChars( sal_uLong nNew ) const
2193 {
2194     if ( m_pParaIdleData_Impl )
2195     {
2196         m_pParaIdleData_Impl->nNumberOfChars = nNew;
2197     }
2198 }
2199 sal_uLong SwTxtNode::GetParaNumberOfChars() const
2200 {
2201     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->nNumberOfChars : 0;
2202 }
2203 void SwTxtNode::SetWordCountDirty( bool bNew ) const
2204 {
2205     if ( m_pParaIdleData_Impl )
2206     {
2207         m_pParaIdleData_Impl->bWordCountDirty = bNew;
2208     }
2209 }
2210 bool SwTxtNode::IsWordCountDirty() const
2211 {
2212     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->bWordCountDirty : 0;
2213 }
2214 void SwTxtNode::SetWrongDirty( bool bNew ) const
2215 {
2216     if ( m_pParaIdleData_Impl )
2217     {
2218         m_pParaIdleData_Impl->bWrongDirty = bNew;
2219     }
2220 }
2221 bool SwTxtNode::IsWrongDirty() const
2222 {
2223     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->bWrongDirty : 0;
2224 }
2225 void SwTxtNode::SetGrammarCheckDirty( bool bNew ) const
2226 {
2227     if ( m_pParaIdleData_Impl )
2228     {
2229         m_pParaIdleData_Impl->bGrammarCheckDirty = bNew;
2230     }
2231 }
2232 bool SwTxtNode::IsGrammarCheckDirty() const
2233 {
2234     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->bGrammarCheckDirty : 0;
2235 }
2236 void SwTxtNode::SetSmartTagDirty( bool bNew ) const
2237 {
2238     if ( m_pParaIdleData_Impl )
2239     {
2240         m_pParaIdleData_Impl->bSmartTagDirty = bNew;
2241     }
2242 }
2243 bool SwTxtNode::IsSmartTagDirty() const
2244 {
2245     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->bSmartTagDirty : 0;
2246 }
2247 void SwTxtNode::SetAutoCompleteWordDirty( bool bNew ) const
2248 {
2249     if ( m_pParaIdleData_Impl )
2250     {
2251         m_pParaIdleData_Impl->bAutoComplDirty = bNew;
2252     }
2253 }
2254 bool SwTxtNode::IsAutoCompleteWordDirty() const
2255 {
2256     return m_pParaIdleData_Impl ? m_pParaIdleData_Impl->bAutoComplDirty : 0;
2257 }
2258 //
2259 // Paragraph statistics end
2260 //
2261 
2262 //Bug 120881:Modify here for Directly Page Numbering
2263 sal_Bool SwTxtFrm::HasPageNumberField()
2264 {
2265 	return GetRegisteredIn()?((SwTxtNode*)GetRegisteredIn())->HasPageNumberField():false;
2266 }
2267 //Bug 120881(End)
2268 
2269