?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lok: Don't attempt to select the exact text after a failed search.
[LibreOffice.git] / cui / source / tabpages / autocdlg.cxx
blobc4a91772b2fe22c57f2bd302271181631dafcbca
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <i18nutil/unicode.hxx>
21 #include <vcl/builderfactory.hxx>
22 #include <vcl/msgbox.hxx>
23 #include <vcl/field.hxx>
24 #include <vcl/keycodes.hxx>
25 #include <vcl/settings.hxx>
26 #include <sot/exchange.hxx>
27 #include <svtools/transfer.hxx>
28 #include <tools/shl.hxx>
29 #include <unotools/syslocale.hxx>
30 #include <sfx2/objsh.hxx>
31 #include <sfx2/viewsh.hxx>
32 #include <unotools/charclass.hxx>
33 #include <unotools/collatorwrapper.hxx>
34 #include <com/sun/star/i18n/CollatorOptions.hpp>
35 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
36 #include <comphelper/processfactory.hxx>
37 #include <comphelper/string.hxx>
38 #include <vcl/svapp.hxx>
39 #include <sfx2/module.hxx>
40 #include <sfx2/request.hxx>
41 #include <sfx2/sfxsids.hrc>
42 #include <svl/eitem.hxx>
43 #include <svl/languageoptions.hxx>
44 #include <svx/SmartTagMgr.hxx>
45 #include <com/sun/star/smarttags/XSmartTagRecognizer.hpp>
46 #include <com/sun/star/smarttags/XSmartTagAction.hpp>
47 #include <rtl/strbuf.hxx>
48
49 #include "autocdlg.hxx"
50 #include "helpid.hrc"
51 #include <editeng/acorrcfg.hxx>
52 #include <editeng/svxacorr.hxx>
53 #include "cuicharmap.hxx"
54 #include "cuires.hrc"
55 #include <editeng/unolingu.hxx>
56 #include <dialmgr.hxx>
57 #include <svx/svxids.hrc>
58 #include <boost/scoped_ptr.hpp>
59
60 static LanguageType eLastDialogLanguage = LANGUAGE_SYSTEM;
61
62 using namespace ::com::sun::star::util;
63 using namespace ::com::sun::star;
64
65 OfaAutoCorrDlg::OfaAutoCorrDlg(vcl::Window* pParent, const SfxItemSet* _pSet )
66 : SfxTabDialog(pParent, "AutoCorrectDialog", "cui/ui/autocorrectdialog.ui", _pSet)
67 {
68 get(m_pLanguageBox, "langbox");
69 get(m_pLanguageLB, "lang");
70
71 bool bShowSWOptions = false;
72 bool bOpenSmartTagOptions = false;
73
74 if ( _pSet )
75 {
76 SFX_ITEMSET_ARG( _pSet, pItem, SfxBoolItem, SID_AUTO_CORRECT_DLG, false );
77 if ( pItem && pItem->GetValue() )
78 bShowSWOptions = true;
79
80 SFX_ITEMSET_ARG( _pSet, pItem2, SfxBoolItem, SID_OPEN_SMARTTAGOPTIONS, false );
81 if ( pItem2 && pItem2->GetValue() )
82 bOpenSmartTagOptions = true;
83 }
84
85 AddTabPage("options", OfaAutocorrOptionsPage::Create, 0);
86 AddTabPage("apply", OfaSwAutoFmtOptionsPage::Create, 0);
87 AddTabPage("wordcompletion", OfaAutoCompleteTabPage::Create, 0);
88 AddTabPage("smarttags", OfaSmartTagOptionsTabPage::Create, 0);
89
90 if (!bShowSWOptions)
91 {
92 RemoveTabPage("apply");
93 RemoveTabPage("wordcompletion");
94 RemoveTabPage("smarttags");
95 }
96 else
97 {
98 // remove smart tag tab page if no extensions are installed
99 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
100 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
101 if ( !pOpt || !pOpt->pSmartTagMgr || 0 == pOpt->pSmartTagMgr->NumberOfRecognizers() )
102 RemoveTabPage("smarttags");
103
104 RemoveTabPage("options");
105 }
106
107 m_nReplacePageId = AddTabPage("replace", OfaAutocorrReplacePage::Create, 0);
108 m_nExceptionsPageId = AddTabPage("exceptions", OfaAutocorrExceptPage::Create, 0);
109 AddTabPage("localized", OfaQuoteTabPage::Create, 0);
110
111 // initialize languages
112 //! LANGUAGE_NONE is displayed as '[All]' and the LanguageType
113 //! will be set to LANGUAGE_UNDETERMINED
114 SvxLanguageListFlags nLangList = SvxLanguageListFlags::WESTERN;
115
116 if( SvtLanguageOptions().IsCTLFontEnabled() )
117 nLangList |= SvxLanguageListFlags::CTL;
118 m_pLanguageLB->SetLanguageList( nLangList, true, true );
119 m_pLanguageLB->SelectLanguage( LANGUAGE_NONE );
120 sal_Int32 nPos = m_pLanguageLB->GetSelectEntryPos();
121 DBG_ASSERT( LISTBOX_ENTRY_NOTFOUND != nPos, "listbox entry missing" );
122 m_pLanguageLB->SetEntryData( nPos, reinterpret_cast<void*>(LANGUAGE_UNDETERMINED) );
123
124 // Initializing doesn't work for static on linux - therefore here
125 if( LANGUAGE_SYSTEM == eLastDialogLanguage )
126 eLastDialogLanguage = Application::GetSettings().GetLanguageTag().getLanguageType();
127
128 LanguageType nSelectLang = LANGUAGE_UNDETERMINED;
129 nPos = m_pLanguageLB->GetEntryPos( reinterpret_cast<void*>(eLastDialogLanguage) );
130 if (LISTBOX_ENTRY_NOTFOUND != nPos)
131 nSelectLang = eLastDialogLanguage;
132 m_pLanguageLB->SelectLanguage( nSelectLang );
133
134 m_pLanguageLB->SetSelectHdl(LINK(this, OfaAutoCorrDlg, SelectLanguageHdl));
135
136 if ( bOpenSmartTagOptions )
137 SetCurPageId("smarttags");
138 }
139
140 OfaAutoCorrDlg::~OfaAutoCorrDlg()
141 {
142 disposeOnce();
143 }
144
145 void OfaAutoCorrDlg::dispose()
146 {
147 m_pLanguageBox.clear();
148 m_pLanguageLB.clear();
149 SfxTabDialog::dispose();
150 }
151
152 void OfaAutoCorrDlg::EnableLanguage(bool bEnable)
153 {
154 m_pLanguageBox->Enable(bEnable);
155 }
156
157 static bool lcl_FindEntry( ListBox& rLB, const OUString& rEntry,
158 CollatorWrapper& rCmpClass )
159 {
160 sal_Int32 nCount = rLB.GetEntryCount();
161 sal_Int32 nSelPos = rLB.GetSelectEntryPos();
162 sal_Int32 i;
163 for(i = 0; i < nCount; i++)
164 {
165 if( 0 == rCmpClass.compareString(rEntry, rLB.GetEntry(i) ))
166 {
167 rLB.SelectEntryPos(i, true);
168 return true;
169 }
170 }
171 if(LISTBOX_ENTRY_NOTFOUND != nSelPos)
172 rLB.SelectEntryPos(nSelPos, false);
173 return false;
174 }
175
176 IMPL_LINK(OfaAutoCorrDlg, SelectLanguageHdl, ListBox*, pBox)
177 {
178 sal_Int32 nPos = pBox->GetSelectEntryPos();
179 void* pVoid = pBox->GetEntryData(nPos);
180 LanguageType eNewLang = (LanguageType)reinterpret_cast<sal_IntPtr>(pVoid);
181 // save old settings and fill anew
182 if(eNewLang != eLastDialogLanguage)
183 {
184 sal_uInt16 nPageId = GetCurPageId();
185 if (m_nReplacePageId == nPageId)
186 static_cast<OfaAutocorrReplacePage*>(GetTabPage( nPageId ))->SetLanguage(eNewLang);
187 else if (m_nExceptionsPageId == nPageId)
188 static_cast<OfaAutocorrExceptPage*>(GetTabPage( nPageId ))->SetLanguage(eNewLang);
189 }
190 return 0;
191 }
192
193 OfaAutocorrOptionsPage::OfaAutocorrOptionsPage(vcl::Window* pParent, const SfxItemSet& rSet)
194 : SfxTabPage(pParent, "AutocorrectOptionsPage", "cui/ui/acoroptionspage.ui", &rSet)
195 , m_sInput(CUI_RESSTR(RID_SVXSTR_USE_REPLACE))
196 , m_sDoubleCaps(CUI_RESSTR(RID_SVXSTR_CPTL_STT_WORD))
197 , m_sStartCap(CUI_RESSTR(RID_SVXSTR_CPTL_STT_SENT))
198 , m_sBoldUnderline(CUI_RESSTR(RID_SVXSTR_BOLD_UNDER))
199 , m_sURL(CUI_RESSTR(RID_SVXSTR_DETECT_URL))
200 , m_sNoDblSpaces(CUI_RESSTR(RID_SVXSTR_NO_DBL_SPACES))
201 , m_sDash(CUI_RESSTR(RID_SVXSTR_DASH))
202 , m_sAccidentalCaps(CUI_RESSTR(RID_SVXSTR_CORRECT_ACCIDENTAL_CAPS_LOCK))
203 {
204 get(m_pCheckLB, "checklist");
205 }
206
207 OfaAutocorrOptionsPage::~OfaAutocorrOptionsPage()
208 {
209 disposeOnce();
210 }
211
212 void OfaAutocorrOptionsPage::dispose()
213 {
214 m_pCheckLB.clear();
215 SfxTabPage::dispose();
216 }
217
218 VclPtr<SfxTabPage> OfaAutocorrOptionsPage::Create( vcl::Window* pParent,
219 const SfxItemSet* rSet)
220 {
221 return VclPtr<OfaAutocorrOptionsPage>::Create(pParent, *rSet);
222 }
223
224 bool OfaAutocorrOptionsPage::FillItemSet( SfxItemSet* )
225 {
226 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
227 long nFlags = pAutoCorrect->GetFlags();
228
229 sal_uLong nPos = 0;
230 pAutoCorrect->SetAutoCorrFlag(Autocorrect, m_pCheckLB->IsChecked(nPos++));
231 pAutoCorrect->SetAutoCorrFlag(CptlSttWrd, m_pCheckLB->IsChecked(nPos++));
232 pAutoCorrect->SetAutoCorrFlag(CptlSttSntnc, m_pCheckLB->IsChecked(nPos++));
233 pAutoCorrect->SetAutoCorrFlag(ChgWeightUnderl, m_pCheckLB->IsChecked(nPos++));
234 pAutoCorrect->SetAutoCorrFlag(SetINetAttr, m_pCheckLB->IsChecked(nPos++));
235 pAutoCorrect->SetAutoCorrFlag(ChgToEnEmDash, m_pCheckLB->IsChecked(nPos++));
236 pAutoCorrect->SetAutoCorrFlag(IgnoreDoubleSpace, m_pCheckLB->IsChecked(nPos++));
237 pAutoCorrect->SetAutoCorrFlag(CorrectCapsLock, m_pCheckLB->IsChecked(nPos++));
238
239 bool bReturn = nFlags != pAutoCorrect->GetFlags();
240 if(bReturn )
241 {
242 SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
243 rCfg.SetModified();
244 rCfg.Commit();
245 }
246 return bReturn;
247 }
248
249 void OfaAutocorrOptionsPage::ActivatePage( const SfxItemSet& )
250 {
251 static_cast<OfaAutoCorrDlg*>(GetTabDialog())->EnableLanguage(false);
252 }
253
254 void OfaAutocorrOptionsPage::Reset( const SfxItemSet* )
255 {
256 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
257 const long nFlags = pAutoCorrect->GetFlags();
258
259 m_pCheckLB->SetUpdateMode(false);
260 m_pCheckLB->Clear();
261
262 m_pCheckLB->InsertEntry(m_sInput);
263 m_pCheckLB->InsertEntry(m_sDoubleCaps);
264 m_pCheckLB->InsertEntry(m_sStartCap);
265 m_pCheckLB->InsertEntry(m_sBoldUnderline);
266 m_pCheckLB->InsertEntry(m_sURL);
267 m_pCheckLB->InsertEntry(m_sDash);
268 m_pCheckLB->InsertEntry(m_sNoDblSpaces);
269 m_pCheckLB->InsertEntry(m_sAccidentalCaps);
270
271 sal_uLong nPos = 0;
272 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & Autocorrect) );
273 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & CptlSttWrd) );
274 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & CptlSttSntnc) );
275 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & ChgWeightUnderl) );
276 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & SetINetAttr) );
277 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & ChgToEnEmDash) );
278 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & IgnoreDoubleSpace) );
279 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & CorrectCapsLock) );
280
281 m_pCheckLB->SetUpdateMode(true);
282 }
283
284 /*********************************************************************/
285 /* */
286 /* helping struct for dUserData of the Checklistbox */
287 /* */
288 /*********************************************************************/
289
290 struct ImpUserData
291 {
292 OUString *pString;
293 vcl::Font *pFont;
294
295 ImpUserData(OUString* pText, vcl::Font* pFnt)
296 { pString = pText; pFont = pFnt;}
297 };
298
299
300 /*********************************************************************/
301 /* */
302 /* dialog for per cent settings */
303 /* */
304 /*********************************************************************/
305
306 class OfaAutoFmtPrcntSet : public ModalDialog
307 {
308 VclPtr<MetricField> m_pPrcntMF;
309 public:
310 OfaAutoFmtPrcntSet(vcl::Window* pParent)
311 : ModalDialog(pParent, "PercentDialog","cui/ui/percentdialog.ui")
312 {
313 get(m_pPrcntMF, "margin");
314 }
315 virtual ~OfaAutoFmtPrcntSet() { disposeOnce(); }
316 virtual void dispose() SAL_OVERRIDE { m_pPrcntMF.clear(); ModalDialog::dispose(); }
317
318 MetricField& GetPrcntFld()
319 {
320 return *m_pPrcntMF;
321 }
322 };
323
324 /*********************************************************************/
325 /* */
326 /* changed LBoxString */
327 /* */
328 /*********************************************************************/
329
330 class OfaImpBrwString : public SvLBoxString
331 {
332 public:
333
334 OfaImpBrwString( SvTreeListEntry* pEntry, sal_uInt16 nFlags,
335 const OUString& rStr ) : SvLBoxString(pEntry,nFlags,rStr){}
336
337 virtual void Paint(const Point& rPos, SvTreeListBox& rDev, vcl::RenderContext& rRenderContext,
338 const SvViewDataEntry* pView, const SvTreeListEntry* pEntry) SAL_OVERRIDE;
339 };
340
341 void OfaImpBrwString::Paint(const Point& rPos, SvTreeListBox& /*rDev*/, vcl::RenderContext& rRenderContext,
342 const SvViewDataEntry* /*pView*/, const SvTreeListEntry* pEntry)
343 {
344 rRenderContext.DrawText(rPos, GetText());
345 if (pEntry->GetUserData())
346 {
347 ImpUserData* pUserData = static_cast<ImpUserData*>(pEntry->GetUserData());
348 Point aNewPos(rPos);
349 aNewPos.X() += rRenderContext.GetTextWidth(GetText());
350 vcl::Font aOldFont(rRenderContext.GetFont());
351 vcl::Font aFont(aOldFont);
352 if (pUserData->pFont)
353 {
354 aFont = *pUserData->pFont;
355 aFont.SetColor(aOldFont.GetColor());
356 aFont.SetSize(aOldFont.GetSize());
357 }
358 aFont.SetWeight(WEIGHT_BOLD);
359
360 bool bFett = true;
361 sal_Int32 nPos = 0;
362 do {
363 OUString sTxt(pUserData->pString->getToken(0, 1, nPos));
364
365 if (bFett)
366 rRenderContext.SetFont(aFont);
367
368 rRenderContext.DrawText(aNewPos, sTxt);
369
370 if (-1 != nPos)
371 aNewPos.X() += rRenderContext.GetTextWidth(sTxt);
372
373 if (bFett)
374 rRenderContext.SetFont(aOldFont);
375
376 bFett = !bFett;
377 } while(-1 != nPos);
378 }
379 }
380
381 /*********************************************************************/
382 /* */
383 /* use TabPage autoformat */
384 /* */
385 /*********************************************************************/
386
387 #define CBCOL_FIRST 0
388 #define CBCOL_SECOND 1
389 #define CBCOL_BOTH 2
390
391 enum OfaAutoFmtOptions
392 {
393 USE_REPLACE_TABLE,
394 CORR_UPPER,
395 BEGIN_UPPER,
396 BOLD_UNDERLINE,
397 DETECT_URL,
398 REPLACE_DASHES,
399 DEL_SPACES_AT_STT_END,
400 DEL_SPACES_BETWEEN_LINES,
401 IGNORE_DBLSPACE,
402 CORRECT_CAPS_LOCK,
403 APPLY_NUMBERING,
404 INSERT_BORDER,
405 CREATE_TABLE,
406 REPLACE_STYLES,
407 DEL_EMPTY_NODE,
408 REPLACE_USER_COLL,
409 REPLACE_BULLETS,
410 MERGE_SINGLE_LINE_PARA
411 };
412
413 OfaSwAutoFmtOptionsPage::OfaSwAutoFmtOptionsPage( vcl::Window* pParent,
414 const SfxItemSet& rSet )
415 : SfxTabPage(pParent, "ApplyAutoFmtPage", "cui/ui/applyautofmtpage.ui", &rSet)
416 , sDeleteEmptyPara(CUI_RESSTR(RID_SVXSTR_DEL_EMPTY_PARA))
417 , sUseReplaceTbl(CUI_RESSTR(RID_SVXSTR_USE_REPLACE))
418 , sCptlSttWord(CUI_RESSTR(RID_SVXSTR_CPTL_STT_WORD))
419 , sCptlSttSent(CUI_RESSTR(RID_SVXSTR_CPTL_STT_SENT))
420 , sUserStyle(CUI_RESSTR(RID_SVXSTR_USER_STYLE))
421 , sBullet(CUI_RESSTR(RID_SVXSTR_BULLET))
422 , sBoldUnder(CUI_RESSTR(RID_SVXSTR_BOLD_UNDER))
423 , sNoDblSpaces(CUI_RESSTR(RID_SVXSTR_NO_DBL_SPACES))
424 , sCorrectCapsLock(CUI_RESSTR(RID_SVXSTR_CORRECT_ACCIDENTAL_CAPS_LOCK))
425 , sDetectURL(CUI_RESSTR(RID_SVXSTR_DETECT_URL))
426 , sDash(CUI_RESSTR(RID_SVXSTR_DASH))
427 , sRightMargin(CUI_RESSTR(RID_SVXSTR_RIGHT_MARGIN))
428 , sNum(CUI_RESSTR(RID_SVXSTR_NUM))
429 , sBorder(CUI_RESSTR(RID_SVXSTR_BORDER))
430 , sTable(CUI_RESSTR(RID_SVXSTR_CREATE_TABLE))
431 , sReplaceTemplates(CUI_RESSTR(RID_SVXSTR_REPLACE_TEMPLATES))
432 , sDelSpaceAtSttEnd(CUI_RESSTR(RID_SVXSTR_DEL_SPACES_AT_STT_END))
433 , sDelSpaceBetweenLines(CUI_RESSTR(RID_SVXSTR_DEL_SPACES_BETWEEN_LINES))
434 , nPercent(50)
435 , pCheckButtonData(NULL)
436 {
437 get(m_pEditPB, "edit");
438
439 SvSimpleTableContainer* pCheckLBContainer(get<SvSimpleTableContainer>("list"));
440 Size aControlSize(248 , 149);
441 aControlSize = LogicToPixel(aControlSize, MAP_APPFONT);
442 pCheckLBContainer->set_width_request(aControlSize.Width());
443 pCheckLBContainer->set_height_request(aControlSize.Height());
444 m_pCheckLB = VclPtr<OfaACorrCheckListBox>::Create(*pCheckLBContainer);
445
446 m_pCheckLB->SetStyle(m_pCheckLB->GetStyle()|WB_HSCROLL| WB_VSCROLL);
447
448 m_pCheckLB->SetSelectHdl(LINK(this, OfaSwAutoFmtOptionsPage, SelectHdl));
449 m_pCheckLB->SetDoubleClickHdl(LINK(this, OfaSwAutoFmtOptionsPage, EditHdl));
450
451 static long aStaticTabs[]=
452 {
453 3, 0, 20, 40
454 };
455
456 m_pCheckLB->SvSimpleTable::SetTabs(aStaticTabs);
457 OUStringBuffer sHeader(get<vcl::Window>("m")->GetText());
458 sHeader.append('\t');
459 sHeader.append(get<vcl::Window>("t")->GetText());
460 sHeader.append('\t');
461 m_pCheckLB->InsertHeaderEntry(sHeader.makeStringAndClear(), HEADERBAR_APPEND,
462 HeaderBarItemBits::CENTER | HeaderBarItemBits::VCENTER | HeaderBarItemBits::FIXEDPOS | HeaderBarItemBits::FIXED);
463
464 m_pEditPB->SetClickHdl(LINK(this, OfaSwAutoFmtOptionsPage, EditHdl));
465 }
466
467 SvTreeListEntry* OfaSwAutoFmtOptionsPage::CreateEntry(OUString& rTxt, sal_uInt16 nCol)
468 {
469 SvTreeListEntry* pEntry = new SvTreeListEntry;
470
471 if ( !pCheckButtonData )
472 {
473 pCheckButtonData = new SvLBoxButtonData( m_pCheckLB );
474 m_pCheckLB->SetCheckButtonData( pCheckButtonData );
475 }
476
477 pEntry->AddItem( new SvLBoxContextBmp( pEntry, 0, Image(), Image(), false));
478
479 OUString sEmpty;
480 if (nCol == CBCOL_SECOND)
481 pEntry->AddItem( new SvLBoxString( pEntry, 0, sEmpty) );
482 else
483 pEntry->AddItem( new SvLBoxButton( pEntry, SvLBoxButtonKind_enabledCheckbox, 0, pCheckButtonData ) );
484
485 if (nCol == CBCOL_FIRST)
486 pEntry->AddItem( new SvLBoxString( pEntry, 0, sEmpty) );
487 else
488 pEntry->AddItem( new SvLBoxButton( pEntry, SvLBoxButtonKind_enabledCheckbox, 0, pCheckButtonData ) );
489 pEntry->AddItem( new OfaImpBrwString( pEntry, 0, rTxt ) );
490
491 return pEntry;
492 }
493
494 OfaSwAutoFmtOptionsPage::~OfaSwAutoFmtOptionsPage()
495 {
496 disposeOnce();
497 }
498
499 void OfaSwAutoFmtOptionsPage::dispose()
500 {
501 if (m_pCheckLB)
502 {
503 delete static_cast<ImpUserData*>(m_pCheckLB->GetUserData( REPLACE_BULLETS ));
504 delete static_cast<ImpUserData*>(m_pCheckLB->GetUserData( APPLY_NUMBERING ));
505 delete static_cast<ImpUserData*>(m_pCheckLB->GetUserData( MERGE_SINGLE_LINE_PARA ));
506 delete pCheckButtonData;
507 pCheckButtonData = NULL;
508 }
509 m_pCheckLB.disposeAndClear();
510 m_pEditPB.clear();
511 SfxTabPage::dispose();
512 }
513
514 VclPtr<SfxTabPage> OfaSwAutoFmtOptionsPage::Create( vcl::Window* pParent,
515 const SfxItemSet* rAttrSet)
516 {
517 return VclPtr<SfxTabPage>( new OfaSwAutoFmtOptionsPage(pParent, *rAttrSet), SAL_NO_ACQUIRE );
518 }
519
520 bool OfaSwAutoFmtOptionsPage::FillItemSet( SfxItemSet* )
521 {
522 bool bModified = false;
523 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
524 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
525 long nFlags = pAutoCorrect->GetFlags();
526
527 bool bCheck = m_pCheckLB->IsChecked(USE_REPLACE_TABLE, CBCOL_FIRST);
528 bModified |= pOpt->bAutoCorrect != bCheck;
529 pOpt->bAutoCorrect = bCheck;
530 pAutoCorrect->SetAutoCorrFlag(Autocorrect,
531 m_pCheckLB->IsChecked(USE_REPLACE_TABLE, CBCOL_SECOND));
532
533 bCheck = m_pCheckLB->IsChecked(CORR_UPPER, CBCOL_FIRST);
534 bModified |= pOpt->bCptlSttWrd != bCheck;
535 pOpt->bCptlSttWrd = bCheck;
536 pAutoCorrect->SetAutoCorrFlag(CptlSttWrd,
537 m_pCheckLB->IsChecked(CORR_UPPER, CBCOL_SECOND));
538
539 bCheck = m_pCheckLB->IsChecked(BEGIN_UPPER, CBCOL_FIRST);
540 bModified |= pOpt->bCptlSttSntnc != bCheck;
541 pOpt->bCptlSttSntnc = bCheck;
542 pAutoCorrect->SetAutoCorrFlag(CptlSttSntnc,
543 m_pCheckLB->IsChecked(BEGIN_UPPER, CBCOL_SECOND));
544
545 bCheck = m_pCheckLB->IsChecked(BOLD_UNDERLINE, CBCOL_FIRST);
546 bModified |= pOpt->bChgWeightUnderl != bCheck;
547 pOpt->bChgWeightUnderl = bCheck;
548 pAutoCorrect->SetAutoCorrFlag(ChgWeightUnderl,
549 m_pCheckLB->IsChecked(BOLD_UNDERLINE, CBCOL_SECOND));
550
551 pAutoCorrect->SetAutoCorrFlag(IgnoreDoubleSpace,
552 m_pCheckLB->IsChecked(IGNORE_DBLSPACE, CBCOL_SECOND));
553
554 pAutoCorrect->SetAutoCorrFlag(CorrectCapsLock,
555 m_pCheckLB->IsChecked(CORRECT_CAPS_LOCK, CBCOL_SECOND));
556
557 bCheck = m_pCheckLB->IsChecked(DETECT_URL, CBCOL_FIRST);
558 bModified |= pOpt->bSetINetAttr != bCheck;
559 pOpt->bSetINetAttr = bCheck;
560 pAutoCorrect->SetAutoCorrFlag(SetINetAttr,
561 m_pCheckLB->IsChecked(DETECT_URL, CBCOL_SECOND));
562
563 bCheck = m_pCheckLB->IsChecked(DEL_EMPTY_NODE, CBCOL_FIRST);
564 bModified |= pOpt->bDelEmptyNode != bCheck;
565 pOpt->bDelEmptyNode = bCheck;
566
567 bCheck = m_pCheckLB->IsChecked(REPLACE_USER_COLL, CBCOL_FIRST);
568 bModified |= pOpt->bChgUserColl != bCheck;
569 pOpt->bChgUserColl = bCheck;
570
571 bCheck = m_pCheckLB->IsChecked(REPLACE_BULLETS, CBCOL_FIRST);
572 bModified |= pOpt->bChgEnumNum != bCheck;
573 pOpt->bChgEnumNum = bCheck;
574 bModified |= aBulletFont != pOpt->aBulletFont;
575 pOpt->aBulletFont = aBulletFont;
576 bModified |= !comphelper::string::equals(sBulletChar, pOpt->cBullet);
577 pOpt->cBullet = sBulletChar[0];
578
579 bModified |= aByInputBulletFont != pOpt->aByInputBulletFont;
580 bModified |= !comphelper::string::equals(sByInputBulletChar, pOpt->cByInputBullet);
581 pOpt->aByInputBulletFont = aByInputBulletFont;
582 pOpt->cByInputBullet = sByInputBulletChar[0];
583
584 bCheck = m_pCheckLB->IsChecked(MERGE_SINGLE_LINE_PARA, CBCOL_FIRST);
585 bModified |= pOpt->bRightMargin != bCheck;
586 pOpt->bRightMargin = bCheck;
587 bModified |= nPercent != pOpt->nRightMargin;
588 pOpt->nRightMargin = (sal_uInt8)nPercent;
589
590 bCheck = m_pCheckLB->IsChecked(APPLY_NUMBERING, CBCOL_SECOND);
591 bModified |= pOpt->bSetNumRule != bCheck;
592 pOpt->bSetNumRule = bCheck;
593
594 bCheck = m_pCheckLB->IsChecked(INSERT_BORDER, CBCOL_SECOND);
595 bModified |= pOpt->bSetBorder != bCheck;
596 pOpt->bSetBorder = bCheck;
597
598 bCheck = m_pCheckLB->IsChecked(CREATE_TABLE, CBCOL_SECOND);
599 bModified |= pOpt->bCreateTable != bCheck;
600 pOpt->bCreateTable = bCheck;
601
602 bCheck = m_pCheckLB->IsChecked(REPLACE_STYLES, CBCOL_SECOND);
603 bModified |= pOpt->bReplaceStyles != bCheck;
604 pOpt->bReplaceStyles = bCheck;
605
606 bCheck = m_pCheckLB->IsChecked(REPLACE_DASHES, CBCOL_FIRST);
607 bModified |= pOpt->bChgToEnEmDash != bCheck;
608 pOpt->bChgToEnEmDash = bCheck;
609 pAutoCorrect->SetAutoCorrFlag(ChgToEnEmDash,
610 m_pCheckLB->IsChecked(REPLACE_DASHES, CBCOL_SECOND));
611
612 bCheck = m_pCheckLB->IsChecked(DEL_SPACES_AT_STT_END, CBCOL_FIRST);
613 bModified |= pOpt->bAFormatDelSpacesAtSttEnd != bCheck;
614 pOpt->bAFormatDelSpacesAtSttEnd = bCheck;
615 bCheck = m_pCheckLB->IsChecked(DEL_SPACES_AT_STT_END, CBCOL_SECOND);
616 bModified |= pOpt->bAFormatByInpDelSpacesAtSttEnd != bCheck;
617 pOpt->bAFormatByInpDelSpacesAtSttEnd = bCheck;
618
619 bCheck = m_pCheckLB->IsChecked(DEL_SPACES_BETWEEN_LINES, CBCOL_FIRST);
620 bModified |= pOpt->bAFormatDelSpacesBetweenLines != bCheck;
621 pOpt->bAFormatDelSpacesBetweenLines = bCheck;
622 bCheck = m_pCheckLB->IsChecked(DEL_SPACES_BETWEEN_LINES, CBCOL_SECOND);
623 bModified |= pOpt->bAFormatByInpDelSpacesBetweenLines != bCheck;
624 pOpt->bAFormatByInpDelSpacesBetweenLines = bCheck;
625
626 if(bModified || nFlags != pAutoCorrect->GetFlags())
627 {
628 SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
629 rCfg.SetModified();
630 rCfg.Commit();
631 }
632
633 return true;
634 }
635
636 void OfaSwAutoFmtOptionsPage::ActivatePage( const SfxItemSet& )
637 {
638 static_cast<OfaAutoCorrDlg*>(GetTabDialog())->EnableLanguage(false);
639 }
640
641 void OfaSwAutoFmtOptionsPage::Reset( const SfxItemSet* )
642 {
643 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
644 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
645 const long nFlags = pAutoCorrect->GetFlags();
646
647 m_pCheckLB->SetUpdateMode(false);
648 m_pCheckLB->Clear();
649
650 // The following entries have to be inserted in the same order
651 // as in the OfaAutoFmtOptions-enum!
652 m_pCheckLB->GetModel()->Insert(CreateEntry(sUseReplaceTbl, CBCOL_BOTH ));
653 m_pCheckLB->GetModel()->Insert(CreateEntry(sCptlSttWord, CBCOL_BOTH ));
654 m_pCheckLB->GetModel()->Insert(CreateEntry(sCptlSttSent, CBCOL_BOTH ));
655 m_pCheckLB->GetModel()->Insert(CreateEntry(sBoldUnder, CBCOL_BOTH ));
656 m_pCheckLB->GetModel()->Insert(CreateEntry(sDetectURL, CBCOL_BOTH ));
657 m_pCheckLB->GetModel()->Insert(CreateEntry(sDash, CBCOL_BOTH ));
658 m_pCheckLB->GetModel()->Insert(CreateEntry(sDelSpaceAtSttEnd, CBCOL_BOTH ));
659 m_pCheckLB->GetModel()->Insert(CreateEntry(sDelSpaceBetweenLines, CBCOL_BOTH ));
660
661 m_pCheckLB->GetModel()->Insert(CreateEntry(sNoDblSpaces, CBCOL_SECOND));
662 m_pCheckLB->GetModel()->Insert(CreateEntry(sCorrectCapsLock, CBCOL_SECOND));
663 m_pCheckLB->GetModel()->Insert(CreateEntry(sNum, CBCOL_SECOND));
664 m_pCheckLB->GetModel()->Insert(CreateEntry(sBorder, CBCOL_SECOND));
665 m_pCheckLB->GetModel()->Insert(CreateEntry(sTable, CBCOL_SECOND));
666 m_pCheckLB->GetModel()->Insert(CreateEntry(sReplaceTemplates, CBCOL_SECOND));
667 m_pCheckLB->GetModel()->Insert(CreateEntry(sDeleteEmptyPara, CBCOL_FIRST ));
668 m_pCheckLB->GetModel()->Insert(CreateEntry(sUserStyle, CBCOL_FIRST ));
669 m_pCheckLB->GetModel()->Insert(CreateEntry(sBullet, CBCOL_FIRST ));
670 m_pCheckLB->GetModel()->Insert(CreateEntry(sRightMargin, CBCOL_FIRST ));
671
672 m_pCheckLB->CheckEntryPos( USE_REPLACE_TABLE, CBCOL_FIRST, pOpt->bAutoCorrect );
673 m_pCheckLB->CheckEntryPos( USE_REPLACE_TABLE, CBCOL_SECOND, 0 != (nFlags & Autocorrect));
674 m_pCheckLB->CheckEntryPos( CORR_UPPER, CBCOL_FIRST, pOpt->bCptlSttWrd );
675 m_pCheckLB->CheckEntryPos( CORR_UPPER, CBCOL_SECOND, 0 != (nFlags & CptlSttWrd) );
676 m_pCheckLB->CheckEntryPos( BEGIN_UPPER, CBCOL_FIRST, pOpt->bCptlSttSntnc );
677 m_pCheckLB->CheckEntryPos( BEGIN_UPPER, CBCOL_SECOND, 0 != (nFlags & CptlSttSntnc) );
678 m_pCheckLB->CheckEntryPos( BOLD_UNDERLINE, CBCOL_FIRST, pOpt->bChgWeightUnderl );
679 m_pCheckLB->CheckEntryPos( BOLD_UNDERLINE, CBCOL_SECOND, 0 != (nFlags & ChgWeightUnderl) );
680 m_pCheckLB->CheckEntryPos( IGNORE_DBLSPACE, CBCOL_SECOND, 0 != (nFlags & IgnoreDoubleSpace) );
681 m_pCheckLB->CheckEntryPos( CORRECT_CAPS_LOCK, CBCOL_SECOND, 0 != (nFlags & CorrectCapsLock) );
682 m_pCheckLB->CheckEntryPos( DETECT_URL, CBCOL_FIRST, pOpt->bSetINetAttr );
683 m_pCheckLB->CheckEntryPos( DETECT_URL, CBCOL_SECOND, 0 != (nFlags & SetINetAttr) );
684 m_pCheckLB->CheckEntryPos( REPLACE_DASHES, CBCOL_FIRST, pOpt->bChgToEnEmDash );
685 m_pCheckLB->CheckEntryPos( REPLACE_DASHES, CBCOL_SECOND, 0 != (nFlags & ChgToEnEmDash) );
686 m_pCheckLB->CheckEntryPos( DEL_SPACES_AT_STT_END, CBCOL_FIRST, pOpt->bAFormatDelSpacesAtSttEnd );
687 m_pCheckLB->CheckEntryPos( DEL_SPACES_AT_STT_END, CBCOL_SECOND, pOpt->bAFormatByInpDelSpacesAtSttEnd );
688 m_pCheckLB->CheckEntryPos( DEL_SPACES_BETWEEN_LINES, CBCOL_FIRST, pOpt->bAFormatDelSpacesBetweenLines );
689 m_pCheckLB->CheckEntryPos( DEL_SPACES_BETWEEN_LINES, CBCOL_SECOND, pOpt->bAFormatByInpDelSpacesBetweenLines );
690 m_pCheckLB->CheckEntryPos( DEL_EMPTY_NODE, CBCOL_FIRST, pOpt->bDelEmptyNode );
691 m_pCheckLB->CheckEntryPos( REPLACE_USER_COLL, CBCOL_FIRST, pOpt->bChgUserColl );
692 m_pCheckLB->CheckEntryPos( REPLACE_BULLETS, CBCOL_FIRST, pOpt->bChgEnumNum );
693
694 aBulletFont = pOpt->aBulletFont;
695 sBulletChar = OUString(pOpt->cBullet);
696 ImpUserData* pUserData = new ImpUserData(&sBulletChar, &aBulletFont);
697 m_pCheckLB->SetUserData( REPLACE_BULLETS, pUserData );
698
699 nPercent = pOpt->nRightMargin;
700 sMargin = " " +
701 unicode::formatPercent(nPercent, Application::GetSettings().GetUILanguageTag());
702 pUserData = new ImpUserData(&sMargin, 0);
703 m_pCheckLB->SetUserData( MERGE_SINGLE_LINE_PARA, pUserData );
704
705 m_pCheckLB->CheckEntryPos( APPLY_NUMBERING, CBCOL_SECOND, pOpt->bSetNumRule );
706
707 aByInputBulletFont = pOpt->aByInputBulletFont;
708 sByInputBulletChar = OUString( pOpt->cByInputBullet );
709 ImpUserData* pUserData2 = new ImpUserData(&sByInputBulletChar, &aByInputBulletFont);
710 m_pCheckLB->SetUserData( APPLY_NUMBERING , pUserData2 );
711
712 m_pCheckLB->CheckEntryPos( MERGE_SINGLE_LINE_PARA, CBCOL_FIRST, pOpt->bRightMargin );
713 m_pCheckLB->CheckEntryPos( INSERT_BORDER, CBCOL_SECOND, pOpt->bSetBorder );
714 m_pCheckLB->CheckEntryPos( CREATE_TABLE, CBCOL_SECOND, pOpt->bCreateTable );
715 m_pCheckLB->CheckEntryPos( REPLACE_STYLES, CBCOL_SECOND, pOpt->bReplaceStyles );
716
717 m_pCheckLB->SetUpdateMode(true);
718 }
719
720 IMPL_LINK(OfaSwAutoFmtOptionsPage, SelectHdl, OfaACorrCheckListBox*, pBox)
721 {
722 m_pEditPB->Enable(0 != pBox->FirstSelected()->GetUserData());
723 return 0;
724 }
725
726 IMPL_LINK_NOARG(OfaSwAutoFmtOptionsPage, EditHdl)
727 {
728 sal_uLong nSelEntryPos = m_pCheckLB->GetSelectEntryPos();
729 if( nSelEntryPos == REPLACE_BULLETS ||
730 nSelEntryPos == APPLY_NUMBERING)
731 {
732 ScopedVclPtrInstance< SvxCharacterMap > pMapDlg(this);
733 ImpUserData* pUserData = static_cast<ImpUserData*>(m_pCheckLB->FirstSelected()->GetUserData());
734 pMapDlg->SetCharFont(*pUserData->pFont);
735 pMapDlg->SetChar( (*pUserData->pString)[0] );
736 if(RET_OK == pMapDlg->Execute())
737 {
738 vcl::Font aFont(pMapDlg->GetCharFont());
739 *pUserData->pFont = aFont;
740 sal_UCS4 aChar = pMapDlg->GetChar();
741 // using the UCS4 constructor
742 OUString aOUStr( &aChar, 1 );
743 *pUserData->pString = aOUStr;
744 }
745 }
746 else if( MERGE_SINGLE_LINE_PARA == nSelEntryPos )
747 {
748 // dialog for per cent settings
749 ScopedVclPtrInstance< OfaAutoFmtPrcntSet > aDlg(this);
750 aDlg->GetPrcntFld().SetValue(nPercent);
751 if(RET_OK == aDlg->Execute())
752 {
753 nPercent = (sal_uInt16)aDlg->GetPrcntFld().GetValue();
754 sMargin = " " +
755 unicode::formatPercent(nPercent, Application::GetSettings().GetUILanguageTag());
756 }
757 }
758 m_pCheckLB->Invalidate();
759 return 0;
760 }
761
762 void OfaACorrCheckListBox::SetTabs()
763 {
764 SvSimpleTable::SetTabs();
765 SvLBoxTabFlags nAdjust = SvLBoxTabFlags::ADJUST_RIGHT|SvLBoxTabFlags::ADJUST_LEFT|SvLBoxTabFlags::ADJUST_CENTER|SvLBoxTabFlags::ADJUST_NUMERIC|SvLBoxTabFlags::FORCE;
766
767 if( aTabs.size() > 1 )
768 {
769 SvLBoxTab* pTab = aTabs[1];
770 pTab->nFlags &= ~nAdjust;
771 pTab->nFlags |= SvLBoxTabFlags::PUSHABLE|SvLBoxTabFlags::ADJUST_CENTER|SvLBoxTabFlags::FORCE;
772 }
773 if( aTabs.size() > 2 )
774 {
775 SvLBoxTab* pTab = aTabs[2];
776 pTab->nFlags &= ~nAdjust;
777 pTab->nFlags |= SvLBoxTabFlags::PUSHABLE|SvLBoxTabFlags::ADJUST_CENTER|SvLBoxTabFlags::FORCE;
778 }
779 }
780
781 void OfaACorrCheckListBox::CheckEntryPos(sal_uLong nPos, sal_uInt16 nCol, bool bChecked)
782 {
783 if ( nPos < GetEntryCount() )
784 SetCheckButtonState(
785 GetEntry(nPos),
786 nCol,
787 bChecked ? SvButtonState( SV_BUTTON_CHECKED ) :
788 SvButtonState( SV_BUTTON_UNCHECKED ) );
789 }
790
791 bool OfaACorrCheckListBox::IsChecked(sal_uLong nPos, sal_uInt16 nCol)
792 {
793 return GetCheckButtonState( GetEntry(nPos), nCol ) == SV_BUTTON_CHECKED;
794 }
795
796 void OfaACorrCheckListBox::SetCheckButtonState( SvTreeListEntry* pEntry, sal_uInt16 nCol, SvButtonState eState)
797 {
798 SvLBoxButton* pItem = static_cast<SvLBoxButton*>(pEntry->GetItem(nCol + 1));
799
800 DBG_ASSERT(pItem,"SetCheckButton:Item not found");
801 if (pItem->GetType() == SV_ITEM_ID_LBOXBUTTON)
802 {
803 switch( eState )
804 {
805 case SV_BUTTON_CHECKED:
806 pItem->SetStateChecked();
807 break;
808
809 case SV_BUTTON_UNCHECKED:
810 pItem->SetStateUnchecked();
811 break;
812
813 case SV_BUTTON_TRISTATE:
814 pItem->SetStateTristate();
815 break;
816 }
817 InvalidateEntry( pEntry );
818 }
819 }
820
821 SvButtonState OfaACorrCheckListBox::GetCheckButtonState( SvTreeListEntry* pEntry, sal_uInt16 nCol )
822 {
823 SvButtonState eState = SV_BUTTON_UNCHECKED;
824 SvLBoxButton* pItem = static_cast<SvLBoxButton*>(pEntry->GetItem(nCol + 1));
825 DBG_ASSERT(pItem,"GetChButnState:Item not found");
826
827 if (pItem->GetType() == SV_ITEM_ID_LBOXBUTTON)
828 {
829 SvItemStateFlags nButtonFlags = pItem->GetButtonFlags();
830 eState = SvLBoxButtonData::ConvertToButtonState( nButtonFlags );
831 }
832
833 return eState;
834 }
835
836 void OfaACorrCheckListBox::HBarClick()
837 {
838 // sorting is stopped by this override
839 }
840
841 void OfaACorrCheckListBox::KeyInput( const KeyEvent& rKEvt )
842 {
843 if(!rKEvt.GetKeyCode().GetModifier() &&
844 KEY_SPACE == rKEvt.GetKeyCode().GetCode())
845 {
846 sal_uLong nSelPos = GetSelectEntryPos();
847 sal_uInt16 nCol = GetCurrentTabPos() - 1;
848 if ( nCol < 2 )
849 {
850 CheckEntryPos( nSelPos, nCol, !IsChecked( nSelPos, nCol ) );
851 CallImplEventListeners( VCLEVENT_CHECKBOX_TOGGLE, (void*)GetEntry( nSelPos ) );
852 }
853 else
854 {
855 sal_uInt16 nCheck = IsChecked(nSelPos, 1) ? 1 : 0;
856 if(IsChecked(nSelPos, 0))
857 nCheck += 2;
858 nCheck--;
859 nCheck &= 3;
860 CheckEntryPos(nSelPos, 1, 0 != (nCheck & 1));
861 CheckEntryPos(nSelPos, 0, 0 != (nCheck & 2));
862 }
863 }
864 else
865 SvSimpleTable::KeyInput(rKEvt);
866 }
867
868 OfaAutocorrReplacePage::OfaAutocorrReplacePage( vcl::Window* pParent,
869 const SfxItemSet& rSet )
870 : SfxTabPage(pParent, "AcorReplacePage", "cui/ui/acorreplacepage.ui", &rSet)
871 , eLang(eLastDialogLanguage)
872 , bHasSelectionText(false)
873 , bFirstSelect(true)
874 , bReplaceEditChanged(false)
875 , bSWriter(true)
876 {
877 get(m_pTextOnlyCB, "textonly");
878 get(m_pDeleteReplacePB, "delete");
879 get(m_pNewReplacePB, "new");
880 sNew = m_pNewReplacePB->GetText();
881 sModify = get<PushButton>("replace")->GetText();
882 get(m_pShortED, "origtext");
883 get(m_pReplaceED, "newtext");
884 get(m_pReplaceTLB, "tabview");
885 m_pReplaceTLB->set_height_request(16 * GetTextHeight());
886
887 SfxModule *pMod = *reinterpret_cast<SfxModule**>(GetAppData(SHL_WRITER));
888 bSWriter = pMod == SfxModule::GetActiveModule();
889
890 LanguageTag aLanguageTag( eLastDialogLanguage );
891 pCompareClass = new CollatorWrapper( comphelper::getProcessComponentContext() );
892 pCompareClass->loadDefaultCollator( aLanguageTag.getLocale(), 0 );
893 pCharClass = new CharClass( aLanguageTag );
894
895 static long aTabs[] = { 2 /* Tab-Count */, 1, 61 };
896 m_pReplaceTLB->SetTabs( &aTabs[0], MAP_APPFONT );
897
898 m_pReplaceTLB->SetStyle( m_pReplaceTLB->GetStyle()|WB_HSCROLL|WB_CLIPCHILDREN );
899 m_pReplaceTLB->SetSelectHdl( LINK(this, OfaAutocorrReplacePage, SelectHdl) );
900 m_pNewReplacePB->SetClickHdl( LINK(this, OfaAutocorrReplacePage, NewDelHdl) );
901 m_pDeleteReplacePB->SetClickHdl( LINK(this, OfaAutocorrReplacePage, NewDelHdl) );
902 m_pShortED->SetModifyHdl( LINK(this, OfaAutocorrReplacePage, ModifyHdl) );
903 m_pReplaceED->SetModifyHdl( LINK(this, OfaAutocorrReplacePage, ModifyHdl) );
904 m_pShortED->SetActionHdl( LINK(this, OfaAutocorrReplacePage, NewDelHdl) );
905 m_pReplaceED->SetActionHdl( LINK(this, OfaAutocorrReplacePage, NewDelHdl) );
906
907 m_pReplaceED->SetSpaces(true);
908 m_pShortED->SetSpaces(true);
909 }
910
911 void OfaAutocorrReplacePage::setTabs()
912 {
913 m_pReplaceTLB->SetTab(0, m_pShortED->GetPosPixel().X(), MAP_PIXEL);
914 m_pReplaceTLB->SetTab(1, m_pReplaceED->GetPosPixel().X(), MAP_PIXEL);
915 }
916
917 void OfaAutocorrReplacePage::StateChanged(StateChangedType nStateChange)
918 {
919 SfxTabPage::StateChanged(nStateChange);
920
921 if (nStateChange == StateChangedType::InitShow)
922 {
923 setTabs();
924 }
925 }
926
927 void OfaAutocorrReplacePage::Resize()
928 {
929 SfxTabPage::Resize();
930 setTabs();
931 }
932
933 OfaAutocorrReplacePage::~OfaAutocorrReplacePage()
934 {
935 disposeOnce();
936 }
937
938 void OfaAutocorrReplacePage::dispose()
939 {
940 aDoubleStringTable.clear();
941 aChangesTable.clear();
942
943 delete pCompareClass;
944 pCompareClass = NULL;
945 delete pCharClass;
946 pCharClass = NULL;
947
948 m_pTextOnlyCB.clear();
949 m_pShortED.clear();
950 m_pReplaceED.clear();
951 m_pReplaceTLB.clear();
952 m_pNewReplacePB.clear();
953 m_pDeleteReplacePB.clear();
954 SfxTabPage::dispose();
955 }
956
957 VclPtr<SfxTabPage> OfaAutocorrReplacePage::Create( vcl::Window* pParent, const SfxItemSet* rSet)
958 {
959 return VclPtr<OfaAutocorrReplacePage>::Create(pParent, *rSet);
960 }
961
962 void OfaAutocorrReplacePage::ActivatePage( const SfxItemSet& )
963 {
964 if(eLang != eLastDialogLanguage)
965 SetLanguage(eLastDialogLanguage);
966 static_cast<OfaAutoCorrDlg*>(GetTabDialog())->EnableLanguage(true);
967 }
968
969 SfxTabPage::sfxpg OfaAutocorrReplacePage::DeactivatePage( SfxItemSet* )
970 {
971 return LEAVE_PAGE;
972 }
973
974 bool OfaAutocorrReplacePage::FillItemSet( SfxItemSet* )
975 {
976 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
977
978 for (StringChangeTable::reverse_iterator it = aChangesTable.rbegin(); it != aChangesTable.rend(); ++it)
979 {
980 LanguageType eCurrentLang = it->first;
981 StringChangeList& rStringChangeList = it->second;
982 std::vector<SvxAutocorrWord> aDeleteWords;
983 std::vector<SvxAutocorrWord> aNewWords;
984
985 for (sal_uInt32 i = 0; i < rStringChangeList.aDeletedEntries.size(); i++)
986 {
987 DoubleString& deleteEntry = rStringChangeList.aDeletedEntries[i];
988 SvxAutocorrWord aDeleteWord( deleteEntry.sShort, deleteEntry.sLong );
989 aDeleteWords.push_back( aDeleteWord );
990 }
991
992 for (sal_uInt32 i = 0; i < rStringChangeList.aNewEntries.size(); i++)
993 {
994 DoubleString& newEntry = rStringChangeList.aNewEntries[i];
995
996 //fdo#67697 if the user data is set then we want to retain the
997 //source formatting of the entry, so don't use the optimized
998 //text-only MakeCombinedChanges for this entry
999 bool bKeepSourceFormatting = newEntry.pUserData == &bHasSelectionText;
1000 if (bKeepSourceFormatting)
1001 {
1002 pAutoCorrect->PutText(newEntry.sShort, *SfxObjectShell::Current(), eCurrentLang);
1003 continue;
1004 }
1005
1006 SvxAutocorrWord aNewWord( newEntry.sShort, newEntry.sLong );
1007 aNewWords.push_back( aNewWord );
1008 }
1009 pAutoCorrect->MakeCombinedChanges( aNewWords, aDeleteWords, eCurrentLang );
1010 }
1011 aChangesTable.clear();
1012 return false;
1013 }
1014
1015 void OfaAutocorrReplacePage::RefillReplaceBox(bool bFromReset,
1016 LanguageType eOldLanguage,
1017 LanguageType eNewLanguage)
1018 {
1019 eLang = eNewLanguage;
1020 if(bFromReset)
1021 {
1022 aDoubleStringTable.clear();
1023 aChangesTable.clear();
1024 }
1025 else
1026 {
1027 DoubleStringArray* pArray;
1028 if(aDoubleStringTable.find(eOldLanguage) != aDoubleStringTable.end())
1029 {
1030 pArray = &aDoubleStringTable[eOldLanguage];
1031 pArray->clear();
1032 }
1033 else
1034 {
1035 pArray = &aDoubleStringTable[eOldLanguage]; // create new array
1036 }
1037
1038 sal_uInt32 nListBoxCount = (sal_uInt32) m_pReplaceTLB->GetEntryCount();
1039 sal_uInt32 i;
1040 for(i = 0; i < nListBoxCount; i++)
1041 {
1042 pArray->push_back(DoubleString());
1043 DoubleString& rDouble = (*pArray)[pArray->size() - 1];
1044 SvTreeListEntry* pEntry = m_pReplaceTLB->GetEntry( i );
1045 rDouble.sShort = SvTabListBox::GetEntryText(pEntry, 0);
1046 rDouble.sLong = SvTabListBox::GetEntryText(pEntry, 1);
1047 rDouble.pUserData = pEntry->GetUserData();
1048 }
1049 }
1050
1051 m_pReplaceTLB->Clear();
1052 if( !bSWriter )
1053 aFormatText.clear();
1054
1055 if( aDoubleStringTable.find(eLang) != aDoubleStringTable.end() )
1056 {
1057 DoubleStringArray& rArray = aDoubleStringTable[eNewLanguage];
1058 for( sal_uInt32 i = 0; i < rArray.size(); i++ )
1059 {
1060 DoubleString& rDouble = rArray[i];
1061 bool bTextOnly = 0 == rDouble.pUserData;
1062 // formatted text is only in Writer
1063 if(bSWriter || bTextOnly)
1064 {
1065 OUString sEntry(rDouble.sShort);
1066 sEntry += "\t";
1067 sEntry += rDouble.sLong;
1068 SvTreeListEntry* pEntry = m_pReplaceTLB->InsertEntry(sEntry);
1069 m_pTextOnlyCB->Check(bTextOnly);
1070 if(!bTextOnly)
1071 pEntry->SetUserData(rDouble.pUserData); // that means: with format info or even with selection text
1072 }
1073 else
1074 {
1075 aFormatText.insert(rDouble.sShort);
1076 }
1077 }
1078 }
1079 else
1080 {
1081 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
1082 SvxAutocorrWordList* pWordList = pAutoCorrect->LoadAutocorrWordList(eLang);
1083 m_pReplaceTLB->SetUpdateMode(false);
1084 SvxAutocorrWordList::Content aContent = pWordList->getSortedContent();
1085 for( SvxAutocorrWordList::Content::const_iterator it = aContent.begin();
1086 it != aContent.end(); ++it )
1087 {
1088 SvxAutocorrWord* pWordPtr = *it;
1089 bool bTextOnly = pWordPtr->IsTextOnly();
1090 // formatted text is only in Writer
1091 if(bSWriter || bTextOnly)
1092 {
1093 OUString sEntry(pWordPtr->GetShort());
1094 sEntry += "\t";
1095 sEntry += pWordPtr->GetLong();
1096 SvTreeListEntry* pEntry = m_pReplaceTLB->InsertEntry(sEntry);
1097 m_pTextOnlyCB->Check(pWordPtr->IsTextOnly());
1098 if(!bTextOnly)
1099 pEntry->SetUserData(m_pTextOnlyCB); // that means: with format info
1100 }
1101 else
1102 {
1103 aFormatText.insert(pWordPtr->GetShort());
1104 }
1105 }
1106 m_pNewReplacePB->Enable(false);
1107 m_pDeleteReplacePB->Enable(false);
1108 m_pReplaceTLB->SetUpdateMode(true);
1109 }
1110
1111 SfxViewShell* pViewShell = SfxViewShell::Current();
1112 if( pViewShell && pViewShell->HasSelection( true ) )
1113 {
1114 bHasSelectionText = true;
1115 const OUString sSelection( pViewShell->GetSelectionText() );
1116 m_pReplaceED->SetText( sSelection );
1117 m_pTextOnlyCB->Check( !bSWriter );
1118 m_pTextOnlyCB->Enable( bSWriter && !sSelection.isEmpty() );
1119 }
1120 else
1121 {
1122 m_pTextOnlyCB->Enable( false );
1123 }
1124 }
1125
1126 void OfaAutocorrReplacePage::Reset( const SfxItemSet* )
1127 {
1128 RefillReplaceBox(true, eLang, eLang);
1129 m_pShortED->GrabFocus();
1130 }
1131
1132 void OfaAutocorrReplacePage::SetLanguage(LanguageType eSet)
1133 {
1134 //save old settings an refill
1135 if(eSet != eLang)
1136 {
1137 RefillReplaceBox(false, eLang, eSet);
1138 eLastDialogLanguage = eSet;
1139 delete pCompareClass;
1140 delete pCharClass;
1141
1142 LanguageTag aLanguageTag( eLastDialogLanguage );
1143 pCompareClass = new CollatorWrapper( comphelper::getProcessComponentContext() );
1144 pCompareClass->loadDefaultCollator( aLanguageTag.getLocale(), 0 );
1145 pCharClass = new CharClass( aLanguageTag );
1146 ModifyHdl(m_pShortED);
1147 }
1148 }
1149
1150 IMPL_LINK(OfaAutocorrReplacePage, SelectHdl, SvTabListBox*, pBox)
1151 {
1152 if(!bFirstSelect || !bHasSelectionText)
1153 {
1154 SvTreeListEntry* pEntry = pBox->FirstSelected();
1155 OUString sTmpShort(SvTabListBox::GetEntryText(pEntry, 0));
1156 // if the text is set via ModifyHdl, the cursor is always at the beginning
1157 // of a word, although you're editing here
1158 bool bSameContent = 0 == pCompareClass->compareString( sTmpShort, m_pShortED->GetText() );
1159 Selection aSel = m_pShortED->GetSelection();
1160 if(m_pShortED->GetText() != sTmpShort)
1161 {
1162 m_pShortED->SetText(sTmpShort);
1163 // if it was only a different notation, the selection has to be set again
1164 if(bSameContent)
1165 {
1166 m_pShortED->SetSelection(aSel);
1167 }
1168 }
1169 m_pReplaceED->SetText( SvTabListBox::GetEntryText(pEntry, 1) );
1170 // with UserData there is a Formatinfo
1171 m_pTextOnlyCB->Check( pEntry->GetUserData() == 0);
1172 }
1173 else
1174 {
1175 bFirstSelect = false;
1176 }
1177
1178 m_pNewReplacePB->Enable(false);
1179 m_pDeleteReplacePB->Enable();
1180 return 0;
1181 };
1182
1183 void OfaAutocorrReplacePage::NewEntry(const OUString& sShort, const OUString& sLong, bool bKeepSourceFormatting)
1184 {
1185 DoubleStringArray& rNewArray = aChangesTable[eLang].aNewEntries;
1186 for (sal_uInt32 i = 0; i < rNewArray.size(); i++)
1187 {
1188 if (rNewArray[i].sShort == sShort)
1189 {
1190 rNewArray.erase(rNewArray.begin() + i);
1191 break;
1192 }
1193 }
1194
1195 DoubleStringArray& rDeletedArray = aChangesTable[eLang].aDeletedEntries;
1196 for (sal_uInt32 i = 0; i < rDeletedArray.size(); i++)
1197 {
1198 if (rDeletedArray[i].sShort == sShort)
1199 {
1200 rDeletedArray.erase(rDeletedArray.begin() + i);
1201 break;
1202 }
1203 }
1204
1205 DoubleString aNewString = DoubleString();
1206 aNewString.sShort = sShort;
1207 aNewString.sLong = sLong;
1208 rNewArray.push_back(aNewString);
1209 if (bKeepSourceFormatting)
1210 rNewArray.back().pUserData = &bHasSelectionText;
1211 }
1212
1213 void OfaAutocorrReplacePage::DeleteEntry(const OUString& sShort, const OUString& sLong)
1214 {
1215 DoubleStringArray& rNewArray = aChangesTable[eLang].aNewEntries;
1216 for (sal_uInt32 i = 0; i < rNewArray.size(); i++)
1217 {
1218 if (rNewArray[i].sShort == sShort)
1219 {
1220 rNewArray.erase(rNewArray.begin() + i);
1221 break;
1222 }
1223 }
1224
1225 DoubleStringArray& rDeletedArray = aChangesTable[eLang].aDeletedEntries;
1226 for (sal_uInt32 i = 0; i < rDeletedArray.size(); i++)
1227 {
1228 if (rDeletedArray[i].sShort == sShort)
1229 {
1230 rDeletedArray.erase(rDeletedArray.begin() + i);
1231 break;
1232 }
1233 }
1234
1235 DoubleString aDeletedString = DoubleString();
1236 aDeletedString.sShort = sShort;
1237 aDeletedString.sLong = sLong;
1238 rDeletedArray.push_back(aDeletedString);
1239 }
1240
1241 IMPL_LINK(OfaAutocorrReplacePage, NewDelHdl, PushButton*, pBtn)
1242 {
1243 SvTreeListEntry* pEntry = m_pReplaceTLB->FirstSelected();
1244 if( pBtn == m_pDeleteReplacePB )
1245 {
1246 DBG_ASSERT( pEntry, "no entry selected" );
1247 if( pEntry )
1248 {
1249 DeleteEntry(SvTabListBox::GetEntryText(pEntry, 0), SvTabListBox::GetEntryText(pEntry, 1));
1250 m_pReplaceTLB->GetModel()->Remove(pEntry);
1251 ModifyHdl(m_pShortED);
1252 return 0;
1253 }
1254 }
1255 if(pBtn == m_pNewReplacePB || m_pNewReplacePB->IsEnabled())
1256 {
1257 SvTreeListEntry* _pNewEntry = m_pReplaceTLB->FirstSelected();
1258 OUString sEntry(m_pShortED->GetText());
1259 if(!sEntry.isEmpty() && ( !m_pReplaceED->GetText().isEmpty() ||
1260 ( bHasSelectionText && bSWriter ) ))
1261 {
1262 bool bKeepSourceFormatting = !bReplaceEditChanged && !m_pTextOnlyCB->IsChecked();
1263
1264 NewEntry(m_pShortED->GetText(), m_pReplaceED->GetText(), bKeepSourceFormatting);
1265 m_pReplaceTLB->SetUpdateMode(false);
1266 sal_uLong nPos = TREELIST_ENTRY_NOTFOUND;
1267 sEntry += "\t";
1268 sEntry += m_pReplaceED->GetText();
1269 if(_pNewEntry)
1270 {
1271 nPos = m_pReplaceTLB->GetModel()->GetAbsPos(_pNewEntry);
1272 m_pReplaceTLB->GetModel()->Remove(_pNewEntry);
1273 }
1274 else
1275 {
1276 sal_uLong j;
1277 for( j = 0; j < m_pReplaceTLB->GetEntryCount(); j++ )
1278 {
1279 SvTreeListEntry* pReplaceEntry = m_pReplaceTLB->GetEntry(j);
1280 if( 0 >= pCompareClass->compareString(sEntry, SvTabListBox::GetEntryText(pReplaceEntry, 0) ) )
1281 break;
1282 }
1283 nPos = j;
1284 }
1285 SvTreeListEntry* pInsEntry = m_pReplaceTLB->InsertEntry(
1286 sEntry, static_cast< SvTreeListEntry * >(NULL), false,
1287 nPos == TREELIST_ENTRY_NOTFOUND ? TREELIST_APPEND : nPos);
1288 if (bKeepSourceFormatting)
1289 {
1290 pInsEntry->SetUserData(&bHasSelectionText); // new formatted text
1291 }
1292
1293 m_pReplaceTLB->MakeVisible( pInsEntry );
1294 m_pReplaceTLB->SetUpdateMode( true );
1295 // if the request came from the ReplaceEdit, give focus to the ShortEdit
1296 if(m_pReplaceED->HasFocus())
1297 {
1298 m_pShortED->GrabFocus();
1299 }
1300 }
1301 }
1302 else
1303 {
1304 // this can only be an enter in one of the two edit fields
1305 // which means EndDialog() - has to be evaluated in KeyInput
1306 return 0;
1307 }
1308 ModifyHdl(m_pShortED);
1309 return 1;
1310 }
1311
1312 IMPL_LINK(OfaAutocorrReplacePage, ModifyHdl, Edit*, pEdt)
1313 {
1314 SvTreeListEntry* pFirstSel = m_pReplaceTLB->FirstSelected();
1315 bool bShort = pEdt == m_pShortED;
1316 const OUString rEntry = pEdt->GetText();
1317 const OUString rRepString = m_pReplaceED->GetText();
1318 OUString aWordStr( pCharClass->lowercase( rEntry ));
1319
1320 if(bShort)
1321 {
1322 if(!rEntry.isEmpty())
1323 {
1324 bool bFound = false;
1325 bool bTmpSelEntry=false;
1326
1327 for(sal_uInt32 i = 0; i < m_pReplaceTLB->GetEntryCount(); i++)
1328 {
1329 SvTreeListEntry* pEntry = m_pReplaceTLB->GetEntry( i );
1330 OUString aTestStr = SvTabListBox::GetEntryText(pEntry, 0);
1331 if( pCompareClass->compareString(rEntry, aTestStr ) == 0 )
1332 {
1333 if( !rRepString.isEmpty() )
1334 {
1335 bFirstSelect = true;
1336 }
1337 m_pReplaceTLB->SetCurEntry(pEntry);
1338 pFirstSel = pEntry;
1339 m_pNewReplacePB->SetText(sModify);
1340 bFound = true;
1341 break;
1342 }
1343 else
1344 {
1345 aTestStr = pCharClass->lowercase( aTestStr );
1346 if( aTestStr.startsWith(aWordStr) && !bTmpSelEntry )
1347 {
1348 m_pReplaceTLB->MakeVisible( pEntry );
1349 bTmpSelEntry = true;
1350 }
1351 }
1352 }
1353 if( !bFound )
1354 {
1355 m_pReplaceTLB->SelectAll( false );
1356 pFirstSel = 0;
1357 m_pNewReplacePB->SetText( sNew );
1358 if( bReplaceEditChanged )
1359 m_pTextOnlyCB->Enable(false);
1360 }
1361 m_pDeleteReplacePB->Enable( bFound );
1362 }
1363 else if( m_pReplaceTLB->GetEntryCount() > 0 )
1364 {
1365 SvTreeListEntry* pEntry = m_pReplaceTLB->GetEntry( 0 );
1366 m_pReplaceTLB->MakeVisible( pEntry );
1367 }
1368
1369 }
1370 else if( !bShort )
1371 {
1372 bReplaceEditChanged = true;
1373 if( pFirstSel )
1374 {
1375 m_pNewReplacePB->SetText( sModify );
1376 }
1377 }
1378
1379 const OUString& rShortTxt = m_pShortED->GetText();
1380 bool bEnableNew = !rShortTxt.isEmpty() &&
1381 ( !rRepString.isEmpty() ||
1382 ( bHasSelectionText && bSWriter )) &&
1383 ( !pFirstSel || rRepString !=
1384 SvTabListBox::GetEntryText( pFirstSel, 1 ) );
1385 if( bEnableNew )
1386 {
1387 for(std::set<OUString>::iterator i = aFormatText.begin(); i != aFormatText.end(); ++i)
1388 {
1389 if((*i).equals(rShortTxt))
1390 {
1391 bEnableNew = false;
1392 break;
1393 }
1394 }
1395 }
1396 m_pNewReplacePB->Enable( bEnableNew );
1397
1398 return 0;
1399 }
1400
1401 static bool lcl_FindInArray(std::vector<OUString>& rStrings, const OUString& rString)
1402 {
1403 for(std::vector<OUString>::iterator i = rStrings.begin(); i != rStrings.end(); ++i)
1404 {
1405 if((*i).equals(rString))
1406 {
1407 return true;
1408 }
1409 }
1410 return false;
1411 }
1412
1413 OfaAutocorrExceptPage::OfaAutocorrExceptPage(vcl::Window* pParent, const SfxItemSet& rSet)
1414 : SfxTabPage(pParent, "AcorExceptPage", "cui/ui/acorexceptpage.ui", &rSet)
1415 , eLang(eLastDialogLanguage)
1416 {
1417 get(m_pAbbrevED, "abbrev");
1418 get(m_pAbbrevLB, "abbrevlist");
1419 m_pAbbrevLB->SetStyle(m_pAbbrevLB->GetStyle() | WB_SORT);
1420 m_pAbbrevLB->SetDropDownLineCount(7);
1421 get(m_pNewAbbrevPB, "newabbrev");
1422 get(m_pDelAbbrevPB, "delabbrev");
1423 get(m_pAutoAbbrevCB, "autoabbrev");
1424
1425 get(m_pDoubleCapsED, "double");
1426 get(m_pDoubleCapsLB, "doublelist");
1427 m_pDoubleCapsLB->SetStyle(m_pDoubleCapsLB->GetStyle() | WB_SORT);
1428 m_pDoubleCapsLB->SetDropDownLineCount(7);
1429 get(m_pNewDoublePB, "newdouble");
1430 get(m_pDelDoublePB, "deldouble");
1431 get(m_pAutoCapsCB, "autodouble");
1432
1433 ::com::sun::star::lang::Locale aLcl( LanguageTag::convertToLocale(eLastDialogLanguage ));
1434 pCompareClass = new CollatorWrapper( comphelper::getProcessComponentContext() );
1435 pCompareClass->loadDefaultCollator( aLcl, 0 );
1436
1437 m_pNewAbbrevPB->SetClickHdl(LINK(this, OfaAutocorrExceptPage, NewDelHdl));
1438 m_pDelAbbrevPB->SetClickHdl(LINK(this, OfaAutocorrExceptPage, NewDelHdl));
1439 m_pNewDoublePB->SetClickHdl(LINK(this, OfaAutocorrExceptPage, NewDelHdl));
1440 m_pDelDoublePB->SetClickHdl(LINK(this, OfaAutocorrExceptPage, NewDelHdl));
1441
1442 m_pAbbrevLB->SetSelectHdl(LINK(this, OfaAutocorrExceptPage, SelectHdl));
1443 m_pDoubleCapsLB->SetSelectHdl(LINK(this, OfaAutocorrExceptPage, SelectHdl));
1444 m_pAbbrevED->SetModifyHdl(LINK(this, OfaAutocorrExceptPage, ModifyHdl));
1445 m_pDoubleCapsED->SetModifyHdl(LINK(this, OfaAutocorrExceptPage, ModifyHdl));
1446
1447 m_pAbbrevED->SetActionHdl(LINK(this, OfaAutocorrExceptPage, NewDelHdl));
1448 m_pDoubleCapsED->SetActionHdl(LINK(this, OfaAutocorrExceptPage, NewDelHdl));
1449 }
1450
1451 OfaAutocorrExceptPage::~OfaAutocorrExceptPage()
1452 {
1453 disposeOnce();
1454 }
1455
1456 void OfaAutocorrExceptPage::dispose()
1457 {
1458 aStringsTable.clear();
1459 delete pCompareClass;
1460 m_pAbbrevED.clear();
1461 m_pAbbrevLB.clear();
1462 m_pNewAbbrevPB.clear();
1463 m_pDelAbbrevPB.clear();
1464 m_pAutoAbbrevCB.clear();
1465 m_pDoubleCapsED.clear();
1466 m_pDoubleCapsLB.clear();
1467 m_pNewDoublePB.clear();
1468 m_pDelDoublePB.clear();
1469 m_pAutoCapsCB.clear();
1470 SfxTabPage::dispose();
1471 }
1472
1473 VclPtr<SfxTabPage> OfaAutocorrExceptPage::Create( vcl::Window* pParent,
1474 const SfxItemSet* rSet)
1475 {
1476 return VclPtr<OfaAutocorrExceptPage>::Create(pParent, *rSet);
1477 }
1478
1479 void OfaAutocorrExceptPage::ActivatePage( const SfxItemSet& )
1480 {
1481 if(eLang != eLastDialogLanguage)
1482 SetLanguage(eLastDialogLanguage);
1483 static_cast<OfaAutoCorrDlg*>(GetTabDialog())->EnableLanguage(true);
1484 }
1485
1486 SfxTabPage::sfxpg OfaAutocorrExceptPage::DeactivatePage( SfxItemSet* )
1487 {
1488 return LEAVE_PAGE;
1489 }
1490
1491 bool OfaAutocorrExceptPage::FillItemSet( SfxItemSet* )
1492 {
1493 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
1494 for(StringsTable::reverse_iterator it1 = aStringsTable.rbegin(); it1 != aStringsTable.rend(); ++it1)
1495 {
1496 LanguageType eCurLang = it1->first;
1497 StringsArrays& rArrays = it1->second;
1498 if(eCurLang != eLang) // current language is treated later
1499 {
1500 SvStringsISortDtor* pWrdList = pAutoCorrect->LoadWrdSttExceptList(eCurLang);
1501
1502 if(pWrdList)
1503 {
1504 size_t nCount = pWrdList->size();
1505 size_t i;
1506 for( i = nCount; i; )
1507 {
1508 OUString aString = (*pWrdList)[ --i ];
1509
1510 if( !lcl_FindInArray(rArrays.aDoubleCapsStrings, aString))
1511 {
1512 pWrdList->erase(i);
1513 }
1514 }
1515
1516 for(std::vector<OUString>::iterator it = rArrays.aDoubleCapsStrings.begin(); it != rArrays.aDoubleCapsStrings.end(); ++it)
1517 {
1518 pWrdList->insert(*it);
1519 }
1520 pAutoCorrect->SaveWrdSttExceptList(eCurLang);
1521 }
1522
1523 SvStringsISortDtor* pCplList = pAutoCorrect->LoadCplSttExceptList(eCurLang);
1524
1525 if(pCplList)
1526 {
1527 size_t nCount = pCplList->size();
1528 size_t i;
1529 for( i = nCount; i; )
1530 {
1531 OUString aString = (*pCplList)[ --i ];
1532 if( !lcl_FindInArray(rArrays.aAbbrevStrings, aString))
1533 {
1534 pCplList->erase(i);
1535 }
1536 }
1537
1538 for(std::vector<OUString>::iterator it = rArrays.aAbbrevStrings.begin(); it != rArrays.aAbbrevStrings.end(); ++it)
1539 {
1540 pCplList->insert(*it);
1541 }
1542
1543 pAutoCorrect->SaveCplSttExceptList(eCurLang);
1544 }
1545 }
1546 }
1547 aStringsTable.clear();
1548
1549 SvStringsISortDtor* pWrdList = pAutoCorrect->LoadWrdSttExceptList(eLang);
1550
1551 if(pWrdList)
1552 {
1553 size_t nCount = pWrdList->size();
1554 size_t i;
1555 for( i = nCount; i; )
1556 {
1557 OUString aString = (*pWrdList)[ --i ];
1558 if( LISTBOX_ENTRY_NOTFOUND == m_pDoubleCapsLB->GetEntryPos(aString) )
1559 {
1560 pWrdList->erase(i);
1561 }
1562 }
1563 nCount = m_pDoubleCapsLB->GetEntryCount();
1564 for( i = 0; i < nCount; ++i )
1565 {
1566 pWrdList->insert( m_pDoubleCapsLB->GetEntry( i ) );
1567 }
1568 pAutoCorrect->SaveWrdSttExceptList(eLang);
1569 }
1570
1571 SvStringsISortDtor* pCplList = pAutoCorrect->LoadCplSttExceptList(eLang);
1572
1573 if(pCplList)
1574 {
1575 size_t nCount = pCplList->size();
1576 for( size_t i = nCount; i; )
1577 {
1578 OUString aString = (*pCplList)[ --i ];
1579 if( LISTBOX_ENTRY_NOTFOUND == m_pAbbrevLB->GetEntryPos(aString) )
1580 {
1581 pCplList->erase(i);
1582 }
1583 }
1584 sal_Int32 nAbbrevCount = m_pAbbrevLB->GetEntryCount();
1585 for( sal_Int32 ia = 0; ia < nAbbrevCount; ++ia )
1586 {
1587 pCplList->insert( m_pAbbrevLB->GetEntry( ia ) );
1588 }
1589 pAutoCorrect->SaveCplSttExceptList(eLang);
1590 }
1591 if(m_pAutoAbbrevCB->IsValueChangedFromSaved())
1592 pAutoCorrect->SetAutoCorrFlag( SaveWordCplSttLst, m_pAutoAbbrevCB->IsChecked());
1593 if(m_pAutoCapsCB->IsValueChangedFromSaved())
1594 pAutoCorrect->SetAutoCorrFlag( SaveWordWrdSttLst, m_pAutoCapsCB->IsChecked());
1595 return false;
1596 }
1597
1598 void OfaAutocorrExceptPage::SetLanguage(LanguageType eSet)
1599 {
1600 if(eLang != eSet)
1601 {
1602 // save old settings and fill anew
1603 RefillReplaceBoxes(false, eLang, eSet);
1604 eLastDialogLanguage = eSet;
1605 delete pCompareClass;
1606 pCompareClass = new CollatorWrapper( comphelper::getProcessComponentContext() );
1607 pCompareClass->loadDefaultCollator( LanguageTag::convertToLocale( eLastDialogLanguage ), 0 );
1608 ModifyHdl(m_pAbbrevED);
1609 ModifyHdl(m_pDoubleCapsED);
1610 }
1611 }
1612
1613 void OfaAutocorrExceptPage::RefillReplaceBoxes(bool bFromReset,
1614 LanguageType eOldLanguage,
1615 LanguageType eNewLanguage)
1616 {
1617 eLang = eNewLanguage;
1618 if(bFromReset)
1619 {
1620 aStringsTable.clear();
1621 }
1622 else
1623 {
1624 StringsArrays* pArrays;
1625 if(aStringsTable.find(eOldLanguage) != aStringsTable.end())
1626 {
1627 pArrays = &aStringsTable[eOldLanguage];
1628 pArrays->aAbbrevStrings.clear();
1629 pArrays->aDoubleCapsStrings.clear();
1630 }
1631 else
1632 {
1633 pArrays = &aStringsTable[eOldLanguage]; // create new array
1634 }
1635
1636 sal_Int32 i;
1637 for(i = 0; i < m_pAbbrevLB->GetEntryCount(); i++)
1638 pArrays->aAbbrevStrings.push_back(OUString(m_pAbbrevLB->GetEntry(i)));
1639
1640 for(i = 0; i < m_pDoubleCapsLB->GetEntryCount(); i++)
1641 pArrays->aDoubleCapsStrings.push_back(OUString(m_pDoubleCapsLB->GetEntry(i)));
1642 }
1643 m_pDoubleCapsLB->Clear();
1644 m_pAbbrevLB->Clear();
1645 OUString sTemp;
1646 m_pAbbrevED->SetText(sTemp);
1647 m_pDoubleCapsED->SetText(sTemp);
1648
1649 if(aStringsTable.find(eLang) != aStringsTable.end())
1650 {
1651 StringsArrays& rArrays = aStringsTable[eLang];
1652 for(std::vector<OUString>::iterator i = rArrays.aAbbrevStrings.begin(); i != rArrays.aAbbrevStrings.end(); ++i)
1653 m_pAbbrevLB->InsertEntry(*i);
1654
1655 for(std::vector<OUString>::iterator i = rArrays.aDoubleCapsStrings.begin(); i != rArrays.aDoubleCapsStrings.end(); ++i)
1656 m_pDoubleCapsLB->InsertEntry(*i);
1657 }
1658 else
1659 {
1660 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
1661 const SvStringsISortDtor* pCplList = pAutoCorrect->GetCplSttExceptList(eLang);
1662 const SvStringsISortDtor* pWrdList = pAutoCorrect->GetWrdSttExceptList(eLang);
1663 size_t i;
1664 for( i = 0; i < pCplList->size(); i++ )
1665 {
1666 m_pAbbrevLB->InsertEntry((*pCplList)[i]);
1667 }
1668 for( i = 0; i < pWrdList->size(); i++ )
1669 {
1670 m_pDoubleCapsLB->InsertEntry((*pWrdList)[i]);
1671 }
1672 }
1673 }
1674
1675 void OfaAutocorrExceptPage::Reset( const SfxItemSet* )
1676 {
1677 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
1678 RefillReplaceBoxes(true, eLang, eLang);
1679 m_pAutoAbbrevCB-> Check( pAutoCorrect->IsAutoCorrFlag( SaveWordCplSttLst ));
1680 m_pAutoCapsCB-> Check( pAutoCorrect->IsAutoCorrFlag( SaveWordWrdSttLst ));
1681 m_pAutoAbbrevCB->SaveValue();
1682 m_pAutoCapsCB->SaveValue();
1683 }
1684
1685 IMPL_LINK(OfaAutocorrExceptPage, NewDelHdl, void*, pBtn)
1686 {
1687 if((pBtn == m_pNewAbbrevPB || pBtn == m_pAbbrevED.get() )
1688 && !m_pAbbrevED->GetText().isEmpty())
1689 {
1690 m_pAbbrevLB->InsertEntry(m_pAbbrevED->GetText());
1691 ModifyHdl(m_pAbbrevED);
1692 }
1693 else if(pBtn == m_pDelAbbrevPB)
1694 {
1695 m_pAbbrevLB->RemoveEntry(m_pAbbrevED->GetText());
1696 ModifyHdl(m_pAbbrevED);
1697 }
1698 else if((pBtn == m_pNewDoublePB || pBtn == m_pDoubleCapsED.get() )
1699 && !m_pDoubleCapsED->GetText().isEmpty())
1700 {
1701 m_pDoubleCapsLB->InsertEntry(m_pDoubleCapsED->GetText());
1702 ModifyHdl(m_pDoubleCapsED);
1703 }
1704 else if(pBtn == m_pDelDoublePB)
1705 {
1706 m_pDoubleCapsLB->RemoveEntry(m_pDoubleCapsED->GetText());
1707 ModifyHdl(m_pDoubleCapsED);
1708 }
1709 return 0;
1710 }
1711
1712 IMPL_LINK(OfaAutocorrExceptPage, SelectHdl, ListBox*, pBox)
1713 {
1714 if (pBox == m_pAbbrevLB)
1715 {
1716 m_pAbbrevED->SetText(pBox->GetSelectEntry());
1717 m_pNewAbbrevPB->Enable(false);
1718 m_pDelAbbrevPB->Enable();
1719 }
1720 else
1721 {
1722 m_pDoubleCapsED->SetText(pBox->GetSelectEntry());
1723 m_pNewDoublePB->Enable(false);
1724 m_pDelDoublePB->Enable();
1725 }
1726 return 0;
1727 }
1728
1729 IMPL_LINK(OfaAutocorrExceptPage, ModifyHdl, Edit*, pEdt)
1730 {
1731 // sal_Bool bSame = pEdt->GetText() == ->GetSelectEntry();
1732 const OUString& sEntry = pEdt->GetText();
1733 bool bEntryLen = !sEntry.isEmpty();
1734 if(pEdt == m_pAbbrevED)
1735 {
1736 bool bSame = lcl_FindEntry(*m_pAbbrevLB, sEntry, *pCompareClass);
1737 if(bSame && sEntry != m_pAbbrevLB->GetSelectEntry())
1738 pEdt->SetText(m_pAbbrevLB->GetSelectEntry());
1739 m_pNewAbbrevPB->Enable(!bSame && bEntryLen);
1740 m_pDelAbbrevPB->Enable(bSame && bEntryLen);
1741 }
1742 else
1743 {
1744 bool bSame = lcl_FindEntry(*m_pDoubleCapsLB, sEntry, *pCompareClass);
1745 if(bSame && sEntry != m_pDoubleCapsLB->GetSelectEntry())
1746 pEdt->SetText(m_pDoubleCapsLB->GetSelectEntry());
1747 m_pNewDoublePB->Enable(!bSame && bEntryLen);
1748 m_pDelDoublePB->Enable(bSame && bEntryLen);
1749 }
1750 return 0;
1751 }
1752
1753 VCL_BUILDER_FACTORY(AutoCorrEdit)
1754
1755 void AutoCorrEdit::KeyInput( const KeyEvent& rKEvt )
1756 {
1757 const vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
1758 const sal_uInt16 nModifier = aKeyCode.GetModifier();
1759 if( aKeyCode.GetCode() == KEY_RETURN )
1760 {
1761 // if there's nothing done on enter, call the
1762 // base class after all to close the dialog
1763 if(!nModifier && !aActionLink.Call(this))
1764 Edit::KeyInput(rKEvt);
1765 }
1766 else if(bSpaces || aKeyCode.GetCode() != KEY_SPACE)
1767 Edit::KeyInput(rKEvt);
1768 }
1769
1770 enum OfaQuoteOptions
1771 {
1772 ADD_NONBRK_SPACE,
1773 REPLACE_1ST
1774 };
1775
1776 SvTreeListEntry* OfaQuoteTabPage::CreateEntry(OUString& rTxt, sal_uInt16 nCol)
1777 {
1778 SvTreeListEntry* pEntry = new SvTreeListEntry;
1779
1780 if ( !pCheckButtonData )
1781 {
1782 pCheckButtonData = new SvLBoxButtonData(m_pSwCheckLB);
1783 m_pSwCheckLB->SetCheckButtonData(pCheckButtonData);
1784 }
1785
1786 pEntry->AddItem( new SvLBoxContextBmp( pEntry, 0, Image(), Image(), false));
1787
1788 OUString sEmpty;
1789 if (nCol == CBCOL_SECOND)
1790 pEntry->AddItem( new SvLBoxString( pEntry, 0, sEmpty) );
1791 else
1792 pEntry->AddItem( new SvLBoxButton( pEntry, SvLBoxButtonKind_enabledCheckbox, 0, pCheckButtonData ) );
1793
1794 if (nCol == CBCOL_FIRST)
1795 pEntry->AddItem( new SvLBoxString( pEntry, 0, sEmpty) );
1796 else
1797 pEntry->AddItem( new SvLBoxButton( pEntry, SvLBoxButtonKind_enabledCheckbox, 0, pCheckButtonData ) );
1798
1799 pEntry->AddItem( new OfaImpBrwString( pEntry, 0, rTxt ) );
1800
1801 return pEntry;
1802 }
1803
1804 OfaQuoteTabPage::OfaQuoteTabPage(vcl::Window* pParent, const SfxItemSet& rSet)
1805 : SfxTabPage(pParent, "ApplyLocalizedPage", "cui/ui/applylocalizedpage.ui", &rSet)
1806 , sNonBrkSpace(CUI_RESSTR(RID_SVXSTR_NON_BREAK_SPACE))
1807 , sOrdinal(CUI_RESSTR(RID_SVXSTR_ORDINAL))
1808 , pCheckButtonData(NULL)
1809 , cSglStartQuote(0)
1810 , cSglEndQuote(0)
1811 , cStartQuote(0)
1812 , cEndQuote(0)
1813 {
1814 get(m_pCheckLB, "checklist");
1815
1816 SvSimpleTableContainer *pListContainer = get<SvSimpleTableContainer>("list");
1817 Size aControlSize(252 , 85);
1818 aControlSize = LogicToPixel(aControlSize, MAP_APPFONT);
1819 pListContainer->set_width_request(aControlSize.Width());
1820 pListContainer->set_height_request(aControlSize.Height());
1821 m_pSwCheckLB = VclPtr<OfaACorrCheckListBox>::Create(*pListContainer),
1822
1823 get(m_pSingleTypoCB, "singlereplace");
1824 get(m_pSglStartQuotePB, "startsingle");
1825 get(m_pSglStartExFT, "singlestartex");
1826 get(m_pSglEndQuotePB, "endsingle");
1827 get(m_pSglEndExFT, "singleendex");
1828 get(m_pSglStandardPB, "defaultsingle");
1829
1830 get(m_pDoubleTypoCB, "doublereplace");
1831 get(m_pDblStartQuotePB, "startdouble");
1832 get(m_pDblStartExFT, "doublestartex");
1833 get(m_pDblEndQuotePB, "enddouble");
1834 get(m_pDblEndExFT, "doubleendex");
1835 get(m_pDblStandardPB, "defaultdouble");
1836
1837 using comphelper::string::strip;
1838
1839 m_sStartQuoteDlg = strip(get<FixedText>("startquoteft")->GetText(), ':');
1840 m_sEndQuoteDlg = strip(get<FixedText>("endquoteft")->GetText(), ':');
1841 m_sStandard = get<FixedText>("singlestartex")->GetText();
1842
1843 bool bShowSWOptions = false;
1844
1845 SFX_ITEMSET_ARG( &rSet, pItem, SfxBoolItem, SID_AUTO_CORRECT_DLG, false );
1846 if ( pItem && pItem->GetValue() )
1847 bShowSWOptions = true;
1848
1849 if ( bShowSWOptions )
1850 {
1851 static long aStaticTabs[]=
1852 {
1853 3, 0, 20, 40
1854 };
1855
1856 m_pSwCheckLB->SetStyle(m_pSwCheckLB->GetStyle() | WB_HSCROLL| WB_VSCROLL);
1857
1858 m_pSwCheckLB->SvSimpleTable::SetTabs(aStaticTabs);
1859 OUString sHeader(get<vcl::Window>("m")->GetText());
1860 sHeader += "\t";
1861 sHeader += get<vcl::Window>("t")->GetText();
1862 sHeader += "\t";
1863 m_pSwCheckLB->InsertHeaderEntry( sHeader, HEADERBAR_APPEND,
1864 HeaderBarItemBits::CENTER | HeaderBarItemBits::VCENTER | HeaderBarItemBits::FIXEDPOS | HeaderBarItemBits::FIXED);
1865 m_pCheckLB->Hide();
1866 }
1867 else
1868 {
1869 m_pSwCheckLB->HideTable();
1870 }
1871
1872 m_pDblStartQuotePB->SetClickHdl(LINK(this, OfaQuoteTabPage, QuoteHdl));
1873 m_pDblEndQuotePB->SetClickHdl(LINK(this, OfaQuoteTabPage, QuoteHdl));
1874 m_pSglStartQuotePB->SetClickHdl(LINK(this, OfaQuoteTabPage, QuoteHdl));
1875 m_pSglEndQuotePB->SetClickHdl(LINK(this, OfaQuoteTabPage, QuoteHdl));
1876 m_pDblStandardPB->SetClickHdl(LINK(this, OfaQuoteTabPage, StdQuoteHdl));
1877 m_pSglStandardPB->SetClickHdl(LINK(this, OfaQuoteTabPage, StdQuoteHdl));
1878 }
1879
1880 OfaQuoteTabPage::~OfaQuoteTabPage()
1881 {
1882 disposeOnce();
1883 }
1884
1885 void OfaQuoteTabPage::dispose()
1886 {
1887 delete pCheckButtonData;
1888 pCheckButtonData = NULL;
1889 m_pSwCheckLB.disposeAndClear();
1890 m_pCheckLB.disposeAndClear();
1891 m_pSingleTypoCB.clear();
1892 m_pSglStartQuotePB.clear();
1893 m_pSglStartExFT.clear();
1894 m_pSglEndQuotePB.clear();
1895 m_pSglEndExFT.clear();
1896 m_pSglStandardPB.clear();
1897 m_pDoubleTypoCB.clear();
1898 m_pDblStartQuotePB.clear();
1899 m_pDblStartExFT.clear();
1900 m_pDblEndQuotePB.clear();
1901 m_pDblEndExFT.clear();
1902 m_pDblStandardPB.clear();
1903 SfxTabPage::dispose();
1904 }
1905
1906 VclPtr<SfxTabPage> OfaQuoteTabPage::Create( vcl::Window* pParent,
1907 const SfxItemSet* rAttrSet)
1908 {
1909 return VclPtr<SfxTabPage>( new OfaQuoteTabPage(pParent, *rAttrSet),
1910 SAL_NO_ACQUIRE );
1911 }
1912
1913 bool OfaQuoteTabPage::FillItemSet( SfxItemSet* )
1914 {
1915 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
1916
1917 long nFlags = pAutoCorrect->GetFlags();
1918
1919 if (m_pCheckLB->IsVisible())
1920 {
1921 sal_uLong nPos = 0;
1922 pAutoCorrect->SetAutoCorrFlag(AddNonBrkSpace, m_pCheckLB->IsChecked(nPos++));
1923 pAutoCorrect->SetAutoCorrFlag(ChgOrdinalNumber, m_pCheckLB->IsChecked(nPos++));
1924 }
1925
1926 bool bModified = false;
1927 if (m_pSwCheckLB->IsVisible())
1928 {
1929 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
1930
1931 bool bCheck = m_pSwCheckLB->IsChecked(ADD_NONBRK_SPACE, CBCOL_FIRST);
1932 bModified |= pOpt->bAddNonBrkSpace != bCheck;
1933 pOpt->bAddNonBrkSpace = bCheck;
1934 pAutoCorrect->SetAutoCorrFlag(AddNonBrkSpace,
1935 m_pSwCheckLB->IsChecked(ADD_NONBRK_SPACE, CBCOL_SECOND));
1936
1937 bCheck = m_pSwCheckLB->IsChecked(REPLACE_1ST, CBCOL_FIRST);
1938 bModified |= pOpt->bChgOrdinalNumber != bCheck;
1939 pOpt->bChgOrdinalNumber = bCheck;
1940 pAutoCorrect->SetAutoCorrFlag(ChgOrdinalNumber,
1941 m_pSwCheckLB->IsChecked(REPLACE_1ST, CBCOL_SECOND));
1942 }
1943
1944 pAutoCorrect->SetAutoCorrFlag(ChgQuotes, m_pDoubleTypoCB->IsChecked());
1945 pAutoCorrect->SetAutoCorrFlag(ChgSglQuotes, m_pSingleTypoCB->IsChecked());
1946 bool bReturn = nFlags != pAutoCorrect->GetFlags();
1947 if(cStartQuote != pAutoCorrect->GetStartDoubleQuote())
1948 {
1949 bReturn = true;
1950 sal_Unicode cUCS2 = static_cast<sal_Unicode>(cStartQuote); //TODO
1951 pAutoCorrect->SetStartDoubleQuote(cUCS2);
1952 }
1953 if(cEndQuote != pAutoCorrect->GetEndDoubleQuote())
1954 {
1955 bReturn = true;
1956 sal_Unicode cUCS2 = static_cast<sal_Unicode>(cEndQuote); //TODO
1957 pAutoCorrect->SetEndDoubleQuote(cUCS2);
1958 }
1959 if(cSglStartQuote != pAutoCorrect->GetStartSingleQuote())
1960 {
1961 bReturn = true;
1962 sal_Unicode cUCS2 = static_cast<sal_Unicode>(cSglStartQuote); //TODO
1963 pAutoCorrect->SetStartSingleQuote(cUCS2);
1964 }
1965 if(cSglEndQuote != pAutoCorrect->GetEndSingleQuote())
1966 {
1967 bReturn = true;
1968 sal_Unicode cUCS2 = static_cast<sal_Unicode>(cSglEndQuote); //TODO
1969 pAutoCorrect->SetEndSingleQuote(cUCS2);
1970 }
1971
1972 if( bModified || bReturn )
1973 {
1974 SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
1975 rCfg.SetModified();
1976 rCfg.Commit();
1977 }
1978 return bReturn;
1979 }
1980
1981 void OfaQuoteTabPage::ActivatePage( const SfxItemSet& )
1982 {
1983 static_cast<OfaAutoCorrDlg*>(GetTabDialog())->EnableLanguage(false);
1984 }
1985
1986 void OfaQuoteTabPage::Reset( const SfxItemSet* )
1987 {
1988 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
1989 const long nFlags = pAutoCorrect->GetFlags();
1990
1991 // Initialize the Sw options
1992 if (m_pSwCheckLB->IsVisible())
1993 {
1994 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
1995
1996 m_pSwCheckLB->SetUpdateMode( false );
1997 m_pSwCheckLB->Clear();
1998
1999 m_pSwCheckLB->GetModel()->Insert(CreateEntry(sNonBrkSpace, CBCOL_BOTH ));
2000 m_pSwCheckLB->GetModel()->Insert(CreateEntry(sOrdinal, CBCOL_BOTH ));
2001
2002 m_pSwCheckLB->CheckEntryPos( ADD_NONBRK_SPACE, CBCOL_FIRST, pOpt->bAddNonBrkSpace );
2003 m_pSwCheckLB->CheckEntryPos( ADD_NONBRK_SPACE, CBCOL_SECOND, 0 != (nFlags & AddNonBrkSpace) );
2004 m_pSwCheckLB->CheckEntryPos( REPLACE_1ST, CBCOL_FIRST, pOpt->bChgOrdinalNumber );
2005 m_pSwCheckLB->CheckEntryPos( REPLACE_1ST, CBCOL_SECOND, 0 != (nFlags & ChgOrdinalNumber) );
2006
2007 m_pSwCheckLB->SetUpdateMode( true );
2008 }
2009
2010 // Initialize the non Sw options
2011 if (m_pCheckLB->IsVisible())
2012 {
2013 m_pCheckLB->SetUpdateMode(false);
2014 m_pCheckLB->Clear();
2015
2016 m_pCheckLB->InsertEntry( sNonBrkSpace );
2017 m_pCheckLB->InsertEntry( sOrdinal );
2018
2019 sal_uLong nPos = 0;
2020 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & AddNonBrkSpace) );
2021 m_pCheckLB->CheckEntryPos( nPos++, 0 != (nFlags & ChgOrdinalNumber) );
2022
2023 m_pCheckLB->SetUpdateMode(true);
2024 }
2025
2026 // Initialize the quote stuffs
2027 m_pDoubleTypoCB->Check(0 != (nFlags & ChgQuotes));
2028 m_pSingleTypoCB->Check(0 != (nFlags & ChgSglQuotes));
2029 m_pDoubleTypoCB->SaveValue();
2030 m_pSingleTypoCB->SaveValue();
2031
2032 cStartQuote = pAutoCorrect->GetStartDoubleQuote();
2033 cEndQuote = pAutoCorrect->GetEndDoubleQuote();
2034 cSglStartQuote = pAutoCorrect->GetStartSingleQuote();
2035 cSglEndQuote = pAutoCorrect->GetEndSingleQuote();
2036
2037 m_pSglStartExFT->SetText(ChangeStringExt_Impl(cSglStartQuote));
2038 m_pSglEndExFT->SetText(ChangeStringExt_Impl(cSglEndQuote));
2039 m_pDblStartExFT->SetText(ChangeStringExt_Impl(cStartQuote));
2040 m_pDblEndExFT->SetText(ChangeStringExt_Impl(cEndQuote));
2041 }
2042
2043 #define SGL_START 0
2044 #define DBL_START 1
2045 #define SGL_END 2
2046 #define DBL_END 3
2047
2048
2049 IMPL_LINK( OfaQuoteTabPage, QuoteHdl, PushButton*, pBtn )
2050 {
2051 sal_uInt16 nMode = SGL_START;
2052 if (pBtn == m_pSglEndQuotePB)
2053 nMode = SGL_END;
2054 else if (pBtn == m_pDblStartQuotePB)
2055 nMode = DBL_START;
2056 else if (pBtn == m_pDblEndQuotePB)
2057 nMode = DBL_END;
2058 // start character selection dialog
2059 ScopedVclPtrInstance< SvxCharacterMap > pMap( this, true );
2060 pMap->SetCharFont( OutputDevice::GetDefaultFont(DefaultFontType::LATIN_TEXT,
2061 LANGUAGE_ENGLISH_US, GetDefaultFontFlags::OnlyOne, 0 ));
2062 pMap->SetText(nMode < SGL_END ? m_sStartQuoteDlg : m_sEndQuoteDlg );
2063 sal_UCS4 cDlg;
2064 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
2065 LanguageType eLang = Application::GetSettings().GetLanguageTag().getLanguageType();
2066 switch( nMode )
2067 {
2068 case SGL_START:
2069 cDlg = cSglStartQuote;
2070 if(cDlg == 0)
2071 cDlg = pAutoCorrect->GetQuote('\'', true, eLang);
2072 break;
2073 case SGL_END:
2074 cDlg = cSglEndQuote;
2075 if(cDlg == 0)
2076 cDlg = pAutoCorrect->GetQuote('\'', false, eLang);
2077 break;
2078 case DBL_START:
2079 cDlg = cStartQuote;
2080 if(cDlg == 0)
2081 cDlg = pAutoCorrect->GetQuote('\"', true, eLang);
2082 break;
2083 case DBL_END:
2084 cDlg = cEndQuote;
2085 if(cDlg == 0)
2086 cDlg = pAutoCorrect->GetQuote('\"', false, eLang);
2087 break;
2088 default:
2089 OSL_FAIL("svx::OfaQuoteTabPage::QuoteHdl(), how to initialize cDlg?" );
2090 cDlg = 0;
2091 break;
2092
2093 }
2094 pMap->SetChar( cDlg );
2095 pMap->DisableFontSelection();
2096 if(pMap->Execute() == RET_OK)
2097 {
2098 sal_UCS4 cNewChar = pMap->GetChar();
2099 switch( nMode )
2100 {
2101 case SGL_START:
2102 cSglStartQuote = cNewChar;
2103 m_pSglStartExFT->SetText(ChangeStringExt_Impl(cNewChar));
2104 break;
2105 case SGL_END:
2106 cSglEndQuote = cNewChar;
2107 m_pSglEndExFT->SetText(ChangeStringExt_Impl(cNewChar));
2108 break;
2109 case DBL_START:
2110 cStartQuote = cNewChar;
2111 m_pDblStartExFT->SetText(ChangeStringExt_Impl(cNewChar));
2112 break;
2113 case DBL_END:
2114 cEndQuote = cNewChar;
2115 m_pDblEndExFT->SetText(ChangeStringExt_Impl(cNewChar));
2116 break;
2117 }
2118 }
2119
2120 return 0;
2121 }
2122
2123 IMPL_LINK( OfaQuoteTabPage, StdQuoteHdl, PushButton*, pBtn )
2124 {
2125 if (pBtn == m_pDblStandardPB)
2126 {
2127 cStartQuote = 0;
2128 m_pDblStartExFT->SetText(ChangeStringExt_Impl(0));
2129 cEndQuote = 0;
2130 m_pDblEndExFT->SetText(ChangeStringExt_Impl(0));
2131
2132 }
2133 else
2134 {
2135 cSglStartQuote = 0;
2136 m_pSglStartExFT->SetText(ChangeStringExt_Impl(0));
2137 cSglEndQuote = 0;
2138 m_pSglEndExFT->SetText(ChangeStringExt_Impl(0));
2139 }
2140 return 0;
2141 }
2142
2143
2144
2145 OUString OfaQuoteTabPage::ChangeStringExt_Impl( sal_UCS4 cChar )
2146 {
2147 if (!cChar)
2148 return m_sStandard;
2149
2150 // convert codepoint value to unicode-hex string
2151 sal_UCS4 aStrCodes[32] = { 0, ' ', '(', 'U', '+', '0' };
2152 aStrCodes[0] = cChar;
2153 int nFullLen = 5;
2154 int nHexLen = 4;
2155 while( (cChar >> (4*nHexLen)) != 0 )
2156 ++nHexLen;
2157 for( int i = nHexLen; --i >= 0;)
2158 {
2159 sal_UCS4 cHexDigit = ((cChar >> (4*i)) & 0x0f) + '0';
2160 if( cHexDigit > '9' )
2161 cHexDigit += 'A' - ('9' + 1);
2162 aStrCodes[ nFullLen++ ] = cHexDigit;
2163 }
2164 aStrCodes[ nFullLen++ ] = ')';
2165 // using the new UCS4 constructor
2166 OUString aOUStr( aStrCodes, nFullLen );
2167 return aOUStr;
2168 }
2169
2170 OfaAutoCompleteTabPage::OfaAutoCompleteTabPage(vcl::Window* pParent,
2171 const SfxItemSet& rSet)
2172 : SfxTabPage(pParent, "WordCompletionPage",
2173 "cui/ui/wordcompletionpage.ui", &rSet)
2174 , m_pAutoCompleteList(0)
2175 , m_nAutoCmpltListCnt(0)
2176 {
2177 get(m_pCBActiv, "enablewordcomplete");
2178 get(m_pCBAppendSpace, "appendspace");
2179 get(m_pCBAsTip, "showastip");
2180 get(m_pCBCollect, "collectwords");
2181 get(m_pCBRemoveList, "whenclosing");
2182
2183 //fdo#65595, we need height-for-width support here, but for now we can
2184 //bodge it
2185 Size aPrefSize(m_pCBRemoveList->get_preferred_size());
2186 Size aSize(m_pCBRemoveList->CalcMinimumSize(32*approximate_char_width()));
2187 if (aPrefSize.Width() > aSize.Width())
2188 {
2189 m_pCBRemoveList->set_width_request(aSize.Width());
2190 m_pCBRemoveList->set_height_request(aSize.Height());
2191 }
2192
2193 get(m_pDCBExpandKey, "acceptwith");
2194 get(m_pNFMinWordlen, "minwordlen");
2195 get(m_pNFMaxEntries, "maxentries");
2196 get(m_pLBEntries, "entries");
2197 m_pLBEntries->SetPage(this);
2198 aSize = LogicToPixel(Size(121, 158), MAP_APPFONT);
2199 m_pLBEntries->set_width_request(aSize.Width());
2200 m_pLBEntries->set_height_request(aSize.Height());
2201 get(m_pPBEntries, "delete");
2202
2203 // the defined KEYs
2204 static const sal_uInt16 aKeyCodes[] = {
2205 KEY_END,
2206 KEY_RETURN,
2207 KEY_SPACE,
2208 KEY_RIGHT,
2209 KEY_TAB,
2210 0
2211 };
2212
2213 for( const sal_uInt16* pKeys = aKeyCodes; *pKeys; ++pKeys )
2214 {
2215 vcl::KeyCode aKCode( *pKeys );
2216 sal_Int32 nPos = m_pDCBExpandKey->InsertEntry( aKCode.GetName() );
2217 m_pDCBExpandKey->SetEntryData( nPos, reinterpret_cast<void*>(*pKeys) );
2218 if( KEY_RETURN == *pKeys ) // default to RETURN
2219 m_pDCBExpandKey->SelectEntryPos( nPos );
2220 }
2221
2222 m_pPBEntries->SetClickHdl(LINK(this, OfaAutoCompleteTabPage, DeleteHdl));
2223 m_pCBActiv->SetToggleHdl(LINK(this, OfaAutoCompleteTabPage, CheckHdl));
2224 m_pCBCollect->SetToggleHdl(LINK(this, OfaAutoCompleteTabPage, CheckHdl));
2225 }
2226
2227 OfaAutoCompleteTabPage::~OfaAutoCompleteTabPage()
2228 {
2229 disposeOnce();
2230 }
2231
2232 void OfaAutoCompleteTabPage::dispose()
2233 {
2234 m_pCBActiv.clear();
2235 m_pCBAppendSpace.clear();
2236 m_pCBAsTip.clear();
2237 m_pCBCollect.clear();
2238 m_pCBRemoveList.clear();
2239 m_pDCBExpandKey.clear();
2240 m_pNFMinWordlen.clear();
2241 m_pNFMaxEntries.clear();
2242 m_pLBEntries.clear();
2243 m_pPBEntries.clear();
2244 SfxTabPage::dispose();
2245 }
2246
2247 VclPtr<SfxTabPage> OfaAutoCompleteTabPage::Create( vcl::Window* pParent,
2248 const SfxItemSet* rSet)
2249 {
2250 return VclPtr<SfxTabPage>( new OfaAutoCompleteTabPage( pParent, *rSet ), SAL_NO_ACQUIRE );
2251 }
2252
2253 bool OfaAutoCompleteTabPage::FillItemSet( SfxItemSet* )
2254 {
2255 bool bModified = false, bCheck;
2256 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
2257 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
2258 sal_uInt16 nVal;
2259
2260 bCheck = m_pCBActiv->IsChecked();
2261 bModified |= pOpt->bAutoCompleteWords != bCheck;
2262 pOpt->bAutoCompleteWords = bCheck;
2263 bCheck = m_pCBCollect->IsChecked();
2264 bModified |= pOpt->bAutoCmpltCollectWords != bCheck;
2265 pOpt->bAutoCmpltCollectWords = bCheck;
2266 bCheck = !m_pCBRemoveList->IsChecked(); // inverted value!
2267 bModified |= pOpt->bAutoCmpltKeepList != bCheck;
2268 pOpt->bAutoCmpltKeepList = bCheck;
2269 bCheck = m_pCBAppendSpace->IsChecked();
2270 bModified |= pOpt->bAutoCmpltAppendBlanc != bCheck;
2271 pOpt->bAutoCmpltAppendBlanc = bCheck;
2272 bCheck = m_pCBAsTip->IsChecked();
2273 bModified |= pOpt->bAutoCmpltShowAsTip != bCheck;
2274 pOpt->bAutoCmpltShowAsTip = bCheck;
2275
2276 nVal = (sal_uInt16)m_pNFMinWordlen->GetValue();
2277 bModified |= nVal != pOpt->nAutoCmpltWordLen;
2278 pOpt->nAutoCmpltWordLen = nVal;
2279
2280 nVal = (sal_uInt16)m_pNFMaxEntries->GetValue();
2281 bModified |= nVal != pOpt->nAutoCmpltListLen;
2282 pOpt->nAutoCmpltListLen = nVal;
2283
2284 nVal = m_pDCBExpandKey->GetSelectEntryPos();
2285 if( nVal < m_pDCBExpandKey->GetEntryCount() )
2286 {
2287 sal_uLong nKey = reinterpret_cast<sal_uLong>(m_pDCBExpandKey->GetEntryData( nVal ));
2288 bModified |= nKey != pOpt->nAutoCmpltExpandKey;
2289 pOpt->nAutoCmpltExpandKey = (sal_uInt16)nKey;
2290 }
2291
2292 if (m_pAutoCompleteList && m_nAutoCmpltListCnt != m_pLBEntries->GetEntryCount())
2293 {
2294 bModified = true;
2295 pOpt->m_pAutoCompleteList = m_pAutoCompleteList;
2296 }
2297 if( bModified )
2298 {
2299 SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get();
2300 rCfg.SetModified();
2301 rCfg.Commit();
2302 }
2303 return true;
2304 }
2305
2306 void OfaAutoCompleteTabPage::Reset( const SfxItemSet* )
2307 {
2308 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
2309 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
2310
2311 m_pCBActiv->Check( pOpt->bAutoCompleteWords );
2312 m_pCBCollect->Check( pOpt->bAutoCmpltCollectWords );
2313 m_pCBRemoveList->Check( !pOpt->bAutoCmpltKeepList ); //inverted value!
2314 m_pCBAppendSpace->Check( pOpt->bAutoCmpltAppendBlanc );
2315 m_pCBAsTip->Check( pOpt->bAutoCmpltShowAsTip );
2316
2317 m_pNFMinWordlen->SetValue( pOpt->nAutoCmpltWordLen );
2318 m_pNFMaxEntries->SetValue( pOpt->nAutoCmpltListLen );
2319
2320 // select the specific KeyCode:
2321 {
2322 sal_uLong nKey = pOpt->nAutoCmpltExpandKey;
2323 for( sal_Int32 n = 0, nCnt = m_pDCBExpandKey->GetEntryCount(); n < nCnt; ++n )
2324 if( nKey == reinterpret_cast<sal_uLong>(m_pDCBExpandKey->GetEntryData( n )))
2325 {
2326 m_pDCBExpandKey->SelectEntryPos( n );
2327 break;
2328 }
2329 }
2330
2331 if (pOpt->m_pAutoCompleteList && pOpt->m_pAutoCompleteList->size())
2332 {
2333 m_pAutoCompleteList = const_cast<editeng::SortedAutoCompleteStrings*>(
2334 pOpt->m_pAutoCompleteList);
2335 pOpt->m_pAutoCompleteList = 0;
2336 m_nAutoCmpltListCnt = m_pAutoCompleteList->size();
2337 for (size_t n = 0; n < m_nAutoCmpltListCnt; ++n)
2338 {
2339 const OUString* pStr =
2340 &(*m_pAutoCompleteList)[n]->GetAutoCompleteString();
2341 sal_Int32 nPos = m_pLBEntries->InsertEntry( *pStr );
2342 m_pLBEntries->SetEntryData( nPos, (void*)pStr );
2343 }
2344 }
2345 else
2346 {
2347 m_pLBEntries->Disable();
2348 m_pPBEntries->Disable();
2349 }
2350
2351 CheckHdl(m_pCBActiv);
2352 CheckHdl(m_pCBCollect);
2353 }
2354
2355 void OfaAutoCompleteTabPage::ActivatePage( const SfxItemSet& )
2356 {
2357 static_cast<OfaAutoCorrDlg*>(GetTabDialog())->EnableLanguage( false );
2358 }
2359
2360 IMPL_LINK_NOARG(OfaAutoCompleteTabPage, DeleteHdl)
2361 {
2362 sal_Int32 nSelCnt =
2363 (m_pAutoCompleteList) ? m_pLBEntries->GetSelectEntryCount() : 0;
2364 while( nSelCnt )
2365 {
2366 sal_Int32 nPos = m_pLBEntries->GetSelectEntryPos( --nSelCnt );
2367 OUString* pStr = static_cast<OUString*>(m_pLBEntries->GetEntryData(nPos));
2368 m_pLBEntries->RemoveEntry( nPos );
2369 editeng::IAutoCompleteString hack(*pStr); // UGLY
2370 m_pAutoCompleteList->erase(&hack);
2371 }
2372 return 0;
2373 }
2374
2375 IMPL_LINK( OfaAutoCompleteTabPage, CheckHdl, CheckBox*, pBox )
2376 {
2377 bool bEnable = pBox->IsChecked();
2378 if (pBox == m_pCBActiv)
2379 {
2380 m_pCBAppendSpace->Enable( bEnable );
2381 m_pCBAppendSpace->Enable( bEnable );
2382 m_pCBAsTip->Enable( bEnable );
2383 m_pDCBExpandKey->Enable( bEnable );
2384 }
2385 else if (m_pCBCollect == pBox)
2386 m_pCBRemoveList->Enable( bEnable );
2387 return 0;
2388 }
2389
2390 void OfaAutoCompleteTabPage::CopyToClipboard() const
2391 {
2392 sal_Int32 nSelCnt = m_pLBEntries->GetSelectEntryCount();
2393 if (m_pAutoCompleteList && nSelCnt)
2394 {
2395 TransferDataContainer* pCntnr = new TransferDataContainer;
2396 ::com::sun::star::uno::Reference<
2397 ::com::sun::star::datatransfer::XTransferable > xRef( pCntnr );
2398
2399 OStringBuffer sData;
2400 const sal_Char aLineEnd[] =
2401 #if defined(WNT)
2402 "\015\012";
2403 #else
2404 "\012";
2405 #endif
2406
2407 rtl_TextEncoding nEncode = osl_getThreadTextEncoding();
2408
2409 for( sal_Int32 n = 0; n < nSelCnt; ++n )
2410 {
2411 sData.append(OUStringToOString(m_pLBEntries->GetSelectEntry(n),
2412 nEncode));
2413 sData.append(aLineEnd);
2414 }
2415 pCntnr->CopyByteString( SotClipboardFormatId::STRING, sData.makeStringAndClear() );
2416 pCntnr->CopyToClipboard( (vcl::Window*)this );
2417 }
2418 }
2419
2420 OfaAutoCompleteTabPage::AutoCompleteMultiListBox::~AutoCompleteMultiListBox()
2421 {
2422 disposeOnce();
2423 }
2424
2425 void OfaAutoCompleteTabPage::AutoCompleteMultiListBox::dispose()
2426 {
2427 m_pPage.clear();
2428 MultiListBox::dispose();
2429 }
2430
2431 bool OfaAutoCompleteTabPage::AutoCompleteMultiListBox::PreNotify(
2432 NotifyEvent& rNEvt )
2433 {
2434 bool nHandled = MultiListBox::PreNotify( rNEvt );
2435
2436 if( !nHandled && MouseNotifyEvent::KEYUP == rNEvt.GetType() )
2437 {
2438 const vcl::KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode();
2439 switch( rKeyCode.GetModifier() | rKeyCode.GetCode() )
2440 {
2441 case KEY_DELETE:
2442 m_pPage->DeleteHdl( 0 );
2443 nHandled = true;
2444 break;
2445
2446 default:
2447 if( KeyFuncType::COPY == rKeyCode.GetFunction() )
2448 {
2449 m_pPage->CopyToClipboard();
2450 nHandled = true;
2451 }
2452 break;
2453 }
2454 }
2455 return nHandled;
2456 }
2457
2458 VCL_BUILDER_DECL_FACTORY(AutoCompleteMultiListBox)
2459 {
2460 WinBits nWinBits = WB_TABSTOP;
2461
2462 OString sBorder = VclBuilder::extractCustomProperty(rMap);
2463 if (!sBorder.isEmpty())
2464 nWinBits |= WB_BORDER;
2465
2466 rRet = VclPtr<OfaAutoCompleteTabPage::AutoCompleteMultiListBox>::Create(pParent, nWinBits);
2467 }
2468
2469 // class OfaSmartTagOptionsTabPage ---------------------------------------------
2470
2471 OfaSmartTagOptionsTabPage::OfaSmartTagOptionsTabPage( vcl::Window* pParent,
2472 const SfxItemSet& rSet )
2473 : SfxTabPage(pParent, "SmartTagOptionsPage", "cui/ui/smarttagoptionspage.ui", &rSet)
2474 {
2475 get(m_pMainCB, "main");
2476 get(m_pSmartTagTypesLB, "list");
2477 get(m_pPropertiesPB, "properties");
2478
2479 // some options for the list box:
2480 m_pSmartTagTypesLB->SetStyle( m_pSmartTagTypesLB->GetStyle() | WB_HSCROLL | WB_HIDESELECTION );
2481 m_pSmartTagTypesLB->SetHighlightRange();
2482 Size aControlSize(LogicToPixel(Size(172, 154), MAP_APPFONT));
2483 m_pSmartTagTypesLB->set_width_request(aControlSize.Width());
2484 m_pSmartTagTypesLB->set_height_request(aControlSize.Height());
2485
2486 // set the handlers:
2487 m_pMainCB->SetToggleHdl(LINK(this, OfaSmartTagOptionsTabPage, CheckHdl));
2488 m_pPropertiesPB->SetClickHdl(LINK(this, OfaSmartTagOptionsTabPage, ClickHdl));
2489 m_pSmartTagTypesLB->SetSelectHdl(LINK(this, OfaSmartTagOptionsTabPage, SelectHdl));
2490 }
2491
2492 OfaSmartTagOptionsTabPage::~OfaSmartTagOptionsTabPage()
2493 {
2494 disposeOnce();
2495 }
2496
2497 void OfaSmartTagOptionsTabPage::dispose()
2498 {
2499 m_pMainCB.clear();
2500 m_pSmartTagTypesLB.clear();
2501 m_pPropertiesPB.clear();
2502 SfxTabPage::dispose();
2503 }
2504
2505 VclPtr<SfxTabPage> OfaSmartTagOptionsTabPage::Create( vcl::Window* pParent, const SfxItemSet* rSet)
2506 {
2507 return VclPtr<OfaSmartTagOptionsTabPage>::Create( pParent, *rSet );
2508 }
2509
2510 /** This struct is used to associate list box entries with smart tag data
2511 */
2512 struct ImplSmartTagLBUserData
2513 {
2514 OUString maSmartTagType;
2515 uno::Reference< smarttags::XSmartTagRecognizer > mxRec;
2516 sal_Int32 mnSmartTagIdx;
2517
2518 ImplSmartTagLBUserData( const OUString& rSmartTagType,
2519 uno::Reference< smarttags::XSmartTagRecognizer > xRec,
2520 sal_Int32 nSmartTagIdx ) :
2521 maSmartTagType( rSmartTagType ),
2522 mxRec( xRec ),
2523 mnSmartTagIdx( nSmartTagIdx ) {}
2524 };
2525
2526 /** Clears m_pSmartTagTypesLB
2527 */
2528 void OfaSmartTagOptionsTabPage::ClearListBox()
2529 {
2530 const sal_uLong nCount = m_pSmartTagTypesLB->GetEntryCount();
2531 for ( sal_uLong i = 0; i < nCount; ++i )
2532 {
2533 const SvTreeListEntry* pEntry = m_pSmartTagTypesLB->GetEntry(i);
2534 const ImplSmartTagLBUserData* pUserData = static_cast< ImplSmartTagLBUserData* >(pEntry->GetUserData());
2535 delete pUserData;
2536 }
2537
2538 m_pSmartTagTypesLB->Clear();
2539 }
2540
2541 /** Inserts items into m_pSmartTagTypesLB
2542 */
2543 void OfaSmartTagOptionsTabPage::FillListBox( const SmartTagMgr& rSmartTagMgr )
2544 {
2545 // first we have to clear the list box:
2546 ClearListBox();
2547
2548 // fill list box:
2549 const sal_uInt32 nNumberOfRecognizers = rSmartTagMgr.NumberOfRecognizers();
2550 const lang::Locale aLocale( LanguageTag::convertToLocale( eLastDialogLanguage ) );
2551
2552 for ( sal_uInt32 i = 0; i < nNumberOfRecognizers; ++i )
2553 {
2554 uno::Reference< smarttags::XSmartTagRecognizer > xRec = rSmartTagMgr.GetRecognizer(i);
2555
2556 const OUString aName = xRec->getName( aLocale );
2557 const sal_Int32 nNumberOfSupportedSmartTags = xRec->getSmartTagCount();
2558
2559 for ( sal_Int32 j = 0; j < nNumberOfSupportedSmartTags; ++j )
2560 {
2561 const OUString aSmartTagType = xRec->getSmartTagName(j);
2562 OUString aSmartTagCaption = rSmartTagMgr.GetSmartTagCaption( aSmartTagType, aLocale );
2563
2564 if ( aSmartTagCaption.isEmpty() )
2565 aSmartTagCaption = aSmartTagType;
2566
2567 const OUString aLBEntry = aSmartTagCaption + " (" + aName + ")";
2568
2569 SvTreeListEntry* pEntry = m_pSmartTagTypesLB->SvTreeListBox::InsertEntry( aLBEntry );
2570 if ( pEntry )
2571 {
2572 const bool bCheck = rSmartTagMgr.IsSmartTagTypeEnabled( aSmartTagType );
2573 m_pSmartTagTypesLB->SetCheckButtonState( pEntry, bCheck ? SV_BUTTON_CHECKED : SV_BUTTON_UNCHECKED );
2574 pEntry->SetUserData(static_cast<void*>(new ImplSmartTagLBUserData( aSmartTagType, xRec, j ) ) );
2575 }
2576 }
2577 }
2578 }
2579
2580 /** Handler for the push button
2581 */
2582 IMPL_LINK_NOARG(OfaSmartTagOptionsTabPage, ClickHdl)
2583 {
2584 const sal_uLong nPos = m_pSmartTagTypesLB->GetSelectEntryPos();
2585 const SvTreeListEntry* pEntry = m_pSmartTagTypesLB->GetEntry(nPos);
2586 const ImplSmartTagLBUserData* pUserData = static_cast< ImplSmartTagLBUserData* >(pEntry->GetUserData());
2587 uno::Reference< smarttags::XSmartTagRecognizer > xRec = pUserData->mxRec;
2588 const sal_Int32 nSmartTagIdx = pUserData->mnSmartTagIdx;
2589
2590 const lang::Locale aLocale( LanguageTag::convertToLocale( eLastDialogLanguage ) );
2591 if ( xRec->hasPropertyPage( nSmartTagIdx, aLocale ) )
2592 xRec->displayPropertyPage( nSmartTagIdx, aLocale );
2593
2594 return 0;
2595 }
2596
2597 /** Handler for the check box
2598 */
2599 IMPL_LINK_NOARG(OfaSmartTagOptionsTabPage, CheckHdl)
2600 {
2601 const bool bEnable = m_pMainCB->IsChecked();
2602 m_pSmartTagTypesLB->Enable( bEnable );
2603 m_pSmartTagTypesLB->Invalidate();
2604 m_pPropertiesPB->Enable( false );
2605
2606 // if the controls are currently enabled, we still have to check
2607 // if the properties button should be disabled because the currently
2608 // seleted smart tag type does not have a properties dialog.
2609 // We do this by calling SelectHdl:
2610 if ( bEnable )
2611 SelectHdl(m_pSmartTagTypesLB);
2612
2613 return 0;
2614 }
2615
2616 /** Handler for the list box
2617 */
2618 IMPL_LINK_NOARG(OfaSmartTagOptionsTabPage, SelectHdl)
2619 {
2620 if ( m_pSmartTagTypesLB->GetEntryCount() < 1 )
2621 return 0;
2622
2623 const sal_uLong nPos = m_pSmartTagTypesLB->GetSelectEntryPos();
2624 const SvTreeListEntry* pEntry = m_pSmartTagTypesLB->GetEntry(nPos);
2625 const ImplSmartTagLBUserData* pUserData = static_cast< ImplSmartTagLBUserData* >(pEntry->GetUserData());
2626 uno::Reference< smarttags::XSmartTagRecognizer > xRec = pUserData->mxRec;
2627 const sal_Int32 nSmartTagIdx = pUserData->mnSmartTagIdx;
2628
2629 const lang::Locale aLocale( LanguageTag::convertToLocale( eLastDialogLanguage ) );
2630 if ( xRec->hasPropertyPage( nSmartTagIdx, aLocale ) )
2631 m_pPropertiesPB->Enable( true );
2632 else
2633 m_pPropertiesPB->Enable( false );
2634
2635 return 0;
2636 }
2637
2638 /** Propagates the current settings to the smart tag manager.
2639 */
2640 bool OfaSmartTagOptionsTabPage::FillItemSet( SfxItemSet* )
2641 {
2642 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
2643 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
2644 SmartTagMgr* pSmartTagMgr = pOpt->pSmartTagMgr;
2645
2646 // robust!
2647 if ( !pSmartTagMgr )
2648 return false;
2649
2650 bool bModifiedSmartTagTypes = false;
2651 std::vector< OUString > aDisabledSmartTagTypes;
2652
2653 const sal_uLong nCount = m_pSmartTagTypesLB->GetEntryCount();
2654
2655 for ( sal_uLong i = 0; i < nCount; ++i )
2656 {
2657 const SvTreeListEntry* pEntry = m_pSmartTagTypesLB->GetEntry(i);
2658 const ImplSmartTagLBUserData* pUserData = static_cast< ImplSmartTagLBUserData* >(pEntry->GetUserData());
2659 const bool bChecked = m_pSmartTagTypesLB->IsChecked(i);
2660 const bool bIsCurrentlyEnabled = pSmartTagMgr->IsSmartTagTypeEnabled( pUserData->maSmartTagType );
2661
2662 bModifiedSmartTagTypes = bModifiedSmartTagTypes || ( !bChecked != !bIsCurrentlyEnabled );
2663
2664 if ( !bChecked )
2665 aDisabledSmartTagTypes.push_back( pUserData->maSmartTagType );
2666
2667 delete pUserData;
2668 }
2669
2670 const bool bModifiedRecognize = ( !m_pMainCB->IsChecked() != !pSmartTagMgr->IsLabelTextWithSmartTags() );
2671 if ( bModifiedSmartTagTypes || bModifiedRecognize )
2672 {
2673 bool bLabelTextWithSmartTags = m_pMainCB->IsChecked();
2674 pSmartTagMgr->WriteConfiguration( bModifiedRecognize ? &bLabelTextWithSmartTags : 0,
2675 bModifiedSmartTagTypes ? &aDisabledSmartTagTypes : 0 );
2676 }
2677
2678 return true;
2679 }
2680
2681 /** Sets the controls based on the current settings at SmartTagMgr.
2682 */
2683 void OfaSmartTagOptionsTabPage::Reset( const SfxItemSet* )
2684 {
2685 SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect();
2686 SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags();
2687 const SmartTagMgr* pSmartTagMgr = pOpt->pSmartTagMgr;
2688
2689 // robust, should not happen!
2690 if ( !pSmartTagMgr )
2691 return;
2692
2693 FillListBox( *pSmartTagMgr );
2694 m_pSmartTagTypesLB->SelectEntryPos( 0 );
2695 m_pMainCB->Check( pSmartTagMgr->IsLabelTextWithSmartTags() );
2696 CheckHdl(m_pMainCB);
2697 }
2698
2699 void OfaSmartTagOptionsTabPage::ActivatePage( const SfxItemSet& )
2700 {
2701 static_cast<OfaAutoCorrDlg*>(GetTabDialog())->EnableLanguage( false );
2702 }
2703
2704 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE