xref: /aoo41x/main/cui/source/dialogs/SpellDialog.cxx (revision 62f0d972)
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_cui.hxx"
26 
27 // include ---------------------------------------------------------------
28 
29 #include <tools/ref.hxx>
30 #include <tools/shl.hxx>
31 #include <vcl/wrkwin.hxx>
32 #include <vcl/menu.hxx>
33 #include <vcl/msgbox.hxx>
34 #include <vcl/scrbar.hxx>
35 #include <SpellAttrib.hxx>
36 #include <sfx2/dispatch.hxx>
37 #include <sfx2/bindings.hxx>
38 #include <svl/undo.hxx>
39 #include <unotools/lingucfg.hxx>
40 #include <svtools/textdata.hxx>
41 #include <svtools/filter.hxx>
42 #include <editeng/unolingu.hxx>
43 #include <editeng/splwrap.hxx>
44 #include <linguistic/lngprops.hxx>
45 #include <linguistic/misc.hxx>
46 #include <comphelper/processfactory.hxx>
47 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
48 #include <com/sun/star/lang/XServiceInfo.hpp>
49 #include <com/sun/star/lang/XServiceDisplayName.hpp>
50 #include <com/sun/star/linguistic2/SpellFailure.hpp>
51 #include <com/sun/star/frame/XStorable.hpp>
52 #include <sfx2/app.hxx>
53 #include <vcl/help.hxx>
54 #include <vcl/graph.hxx>
55 #include <osl/file.hxx>
56 #include <cuires.hrc>
57 #include <helpid.hrc>
58 #include "SpellDialog.hrc"
59 #include <editeng/optitems.hxx>
60 #include <editeng/svxenum.hxx>
61 #include <svx/SpellDialogChildWindow.hxx>
62 #include "SpellDialog.hxx"
63 #include <svx/dlgutil.hxx>
64 #include "optlingu.hxx"
65 #include <dialmgr.hxx>
66 #include <svx/svxerr.hxx>
67 #include "treeopt.hxx"
68 #include <svtools/langtab.hxx>
69 
70 using namespace ::com::sun::star;
71 using namespace ::com::sun::star::uno;
72 using namespace ::com::sun::star::beans;
73 using namespace ::com::sun::star::linguistic2;
74 
75 using ::rtl::OUString;
76 
77 #define C2U(cChar) 					::rtl::OUString::createFromAscii(cChar)
78 // struct SpellDialog_Impl ---------------------------------------------
79 
80 struct SpellDialog_Impl
81 {
82 	Sequence< Reference< XDictionary >  >	aDics;
83 };
84 // -----------------------------------------------------------------------
85 //#define VENDOR_IMAGE_HEIGHT 44 //as specified
86 
87 #define SPELLUNDO_START                     200
88 
89 #define SPELLUNDO_CHANGE_LANGUAGE           (SPELLUNDO_START + 1)
90 #define SPELLUNDO_CHANGE_TEXTENGINE         (SPELLUNDO_START + 2)
91 #define SPELLUNDO_CHANGE_NEXTERROR          (SPELLUNDO_START + 3)
92 #define SPELLUNDO_CHANGE_ADD_TO_DICTIONARY  (SPELLUNDO_START + 4)
93 #define SPELLUNDO_CHANGE_GROUP              (SPELLUNDO_START + 5) //undo list
94 #define SPELLUNDO_MOVE_ERROREND             (SPELLUNDO_START + 6)
95 #define SPELLUNDO_UNDO_EDIT_MODE            (SPELLUNDO_START + 7)
96 #define SPELLUNDO_ADD_IGNORE_RULE           (SPELLUNDO_START + 8)
97 
98 namespace svx{
99 class SpellUndoAction_Impl : public SfxUndoAction
100 {
101     sal_uInt16          m_nId;
102     const Link&     m_rActionLink;
103     //undo of button enabling
104     bool            m_bEnableChangePB;
105     bool            m_bEnableChangeAllPB;
106     //undo of MarkNextError - used in change and change all, ignore and ignore all
107     long            m_nNewErrorStart;
108     long            m_nNewErrorEnd;
109     long            m_nOldErrorStart;
110     long            m_nOldErrorEnd;
111     bool            m_bIsErrorLanguageSelected;
112     ::rtl::OUString m_sRuleId;
113     //undo of AddToDictionary
114     Reference<XDictionary>  m_xDictionary;
115     ::rtl::OUString                m_sAddedWord;
116     //move end of error - ::ChangeMarkedWord()
117     long            m_nOffset;
118 
119 public:
SpellUndoAction_Impl(sal_uInt16 nId,const Link & rActionLink)120     SpellUndoAction_Impl(sal_uInt16 nId, const Link& rActionLink) :
121         m_nId(nId),
122         m_rActionLink( rActionLink),
123         m_bEnableChangePB(false),
124         m_bEnableChangeAllPB(false),
125         m_nNewErrorStart(-1),
126         m_nNewErrorEnd(-1),
127         m_nOldErrorStart(-1),
128         m_nOldErrorEnd(-1),
129         m_bIsErrorLanguageSelected(false),
130         m_nOffset(0)
131         {}
132 
133     ~SpellUndoAction_Impl();
134 
135     virtual void            Undo();
136     virtual sal_uInt16          GetId() const;
137 
SetEnableChangePB()138     void                    SetEnableChangePB(){m_bEnableChangePB = true;}
IsEnableChangePB()139     bool                    IsEnableChangePB(){return m_bEnableChangePB;}
140 
SetEnableChangeAllPB()141     void                    SetEnableChangeAllPB(){m_bEnableChangeAllPB = true;}
IsEnableChangeAllPB()142     bool                    IsEnableChangeAllPB(){return m_bEnableChangeAllPB;}
143 
SetErrorMove(long nNewStart,long nNewEnd,long nOldStart,long nOldEnd)144     void                    SetErrorMove(long nNewStart, long nNewEnd, long nOldStart, long nOldEnd)
145                                 {
146                                         m_nNewErrorStart = nNewStart;
147                                         m_nNewErrorEnd  = nNewEnd;
148                                         m_nOldErrorStart = nOldStart;
149                                         m_nOldErrorEnd = nOldEnd;
150                                 }
GetNewErrorStart()151     long                    GetNewErrorStart() { return m_nNewErrorStart;}
GetNewErrorEnd()152     long                    GetNewErrorEnd() { return m_nNewErrorEnd;}
GetOldErrorStart()153     long                    GetOldErrorStart() { return m_nOldErrorStart;}
GetOldErrorEnd()154     long                    GetOldErrorEnd() { return m_nOldErrorEnd;}
155 
SetErrorLanguageSelected(bool bSet)156     void                    SetErrorLanguageSelected(bool bSet){ m_bIsErrorLanguageSelected = bSet;}
IsErrorLanguageSelected() const157     bool                    IsErrorLanguageSelected() const {return m_bIsErrorLanguageSelected;}
158 
159 
SetDictionary(Reference<XDictionary> xDict)160     void                    SetDictionary(Reference<XDictionary> xDict) { m_xDictionary = xDict; }
GetDictionary() const161     Reference<XDictionary>  GetDictionary() const {return m_xDictionary;}
SetAddedWord(const::rtl::OUString & rWord)162     void                    SetAddedWord(const ::rtl::OUString& rWord) {m_sAddedWord = rWord;}
GetAddedWord() const163     const ::rtl::OUString&         GetAddedWord() const { return m_sAddedWord;}
164 
SetOffset(long nSet)165     void                    SetOffset(long nSet) {m_nOffset = nSet;}
GetOffset() const166     long                    GetOffset() const {return m_nOffset;}
167 
SetErrorType(const::rtl::OUString & rId)168     void                    SetErrorType( const ::rtl::OUString& rId ) { m_sRuleId = rId; }
GetErrorType() const169     const ::rtl::OUString&  GetErrorType() const { return m_sRuleId; }
170 
171 };
172 }//namespace svx
173 using namespace ::svx;
174 /*-- 06.11.2003 12:16:02---------------------------------------------------
175 
176   -----------------------------------------------------------------------*/
~SpellUndoAction_Impl()177 SpellUndoAction_Impl::~SpellUndoAction_Impl()
178 {
179 }
180 /*-- 06.11.2003 12:16:02---------------------------------------------------
181 
182   -----------------------------------------------------------------------*/
Undo()183 void SpellUndoAction_Impl::Undo()
184 {
185     m_rActionLink.Call(this);
186 }
187 /*-- 06.11.2003 12:16:02---------------------------------------------------
188 
189   -----------------------------------------------------------------------*/
GetId() const190 sal_uInt16 SpellUndoAction_Impl::GetId()const
191 {
192     return m_nId;
193 }
194 
195 // class SvxSpellCheckDialog ---------------------------------------------
196 
SpellDialog(SpellDialogChildWindow * pChildWindow,Window * pParent,SfxBindings * _pBindings)197 SpellDialog::SpellDialog(
198         SpellDialogChildWindow* pChildWindow,
199         Window * pParent,
200         SfxBindings* _pBindings)
201             : SfxModelessDialog (_pBindings,
202                                     pChildWindow,
203                                     pParent,
204                                     CUI_RES(RID_SVXDLG_SPELLCHECK)),
205 
206     aVendorImageFI  ( this , CUI_RES( IMG_VENDOR ) ),
207     aLanguageFT     ( this, CUI_RES( FT_LANGUAGE ) ),
208     aLanguageLB     ( this, CUI_RES( LB_LANGUAGE ) ),
209     aNotInDictFT    ( this, CUI_RES( FT_NOTINDICT ) ),
210     aSentenceED      ( this, CUI_RES( ED_NEWWORD ) ),
211     aSuggestionFT   ( this, CUI_RES( FT_SUGGESTION ) ),
212     aSuggestionLB   ( this, CUI_RES( LB_SUGGESTION ) ),
213 
214     aIgnorePB       ( this, CUI_RES( PB_IGNORE ) ),
215     aIgnoreAllPB    ( this, CUI_RES( PB_IGNOREALL ) ),
216     aIgnoreRulePB   ( this, CUI_RES( PB_IGNORERULE ) ),
217     aAddToDictMB    ( this, CUI_RES( MB_ADDTODICT ) ),
218 
219     aChangePB       ( this, CUI_RES( PB_CHANGE ) ),
220     aChangeAllPB    ( this, CUI_RES( PB_CHANGEALL ) ),
221     aExplainPB      ( this, CUI_RES( PB_EXPLAIN) ),
222     aAutoCorrPB     ( this, CUI_RES( PB_AUTOCORR ) ),
223 
224     aCheckGrammarCB ( this, CUI_RES( CB_CHECK_GRAMMAR ) ),
225 
226     aHelpPB         ( this, CUI_RES( PB_HELP ) ),
227     aOptionsPB      ( this, CUI_RES( PB_OPTIONS ) ),
228     aUndoPB         ( this, CUI_RES( PB_UNDO ) ),
229     aClosePB        ( this, CUI_RES( PB_CLOSE ) ),
230     aBackgroundGB   ( this, CUI_RES( GB_BACKGROUND ) ),
231 
232     aVendorImage    ( CUI_RES( IMG_DEFAULT_VENDOR ) ),
233     aVendorImageHC  ( CUI_RES( IMG_DEFAULT_VENDOR_HC ) ),
234 
235     aResumeST       ( CUI_RES(ST_RESUME )),
236     aIgnoreOnceST   ( aIgnorePB.GetText()),
237     aNoSuggestionsST( CUI_RES(ST_NOSUGGESTIONS)),
238     m_sTitleSpelling              ( CUI_RES( ST_SPELLING                        ) ),
239     m_sTitleSpellingGrammar       ( CUI_RES( ST_SPELLING_AND_GRAMMAR            ) ),
240     m_sTitleSpellingGrammarVendor ( CUI_RES( ST_SPELLING_AND_GRAMMAR_VENDORNAME ) ),
241     aDialogUndoLink( LINK (this, SpellDialog, DialogUndoHdl)),
242     bModified( false ),
243     bFocusLocked( true ),
244     rParent         ( *pChildWindow ),
245     nOldLang        ( LANGUAGE_NONE )
246 {
247     FreeResource();
248     xSpell = LinguMgr::GetSpellChecker();
249     pImpl = new SpellDialog_Impl;
250 
251     //HelpIds
252     aClosePB.       SetHelpId(HID_SPLDLG_BUTTON_CLOSE    );
253     aIgnorePB.      SetHelpId(HID_SPLDLG_BUTTON_IGNORE   );
254     aIgnoreAllPB.   SetHelpId(HID_SPLDLG_BUTTON_IGNOREALL);
255     aIgnoreRulePB.  SetHelpId(HID_SPLDLG_BUTTON_IGNORERULE);
256     aChangePB.      SetHelpId(HID_SPLDLG_BUTTON_CHANGE   );
257     aChangeAllPB.   SetHelpId(HID_SPLDLG_BUTTON_CHANGEALL);
258     aExplainPB.     SetHelpId(HID_SPLDLG_BUTTON_EXPLAIN );
259 
260     aAddToDictMB.SetPopupMenu( new PopupMenu );
261 
262 	Init_Impl();
263 
264 	// disable controls if service is missing
265 	if (!xSpell.is())
266 		Enable( sal_False );
267 
268     Application::PostUserEvent( STATIC_LINK(
269                         this, SpellDialog, InitHdl ) );
270 }
271 
272 // -----------------------------------------------------------------------
273 
~SpellDialog()274 SpellDialog::~SpellDialog()
275 {
276     // save possibly modified user-dictionaries
277     Reference< XDictionaryList >  xDicList( SvxGetDictionaryList() );
278     if (xDicList.is())
279     {
280         linguistic::SaveDictionaries( xDicList );
281     }
282 
283     delete aAddToDictMB.GetPopupMenu();
284     delete pImpl;
285 }
286 
287 // -----------------------------------------------------------------------
288 
Init_Impl()289 void SpellDialog::Init_Impl()
290 {
291 	// Handler initialisieren
292     aClosePB.SetClickHdl(LINK( this, SpellDialog, CancelHdl ) );
293     aChangePB.SetClickHdl(LINK( this, SpellDialog, ChangeHdl ) );
294     aChangeAllPB.SetClickHdl(LINK( this, SpellDialog, ChangeAllHdl ) );
295     aIgnorePB.SetClickHdl(LINK( this, SpellDialog, IgnoreHdl ) );
296     aIgnoreAllPB.SetClickHdl(LINK( this, SpellDialog, IgnoreAllHdl ) );
297     aIgnoreRulePB.SetClickHdl(LINK( this, SpellDialog, IgnoreAllHdl ) );
298     aUndoPB.SetClickHdl(LINK( this, SpellDialog, UndoHdl ) );
299 
300     aAutoCorrPB.SetClickHdl( LINK( this, SpellDialog, ExtClickHdl ) );
301     aCheckGrammarCB.SetClickHdl( LINK( this, SpellDialog, CheckGrammarHdl ));
302     aOptionsPB .SetClickHdl( LINK( this, SpellDialog, ExtClickHdl ) );
303 
304     aSuggestionLB.SetDoubleClickHdl( LINK( this, SpellDialog, ChangeHdl ) );
305 
306     aSentenceED.SetModifyHdl(LINK ( this, SpellDialog, ModifyHdl) );
307     aAddToDictMB.SetActivateHdl(LINK ( this, SpellDialog, MenuButtonActivateHdl ) );
308     aAddToDictMB.SetSelectHdl(LINK ( this, SpellDialog, AddToDictionaryHdl ) );
309     aLanguageLB.SetSelectHdl(LINK( this, SpellDialog, LanguageSelectHdl ) );
310 
311     // initialize language ListBox
312     aLanguageLB.SetLanguageList( LANG_LIST_SPELL_USED, sal_False, sal_False, sal_True );
313 
314     // get current language
315 	UpdateBoxes_Impl();
316 
317     aSentenceED.ClearModifyFlag();
318 	SvxGetChangeAllList()->clear();
319 }
320 
321 // -----------------------------------------------------------------------
322 
UpdateBoxes_Impl()323 void SpellDialog::UpdateBoxes_Impl()
324 {
325     sal_Int32 i;
326     aSuggestionLB.Clear();
327 
328     const SpellErrorDescription* pSpellErrorDescription = aSentenceED.GetAlternatives();
329 
330 	LanguageType nAltLanguage = LANGUAGE_NONE;
331     //String      aAltWord;
332 	Sequence< ::rtl::OUString >	aNewWords;
333     bool bIsGrammarError = false;
334     if( pSpellErrorDescription )
335 	{
336         nAltLanguage    = SvxLocaleToLanguage( pSpellErrorDescription->aLocale );
337         //aAltWord       = String( xAlt->getWord() );
338         aNewWords       = pSpellErrorDescription->aSuggestions;
339         bIsGrammarError = pSpellErrorDescription->bIsGrammarError;
340         aExplainPB.SetExplanation(pSpellErrorDescription->sExplanation );
341 	}
342     if( pSpellErrorDescription && pSpellErrorDescription->sDialogTitle.getLength() )
343     {
344         // use this function to apply the correct image to be used...
345         SetTitle_Impl( nAltLanguage );
346         // then change the title to the one to be actually used
347         SetText( pSpellErrorDescription->sDialogTitle );
348     }
349     else
350         SetTitle_Impl( nAltLanguage );
351 
352     SetSelectedLang_Impl( nAltLanguage );
353 
354     // Initialize/update user dictionaries after setting the language in the listbox
355     InitUserDicts();
356 
357 	// Alternativen eintragen
358 	const ::rtl::OUString *pNewWords = aNewWords.getConstArray();
359 	const sal_Int32 nSize = aNewWords.getLength();
360 	for ( i = 0; i < nSize; ++i )
361 	{
362 		String aTmp( pNewWords[i] );
363         if ( LISTBOX_ENTRY_NOTFOUND == aSuggestionLB.GetEntryPos( aTmp ) )
364         {
365             aSuggestionLB.InsertEntry( aTmp );
366             aSuggestionLB.SetEntryFlags(aSuggestionLB.GetEntryCount() - 1, LISTBOX_ENTRY_FLAG_MULTILINE);
367         }
368 	}
369     if(!nSize)
370         aSuggestionLB.InsertEntry( aNoSuggestionsST );
371     aAutoCorrPB.Enable( nSize > 0 );
372     //aSentenceED.GrabFocus();
373 
374     aSuggestionFT.Enable(nSize > 0);
375     aSuggestionLB.Enable(nSize > 0);
376     if( nSize )
377 	{
378         aSuggestionLB.SelectEntryPos(0);
379 	}
380     aChangePB.Enable( nSize > 0);
381     aChangeAllPB.Enable(nSize > 0);
382     bool bShowChangeAll = !bIsGrammarError;
383     aChangeAllPB.Show( bShowChangeAll );
384     aExplainPB.Show( !bShowChangeAll );
385     aLanguageLB.Enable( bShowChangeAll );
386     aIgnoreAllPB.Show( bShowChangeAll );
387     aAddToDictMB.Show( bShowChangeAll );
388     aIgnoreRulePB.Show( !bShowChangeAll );
389     aIgnoreRulePB.Enable(pSpellErrorDescription && pSpellErrorDescription->sRuleId.getLength());
390     aExplainPB.Enable( aExplainPB.HasExplanation() );
391     aAutoCorrPB.Show( bShowChangeAll && rParent.HasAutoCorrection() );
392 
393 }
394 // -----------------------------------------------------------------------
395 
SpellContinue_Impl(bool bUseSavedSentence,bool bIgnoreCurrentError)396 void SpellDialog::SpellContinue_Impl(bool bUseSavedSentence, bool bIgnoreCurrentError )
397 {
398     //initially or after the last error of a sentence MarkNextError will fail
399     //then GetNextSentence() has to be called followed again by MarkNextError()
400 	//MarkNextError is not initally called if the UndoEdit mode is active
401     bool bNextSentence = false;
402     if((!aSentenceED.IsUndoEditMode() && aSentenceED.MarkNextError( bIgnoreCurrentError )) ||
403             true == ( bNextSentence = GetNextSentence_Impl(bUseSavedSentence, aSentenceED.IsUndoEditMode()) && aSentenceED.MarkNextError( false )))
404     {
405         const SpellErrorDescription* pSpellErrorDescription = aSentenceED.GetAlternatives();
406         if( pSpellErrorDescription )
407         {
408 			UpdateBoxes_Impl();
409             Control* aControls[] =
410             {
411                 &aNotInDictFT,
412                 &aSentenceED,
413                 &aLanguageFT,
414                 0
415             };
416             sal_Int32 nIdx = 0;
417             do
418             {
419                 aControls[nIdx]->Enable(sal_True);
420             }
421             while(aControls[++nIdx]);
422 
423 
424         }
425         if( bNextSentence )
426         {
427             //remove undo if a new sentence is active
428             aSentenceED.ResetUndo();
429             aUndoPB.Enable(sal_False);
430         }
431     }
432 }
433 /* -----------------10.09.2003 14:04-----------------
434     Initialize, asynchronous to prevent virtial calls
435     from a constructor
436  --------------------------------------------------*/
IMPL_STATIC_LINK(SpellDialog,InitHdl,SpellDialog *,EMPTYARG)437 IMPL_STATIC_LINK( SpellDialog, InitHdl, SpellDialog *, EMPTYARG )
438 {
439     pThis->SetUpdateMode( sal_False );
440     //show or hide AutoCorrect depending on the modules abilities
441     pThis->aAutoCorrPB.Show(pThis->rParent.HasAutoCorrection());
442     pThis->SpellContinue_Impl();
443     pThis->aSentenceED.ResetUndo();
444     pThis->aUndoPB.Enable(sal_False);
445 
446     pThis->LockFocusChanges(true);
447     if( pThis->aChangePB.IsEnabled() )
448         pThis->aChangePB.GrabFocus();
449     else if( pThis->aIgnorePB.IsEnabled() )
450         pThis->aIgnorePB.GrabFocus();
451     else if( pThis->aClosePB.IsEnabled() )
452         pThis->aClosePB.GrabFocus();
453     pThis->LockFocusChanges(false);
454     //show grammar CheckBox depending on the modules abilities
455     bool bHasGrammarChecking = pThis->rParent.HasGrammarChecking();
456     pThis->aCheckGrammarCB.Show( bHasGrammarChecking );
457     if( !bHasGrammarChecking )
458     {
459         //resize the dialog to hide the hidden area of the CheckBox
460         Size aBackSize = pThis->aBackgroundGB.GetSizePixel();
461         sal_Int32 nDiff = pThis->aBackgroundGB.GetPosPixel().Y() + aBackSize.Height()
462                             - pThis->aCheckGrammarCB.GetPosPixel().Y();
463         aBackSize.Height() -= nDiff;
464         pThis->aBackgroundGB.SetSizePixel(aBackSize);
465         Button* aButtons[] = { &pThis->aHelpPB, &pThis->aOptionsPB, &pThis->aUndoPB, &pThis->aClosePB, 0 };
466         sal_Int32 nButton = 0;
467         while( aButtons[nButton])
468         {
469             Point aPos = aButtons[nButton]->GetPosPixel();
470             aPos.Y() -= nDiff;
471             aButtons[nButton]->SetPosPixel(aPos);
472             ++nButton;
473         }
474         Size aDlgSize = pThis->GetSizePixel();
475         aDlgSize.Height() -= nDiff;
476         pThis->SetSizePixel( aDlgSize );
477     }
478     else
479     {
480         if( SvtLinguConfig().HasVendorImages( "SpellAndGrammarDialogImage" ) )
481         {
482             pThis->aVendorImageFI.Show();
483             Size aVendorSize = pThis->aVendorImageFI.GetSizePixel();
484             Size aImageSize = pThis->aVendorImageFI.GetImage().GetSizePixel();
485             if( aImageSize.Height() )
486             {
487                 aVendorSize.Height() = aImageSize.Height();
488                 if(aVendorSize.Width() < aImageSize.Width())
489                     aVendorSize.Width() = aImageSize.Width();
490                 pThis->aVendorImageFI.SetSizePixel( aVendorSize );
491             }
492             //aVendorSize.Height() = nDiff;
493             sal_Int32 nDiff = aVendorSize.Height();
494             pThis->aVendorImageFI.SetSizePixel(aVendorSize);
495             Control* aControls[] = {
496                 &pThis->aLanguageFT,
497                 &pThis->aLanguageLB,
498                 &pThis->aNotInDictFT,
499                 &pThis->aSentenceED,
500                 &pThis->aSuggestionFT,
501                 &pThis->aSuggestionLB,
502                 &pThis->aIgnorePB,
503                 &pThis->aIgnoreAllPB,
504                 &pThis->aIgnoreRulePB,
505                 &pThis->aAddToDictMB,
506                 &pThis->aChangePB,
507                 &pThis->aChangeAllPB,
508                 &pThis->aExplainPB,
509                 &pThis->aAutoCorrPB,
510                 &pThis->aCheckGrammarCB,
511                 &pThis->aHelpPB,
512                 &pThis->aOptionsPB,
513                 &pThis->aUndoPB,
514                 &pThis->aClosePB,
515                 &pThis->aBackgroundGB,
516                 0
517             };
518             sal_Int32 nControl = 0;
519             while( aControls[nControl])
520             {
521                 Point aPos = aControls[nControl]->GetPosPixel();
522                 aPos.Y() += nDiff;
523                 aControls[nControl]->SetPosPixel(aPos);
524                 ++nControl;
525             }
526             Size aDlgSize = pThis->GetSizePixel();
527             aDlgSize.Height() += nDiff;
528             pThis->SetSizePixel( aDlgSize );
529             pThis->Invalidate();
530         }
531     }
532     pThis->aCheckGrammarCB.Check( pThis->rParent.IsGrammarChecking() );
533     pThis->SetUpdateMode( sal_True );
534     pThis->Show();
535     return 0;
536 };
537 
538 // -----------------------------------------------------------------------
539 
IMPL_LINK(SpellDialog,ExtClickHdl,Button *,pBtn)540 IMPL_LINK( SpellDialog, ExtClickHdl, Button *, pBtn )
541 {
542     if (&aOptionsPB == pBtn)
543 		StartSpellOptDlg_Impl();
544     else if(&aAutoCorrPB == pBtn)
545     {
546         //get the currently selected wrong word
547         String sCurrentErrorText = aSentenceED.GetErrorText();
548         //get the wrong word from the XSpellAlternative
549         const SpellErrorDescription* pSpellErrorDescription = aSentenceED.GetAlternatives();
550         if( pSpellErrorDescription )
551         {
552             String sWrong(pSpellErrorDescription->sErrorText);
553             //if the word has not been edited in the MultiLineEdit then
554             //the current suggestion should be used
555             //if it's not the 'no suggestions' entry
556             if(sWrong == sCurrentErrorText &&
557                     aSuggestionLB.IsEnabled() && aSuggestionLB.GetSelectEntryCount() > 0 &&
558                     aNoSuggestionsST != aSuggestionLB.GetSelectEntry())
559             {
560                 sCurrentErrorText = aSuggestionLB.GetSelectEntry();
561             }
562             if(sWrong != sCurrentErrorText)
563             {
564                 SvxPrepareAutoCorrect( sWrong, sCurrentErrorText );
565                 LanguageType eLang = GetSelectedLang_Impl();
566                 rParent.AddAutoCorrection( sWrong, sCurrentErrorText, eLang );
567             }
568         }
569     }
570 	return 0;
571 }
572 // -----------------------------------------------------------------------
IMPL_LINK(SpellDialog,CheckGrammarHdl,CheckBox *,pBox)573 IMPL_LINK( SpellDialog, CheckGrammarHdl, CheckBox*, pBox )
574 {
575     rParent.SetGrammarChecking( pBox->IsChecked() );
576     Impl_Restore();
577     return 0;
578 }
579 
StartSpellOptDlg_Impl()580 void SpellDialog::StartSpellOptDlg_Impl()
581 {
582     sal_uInt16 aSpellInfos[] =
583     {
584         SID_ATTR_SPELL,SID_ATTR_SPELL,
585         SID_SPELL_MODIFIED, SID_SPELL_MODIFIED,
586         SID_AUTOSPELL_CHECK, SID_AUTOSPELL_CHECK,
587         0
588     };
589     SfxItemSet aSet( SFX_APP()->GetPool(), aSpellInfos);
590     aSet.Put(SfxSpellCheckItem( xSpell, SID_ATTR_SPELL ));
591 	SfxSingleTabDialog* pDlg =
592 		new SfxSingleTabDialog( this, aSet, RID_SFXPAGE_LINGU );
593 	SfxTabPage* pPage = SvxLinguTabPage::Create( pDlg, aSet );
594 	( (SvxLinguTabPage*)pPage )->HideGroups( GROUP_MODULES );
595 	pDlg->SetTabPage( pPage );
596 	if(RET_OK == pDlg->Execute())
597 	{
598 
599     	// Benutzerb"ucher anzeigen
600 	    InitUserDicts();
601         const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
602         if(pOutSet)
603             OfaTreeOptionsDialog::ApplyLanguageOptions(*pOutSet);
604     }
605 	delete pDlg;
606 
607 }
608 
609 // -----------------------------------------------------------------------
610 
IMPL_LINK(SpellDialog,ChangeHdl,Button *,EMPTYARG)611 IMPL_LINK( SpellDialog, ChangeHdl, Button *, EMPTYARG )
612 {
613     if(aSentenceED.IsUndoEditMode())
614     {
615         SpellContinue_Impl();
616     }
617     else
618     {
619         aSentenceED.UndoActionStart( SPELLUNDO_CHANGE_GROUP );
620         String aString = aSentenceED.GetErrorText();
621         //dots are sometimes part of the spelled word but they are not necessarily part of the replacement
622         bool bDot = aString.Len() && aString.GetChar(aString.Len() - 1 ) == '.';
623         if(aSuggestionLB.IsEnabled() &&
624                 aSuggestionLB.GetSelectEntryCount()>0 &&
625                 aNoSuggestionsST != aSuggestionLB.GetSelectEntry())
626             aString = aSuggestionLB.GetSelectEntry();
627         if(bDot && (!aString.Len() || aString.GetChar(aString.Len() - 1 ) != '.'))
628             aString += '.';
629 
630         aSentenceED.ChangeMarkedWord(aString, GetSelectedLang_Impl());
631         SpellContinue_Impl();
632         bModified = false;
633         aSentenceED.UndoActionEnd();
634     }
635     if(!aChangePB.IsEnabled())
636         aIgnorePB.GrabFocus();
637     return 1;
638 }
639 
640 
641 // -----------------------------------------------------------------------
642 
IMPL_LINK(SpellDialog,ChangeAllHdl,Button *,EMPTYARG)643 IMPL_LINK( SpellDialog, ChangeAllHdl, Button *, EMPTYARG )
644 {
645     aSentenceED.UndoActionStart( SPELLUNDO_CHANGE_GROUP );
646     // change the current word first
647     String aString = aSentenceED.GetErrorText();
648     if(aSuggestionLB.IsEnabled() &&
649             aSuggestionLB.GetSelectEntryCount()>0 &&
650             aNoSuggestionsST != aSuggestionLB.GetSelectEntry())
651         aString = aSuggestionLB.GetSelectEntry();
652 
653     LanguageType eLang = GetSelectedLang_Impl();
654 
655 	// add new word to ChangeAll list
656     String  aOldWord( aSentenceED.GetErrorText() );
657     SvxPrepareAutoCorrect( aOldWord, aString );
658     Reference<XDictionary> aXDictionary( SvxGetChangeAllList(), UNO_QUERY );
659     sal_uInt8 nAdded = linguistic::AddEntryToDic( aXDictionary,
660             aOldWord , sal_True,
661             aString, eLang );
662 
663     if(nAdded == DIC_ERR_NONE)
664     {
665         SpellUndoAction_Impl* pAction = new SpellUndoAction_Impl(
666                         SPELLUNDO_CHANGE_ADD_TO_DICTIONARY, aDialogUndoLink);
667         pAction->SetDictionary(aXDictionary);
668         pAction->SetAddedWord(aOldWord);
669         aSentenceED.AddUndoAction(pAction);
670     }
671 
672     aSentenceED.ChangeMarkedWord(aString, eLang);
673 	SpellContinue_Impl();
674     bModified = false;
675     aSentenceED.UndoActionEnd();
676     return 1;
677 }
678 // -----------------------------------------------------------------------
679 
IMPL_LINK(SpellDialog,IgnoreAllHdl,Button *,pButton)680 IMPL_LINK( SpellDialog, IgnoreAllHdl, Button *, pButton )
681 {
682     aSentenceED.UndoActionStart( SPELLUNDO_CHANGE_GROUP );
683     // add word to IgnoreAll list
684     Reference< XDictionary > aXDictionary( SvxGetIgnoreAllList(), UNO_QUERY );
685     //in case the error has been changed manually it has to be restored
686     aSentenceED.RestoreCurrentError();
687     if( pButton == &aIgnoreRulePB )
688     {
689         const SpellErrorDescription* pSpellErrorDescription = aSentenceED.GetAlternatives();
690         try
691         {
692             if( pSpellErrorDescription && pSpellErrorDescription->xGrammarChecker.is() )
693             {
694                 pSpellErrorDescription->xGrammarChecker->ignoreRule( pSpellErrorDescription->sRuleId,
695                     pSpellErrorDescription->aLocale );
696             }
697         }
698         catch( const uno::Exception& )
699         {
700         }
701     }
702     else
703     {
704         String sErrorText(aSentenceED.GetErrorText());
705         sal_uInt8 nAdded = linguistic::AddEntryToDic( aXDictionary,
706             sErrorText, sal_False,
707             ::rtl::OUString(), LANGUAGE_NONE );
708         if(nAdded == DIC_ERR_NONE)
709         {
710             SpellUndoAction_Impl* pAction = new SpellUndoAction_Impl(
711                             SPELLUNDO_CHANGE_ADD_TO_DICTIONARY, aDialogUndoLink);
712             pAction->SetDictionary(aXDictionary);
713             pAction->SetAddedWord(sErrorText);
714             aSentenceED.AddUndoAction(pAction);
715         }
716     }
717 
718 	SpellContinue_Impl();
719     bModified = false;
720     aSentenceED.UndoActionEnd();
721     return 1;
722 }
723 /*-- 06.11.2003 11:24:08---------------------------------------------------
724 
725   -----------------------------------------------------------------------*/
IMPL_LINK(SpellDialog,UndoHdl,Button *,EMPTYARG)726 IMPL_LINK( SpellDialog, UndoHdl, Button*, EMPTYARG )
727 {
728     aSentenceED.Undo();
729     if(!aSentenceED.GetUndoActionCount())
730         aUndoPB.Enable(sal_False);
731     return 0;
732 }
733 /*-- 06.11.2003 12:19:15---------------------------------------------------
734 
735   -----------------------------------------------------------------------*/
IMPL_LINK(SpellDialog,DialogUndoHdl,SpellUndoAction_Impl *,pAction)736 IMPL_LINK( SpellDialog, DialogUndoHdl, SpellUndoAction_Impl*, pAction )
737 {
738     switch(pAction->GetId())
739     {
740         case SPELLUNDO_CHANGE_TEXTENGINE:
741         {
742             if(pAction->IsEnableChangePB())
743                 aChangePB.Enable(sal_False);
744             if(pAction->IsEnableChangeAllPB())
745                 aChangeAllPB.Enable(sal_False);
746         }
747         break;
748         case SPELLUNDO_CHANGE_NEXTERROR:
749         {
750             aSentenceED.MoveErrorMarkTo((sal_uInt16)pAction->GetOldErrorStart(), (sal_uInt16)pAction->GetOldErrorEnd(), false);
751             if(pAction->IsErrorLanguageSelected())
752             {
753                 UpdateBoxes_Impl();
754             }
755         }
756         break;
757         case SPELLUNDO_CHANGE_ADD_TO_DICTIONARY:
758         {
759             if(pAction->GetDictionary().is())
760                 pAction->GetDictionary()->remove(pAction->GetAddedWord());
761         }
762         break;
763         case SPELLUNDO_MOVE_ERROREND :
764         {
765             if(pAction->GetOffset() != 0)
766                 aSentenceED.MoveErrorEnd(pAction->GetOffset());
767         }
768         break;
769         case SPELLUNDO_UNDO_EDIT_MODE :
770         {
771             //refill the dialog with the currently spelled sentence - throw away all changes
772             SpellContinue_Impl(true);
773         }
774         break;
775         case SPELLUNDO_ADD_IGNORE_RULE:
776             //undo of ignored rules is not supported
777         break;
778     }
779 
780     return 0;
781 }
782 // -----------------------------------------------------------------------
Impl_Restore()783 void SpellDialog::Impl_Restore()
784 {
785     //clear the "ChangeAllList"
786     SvxGetChangeAllList()->clear();
787     //get a new sentence
788     aSentenceED.SetText(rtl::OUString());
789     aSentenceED.ResetModified();
790     SpellContinue_Impl(true);
791     aIgnorePB.SetText(aIgnoreOnceST);
792 }
793 
IMPL_LINK(SpellDialog,IgnoreHdl,Button *,EMPTYARG)794 IMPL_LINK( SpellDialog, IgnoreHdl, Button *, EMPTYARG )
795 {
796     if(aIgnorePB.GetText() == aResumeST)
797     {
798         Impl_Restore();
799     }
800     else
801     {
802         //in case the error has been changed manually it has to be restored,
803         // since the users choice now was to ignore the error
804         aSentenceED.RestoreCurrentError();
805 
806         // the word is being ignored
807         SpellContinue_Impl( false, true );
808     }
809 	return 1;
810 }
811 
812 
813 // -----------------------------------------------------------------------
814 
Close()815 sal_Bool SpellDialog::Close()
816 {
817     GetBindings().GetDispatcher()->
818         Execute(rParent.GetType(),
819         SFX_CALLMODE_ASYNCHRON|SFX_CALLMODE_RECORD);
820     return sal_True;
821 }
822 // -----------------------------------------------------------------------
823 
SetSelectedLang_Impl(LanguageType nLang)824 void SpellDialog::SetSelectedLang_Impl( LanguageType nLang )
825 {
826     aLanguageLB.SelectLanguage( nLang );
827 }
828 
829 // -----------------------------------------------------------------------
830 
GetSelectedLang_Impl() const831 LanguageType SpellDialog::GetSelectedLang_Impl() const
832 {
833     sal_Int16 nLang = aLanguageLB.GetSelectLanguage();
834 	return nLang;
835 }
836 /* -----------------28.10.2003 14:27-----------------
837 
838  --------------------------------------------------*/
IMPL_LINK(SpellDialog,LanguageSelectHdl,SvxLanguageBox *,pBox)839 IMPL_LINK(SpellDialog, LanguageSelectHdl, SvxLanguageBox*, pBox)
840 {
841     //if currently an error is selected then search for alternatives for
842     //this word and fill the alternatives ListBox accordingly
843     String sError = aSentenceED.GetErrorText();
844     aSuggestionLB.Clear();
845     if(sError.Len())
846     {
847         LanguageType eLanguage = pBox->GetSelectLanguage();
848         Reference <XSpellAlternatives> xAlt = xSpell->spell( sError, eLanguage,
849                                             Sequence< PropertyValue >() );
850         if( xAlt.is() )
851             aSentenceED.SetAlternatives( xAlt );
852         else
853         {
854             aSentenceED.ChangeMarkedWord( sError, eLanguage );
855             SpellContinue_Impl();
856         }
857 
858          aSentenceED.AddUndoAction(new SpellUndoAction_Impl(SPELLUNDO_CHANGE_LANGUAGE, aDialogUndoLink));
859     }
860 
861     // Update listboxes and user dictionaries when selected language changes
862     SpellDialog::UpdateBoxes_Impl();
863     return 0;
864 }
865 // -----------------------------------------------------------------------
866 
SetLanguage(sal_uInt16 nLang)867 void SpellDialog::SetLanguage( sal_uInt16 nLang )
868 
869 /*	[Beschreibung]
870 
871 	wenn die Sprache im Thesaurus umgestellt wurde,
872 	muss auch hier die Sprache umgestellt werden.
873 */
874 
875 {
876     SetTitle_Impl( nLang );
877 
878 	// den richtigen Eintrag finden, da sortiert
879     aLanguageLB.SelectLanguage( nLang );
880 }
881 /*-- 16.06.2008 11:27:02---------------------------------------------------
882 
883   -----------------------------------------------------------------------*/
lcl_GetImageFromPngUrl(const::rtl::OUString & rFileUrl)884 static Image lcl_GetImageFromPngUrl( const ::rtl::OUString &rFileUrl )
885 {
886     Image aRes;
887     ::rtl::OUString aTmp;
888     osl::FileBase::getSystemPathFromFileURL( rFileUrl, aTmp );
889     Graphic aGraphic;
890     const String aFilterName( RTL_CONSTASCII_USTRINGPARAM( IMP_PNG ) );
891     if( GRFILTER_OK == GraphicFilter::LoadGraphic( aTmp, aFilterName, aGraphic ) )
892     {
893         aRes = Image( aGraphic.GetBitmapEx() );
894     }
895     return aRes;
896 }
SetTitle_Impl(LanguageType nLang)897 void SpellDialog::SetTitle_Impl(LanguageType nLang)
898 {
899     String sTitle( m_sTitleSpelling );
900     if( rParent.HasGrammarChecking() )
901     {
902         String sVendor;
903         const SpellErrorDescription* pSpellErrorDescription = aSentenceED.GetAlternatives();
904         if( pSpellErrorDescription && pSpellErrorDescription->sServiceName.getLength() )
905         {
906             bool bHighContrast = GetSettings().GetStyleSettings().GetHighContrastMode();
907             ::rtl::OUString sSuggestionImageUrl =
908                 SvtLinguConfig().GetSpellAndGrammarDialogImage( pSpellErrorDescription->sServiceName, bHighContrast );
909             aVendorImageFI.SetImage( lcl_GetImageFromPngUrl( sSuggestionImageUrl ) );
910             uno::Reference< lang::XServiceDisplayName > xDisplayName( pSpellErrorDescription->xGrammarChecker, uno::UNO_QUERY );
911             if( xDisplayName.is() )
912                 sVendor = xDisplayName->getServiceDisplayName( pSpellErrorDescription->aLocale );
913         }
914         else
915         {
916             bool bHighContrast = GetSettings().GetStyleSettings().GetHighContrastMode();
917             aVendorImageFI.SetImage( bHighContrast ? aVendorImageHC : aVendorImage );
918         }
919 
920         if( sVendor.Len() )
921         {
922             sTitle = m_sTitleSpellingGrammarVendor;
923             sTitle.SearchAndReplaceAscii( "$VendorName", sVendor );
924         }
925         else
926         {
927             //bool bHighContrast = GetSettings().GetStyleSettings().GetHighContrastMode();
928             sTitle = m_sTitleSpellingGrammar;
929         }
930     }
931     sTitle.SearchAndReplaceAscii( "$LANGUAGE ($LOCATION)", SvtLanguageTable::GetLanguageString(nLang) );
932     SetText( sTitle );
933 }
934 /*-------------------------------------------------------------------------
935 
936   -----------------------------------------------------------------------*/
InitUserDicts()937 void SpellDialog::InitUserDicts()
938 {
939     bool bEnable = false;
940 
941     // get list of dictionaries
942     Reference< XDictionaryList >  xDicList( SvxGetDictionaryList() );
943     if (xDicList.is())
944     {
945         // add active, positive dictionary to dic-list (if not already done).
946         // This is to ensure that there is at least one dictionary to which
947         // words could be added.
948         Reference< XDictionary >  xDic( SvxGetOrCreatePosDic( xDicList ) );
949         if (xDic.is())
950             xDic->setActive( sal_True );
951 
952         pImpl->aDics = xDicList->getDictionaries();
953 
954         // this is redundant, there will always be *at least* one dictionary
955         bEnable = pImpl->aDics.getLength();
956     }
957 
958     aAddToDictMB.Enable( bEnable );
959 }
960 
961 IMPL_LINK(SpellDialog, MenuButtonActivateHdl, MenuButton*, )
962 {
963     bool bEnable = false;
964     const LanguageType nLang = aLanguageLB.GetSelectLanguage();
965     const Reference< XDictionary >  *pDic = 0;
966 
967     SvtLinguConfig aCfg;
968     const bool bHC = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
969 
970     // list suitable dictionaries
971     const sal_Int32 nSize = pImpl->aDics.getLength();
972     pDic = pImpl->aDics.getConstArray();
973 
974     PopupMenu* pMenu = aAddToDictMB.GetPopupMenu();
975     OSL_ENSURE( pMenu, "svx::SpellDialog::MenuButtonActivateHdl - no PopupMenu!" );
976     pMenu->Clear();
977     pMenu->SetMenuFlags(MENU_FLAG_NOAUTOMNEMONICS);
978 
979     sal_uInt16 nItemId = 1;     // menu items should be enumerated from 1 and not 0
980     for (sal_Int32 i = 0; i < nSize; ++i)
981     {
982         uno::Reference< linguistic2::XDictionary >  xDicTmp( pDic[i], uno::UNO_QUERY );
983         if (!xDicTmp.is() || SvxGetIgnoreAllList() == xDicTmp)
984             continue;
985 
986         uno::Reference< frame::XStorable > xStor( xDicTmp, uno::UNO_QUERY );
987         LanguageType nActLanguage = SvxLocaleToLanguage( xDicTmp->getLocale() );
988         if( xDicTmp->isActive()
989             &&  xDicTmp->getDictionaryType() != linguistic2::DictionaryType_NEGATIVE
990             && (nLang == nActLanguage || LANGUAGE_NONE == nActLanguage )
991             && (!xStor.is() || !xStor->isReadonly()) )
992         {
993             pMenu->InsertItem( nItemId, xDicTmp->getName() );
994             bEnable = sal_True;
995 
996             uno::Reference< lang::XServiceInfo > xSvcInfo( xDicTmp, uno::UNO_QUERY );
997             if (xSvcInfo.is())
998             {
999                 OUString aDictionaryImageUrl( aCfg.GetSpellAndGrammarContextDictionaryImage(
1000                         xSvcInfo->getImplementationName(), bHC) );
1001                 if (aDictionaryImageUrl.getLength() > 0)
1002                 {
1003                     Image aImage( lcl_GetImageFromPngUrl( aDictionaryImageUrl ) );
1004                     pMenu->SetItemImage( nItemId, aImage );
1005                 }
1006             }
1007 
1008             ++nItemId;
1009         }
1010     }
1011 
1012     aAddToDictMB.Enable( bEnable );
1013 
1014     return 0;
1015 }
1016 
1017 /*-- 20.10.2003 15:31:06---------------------------------------------------
1018 
1019   -----------------------------------------------------------------------*/
IMPL_LINK(SpellDialog,AddToDictionaryHdl,MenuButton *,pButton)1020 IMPL_LINK(SpellDialog, AddToDictionaryHdl, MenuButton*, pButton )
1021 {
1022     aSentenceED.UndoActionStart( SPELLUNDO_CHANGE_GROUP );
1023 
1024     //GetErrorText() returns the current error even if the text is already
1025     //manually changed
1026     const String aNewWord= aSentenceED.GetErrorText();
1027 
1028     sal_uInt16 nItemId = pButton->GetCurItemId();
1029     PopupMenu *pMenu = pButton->GetPopupMenu();
1030     String aDicName ( pMenu->GetItemText( nItemId ) );
1031 
1032     uno::Reference< linguistic2::XDictionary >      xDic;
1033     uno::Reference< linguistic2::XDictionaryList >  xDicList( SvxGetDictionaryList() );
1034     if (xDicList.is())
1035         xDic = xDicList->getDictionaryByName( aDicName );
1036 
1037     sal_Int16 nAddRes = DIC_ERR_UNKNOWN;
1038     if (xDic.is())
1039     {
1040         nAddRes = linguistic::AddEntryToDic( xDic, aNewWord, sal_False, OUString(), LANGUAGE_NONE );
1041         // save modified user-dictionary if it is persistent
1042         uno::Reference< frame::XStorable >  xSavDic( xDic, uno::UNO_QUERY );
1043         if (xSavDic.is())
1044             xSavDic->store();
1045 
1046         if (nAddRes == DIC_ERR_NONE)
1047         {
1048             SpellUndoAction_Impl* pAction = new SpellUndoAction_Impl(
1049                             SPELLUNDO_CHANGE_ADD_TO_DICTIONARY, aDialogUndoLink);
1050             pAction->SetDictionary( xDic );
1051             pAction->SetAddedWord( aNewWord );
1052             aSentenceED.AddUndoAction( pAction );
1053         }
1054         // failed because there is already an entry?
1055         if (DIC_ERR_NONE != nAddRes && xDic->getEntry( aNewWord ).is())
1056             nAddRes = DIC_ERR_NONE;
1057     }
1058     if (DIC_ERR_NONE != nAddRes)
1059     {
1060         SvxDicError( this, nAddRes );
1061         return 0;   // Nicht weitermachen
1062     }
1063 
1064     // go on
1065     SpellContinue_Impl();
1066     aSentenceED.UndoActionEnd();
1067     return 0;
1068 }
1069 /*-------------------------------------------------------------------------
1070 
1071   -----------------------------------------------------------------------*/
IMPL_LINK(SpellDialog,ModifyHdl,SentenceEditWindow_Impl *,pEd)1072 IMPL_LINK(SpellDialog, ModifyHdl, SentenceEditWindow_Impl*, pEd)
1073 {
1074     if (&aSentenceED == pEd)
1075 	{
1076         bModified = true;
1077         aSuggestionLB.SetNoSelection();
1078         aSuggestionLB.Disable();
1079         String sNewText( aSentenceED.GetText() );
1080         aAutoCorrPB.Enable( sNewText != aSentenceED.GetText() );
1081         SpellUndoAction_Impl* pSpellAction = new SpellUndoAction_Impl(SPELLUNDO_CHANGE_TEXTENGINE, aDialogUndoLink);
1082         if(!aChangeAllPB.IsEnabled())
1083         {
1084             aChangeAllPB.Enable();
1085             pSpellAction->SetEnableChangeAllPB();
1086         }
1087         if(!aChangePB.IsEnabled())
1088         {
1089             aChangePB.Enable();
1090             pSpellAction->SetEnableChangePB();
1091         }
1092         aSentenceED.AddUndoAction(pSpellAction);
1093 	}
1094 	return 0;
1095 };
1096 /*-------------------------------------------------------------------------
1097 
1098   -----------------------------------------------------------------------*/
IMPL_LINK(SpellDialog,CancelHdl,Button *,EMPTYARG)1099 IMPL_LINK(SpellDialog, CancelHdl, Button *, EMPTYARG )
1100 {
1101     //apply changes and ignored text parts first - if there are any
1102     rParent.ApplyChangedSentence(aSentenceED.CreateSpellPortions(true), false);
1103     Close();
1104 	return 0;
1105 }
1106 /*-------------------------------------------------------------------------
1107 
1108   -----------------------------------------------------------------------*/
Paint(const Rectangle & rRect)1109 void SpellDialog::Paint( const Rectangle& rRect )
1110 {
1111     ModelessDialog::Paint(rRect );
1112     Rectangle aRect(aBackgroundGB.GetPosPixel(), aBackgroundGB.GetSizePixel());
1113     DecorationView aDecoView( this );
1114     aDecoView.DrawButton( aRect, BUTTON_DRAW_NOFILL);
1115 }
1116 /*-- 28.10.2003 13:26:39---------------------------------------------------
1117 
1118   -----------------------------------------------------------------------*/
Notify(NotifyEvent & rNEvt)1119 long SpellDialog::Notify( NotifyEvent& rNEvt )
1120 {
1121     /* #i38338#
1122     *   FIXME: LoseFocus and GetFocus are signals from vcl that
1123     *   a window actually got/lost the focus, it never should be
1124     *   forwarded from another window, that is simply wrong.
1125     *   FIXME: overloading the virtual methods GetFocus and LoseFocus
1126     *   in SpellDialogChildWindow by making them pure is at least questionable.
1127     *   The only sensible thing would be to call the new Method differently,
1128     *   e.g. DialogGot/LostFocus or so.
1129     */
1130     if( IsVisible() && !bFocusLocked )
1131     {
1132         if( rNEvt.GetType() ==  EVENT_GETFOCUS )
1133         {
1134             //notify the child window of the focus change
1135             rParent.GetFocus();
1136         }
1137         else if( rNEvt.GetType() == EVENT_LOSEFOCUS )
1138         {
1139             //notify the child window of the focus change
1140             rParent.LoseFocus();
1141         }
1142     }
1143     return SfxModelessDialog::Notify(rNEvt);
1144 }
1145 /* -----------------10.09.2003 08:26-----------------
1146 
1147  --------------------------------------------------*/
InvalidateDialog()1148 void SpellDialog::InvalidateDialog()
1149 {
1150     if( bFocusLocked )
1151         return;
1152     aIgnorePB.SetText(aResumeST);
1153     Window* aDisableArr[] =
1154             {
1155                 &aNotInDictFT,
1156                 &aSentenceED,
1157                 &aSuggestionFT,
1158                 &aSuggestionLB,
1159                 &aLanguageFT,
1160                 &aLanguageLB,
1161                 &aIgnoreAllPB,
1162                 &aIgnoreRulePB,
1163                 &aAddToDictMB,
1164                 &aChangePB,
1165                 &aChangeAllPB,
1166                 &aAutoCorrPB,
1167                 &aUndoPB,
1168                 0
1169             };
1170     sal_Int16 i = 0;
1171 	while(aDisableArr[i])
1172     {
1173         aDisableArr[i]->Enable(sal_False);
1174         i++;
1175     }
1176     SfxModelessDialog::Deactivate();
1177 }
1178 
1179 /*-- 10.09.2003 08:35:56---------------------------------------------------
1180 
1181   -----------------------------------------------------------------------*/
GetNextSentence_Impl(bool bUseSavedSentence,bool bRecheck)1182 bool SpellDialog::GetNextSentence_Impl(bool bUseSavedSentence, bool bRecheck)
1183 {
1184     bool bRet = false;
1185     if(!bUseSavedSentence /*&& aSentenceED.IsModified()*/)
1186     {
1187         //apply changes and ignored text parts
1188         rParent.ApplyChangedSentence(aSentenceED.CreateSpellPortions(true), bRecheck);
1189     }
1190     aSentenceED.ResetIgnoreErrorsAt();
1191     aSentenceED.ResetModified();
1192     SpellPortions aSentence = bUseSavedSentence ? m_aSavedSentence : rParent.GetNextWrongSentence( bRecheck );
1193     if(!bUseSavedSentence)
1194         m_aSavedSentence = aSentence;
1195     bool bHasReplaced = false;
1196     while(aSentence.size())
1197     {
1198         //apply all changes that are already part of the "ChangeAllList"
1199         //returns true if the list still contains errors after the changes have been applied
1200 
1201         if(!ApplyChangeAllList_Impl(aSentence, bHasReplaced))
1202         {
1203             rParent.ApplyChangedSentence(aSentence, bRecheck);
1204 			aSentence = rParent.GetNextWrongSentence( bRecheck );
1205         }
1206 		else
1207             break;
1208     }
1209 
1210     if(aSentence.size())
1211     {
1212         SpellPortions::iterator aStart = aSentence.begin();
1213         rtl::OUString sText;
1214         while(aStart != aSentence.end())
1215         {
1216             // hidden text has to be ignored
1217             if(!aStart->bIsHidden)
1218                 sText += aStart->sText;
1219             aStart++;
1220         }
1221         aSentenceED.SetText(sText);
1222         aStart = aSentence.begin();
1223         sal_Int32 nStartPosition = 0;
1224         sal_Int32 nEndPosition = 0;
1225 
1226         while(aStart != aSentence.end())
1227         {
1228             // hidden text has to be ignored
1229             if(!aStart->bIsHidden)
1230             {
1231                 nEndPosition += aStart->sText.getLength();
1232                 if(aStart->xAlternatives.is())
1233                 {
1234                     uno::Reference< container::XNamed > xNamed( aStart->xAlternatives, uno::UNO_QUERY );
1235                     ::rtl::OUString sServiceName;
1236                     if( xNamed.is() )
1237                         sServiceName = xNamed->getName();
1238                     SpellErrorDescription aDesc( false, aStart->xAlternatives->getWord(),
1239                                     aStart->xAlternatives->getLocale(), aStart->xAlternatives->getAlternatives(), 0, sServiceName);
1240                     aSentenceED.SetAttrib( SpellErrorAttrib(aDesc), 0, (sal_uInt16) nStartPosition, (sal_uInt16) nEndPosition );
1241                 }
1242                 else if(aStart->bIsGrammarError )
1243                 {
1244                     uno::Reference< lang::XServiceInfo > xInfo( aStart->xGrammarChecker, uno::UNO_QUERY );
1245                     SpellErrorDescription aDesc( true,
1246                         aStart->sText,
1247 						SvxCreateLocale( aStart->eLanguage ),
1248                         aStart->aGrammarError.aSuggestions,
1249                         aStart->xGrammarChecker,
1250                         xInfo->getImplementationName(),
1251                         &aStart->sDialogTitle,
1252                         &aStart->aGrammarError.aFullComment,
1253                         &aStart->aGrammarError.aRuleIdentifier );
1254                     aSentenceED.SetAttrib( SpellErrorAttrib(aDesc), 0, (sal_uInt16) nStartPosition, (sal_uInt16) nEndPosition );
1255                 }
1256                 if(aStart->bIsField)
1257                     aSentenceED.SetAttrib( SpellBackgroundAttrib(COL_LIGHTGRAY), 0, (sal_uInt16) nStartPosition, (sal_uInt16) nEndPosition );
1258                 aSentenceED.SetAttrib( SpellLanguageAttrib(aStart->eLanguage), 0, (sal_uInt16) nStartPosition, (sal_uInt16) nEndPosition );
1259                 nStartPosition = nEndPosition;
1260             }
1261             aStart++;
1262         }
1263         //the edit field needs to be modified to apply the change from the ApplyChangeAllList
1264         if(!bHasReplaced)
1265             aSentenceED.ClearModifyFlag();
1266         aSentenceED.ResetUndo();
1267         aUndoPB.Enable(sal_False);
1268         bRet = nStartPosition > 0;
1269     }
1270     return bRet;
1271 }
1272 /*-- 12.11.2003 15:21:25---------------------------------------------------
1273     replace errrors that have a replacement in the ChangeAllList
1274     returns false if the result doesn't contain errors after the replacement
1275   -----------------------------------------------------------------------*/
ApplyChangeAllList_Impl(SpellPortions & rSentence,bool & bHasReplaced)1276 bool SpellDialog::ApplyChangeAllList_Impl(SpellPortions& rSentence, bool &bHasReplaced)
1277 {
1278     bHasReplaced = false;
1279     bool bRet = true;
1280     SpellPortions::iterator aStart = rSentence.begin();
1281     Reference<XDictionary> xChangeAll( SvxGetChangeAllList(), UNO_QUERY );
1282     if(!xChangeAll->getCount())
1283         return bRet;
1284     bRet = false;
1285     while(aStart != rSentence.end())
1286     {
1287         if(aStart->xAlternatives.is())
1288         {
1289             Reference<XDictionaryEntry> xEntry = xChangeAll->getEntry( aStart->sText );
1290             if(xEntry.is())
1291             {
1292                 aStart->sText = xEntry->getReplacementText();
1293                 aStart->xAlternatives = 0;
1294                 bHasReplaced = true;
1295             }
1296             else
1297                 bRet = true;
1298         }
1299         else if( aStart->bIsGrammarError )
1300             bRet = true;
1301         aStart++;
1302     }
1303     return bRet;
1304 }
1305 /*-- 10.09.2003 10:40:21---------------------------------------------------
1306 
1307   -----------------------------------------------------------------------*/
SentenceEditWindow_Impl(SpellDialog * pParent,const ResId & rResId)1308 SentenceEditWindow_Impl::SentenceEditWindow_Impl( SpellDialog* pParent, const ResId& rResId ) :
1309     MultiLineEdit( pParent, rResId ),
1310     m_nErrorStart(0),
1311     m_nErrorEnd(0),
1312     m_bIsUndoEditMode(false)
1313 {
1314     DisableSelectionOnFocus();
1315 }
1316 /*-- 10.09.2003 10:40:11---------------------------------------------------
1317 
1318   -----------------------------------------------------------------------*/
~SentenceEditWindow_Impl()1319 SentenceEditWindow_Impl::~SentenceEditWindow_Impl()
1320 {
1321 }
1322 /*-- 20.10.2003 13:42:34---------------------------------------------------
1323     The selection before inputting a key may have a range or not
1324     and it may be inside or outside of field or error attributes.
1325     A range may include the attribute partially, completely or together
1326     with surrounding text. It may also contain more than one attribute
1327     or no attribute at all.
1328     Depending on this starting conditions some actions are necessary:
1329     Attempts to delete a field are only allowed if the selection is the same
1330     as the field's selection. Otherwise the field has to be selected and the key
1331     input action has to be skipped.
1332     Input of text at the start of the field requires the field attribute to be
1333     corrected - it is not allowed to grow.
1334 
1335     In case of errors the appending of text should grow the error attribute because
1336     that is what the user usually wants to do.
1337 
1338     Backspace at the start of the attribute requires to find out if a field ends
1339     directly in front of the cursor position. In case of a field this attribute has to be
1340     selected otherwise the key input method is allowed.
1341 
1342     All changes outside of the error attributes switch the dialog mode to a "Undo edit" state that
1343     removes all visible attributes and switches off further attribute checks.
1344     Undo in this restarts the dialog with a current sentence newly presented.
1345     All changes to the sentence are undone including the ones before the "Undo edit state" has been reached
1346 
1347     We end up with 9 types of selection
1348     1 (LEFT_NO)     - no range, start of attribute - can also be 3 at the same time
1349     2 (INSIDE_NO)   - no range, inside of attribute
1350     3 (RIGHT_NO)    - no range, end of attribute - can also be 1 at the same time
1351     4 (FULL)        - range, same as attribute
1352     5 (INSIDE_YES)  - range, inside of the attribute
1353     6 (BRACE)- range, from outside of the attribute to the inside or
1354                 including the complete attribute and something outside,
1355                 maybe more than one attribute
1356     7 (OUTSIDE_NO)  - no range, not at an attribute
1357     8 (OUTSIDE_YES) - range, completely outside of all attributes
1358 
1359     What has to be done depending on the attribute type involved
1360     possible actions:   UE - Undo edit mode
1361                         CO - Continue, no additional action is required
1362                         FS - Field has to be completely selected
1363                         EX - The attribute has to be expanded to include the added text
1364 
1365     1 - backspace                   delete                      any other
1366         UE                          on field FS on error CO     on field FS on error CO
1367 
1368     2 - on field FS on error C
1369     3 - backspace                   delete                      any other
1370         on field FS on error CO     UE                          on field UE on error EX
1371 
1372     if 1 and 3 happen to apply both then backspace and other handling is 1 delete is 3
1373 
1374     4 - on field UE and on error CO
1375     5 - on field FS and on error CO
1376     6 - on field FS and on error UE
1377     7 - UE
1378     8 - UE
1379   -----------------------------------------------------------------------*/
1380 #define     INVALID     0
1381 #define     LEFT_NO     1
1382 #define     INSIDE_NO   2
1383 #define     RIGHT_NO    3
1384 #define     FULL        4
1385 #define     INSIDE_YES  5
1386 #define     BRACE       6
1387 #define     OUTSIDE_NO  7
1388 #define     OUTSIDE_YES 8
1389 
1390 #define ACTION_UNDOEDIT    0
1391 #define ACTION_CONTINUE    1
1392 #define ACTION_SELECTFIELD 2
1393 #define ACTION_EXPAND      3
1394 
PreNotify(NotifyEvent & rNEvt)1395 long SentenceEditWindow_Impl::PreNotify( NotifyEvent& rNEvt )
1396 {
1397     bool bChange = false;
1398     const TextCharAttrib*  pErrorAttrib = 0;
1399     if(rNEvt.GetType() == EVENT_KEYINPUT)
1400     {
1401         const KeyEvent& rKeyEvt = *rNEvt.GetKeyEvent();
1402         bChange = TextEngine::DoesKeyChangeText( rKeyEvt );
1403         if(bChange && !IsUndoEditMode() &&
1404             rKeyEvt.GetKeyCode().GetCode() != KEY_TAB)
1405         {
1406             TextEngine* pTextEngine = GetTextEngine();
1407             TextView* pTextView = pTextEngine->GetActiveView();
1408             const TextSelection& rCurrentSelection = pTextView->GetSelection();
1409             //determine if the selection contains a field
1410             bool bHasField = false;
1411             bool bHasError = false;
1412             bool bHasFieldLeft = false;
1413             bool bHasErrorLeft = false;
1414 //            bool bInsideAttr = false;
1415 
1416             bool bHasRange = rCurrentSelection.HasRange();
1417             sal_uInt8 nSelectionType = 0; // invalid type!
1418 
1419             TextPaM aCursor(rCurrentSelection.GetStart());
1420             const TextCharAttrib* pBackAttr = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_BACKGROUND );
1421             const TextCharAttrib* pErrorAttr = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_ERROR );
1422             const TextCharAttrib* pBackAttrLeft = 0;
1423             const TextCharAttrib* pErrorAttrLeft = 0;
1424 
1425             bHasField = pBackAttr != 0 && (bHasRange || pBackAttr->GetEnd() > aCursor.GetIndex());
1426             bHasError = pErrorAttr != 0 && (bHasRange || pErrorAttr->GetEnd() > aCursor.GetIndex());
1427             if(bHasRange)
1428             {
1429                 if(pBackAttr &&
1430                         pBackAttr->GetStart() == rCurrentSelection.GetStart().GetIndex() &&
1431                         pBackAttr->GetEnd() == rCurrentSelection.GetEnd().GetIndex())
1432                 {
1433                     nSelectionType = FULL;
1434                 }
1435                 else if(pErrorAttr &&
1436                         pErrorAttr->GetStart() <= rCurrentSelection.GetStart().GetIndex() &&
1437                         pErrorAttr->GetEnd() >= rCurrentSelection.GetEnd().GetIndex())
1438                 {
1439                     nSelectionType = INSIDE_YES;
1440                 }
1441                 else
1442                 {
1443                     nSelectionType = bHasField||bHasError ? BRACE : OUTSIDE_NO;
1444                     while(aCursor.GetIndex() < rCurrentSelection.GetEnd().GetIndex())
1445                     {
1446                         ++aCursor.GetIndex();
1447                         const TextCharAttrib* pIntBackAttr = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_BACKGROUND );
1448                         const TextCharAttrib* pIntErrorAttr = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_ERROR );
1449                         //if any attr has been found then BRACE
1450                         if(pIntBackAttr || pIntErrorAttr)
1451                             nSelectionType = BRACE;
1452                         //the field has to be selected
1453                         if(pIntBackAttr && !pBackAttr)
1454                             pBackAttr = pIntBackAttr;
1455                         bHasField |= pIntBackAttr != 0;
1456                     }
1457                 }
1458             }
1459             else
1460             {
1461                 //no range selection: then 1 2 3 and 8 are possible
1462                 const TextCharAttrib* pCurAttr = pBackAttr ? pBackAttr : pErrorAttr;
1463                 if(pCurAttr)
1464                 {
1465                     nSelectionType = pCurAttr->GetStart() == rCurrentSelection.GetStart().GetIndex() ?
1466                             LEFT_NO : pCurAttr->GetEnd() == rCurrentSelection.GetEnd().GetIndex() ? RIGHT_NO : INSIDE_NO;
1467                 }
1468                 else
1469                     nSelectionType = OUTSIDE_NO;
1470 
1471                 bHasFieldLeft = pBackAttr && pBackAttr->GetEnd() == aCursor.GetIndex();
1472 				if(bHasFieldLeft)
1473 				{
1474 					pBackAttrLeft = pBackAttr;
1475 					pBackAttr = 0;
1476 				}
1477                 bHasErrorLeft = pErrorAttr && pErrorAttr->GetEnd() == aCursor.GetIndex();
1478 				if(bHasErrorLeft)
1479 				{
1480 					pErrorAttrLeft = pErrorAttr;
1481 					pErrorAttr = 0;
1482 				}
1483 
1484                 //check previous position if this exists
1485 				//that is a redundant in the case the the attribute found above already is on the left cursor side
1486 				//but it's o.k. for two errors/fields side by side
1487                 if(aCursor.GetIndex())
1488                 {
1489                     --aCursor.GetIndex();
1490                     pBackAttrLeft = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_BACKGROUND );
1491                     pErrorAttrLeft = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_ERROR );
1492                     bHasFieldLeft = pBackAttrLeft !=0;
1493                     bHasErrorLeft = pErrorAttrLeft != 0;
1494 //                    bInsideAttr = (bHasField || bHasError) && (bHasFieldLeft || bHasErrorLeft);
1495                     ++aCursor.GetIndex();
1496                 }
1497             }
1498 			//Here we have to determine if the error found is the one currently active
1499 			bool bIsErrorActive = (pErrorAttr && pErrorAttr->GetStart() == m_nErrorStart) ||
1500 					(pErrorAttrLeft && pErrorAttrLeft->GetStart() == m_nErrorStart);
1501 
1502             DBG_ASSERT(nSelectionType != INVALID, "selection type not set!");
1503 
1504             const KeyCode& rKeyCode = rKeyEvt.GetKeyCode();
1505             bool bDelete = rKeyCode.GetCode() == KEY_DELETE;
1506             bool bBackspace = rKeyCode.GetCode() == KEY_BACKSPACE;
1507 
1508             sal_Int8 nAction = ACTION_CONTINUE;
1509 //            nAction = ACTION_UNDOEDIT
1510 //            nAction = ACTION_SELECTFIELD
1511 //            nAction = ACTION_EXPAND
1512             switch(nSelectionType)
1513             {
1514 //    1 - backspace                   delete                      any other
1515 //        UE                          on field FS on error CO     on field FS on error CO
1516                 case LEFT_NO    :
1517                     if(bBackspace)
1518                     {
1519                         nAction = bHasFieldLeft ? ACTION_SELECTFIELD : ACTION_UNDOEDIT;
1520                         //to force the use of pBackAttrLeft
1521                         pBackAttr = 0;
1522                     }
1523                     else if(bDelete)
1524 						nAction = bHasField ? ACTION_SELECTFIELD : ACTION_CONTINUE;
1525 					else
1526 						nAction = bHasError && !aCursor.GetIndex() ? ACTION_CONTINUE :
1527 							bHasError ? ACTION_EXPAND : bHasErrorLeft ? ACTION_CONTINUE : ACTION_UNDOEDIT;
1528                 break;
1529 //    2 - on field FS on error C
1530                 case INSIDE_NO  :
1531                     nAction =  bHasField ? ACTION_SELECTFIELD :
1532                         bIsErrorActive ? ACTION_CONTINUE : ACTION_UNDOEDIT;
1533                 break;
1534 //    3 - backspace                   delete                      any other
1535 //        on field FS on error CO     UE                          on field UE on error EX
1536                 case RIGHT_NO   :
1537                     if(bBackspace)
1538                         nAction = bHasFieldLeft ? ACTION_SELECTFIELD : ACTION_CONTINUE;
1539                     else if(bDelete)
1540 						nAction = bHasFieldLeft && bHasError ? ACTION_CONTINUE : ACTION_UNDOEDIT;
1541 					else
1542 						nAction = bHasFieldLeft && bHasError ? ACTION_EXPAND :
1543 							bHasError ? ACTION_CONTINUE : bHasErrorLeft ? ACTION_EXPAND :ACTION_UNDOEDIT;
1544                 break;
1545 //    4 - on field UE and on error CO
1546                 case FULL       :
1547                     nAction = bHasField ? ACTION_UNDOEDIT : ACTION_CONTINUE;
1548                 break;
1549 //    5 - on field FS and on error CO
1550                 case INSIDE_YES :
1551                     nAction = bHasField ? ACTION_SELECTFIELD : ACTION_CONTINUE;
1552                 break;
1553 //    6 - on field FS and on error UE
1554                 case BRACE      :
1555                     nAction = bHasField ? ACTION_SELECTFIELD : ACTION_UNDOEDIT;;
1556                 break;
1557 //    7 - UE
1558 //    8 - UE
1559                 case OUTSIDE_NO :
1560                 case OUTSIDE_YES:
1561                     nAction = ACTION_UNDOEDIT;
1562                 break;
1563             }
1564 			//save the current paragraph
1565 			sal_uInt16 nCurrentLen = GetText().Len();
1566             if(nAction != ACTION_SELECTFIELD)
1567                 pTextView->GetWindow()->KeyInput(rKeyEvt);
1568             else
1569             {
1570                 const TextCharAttrib* pCharAttr = pBackAttr ? pBackAttr : pBackAttrLeft;
1571                 if(pCharAttr)
1572                 {
1573                     TextPaM aStart(0, pCharAttr->GetStart());
1574                     TextPaM aEnd(0, pCharAttr->GetEnd());
1575                     TextSelection aNewSel(aStart, aEnd);
1576                     pTextView->SetSelection( aNewSel);
1577                 }
1578             }
1579             if(nAction == ACTION_EXPAND)
1580             {
1581                 DBG_ASSERT(pErrorAttrLeft || pErrorAttr, "where is the error");
1582                 //text has been added on the right and only the 'error attribute has to be corrected
1583 				if(pErrorAttrLeft)
1584                 {
1585                     TextAttrib* pNewError =  pErrorAttrLeft->GetAttr().Clone();
1586                     sal_uInt16 nStart = pErrorAttrLeft->GetStart();
1587                     sal_uInt16 nEnd = pErrorAttrLeft->GetEnd();
1588                     pTextEngine->RemoveAttrib( 0, *pErrorAttrLeft );
1589                     SetAttrib( *pNewError, 0, nStart, ++nEnd );
1590                     //only active errors move the mark
1591 					if(bIsErrorActive)
1592                     {
1593                         bool bGrammar = static_cast<const SpellErrorAttrib&>(*pNewError).GetErrorDescription().bIsGrammarError;
1594                         MoveErrorMarkTo(nStart, nEnd, bGrammar);
1595                     }
1596                     delete pNewError;
1597                 }
1598 				//text has been added on the left then the error attribute has to be expanded and the
1599 				//field attribute on the right - if any - has to be contracted
1600 				else if(pErrorAttr)
1601 				{
1602 					//determine the change
1603 					sal_uInt16 nAddedChars = GetText().Len() - nCurrentLen;
1604 
1605                     TextAttrib* pNewError =  pErrorAttr->GetAttr().Clone();
1606                     sal_uInt16 nStart = pErrorAttr->GetStart();
1607                     sal_uInt16 nEnd = pErrorAttr->GetEnd();
1608                     pTextEngine->RemoveAttrib( 0, *pErrorAttr );
1609                     nStart = nStart - (sal_uInt16)nAddedChars;
1610 					SetAttrib( *pNewError, 0, nStart - nAddedChars, nEnd );
1611                     //only if the error is active the mark is moved here
1612 					if(bIsErrorActive)
1613                     {
1614                         bool bGrammar = static_cast<const SpellErrorAttrib&>(*pNewError).GetErrorDescription().bIsGrammarError;
1615                         MoveErrorMarkTo(nStart, nEnd, bGrammar);
1616                     }
1617                     delete pNewError;
1618 
1619 					if(pBackAttrLeft)
1620 					{
1621 						TextAttrib* pNewBack =  pBackAttrLeft->GetAttr().Clone();
1622                         sal_uInt16 _nStart = pBackAttrLeft->GetStart();
1623                         sal_uInt16 _nEnd = pBackAttrLeft->GetEnd();
1624 						pTextEngine->RemoveAttrib( 0, *pBackAttrLeft );
1625                         SetAttrib( *pNewBack, 0, _nStart, _nEnd - nAddedChars);
1626 						delete pNewBack;
1627 					}
1628 				}
1629             }
1630             else if(nAction == ACTION_UNDOEDIT)
1631             {
1632                 SetUndoEditMode(true);
1633             }
1634             //make sure the error positions are correct after text changes
1635             //the old attribute may have been deleted
1636             //all changes inside of the current error leave the error attribute at the current
1637             //start position
1638             if(!IsUndoEditMode() && bIsErrorActive)
1639             {
1640                 const TextCharAttrib* pFontColor = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_FONTCOLOR );
1641                 pErrorAttrib = pTextEngine->FindCharAttrib( TextPaM(0, m_nErrorStart), TEXTATTR_SPELL_ERROR );
1642                 if(pFontColor && pErrorAttrib )
1643                 {
1644                     m_nErrorStart = pFontColor->GetStart();
1645                     m_nErrorEnd = pFontColor->GetEnd();
1646                     if(pErrorAttrib->GetStart() != m_nErrorStart || pErrorAttrib->GetEnd() != m_nErrorEnd)
1647                     {
1648                         TextAttrib* pNewError =  pErrorAttrib->GetAttr().Clone();
1649                         pTextEngine->RemoveAttrib( 0, *pErrorAttr );
1650                         SetAttrib( *pNewError, 0, m_nErrorStart, m_nErrorEnd );
1651                         delete pNewError;
1652                     }
1653                 }
1654             }
1655             //this is not a modification anymore
1656 			if(nAction != ACTION_SELECTFIELD && !m_bIsUndoEditMode)
1657 				CallModifyLink();
1658         }
1659 		else
1660 			bChange = false;
1661     }
1662     long nRet = bChange ? 1 : MultiLineEdit::PreNotify(rNEvt);
1663     return nRet;
1664 }
1665 /*-- 10.09.2003 13:38:14---------------------------------------------------
1666 
1667   -----------------------------------------------------------------------*/
MarkNextError(bool bIgnoreCurrentError)1668 bool SentenceEditWindow_Impl::MarkNextError( bool bIgnoreCurrentError )
1669 {
1670     if (bIgnoreCurrentError)
1671         m_aIgnoreErrorsAt.insert( m_nErrorStart );
1672     ExtTextEngine* pTextEngine = GetTextEngine();
1673     sal_uInt16 nTextLen = pTextEngine->GetTextLen(0);
1674     if(m_nErrorEnd >= nTextLen - 1)
1675         return false;
1676 	//if it's not already modified the modified flag has to be reset at the and of the marking
1677     bool bModified = IsModified();
1678     bool bRet = false;
1679     const sal_uInt16 nOldErrorStart = m_nErrorStart;
1680     const sal_uInt16 nOldErrorEnd   = m_nErrorEnd;
1681 
1682     //create a cursor behind the end of the last error
1683 	//- or at 0 at the start of the sentence
1684     TextPaM aCursor(0, m_nErrorEnd ? m_nErrorEnd + 1 : 0);
1685     //search for SpellErrorAttrib
1686 
1687     const TextCharAttrib* pNextError = 0;
1688     //iterate over the text and search for the next error that maybe has
1689     //to be replace by a ChangeAllList replacement
1690     bool bGrammarError = false;
1691     while(aCursor.GetIndex() < nTextLen)
1692     {
1693         while(aCursor.GetIndex() < nTextLen &&
1694                 0 == (pNextError = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_ERROR)))
1695         {
1696             ++aCursor.GetIndex();
1697         }
1698         // maybe the error found here is already in the ChangeAllList and has to be replaced
1699 
1700         Reference<XDictionary> xChangeAll( SvxGetChangeAllList(), UNO_QUERY );
1701         Reference<XDictionaryEntry> xEntry;
1702 
1703 //        Reference <XSpellAlternatives> xAlternatives;
1704         const SpellErrorDescription* pSpellErrorDescription = 0;
1705         if(pNextError)
1706         {
1707             pSpellErrorDescription = &static_cast<const SpellErrorAttrib&>(pNextError->GetAttr()).GetErrorDescription();
1708             bGrammarError = pSpellErrorDescription->bIsGrammarError;
1709         }
1710         if(xChangeAll->getCount() && pSpellErrorDescription &&
1711                 (xEntry = xChangeAll->getEntry( pSpellErrorDescription->sErrorText )).is())
1712         {
1713             m_nErrorStart = pNextError->GetStart();
1714             m_nErrorEnd = pNextError->GetEnd();
1715             ChangeMarkedWord(xEntry->getReplacementText(),
1716                     SvxLocaleToLanguage( pSpellErrorDescription->aLocale ));
1717             aCursor.GetIndex() = aCursor.GetIndex() + (sal_uInt16)(xEntry->getReplacementText().getLength());
1718         }
1719 		else
1720 			break;
1721     }
1722 
1723     //if an attrib has been found search for the end of the error string
1724     if(aCursor.GetIndex() < nTextLen)
1725     {
1726         m_nErrorStart = aCursor.GetIndex();
1727         m_nErrorEnd = pNextError->GetEnd();
1728         MoveErrorMarkTo(m_nErrorStart, m_nErrorEnd, bGrammarError);
1729         bRet = true;
1730 		//add an undo action
1731         SpellUndoAction_Impl* pAction = new SpellUndoAction_Impl(
1732                 SPELLUNDO_CHANGE_NEXTERROR, GetSpellDialog()->aDialogUndoLink);
1733         pAction->SetErrorMove(m_nErrorStart, m_nErrorEnd, nOldErrorStart, nOldErrorEnd);
1734         const SpellErrorAttrib* pOldAttrib = static_cast<const SpellErrorAttrib*>(
1735                 pTextEngine->FindAttrib( TextPaM(0, nOldErrorStart), TEXTATTR_SPELL_ERROR ));
1736         pAction->SetErrorLanguageSelected(pOldAttrib && pOldAttrib->GetErrorDescription().aSuggestions.getLength() &&
1737                 SvxLocaleToLanguage( pOldAttrib->GetErrorDescription().aLocale) ==
1738                                         GetSpellDialog()->aLanguageLB.GetSelectLanguage());
1739         AddUndoAction(pAction);
1740     }
1741     else
1742         m_nErrorStart = m_nErrorEnd = nTextLen;
1743     if( !bModified )
1744         ClearModifyFlag();
1745     SpellDialog* pSpellDialog = GetSpellDialog();
1746     pSpellDialog->aIgnorePB.Enable(bRet);
1747     pSpellDialog->aIgnoreAllPB.Enable(bRet);
1748     pSpellDialog->aAutoCorrPB.Enable(bRet);
1749     pSpellDialog->aAddToDictMB.Enable(bRet);
1750 	return bRet;
1751 }
1752 
1753 /*-- 06.11.2003 13:30:26---------------------------------------------------
1754 
1755   -----------------------------------------------------------------------*/
MoveErrorMarkTo(sal_uInt16 nStart,sal_uInt16 nEnd,bool bGrammarError)1756 void SentenceEditWindow_Impl::MoveErrorMarkTo(sal_uInt16 nStart, sal_uInt16 nEnd, bool bGrammarError)
1757 {
1758     TextEngine* pTextEngine = GetTextEngine();
1759     pTextEngine->RemoveAttribs( 0, (sal_uInt16)TEXTATTR_FONTCOLOR, sal_True );
1760     pTextEngine->RemoveAttribs( 0, (sal_uInt16)TEXTATTR_FONTWEIGHT, sal_True );
1761     pTextEngine->SetAttrib( TextAttribFontWeight(WEIGHT_BOLD), 0, nStart, nEnd );
1762     pTextEngine->SetAttrib( TextAttribFontColor(bGrammarError ? COL_LIGHTBLUE : COL_LIGHTRED), 0, nStart, nEnd );
1763     m_nErrorStart = nStart;
1764     m_nErrorEnd = nEnd;
1765 }
1766 
1767 /*-- 17.09.2003 10:13:08---------------------------------------------------
1768 
1769   -----------------------------------------------------------------------*/
ChangeMarkedWord(const String & rNewWord,LanguageType eLanguage)1770 void SentenceEditWindow_Impl::ChangeMarkedWord(const String& rNewWord, LanguageType eLanguage)
1771 {
1772     //calculate length changes
1773     long nDiffLen = rNewWord.Len() - m_nErrorEnd + m_nErrorStart;
1774     TextSelection aSel(TextPaM(0, m_nErrorStart), TextPaM(0, m_nErrorEnd));
1775     //Remove spell errror attribute
1776     ExtTextEngine* pTextEngine = GetTextEngine();
1777     pTextEngine->UndoActionStart();
1778     const TextCharAttrib*  pErrorAttrib = pTextEngine->FindCharAttrib( TextPaM(0, m_nErrorStart), TEXTATTR_SPELL_ERROR );
1779     DBG_ASSERT(pErrorAttrib, "no error attribute found");
1780 //  Reference <XSpellAlternatives> xAlternatives;
1781     const SpellErrorDescription* pSpellErrorDescription = 0;
1782     if(pErrorAttrib)
1783 	{
1784         pTextEngine->RemoveAttrib(0, *pErrorAttrib);
1785         pSpellErrorDescription = &static_cast<const SpellErrorAttrib&>(pErrorAttrib->GetAttr()).GetErrorDescription();
1786 	}
1787     const TextCharAttrib*  pBackAttrib = pTextEngine->FindCharAttrib( TextPaM(0, m_nErrorStart), TEXTATTR_SPELL_BACKGROUND );
1788     pTextEngine->ReplaceText( aSel, rNewWord );
1789     //
1790     if(!m_nErrorStart)
1791     {
1792         //attributes following an error at the start of the text are not moved but expanded from the
1793         //text engine - this is done to keep full-paragraph-attributes
1794         //in the current case that handling is not desired
1795         const TextCharAttrib*  pLangAttrib =
1796                 pTextEngine->FindCharAttrib(
1797                     TextPaM(0, m_nErrorEnd), TEXTATTR_SPELL_LANGUAGE );
1798         sal_uInt16 nTextLen = pTextEngine->GetTextLen( 0 );
1799         if(pLangAttrib && !pLangAttrib->GetStart() && pLangAttrib->GetEnd() ==
1800             nTextLen)
1801         {
1802             SpellLanguageAttrib aNewLangAttrib( static_cast<const SpellLanguageAttrib&>(pLangAttrib->GetAttr()).GetLanguage());
1803             pTextEngine->RemoveAttrib(0, *pLangAttrib);
1804             pTextEngine->SetAttrib( aNewLangAttrib, 0, (sal_uInt16)(m_nErrorEnd + nDiffLen) , nTextLen );
1805         }
1806     }
1807 	// undo expanded attributes!
1808 	if( pBackAttrib && pBackAttrib->GetStart() < m_nErrorStart && pBackAttrib->GetEnd() == m_nErrorEnd + nDiffLen)
1809 	{
1810 		TextAttrib* pNewBackground = pBackAttrib->GetAttr().Clone();
1811         sal_uInt16 nStart = pBackAttrib->GetStart();
1812 		pTextEngine->RemoveAttrib(0, *pBackAttrib);
1813 		pTextEngine->SetAttrib(*pNewBackground, 0, nStart, m_nErrorStart);
1814 		delete pNewBackground;
1815 	}
1816     pTextEngine->SetModified(sal_True);
1817 
1818     //adjust end position
1819     long nEndTemp = m_nErrorEnd;
1820     nEndTemp += nDiffLen;
1821     m_nErrorEnd = (sal_uInt16)nEndTemp;
1822 
1823     SpellUndoAction_Impl* pAction = new SpellUndoAction_Impl(
1824                     SPELLUNDO_MOVE_ERROREND, GetSpellDialog()->aDialogUndoLink);
1825     pAction->SetOffset(nDiffLen);
1826     AddUndoAction(pAction);
1827     if(pSpellErrorDescription)
1828         SetAttrib( SpellErrorAttrib(*pSpellErrorDescription), 0, m_nErrorStart, m_nErrorEnd );
1829     SetAttrib( SpellLanguageAttrib(eLanguage), 0, m_nErrorStart, m_nErrorEnd );
1830     pTextEngine->UndoActionEnd();
1831 }
1832 /* -----------------08.10.2003 13:18-----------------
1833 
1834  --------------------------------------------------*/
GetErrorText() const1835 String SentenceEditWindow_Impl::GetErrorText() const
1836 {
1837     return GetTextEngine()->GetText(TextSelection(TextPaM(0, m_nErrorStart), TextPaM(0, m_nErrorEnd) ));
1838 }
1839 /*-- 26.06.2008 10:54:13---------------------------------------------------
1840 
1841   -----------------------------------------------------------------------*/
GetAlternatives()1842 const SpellErrorDescription* SentenceEditWindow_Impl::GetAlternatives()
1843 {
1844     TextPaM aCursor(0, m_nErrorStart);
1845     const SpellErrorAttrib* pAttrib = static_cast<const SpellErrorAttrib*>(
1846             GetTextEngine()->FindAttrib( aCursor, TEXTATTR_SPELL_ERROR));
1847     return pAttrib ? &pAttrib->GetErrorDescription() : 0;
1848 }
1849 /*-- 06.09.2004 10:50:32---------------------------------------------------
1850 
1851   -----------------------------------------------------------------------*/
RestoreCurrentError()1852 void SentenceEditWindow_Impl::RestoreCurrentError()
1853 {
1854     TextPaM aCursor(0, m_nErrorStart);
1855     const SpellErrorAttrib* pAttrib = static_cast<const SpellErrorAttrib*>(
1856             GetTextEngine()->FindAttrib( aCursor, TEXTATTR_SPELL_ERROR));
1857     if( pAttrib )
1858     {
1859         const SpellErrorDescription& rDesc = pAttrib->GetErrorDescription();
1860         if( !rDesc.sErrorText.equals( GetErrorText() ) )
1861             ChangeMarkedWord(rDesc.sErrorText, SvxLocaleToLanguage( rDesc.aLocale ));
1862     }
1863 }
1864 /*-- 28.10.2003 14:44:10---------------------------------------------------
1865 
1866   -----------------------------------------------------------------------*/
SetAlternatives(Reference<XSpellAlternatives> xAlt)1867 void SentenceEditWindow_Impl::SetAlternatives( Reference< XSpellAlternatives> xAlt )
1868 {
1869     TextPaM aCursor(0, m_nErrorStart);
1870     DBG_ASSERT(static_cast<const SpellErrorAttrib*>(
1871             GetTextEngine()->FindAttrib( aCursor, TEXTATTR_SPELL_ERROR)), "no error set?");
1872 
1873 	::rtl::OUString	aWord;
1874 	lang::Locale	aLocale;
1875 	uno::Sequence< ::rtl::OUString >	aAlts;
1876     ::rtl::OUString sServiceName;
1877 	if (xAlt.is())
1878 	{
1879 		aWord	= xAlt->getWord();
1880 		aLocale	= xAlt->getLocale();
1881 		aAlts	= xAlt->getAlternatives();
1882         uno::Reference< container::XNamed > xNamed( xAlt, uno::UNO_QUERY );
1883 		if (xNamed.is())
1884 			sServiceName = xNamed->getName();
1885 	}
1886     SpellErrorDescription aDesc( false, aWord, aLocale, aAlts, 0, sServiceName);
1887     GetTextEngine()->SetAttrib( SpellErrorAttrib(aDesc), 0, m_nErrorStart, m_nErrorEnd );
1888 }
1889 
1890 /*-- 10.09.2003 14:43:02---------------------------------------------------
1891 
1892   -----------------------------------------------------------------------*/
SetAttrib(const TextAttrib & rAttr,sal_uLong nPara,sal_uInt16 nStart,sal_uInt16 nEnd)1893 void SentenceEditWindow_Impl::SetAttrib( const TextAttrib& rAttr, sal_uLong nPara, sal_uInt16 nStart, sal_uInt16 nEnd )
1894 {
1895     GetTextEngine()->SetAttrib(rAttr, nPara, nStart, nEnd);
1896 }
1897 /*-- 10.09.2003 14:43:02---------------------------------------------------
1898 
1899   -----------------------------------------------------------------------*/
SetText(const String & rStr)1900 void SentenceEditWindow_Impl::SetText( const String& rStr )
1901 {
1902     m_nErrorStart = m_nErrorEnd = 0;
1903     GetTextEngine()->SetText(rStr);
1904 //    InitScrollBars();
1905 }
1906 /*-- 08.10.2003 14:35:52---------------------------------------------------
1907 
1908   -----------------------------------------------------------------------*/
1909 struct LanguagePosition_Impl
1910 {
1911     sal_uInt16          nPosition;
1912     LanguageType    eLanguage;
1913 
LanguagePosition_ImplLanguagePosition_Impl1914     LanguagePosition_Impl(sal_uInt16 nPos, LanguageType eLang) :
1915         nPosition(nPos),
1916         eLanguage(eLang)
1917         {}
1918 };
1919 typedef std::vector<LanguagePosition_Impl> LanguagePositions_Impl;
1920 
lcl_InsertBreakPosition_Impl(LanguagePositions_Impl & rBreakPositions,sal_uInt16 nInsert,LanguageType eLanguage)1921 void lcl_InsertBreakPosition_Impl(
1922         LanguagePositions_Impl& rBreakPositions, sal_uInt16 nInsert, LanguageType eLanguage)
1923 {
1924     LanguagePositions_Impl::iterator aStart = rBreakPositions.begin();
1925     while(aStart != rBreakPositions.end())
1926     {
1927         if(aStart->nPosition == nInsert)
1928 		{
1929             //the language of following starts has to overwrite
1930 			//the one of previous ends
1931 			aStart->eLanguage = eLanguage;
1932 			return;
1933 		}
1934         else if(aStart->nPosition > nInsert)
1935         {
1936 
1937             rBreakPositions.insert(aStart, LanguagePosition_Impl(nInsert, eLanguage));
1938             return;
1939         }
1940         else
1941             ++aStart;
1942     }
1943     rBreakPositions.push_back(LanguagePosition_Impl(nInsert, eLanguage));
1944 }
1945 /*-- 17.09.2003 14:26:59---------------------------------------------------
1946     Returns the text in spell portions. Each portion contains text with an
1947     equal language and attribute. The spell alternatives are empty.
1948   -----------------------------------------------------------------------*/
CreateSpellPortions(bool bSetIgnoreFlag) const1949 svx::SpellPortions SentenceEditWindow_Impl::CreateSpellPortions( bool bSetIgnoreFlag ) const
1950 {
1951     svx::SpellPortions aRet;
1952     ExtTextEngine* pTextEngine = GetTextEngine();
1953     const sal_uInt16 nTextLen = pTextEngine->GetTextLen(0);
1954     if(nTextLen)
1955     {
1956         TextPaM aCursor(0, 0);
1957         LanguagePositions_Impl aBreakPositions;
1958         const TextCharAttrib* pLastLang = 0;
1959         const TextCharAttrib* pLastError = 0;
1960         LanguageType eLang = LANGUAGE_DONTKNOW;
1961 		const TextCharAttrib* pError = 0;
1962         while(aCursor.GetIndex() < nTextLen)
1963         {
1964             const TextCharAttrib* pLang = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_LANGUAGE);
1965             if(pLang && pLang != pLastLang)
1966             {
1967                 eLang = static_cast<const SpellLanguageAttrib&>(pLang->GetAttr()).GetLanguage();
1968                 lcl_InsertBreakPosition_Impl(aBreakPositions, pLang->GetStart(), eLang);
1969                 lcl_InsertBreakPosition_Impl(aBreakPositions, pLang->GetEnd(), eLang);
1970                 pLastLang = pLang;
1971             }
1972             pError = pTextEngine->FindCharAttrib( aCursor, TEXTATTR_SPELL_ERROR);
1973             if(pError && pLastError != pError)
1974             {
1975                 lcl_InsertBreakPosition_Impl(aBreakPositions, pError->GetStart(), eLang);
1976                 lcl_InsertBreakPosition_Impl(aBreakPositions, pError->GetEnd(), eLang);
1977                 pLastError = pError;
1978 
1979             }
1980             aCursor.GetIndex()++;
1981         }
1982         //
1983         if(nTextLen && aBreakPositions.empty())
1984         {
1985             //if all content has been overwritten the attributes may have been removed, too
1986             svx::SpellPortion aPortion1;
1987             aPortion1.eLanguage = GetSpellDialog()->GetSelectedLang_Impl();
1988             aPortion1.sText = pTextEngine->GetText(
1989                         TextSelection(TextPaM(0, 0), TextPaM(0, nTextLen)));
1990 
1991             aRet.push_back(aPortion1);
1992 
1993         }
1994         else if(!aBreakPositions.empty())
1995         {
1996             LanguagePositions_Impl::iterator aStart = aBreakPositions.begin();
1997             //start should always be Null
1998             eLang = aStart->eLanguage;
1999             sal_uInt16 nStart = aStart->nPosition;
2000             DBG_ASSERT(!nStart, "invalid start position - language attribute missing?");
2001             ++aStart;
2002 
2003             while(aStart != aBreakPositions.end())
2004             {
2005                 svx::SpellPortion aPortion1;
2006                 aPortion1.eLanguage = eLang;
2007                 aPortion1.sText = pTextEngine->GetText(
2008                             TextSelection(TextPaM(0, nStart), TextPaM(0, aStart->nPosition)));
2009                 bool bIsIgnoreError = m_aIgnoreErrorsAt.find( nStart ) != m_aIgnoreErrorsAt.end();
2010                 if( bSetIgnoreFlag && bIsIgnoreError /*m_nErrorStart == nStart*/ )
2011                 {
2012                     aPortion1.bIgnoreThisError = true;
2013                 }
2014                 aRet.push_back(aPortion1);
2015                 nStart = aStart->nPosition;
2016                 eLang = aStart->eLanguage;
2017                 ++aStart;
2018             }
2019         }
2020 
2021 		// quick partly fix of #i71318. Correct fix needs to patch the TextEngine itself...
2022 		// this one will only prevent text from disappearing. It may to not have the
2023 		// correct language and will probably not spell checked...
2024 		sal_uLong nPara = pTextEngine->GetParagraphCount();
2025 		if (nPara > 1)
2026 		{
2027 			String aLeftOverText;
2028 			for (sal_uLong i = 1;  i < nPara;  ++i)
2029 			{
2030 				aLeftOverText.AppendAscii( "\x0a" );	// the manual line break...
2031 				aLeftOverText += pTextEngine->GetText(i);
2032 			}
2033 			if (pError)
2034 			{	// we need to add a new portion containing the left-over text
2035 				svx::SpellPortion aPortion2;
2036 				aPortion2.eLanguage = eLang;
2037 				aPortion2.sText = aLeftOverText;
2038 				aRet.push_back( aPortion2 );
2039 			}
2040 			else
2041 			{	// we just need to append the left-over text to the last portion (which had no errors)
2042 				aRet[ aRet.size() - 1 ].sText += aLeftOverText;
2043 			}
2044 		}
2045    }
2046     return aRet;
2047 }
2048 
2049 /*-- 06.11.2003 11:30:10---------------------------------------------------
2050 
2051   -----------------------------------------------------------------------*/
Undo()2052 void SentenceEditWindow_Impl::Undo()
2053 {
2054     ::svl::IUndoManager& rUndoMgr = GetTextEngine()->GetUndoManager();
2055     DBG_ASSERT(GetUndoActionCount(), "no undo actions available" );
2056     if(!GetUndoActionCount())
2057         return;
2058     bool bSaveUndoEdit = IsUndoEditMode();
2059     sal_uInt16 nId;
2060     //if the undo edit mode is active then undo all changes until the UNDO_EDIT_MODE action has been found
2061     do
2062     {
2063         nId = rUndoMgr.GetUndoActionId();
2064         rUndoMgr.Undo();
2065     }while(bSaveUndoEdit && SPELLUNDO_UNDO_EDIT_MODE != nId && GetUndoActionCount());
2066 
2067     if(bSaveUndoEdit || SPELLUNDO_CHANGE_GROUP == nId)
2068         GetSpellDialog()->UpdateBoxes_Impl();
2069 }
2070 /*-- 06.11.2003 11:30:10---------------------------------------------------
2071 
2072   -----------------------------------------------------------------------*/
ResetUndo()2073 void SentenceEditWindow_Impl::ResetUndo()
2074 {
2075     GetTextEngine()->ResetUndo();
2076 }
2077 /*-- 06.11.2003 12:30:41---------------------------------------------------
2078 
2079   -----------------------------------------------------------------------*/
AddUndoAction(SfxUndoAction * pAction,sal_Bool bTryMerg)2080 void SentenceEditWindow_Impl::AddUndoAction( SfxUndoAction *pAction, sal_Bool bTryMerg )
2081 {
2082     ::svl::IUndoManager& rUndoMgr = GetTextEngine()->GetUndoManager();
2083     rUndoMgr.AddUndoAction(pAction, bTryMerg);
2084     GetSpellDialog()->aUndoPB.Enable();
2085 }
2086 /*-- 06.11.2003 12:38:44---------------------------------------------------
2087 
2088   -----------------------------------------------------------------------*/
GetUndoActionCount()2089 sal_uInt16 SentenceEditWindow_Impl::GetUndoActionCount()
2090 {
2091     return GetTextEngine()->GetUndoManager().GetUndoActionCount();
2092 }
2093 
2094 /*-- 12.11.2003 12:12:38---------------------------------------------------
2095 
2096   -----------------------------------------------------------------------*/
UndoActionStart(sal_uInt16 nId)2097 void SentenceEditWindow_Impl::UndoActionStart( sal_uInt16 nId )
2098 {
2099     GetTextEngine()->UndoActionStart(nId);
2100 }
2101 /*-- 12.11.2003 12:12:38---------------------------------------------------
2102 
2103   -----------------------------------------------------------------------*/
UndoActionEnd()2104 void SentenceEditWindow_Impl::UndoActionEnd()
2105 {
2106     GetTextEngine()->UndoActionEnd();
2107 }
2108 /*-- 12.11.2003 12:12:38---------------------------------------------------
2109 
2110   -----------------------------------------------------------------------*/
MoveErrorEnd(long nOffset)2111 void SentenceEditWindow_Impl::MoveErrorEnd(long nOffset)
2112 {
2113     if(nOffset > 0)
2114         m_nErrorEnd = m_nErrorEnd - (sal_uInt16)nOffset;
2115     else
2116         m_nErrorEnd = m_nErrorEnd -(sal_uInt16)- nOffset;
2117 }
2118 /*-- 13.11.2003 15:15:19---------------------------------------------------
2119 
2120   -----------------------------------------------------------------------*/
SetUndoEditMode(bool bSet)2121 void  SentenceEditWindow_Impl::SetUndoEditMode(bool bSet)
2122 {
2123     DBG_ASSERT(!bSet || m_bIsUndoEditMode != bSet, "SetUndoEditMode with equal values?");
2124     m_bIsUndoEditMode = bSet;
2125     //disable all buttons except the Change
2126     SpellDialog* pSpellDialog = GetSpellDialog();
2127     Control* aControls[] =
2128     {
2129         &pSpellDialog->aChangeAllPB,
2130         &pSpellDialog->aExplainPB,
2131         &pSpellDialog->aIgnoreAllPB,
2132         &pSpellDialog->aIgnoreRulePB,
2133         &pSpellDialog->aIgnorePB,
2134         &pSpellDialog->aSuggestionLB,
2135         &pSpellDialog->aSuggestionFT,
2136         &pSpellDialog->aLanguageFT,
2137         &pSpellDialog->aLanguageLB,
2138         &pSpellDialog->aAddToDictMB,
2139         &pSpellDialog->aAutoCorrPB,
2140         0
2141     };
2142     sal_Int32 nIdx = 0;
2143     do
2144     {
2145         aControls[nIdx]->Enable(sal_False);
2146     }
2147     while(aControls[++nIdx]);
2148 
2149     //remove error marks
2150     TextEngine* pTextEngine = GetTextEngine();
2151     pTextEngine->RemoveAttribs( 0, (sal_uInt16)TEXTATTR_FONTCOLOR, sal_True );
2152     pTextEngine->RemoveAttribs( 0, (sal_uInt16)TEXTATTR_FONTWEIGHT, sal_True );
2153 
2154     //put the appropriate action on the Undo-stack
2155     SpellUndoAction_Impl* pAction = new SpellUndoAction_Impl(
2156                         SPELLUNDO_UNDO_EDIT_MODE, GetSpellDialog()->aDialogUndoLink);
2157     AddUndoAction(pAction);
2158     pSpellDialog->aChangePB.Enable();
2159 }
2160 
2161 /*-- 30.06.2008 14:15:19---------------------------------------------------
2162 
2163   -----------------------------------------------------------------------*/
~ExplainButton()2164 ExplainButton::~ExplainButton()
2165 {
2166 }
2167 /*-- 30.06.2008 14:15:19---------------------------------------------------
2168 
2169   -----------------------------------------------------------------------*/
RequestHelp(const HelpEvent &)2170 void ExplainButton::RequestHelp( const HelpEvent& )
2171 {
2172     Help::ShowBalloon( this, GetPosPixel(), m_sExplanation );
2173 }
2174 
Click()2175 void ExplainButton::Click()
2176 {
2177     RequestHelp( HelpEvent() );
2178 }
2179