Debian Codegraph @

svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.cxx

raw
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
21 #include "chinese_dictionarydialog.hxx"
22 #include <com/sun/star/i18n/TextConversionOption.hpp>
23 #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
24 #include <com/sun/star/linguistic2/ConversionPropertyType.hpp>
25 #include <com/sun/star/linguistic2/ConversionDictionaryList.hpp>
26 #include <com/sun/star/linguistic2/XConversionPropertyType.hpp>
27 #include <com/sun/star/util/XFlushable.hpp>
28 #include <com/sun/star/lang/Locale.hpp>
29 #include <comphelper/processfactory.hxx>
30 #include <o3tl/safeint.hxx>
31 #include <unotools/lingucfg.hxx>
32 #include <unotools/linguprops.hxx>
33 #include <utility>
34 #include <osl/diagnose.h>
35
36 namespace textconversiondlgs
37 {
38
39 using namespace ::com::sun::star;
40 using namespace ::com::sun::star::uno;
41
42 DictionaryList::DictionaryList(std::unique_ptr<weld::TreeView> xControl)
43 : m_xControl(std::move(xControl))
44 , m_xIter(m_xControl->make_iterator())
45 , m_pED_Term(nullptr)
46 , m_pED_Mapping(nullptr)
47 , m_pLB_Property(nullptr)
48 {
49 m_xControl->make_sorted();
50 }
51
52 OUString DictionaryList::getPropertyTypeName( sal_Int16 nConversionPropertyType ) const
53 {
54 if (!m_pLB_Property || !m_pLB_Property->get_count())
55 return OUString();
56
57 sal_uInt16 nPos = static_cast<sal_uInt16>( nConversionPropertyType )-1;
58 if (nPos < m_pLB_Property->get_count())
59 return m_pLB_Property->get_text(nPos);
60 return m_pLB_Property->get_text(0);
61 }
62
63 void DictionaryList::save()
64 {
65 if (!m_xDictionary.is())
66 return;
67
68 Reference< linguistic2::XConversionPropertyType > xPropertyType( m_xDictionary, uno::UNO_QUERY );
69
70 sal_Int32 nN;
71 DictionaryEntry* pE;
72
73 for( nN = m_aToBeDeleted.size(); nN--; )
74 {
75 pE = m_aToBeDeleted[nN];
76 m_xDictionary->removeEntry( pE->m_aTerm, pE->m_aMapping );
77 }
78 int nRowCount = m_xControl->n_children();
79 for( nN = nRowCount; nN--; )
80 {
81 pE = getEntryOnPos( nN );
82 if(pE->m_bNewEntry)
83 {
84 try
85 {
86 m_xDictionary->addEntry( pE->m_aTerm, pE->m_aMapping );
87 xPropertyType->setPropertyType( pE->m_aTerm, pE->m_aMapping, pE->m_nConversionPropertyType );
88 }
89 catch( uno::Exception& )
90 {
91
92 }
93 }
94 }
95 Reference< util::XFlushable > xFlush( m_xDictionary, uno::UNO_QUERY );
96 if( xFlush.is() )
97 xFlush->flush();
98 }
99
100 void DictionaryList::deleteAll()
101 {
102 sal_Int32 nN;
103 int nRowCount = m_xControl->n_children();
104 for( nN = nRowCount; nN--; )
105 deleteEntryOnPos( nN );
106 for( nN = m_aToBeDeleted.size(); nN--; )
107 {
108 DictionaryEntry* pE = m_aToBeDeleted[nN];
109 delete pE;
110 }
111 m_aToBeDeleted.clear();
112 }
113
114 void DictionaryList::refillFromDictionary( sal_Int32 nTextConversionOptions )
115 {
116 deleteAll();
117
118 if(!m_xDictionary.is())
119 return;
120
121 const Sequence< OUString > aLeftList( m_xDictionary->getConversionEntries( linguistic2::ConversionDirection_FROM_LEFT ) );
122
123 Reference< linguistic2::XConversionPropertyType > xPropertyType( m_xDictionary, uno::UNO_QUERY );
124
125 OUString aRight;
126 sal_Int16 nConversionPropertyType;
127
128 for(const OUString& aLeft : aLeftList)
129 {
130 Sequence< OUString > aRightList( m_xDictionary->getConversions(
131 aLeft, 0, aLeft.getLength()
132 , linguistic2::ConversionDirection_FROM_LEFT, nTextConversionOptions ) );
133
134 if(aRightList.getLength()!=1)
135 {
136 OSL_FAIL("The Chinese Translation Dictionary should have exactly one Mapping for each term.");
137 continue;
138 }
139
140 aRight = aRightList[0];
141 nConversionPropertyType = linguistic2::ConversionPropertyType::OTHER;
142 if(xPropertyType.is())
143 nConversionPropertyType = xPropertyType->getPropertyType(aLeft, aRight);
144
145 DictionaryEntry* pEntry = new DictionaryEntry( aLeft, aRight, nConversionPropertyType );
146
147 m_xControl->append(m_xIter.get());
148 m_xControl->set_text(*m_xIter, pEntry->m_aTerm, 0);
149 m_xControl->set_text(*m_xIter, pEntry->m_aMapping, 1);
150 m_xControl->set_text(*m_xIter, getPropertyTypeName(pEntry->m_nConversionPropertyType), 2);
151 m_xControl->set_id(*m_xIter, weld::toId(pEntry));
152 }
153 }
154
155 DictionaryEntry* DictionaryList::getFirstSelectedEntry() const
156 {
157 DictionaryEntry* pRet=nullptr;
158 int nN = m_xControl->get_selected_index();
159 if (nN != -1)
160 pRet = getEntryOnPos( nN );
161 return pRet;
162 }
163
164 DictionaryEntry* DictionaryList::getEntryOnPos(sal_Int32 nPos) const
165 {
166 OUString sLBEntry = m_xControl->get_id(nPos);
167 return weld::fromId<DictionaryEntry*>(sLBEntry);
168 }
169
170 DictionaryEntry* DictionaryList::getTermEntry( std::u16string_view rTerm ) const
171 {
172 int nRowCount = m_xControl->n_children();
173 for( sal_Int32 nN = nRowCount; nN--; )
174 {
175 DictionaryEntry* pE = getEntryOnPos( nN );
176 if( pE && rTerm == pE->m_aTerm )
177 return pE;
178 }
179 return nullptr;
180 }
181
182 bool DictionaryList::hasTerm( std::u16string_view rTerm ) const
183 {
184 return getTermEntry(rTerm) !=nullptr ;
185 }
186
187 void DictionaryList::addEntry(const OUString& rTerm, const OUString& rMapping,
188 sal_Int16 nConversionPropertyType, int nPos)
189 {
190 if( hasTerm( rTerm ) )
191 return;
192
193 DictionaryEntry* pEntry = new DictionaryEntry( rTerm, rMapping, nConversionPropertyType, true );
194 m_xControl->insert(nPos, m_xIter.get());
195 m_xControl->set_text(*m_xIter, pEntry->m_aTerm, 0);
196 m_xControl->set_text(*m_xIter, pEntry->m_aMapping, 1);
197 m_xControl->set_text(*m_xIter, getPropertyTypeName(pEntry->m_nConversionPropertyType), 2);
198 m_xControl->set_id(*m_xIter, weld::toId(pEntry));
199 m_xControl->select(*m_xIter);
200 }
201
202 void DictionaryList::deleteEntryOnPos( sal_Int32 nPos )
203 {
204 DictionaryEntry* pEntry = getEntryOnPos( nPos );
205 m_xControl->remove(nPos);
206 if (pEntry)
207 {
208 if( pEntry->m_bNewEntry )
209 delete pEntry;
210 else
211 m_aToBeDeleted.push_back( pEntry );
212 }
213 }
214
215 int DictionaryList::deleteEntries( std::u16string_view rTerm )
216 {
217 int nPos = -1;
218 int nRowCount = m_xControl->n_children();
219 for (sal_Int32 nN = nRowCount; nN--;)
220 {
221 DictionaryEntry* pCurEntry = getEntryOnPos( nN );
222 if( rTerm == pCurEntry->m_aTerm )
223 {
224 nPos = nN;
225 m_xControl->remove(nN);
226 if( pCurEntry->m_bNewEntry )
227 delete pCurEntry;
228 else
229 m_aToBeDeleted.push_back( pCurEntry );
230 }
231 }
232 return nPos;
233 }
234
235 DictionaryEntry::DictionaryEntry( OUString aTerm, OUString aMapping
236 , sal_Int16 nConversionPropertyType
237 , bool bNewEntry )
238 : m_aTerm(std::move( aTerm ))
239 , m_aMapping(std::move( aMapping ))
240 , m_nConversionPropertyType( nConversionPropertyType )
241 , m_bNewEntry( bNewEntry )
242 {
243 if( m_nConversionPropertyType == 0 )
244 m_nConversionPropertyType = 1;
245 }
246
247 DictionaryEntry::~DictionaryEntry()
248 {
249 }
250
251 IMPL_LINK_NOARG(ChineseDictionaryDialog, SizeAllocHdl, const Size&, void)
252 {
253 DictionaryList* pControl = m_xCT_DictionaryToTraditional->get_visible() ?
254 m_xCT_DictionaryToTraditional.get() :
255 m_xCT_DictionaryToSimplified.get();
256 std::vector<int> aWidths;
257 int x1, x2, y, width, height;
258 if (!m_xED_Mapping->get_extents_relative_to(pControl->get_widget(), x1, y, width, height))
259 return;
260 aWidths.push_back(x1);
261 if (!m_xLB_Property->get_extents_relative_to(pControl->get_widget(), x2, y, width, height))
262 return;
263 aWidths.push_back(x2 - x1);
264 m_xCT_DictionaryToTraditional->get_widget().set_column_fixed_widths(aWidths);
265 m_xCT_DictionaryToSimplified->get_widget().set_column_fixed_widths(aWidths);
266 }
267
268 void DictionaryList::init(const Reference< linguistic2::XConversionDictionary>& xDictionary,
269 weld::Entry *pED_Term, weld::Entry *pED_Mapping, weld::ComboBox *pLB_Property)
270 {
271 if (m_xDictionary.is())
272 return;
273
274 m_xDictionary = xDictionary;
275
276 m_pED_Term = pED_Term;
277 m_pED_Mapping = pED_Mapping;
278 m_pLB_Property = pLB_Property;
279
280 m_xControl->set_sort_column(0);
281 m_xControl->set_sort_indicator(TRISTATE_TRUE, 0);
282
283 std::vector<int> aWidths
284 {
285 o3tl::narrowing<int>(m_pED_Term->get_preferred_size().Width()),
286 o3tl::narrowing<int>(m_pED_Mapping->get_preferred_size().Width())
287 };
288 m_xControl->set_column_fixed_widths(aWidths);
289 }
290
291 void ChineseDictionaryDialog::initDictionaryControl(DictionaryList *pList,
292 const Reference< linguistic2::XConversionDictionary>& xDictionary)
293 {
294 //set widgets to track the width of for columns
295 pList->init(xDictionary,
296 m_xED_Term.get(), m_xED_Mapping.get(), m_xLB_Property.get());
297 }
298
299 ChineseDictionaryDialog::ChineseDictionaryDialog(weld::Window* pParent)
300 : GenericDialogController(pParent, u"svx/ui/chinesedictionary.ui"_ustr, u"ChineseDictionaryDialog"_ustr)
301 , m_nTextConversionOptions(i18n::TextConversionOption::NONE)
302 , m_xRB_To_Simplified(m_xBuilder->weld_radio_button(u"tradtosimple"_ustr))
303 , m_xRB_To_Traditional(m_xBuilder->weld_radio_button(u"simpletotrad"_ustr))
304 , m_xCB_Reverse(m_xBuilder->weld_check_button(u"reverse"_ustr))
305 , m_xED_Term(m_xBuilder->weld_entry(u"term"_ustr))
306 , m_xED_Mapping(m_xBuilder->weld_entry(u"mapping"_ustr))
307 , m_xLB_Property(m_xBuilder->weld_combo_box(u"property"_ustr))
308 , m_xCT_DictionaryToSimplified(new DictionaryList(m_xBuilder->weld_tree_view(u"tradtosimpleview"_ustr)))
309 , m_xCT_DictionaryToTraditional(new DictionaryList(m_xBuilder->weld_tree_view(u"simpletotradview"_ustr)))
310 , m_xPB_Add(m_xBuilder->weld_button(u"add"_ustr))
311 , m_xPB_Modify(m_xBuilder->weld_button(u"modify"_ustr))
312 , m_xPB_Delete(m_xBuilder->weld_button(u"delete"_ustr))
313 {
314 m_xCT_DictionaryToSimplified->set_size_request(-1, m_xCT_DictionaryToSimplified->get_height_rows(8));
315 m_xCT_DictionaryToTraditional->set_size_request(-1, m_xCT_DictionaryToTraditional->get_height_rows(8));
316
317 SvtLinguConfig aLngCfg;
318 bool bValue;
319 Any aAny( aLngCfg.GetProperty( UPN_IS_REVERSE_MAPPING ) );
320 if( aAny >>= bValue )
321 m_xCB_Reverse->set_active( bValue );
322
323 m_xLB_Property->set_active(0);
324
325 Reference< linguistic2::XConversionDictionary > xDictionary_To_Simplified;
326 Reference< linguistic2::XConversionDictionary > xDictionary_To_Traditional;
327 //get dictionaries
328 {
329 css::uno::Reference<css::uno::XComponentContext> xContext = ::comphelper::getProcessComponentContext();
330 if (xContext.is())
331 {
332 Reference< linguistic2::XConversionDictionaryList > xDictionaryList = linguistic2::ConversionDictionaryList::create(xContext);
333 Reference< container::XNameContainer > xContainer( xDictionaryList->getDictionaryContainer() );
334 if(xContainer.is())
335 {
336 try
337 {
338 OUString aNameTo_Simplified(u"ChineseT2S"_ustr);
339 OUString aNameTo_Traditional(u"ChineseS2T"_ustr);
340 lang::Locale aLocale;
341 aLocale.Language = "zh";
342
343 if( xContainer->hasByName( aNameTo_Simplified ) )
344 xDictionary_To_Simplified.set(
345 xContainer->getByName( aNameTo_Simplified ), UNO_QUERY );
346 else
347 {
348 aLocale.Country = "TW";
349 xDictionary_To_Simplified =
350 xDictionaryList->addNewDictionary( aNameTo_Simplified
351 , aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE
352 );
353 }
354 if (xDictionary_To_Simplified.is())
355 xDictionary_To_Simplified->setActive( true );
356
357
358 if( xContainer->hasByName( aNameTo_Traditional ) )
359 xDictionary_To_Traditional.set(
360 xContainer->getByName( aNameTo_Traditional ), UNO_QUERY );
361 else
362 {
363 aLocale.Country = "CN";
364 xDictionary_To_Traditional =
365 xDictionaryList->addNewDictionary( aNameTo_Traditional
366 ,aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE);
367 }
368 if (xDictionary_To_Traditional.is())
369 xDictionary_To_Traditional->setActive( true );
370
371 }
372 catch(const uno::Exception& )
373 {
374 }
375 }
376 }
377 }
378
379 //init dictionary controls
380 initDictionaryControl(m_xCT_DictionaryToSimplified.get(), xDictionary_To_Simplified);
381 initDictionaryControl(m_xCT_DictionaryToTraditional.get(), xDictionary_To_Traditional);
382
383 //set hdl
384 m_xCT_DictionaryToSimplified->connect_column_clicked(LINK(this, ChineseDictionaryDialog, ToSimplifiedHeaderBarClick));
385 m_xCT_DictionaryToTraditional->connect_column_clicked(LINK(this, ChineseDictionaryDialog, ToTraditionalHeaderBarClick));
386
387 updateAfterDirectionChange();
388
389 m_xED_Term->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) );
390 m_xED_Mapping->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) );
391 m_xLB_Property->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsListBoxHdl ) );
392
393 m_xRB_To_Simplified->connect_toggled( LINK( this, ChineseDictionaryDialog, DirectionHdl ) );
394
395 m_xCT_DictionaryToSimplified->connect_changed( LINK( this, ChineseDictionaryDialog, MappingSelectHdl ));
396 m_xCT_DictionaryToTraditional->connect_changed( LINK( this, ChineseDictionaryDialog, MappingSelectHdl ));
397
398 m_xPB_Add->connect_clicked( LINK( this, ChineseDictionaryDialog, AddHdl ) );
399 m_xPB_Modify->connect_clicked( LINK( this, ChineseDictionaryDialog, ModifyHdl ) );
400 m_xPB_Delete->connect_clicked( LINK( this, ChineseDictionaryDialog, DeleteHdl ) );
401
402 m_xED_Mapping->connect_size_allocate(LINK(this, ChineseDictionaryDialog, SizeAllocHdl));
403 m_xLB_Property->connect_size_allocate(LINK(this, ChineseDictionaryDialog, SizeAllocHdl));
404 }
405
406 ChineseDictionaryDialog::~ChineseDictionaryDialog()
407 {
408 }
409
410 void ChineseDictionaryDialog::setDirectionAndTextConversionOptions( bool bDirectionToSimplified, sal_Int32 nTextConversionOptions /*i18n::TextConversionOption*/ )
411 {
412 if( bDirectionToSimplified == m_xRB_To_Simplified->get_active()
413 && nTextConversionOptions == m_nTextConversionOptions )
414 return;
415
416 m_nTextConversionOptions = nTextConversionOptions;
417
418 if (bDirectionToSimplified)
419 m_xRB_To_Simplified->set_active(true);
420 else
421 m_xRB_To_Traditional->set_active(true);
422 updateAfterDirectionChange();
423 }
424
425 IMPL_LINK_NOARG(ChineseDictionaryDialog, DirectionHdl, weld::Toggleable&, void)
426 {
427 updateAfterDirectionChange();
428 }
429
430 void ChineseDictionaryDialog::updateAfterDirectionChange()
431 {
432 Reference< linguistic2::XConversionDictionary > xDictionary;
433
434 if (m_xRB_To_Simplified->get_active())
435 {
436 m_xCT_DictionaryToTraditional->hide();
437 m_xCT_DictionaryToSimplified->show();
438 xDictionary = m_xCT_DictionaryToSimplified->m_xDictionary;
439 }
440 else
441 {
442 m_xCT_DictionaryToSimplified->hide();
443 m_xCT_DictionaryToTraditional->show();
444 xDictionary = m_xCT_DictionaryToTraditional->m_xDictionary;
445 }
446
447 updateButtons();
448 }
449
450 IMPL_LINK_NOARG(ChineseDictionaryDialog, EditFieldsListBoxHdl, weld::ComboBox&, void)
451 {
452 updateButtons();
453 }
454
455 IMPL_LINK_NOARG(ChineseDictionaryDialog, EditFieldsHdl, weld::Entry&, void)
456 {
457 updateButtons();
458 }
459
460 IMPL_LINK_NOARG(ChineseDictionaryDialog, MappingSelectHdl, weld::TreeView&, void)
461 {
462 DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry();
463 if (pE)
464 {
465 m_xED_Term->set_text( pE->m_aTerm );
466 m_xED_Mapping->set_text( pE->m_aMapping );
467 sal_Int16 nPos = pE->m_nConversionPropertyType-1;
468 if (nPos<0 || nPos>=m_xLB_Property->get_count())
469 nPos=0;
470 if (m_xLB_Property->get_count())
471 m_xLB_Property->set_active(nPos);
472 }
473
474 updateButtons();
475 }
476
477 bool ChineseDictionaryDialog::isEditFieldsHaveContent() const
478 {
479 return !m_xED_Term->get_text().isEmpty() && !m_xED_Mapping->get_text().isEmpty();
480 }
481
482 bool ChineseDictionaryDialog::isEditFieldsContentEqualsSelectedListContent() const
483 {
484 DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry();
485 if( pE )
486 {
487 if (pE->m_aTerm != m_xED_Term->get_text())
488 return false;
489 if (pE->m_aMapping != m_xED_Mapping->get_text())
490 return false;
491 if (pE->m_nConversionPropertyType != m_xLB_Property->get_active() + 1)
492 return false;
493 return true;
494 }
495 return false;
496 }
497
498 const DictionaryList& ChineseDictionaryDialog::getActiveDictionary() const
499 {
500 if( m_xRB_To_Traditional->get_active() )
501 return *m_xCT_DictionaryToTraditional;
502 return *m_xCT_DictionaryToSimplified;
503 }
504
505 DictionaryList& ChineseDictionaryDialog::getActiveDictionary()
506 {
507 if( m_xRB_To_Traditional->get_active() )
508 return *m_xCT_DictionaryToTraditional;
509 return *m_xCT_DictionaryToSimplified;
510 }
511
512 const DictionaryList& ChineseDictionaryDialog::getReverseDictionary() const
513 {
514 if( m_xRB_To_Traditional->get_active() )
515 return *m_xCT_DictionaryToSimplified;
516 return *m_xCT_DictionaryToTraditional;
517 }
518
519 DictionaryList& ChineseDictionaryDialog::getReverseDictionary()
520 {
521 if( m_xRB_To_Traditional->get_active() )
522 return *m_xCT_DictionaryToSimplified;
523 return *m_xCT_DictionaryToTraditional;
524 }
525
526 void ChineseDictionaryDialog::updateButtons()
527 {
528 bool bAdd = isEditFieldsHaveContent() && !getActiveDictionary().hasTerm(m_xED_Term->get_text());
529 m_xPB_Add->set_sensitive( bAdd );
530
531 m_xPB_Delete->set_sensitive(!bAdd && getActiveDictionary().get_selected_index() != -1);
532
533 bool bModify = false;
534 {
535 DictionaryEntry* pFirstSelectedEntry = getActiveDictionary().getFirstSelectedEntry();
536 bModify = !bAdd && pFirstSelectedEntry && pFirstSelectedEntry->m_aTerm == m_xED_Term->get_text();
537 if( bModify && isEditFieldsContentEqualsSelectedListContent() )
538 bModify = false;
539 }
540 m_xPB_Modify->set_sensitive( bModify );
541 }
542
543 IMPL_LINK_NOARG(ChineseDictionaryDialog, AddHdl, weld::Button&, void)
544 {
545 if( !isEditFieldsHaveContent() )
546 return;
547
548 sal_Int16 nConversionPropertyType = m_xLB_Property->get_active() + 1;
549
550 getActiveDictionary().addEntry( m_xED_Term->get_text(), m_xED_Mapping->get_text(), nConversionPropertyType );
551
552 if( m_xCB_Reverse->get_active() )
553 {
554 getReverseDictionary().deleteEntries( m_xED_Mapping->get_text() );
555 getReverseDictionary().addEntry( m_xED_Mapping->get_text(), m_xED_Term->get_text(), nConversionPropertyType );
556 }
557
558 updateButtons();
559 }
560
561 IMPL_LINK_NOARG(ChineseDictionaryDialog, ModifyHdl, weld::Button&, void)
562 {
563 OUString aTerm( m_xED_Term->get_text() );
564 OUString aMapping( m_xED_Mapping->get_text() );
565 sal_Int16 nConversionPropertyType = m_xLB_Property->get_active() + 1;
566
567 DictionaryList& rActive = getActiveDictionary();
568 DictionaryList& rReverse = getReverseDictionary();
569
570 DictionaryEntry* pE = rActive.getFirstSelectedEntry();
571 if( pE && pE->m_aTerm != aTerm )
572 return;
573
574 if( pE )
575 {
576 if( pE->m_aMapping != aMapping || pE->m_nConversionPropertyType != nConversionPropertyType )
577 {
578 if( m_xCB_Reverse->get_active() )
579 {
580 rReverse.deleteEntries( pE->m_aMapping );
581 int nPos = rReverse.deleteEntries( aMapping );
582 rReverse.addEntry( aMapping, aTerm, nConversionPropertyType, nPos );
583 }
584
585 int nPos = rActive.deleteEntries( aTerm );
586 rActive.addEntry( aTerm, aMapping, nConversionPropertyType, nPos );
587 }
588 }
589
590 updateButtons();
591 }
592
593 IMPL_LINK_NOARG(ChineseDictionaryDialog, DeleteHdl, weld::Button&, void)
594 {
595 DictionaryList& rActive = getActiveDictionary();
596 DictionaryList& rReverse = getReverseDictionary();
597
598 int nEntry = rActive.get_selected_index();
599 if (nEntry != -1)
600 {
601 DictionaryEntry* pEntry = rActive.getEntryOnPos(nEntry);
602 if (pEntry)
603 {
604 OUString aMapping = pEntry->m_aMapping;
605 rActive.deleteEntryOnPos(nEntry);
606 if (m_xCB_Reverse->get_active())
607 rReverse.deleteEntries(aMapping);
608 }
609 }
610
611 updateButtons();
612 }
613
614 short ChineseDictionaryDialog::run()
615 {
616 sal_Int32 nTextConversionOptions = m_nTextConversionOptions;
617 if(m_nTextConversionOptions & i18n::TextConversionOption::USE_CHARACTER_VARIANTS )
618 nTextConversionOptions = nTextConversionOptions^i18n::TextConversionOption::USE_CHARACTER_VARIANTS ;
619
620 m_xCT_DictionaryToSimplified->refillFromDictionary( nTextConversionOptions );
621 m_xCT_DictionaryToTraditional->refillFromDictionary( m_nTextConversionOptions );
622
623 short nRet = GenericDialogController::run();
624
625 if( nRet == RET_OK )
626 {
627 //save settings to configuration
628 SvtLinguConfig aLngCfg;
629 aLngCfg.SetProperty( UPN_IS_REVERSE_MAPPING, uno::Any(m_xCB_Reverse->get_active()) );
630
631 m_xCT_DictionaryToSimplified->save();
632 m_xCT_DictionaryToTraditional->save();
633 }
634
635 m_xCT_DictionaryToSimplified->deleteAll();
636 m_xCT_DictionaryToTraditional->deleteAll();
637
638 return nRet;
639 }
640
641 void ChineseDictionaryDialog::HeaderBarClick(DictionaryList& rList, int nColumn)
642 {
643 bool bSortAtoZ = rList.get_sort_order();
644
645 //set new arrow positions in headerbar
646 if (nColumn == rList.get_sort_column())
647 {
648 bSortAtoZ = !bSortAtoZ;
649 rList.set_sort_order(bSortAtoZ);
650 }
651 else
652 {
653 rList.set_sort_indicator(TRISTATE_INDET, rList.get_sort_column());
654 rList.set_sort_column(nColumn);
655 }
656
657 //sort lists
658 rList.set_sort_indicator(bSortAtoZ ? TRISTATE_TRUE : TRISTATE_FALSE, nColumn);
659 }
660
661 IMPL_LINK(ChineseDictionaryDialog, ToSimplifiedHeaderBarClick, int, nColumn, void)
662 {
663 HeaderBarClick(*m_xCT_DictionaryToSimplified, nColumn);
664 }
665
666 IMPL_LINK(ChineseDictionaryDialog, ToTraditionalHeaderBarClick, int, nColumn, void)
667 {
668 HeaderBarClick(*m_xCT_DictionaryToTraditional, nColumn);
669 }
670
671 } //end namespace
672
673 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */