svx/source/unodialogs/textconversiondlgs/chinese_dictionarydialog.cxx

   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 <cppuhelper/bootstrap.hxx>
  23 #include <com/sun/star/i18n/TextConversionOption.hpp>
  24 #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
  25 #include <com/sun/star/linguistic2/ConversionPropertyType.hpp>
  26 #include <com/sun/star/linguistic2/ConversionDictionaryList.hpp>
  27 #include <com/sun/star/linguistic2/XConversionPropertyType.hpp>
  28 #include <com/sun/star/util/XFlushable.hpp>
  29 #include <com/sun/star/lang/Locale.hpp>
  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         if(!m_xContext.is())
 330             m_xContext.set( ::cppu::defaultBootstrap_InitialComponentContext() );
 331         if(m_xContext.is())
 332         {
 333             Reference< linguistic2::XConversionDictionaryList > xDictionaryList = linguistic2::ConversionDictionaryList::create(m_xContext);
 334             Reference< container::XNameContainer > xContainer( xDictionaryList->getDictionaryContainer() );
 335             if(xContainer.is())
 336             {
 337                 try
 338                 {
 339                     OUString aNameTo_Simplified(u"ChineseT2S"_ustr);
 340                     OUString aNameTo_Traditional(u"ChineseS2T"_ustr);
 341                     lang::Locale aLocale;
 342                     aLocale.Language = "zh";
 343
 344                     if( xContainer->hasByName( aNameTo_Simplified ) )
 345                         xDictionary_To_Simplified.set(
 346                                 xContainer->getByName( aNameTo_Simplified ), UNO_QUERY );
 347                     else
 348                     {
 349                         aLocale.Country = "TW";
 350                         xDictionary_To_Simplified =
 351                                 xDictionaryList->addNewDictionary( aNameTo_Simplified
 352                                     , aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE
 353                                 );
 354                     }
 355                     if (xDictionary_To_Simplified.is())
 356                         xDictionary_To_Simplified->setActive( true );
 357
 358
 359                     if( xContainer->hasByName( aNameTo_Traditional ) )
 360                         xDictionary_To_Traditional.set(
 361                                 xContainer->getByName( aNameTo_Traditional ), UNO_QUERY );
 362                     else
 363                     {
 364                         aLocale.Country = "CN";
 365                         xDictionary_To_Traditional =
 366                                 xDictionaryList->addNewDictionary( aNameTo_Traditional
 367                                     ,aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE);
 368                     }
 369                     if (xDictionary_To_Traditional.is())
 370                         xDictionary_To_Traditional->setActive( true );
 371
 372                 }
 373                 catch(const uno::Exception& )
 374                 {
 375                 }
 376             }
 377         }
 378     }
 379
 380     //init dictionary controls
 381     initDictionaryControl(m_xCT_DictionaryToSimplified.get(), xDictionary_To_Simplified);
 382     initDictionaryControl(m_xCT_DictionaryToTraditional.get(), xDictionary_To_Traditional);
 383
 384     //set hdl
 385     m_xCT_DictionaryToSimplified->connect_column_clicked(LINK(this, ChineseDictionaryDialog, ToSimplifiedHeaderBarClick));
 386     m_xCT_DictionaryToTraditional->connect_column_clicked(LINK(this, ChineseDictionaryDialog, ToTraditionalHeaderBarClick));
 387
 388     updateAfterDirectionChange();
 389
 390     m_xED_Term->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) );
 391     m_xED_Mapping->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) );
 392     m_xLB_Property->connect_changed( LINK( this, ChineseDictionaryDialog, EditFieldsListBoxHdl ) );
 393
 394     m_xRB_To_Simplified->connect_toggled( LINK( this, ChineseDictionaryDialog, DirectionHdl ) );
 395
 396     m_xCT_DictionaryToSimplified->connect_changed( LINK( this, ChineseDictionaryDialog, MappingSelectHdl ));
 397     m_xCT_DictionaryToTraditional->connect_changed( LINK( this, ChineseDictionaryDialog, MappingSelectHdl ));
 398
 399     m_xPB_Add->connect_clicked( LINK( this, ChineseDictionaryDialog, AddHdl ) );
 400     m_xPB_Modify->connect_clicked( LINK( this, ChineseDictionaryDialog, ModifyHdl ) );
 401     m_xPB_Delete->connect_clicked( LINK( this, ChineseDictionaryDialog, DeleteHdl ) );
 402
 403     m_xED_Mapping->connect_size_allocate(LINK(this, ChineseDictionaryDialog, SizeAllocHdl));
 404     m_xLB_Property->connect_size_allocate(LINK(this, ChineseDictionaryDialog, SizeAllocHdl));
 405 }
 406
 407 ChineseDictionaryDialog::~ChineseDictionaryDialog()
 408 {
 409 }
 410
 411 void ChineseDictionaryDialog::setDirectionAndTextConversionOptions( bool bDirectionToSimplified, sal_Int32 nTextConversionOptions /*i18n::TextConversionOption*/ )
 412 {
 413     if( bDirectionToSimplified == m_xRB_To_Simplified->get_active()
 414         && nTextConversionOptions == m_nTextConversionOptions )
 415         return;
 416
 417     m_nTextConversionOptions = nTextConversionOptions;
 418
 419     if (bDirectionToSimplified)
 420         m_xRB_To_Simplified->set_active(true);
 421     else
 422         m_xRB_To_Traditional->set_active(true);
 423     updateAfterDirectionChange();
 424 }
 425
 426 IMPL_LINK_NOARG(ChineseDictionaryDialog, DirectionHdl, weld::Toggleable&, void)
 427 {
 428     updateAfterDirectionChange();
 429 }
 430
 431 void ChineseDictionaryDialog::updateAfterDirectionChange()
 432 {
 433     Reference< linguistic2::XConversionDictionary > xDictionary;
 434
 435     if (m_xRB_To_Simplified->get_active())
 436     {
 437         m_xCT_DictionaryToTraditional->hide();
 438         m_xCT_DictionaryToSimplified->show();
 439         xDictionary = m_xCT_DictionaryToSimplified->m_xDictionary;
 440     }
 441     else
 442     {
 443         m_xCT_DictionaryToSimplified->hide();
 444         m_xCT_DictionaryToTraditional->show();
 445         xDictionary = m_xCT_DictionaryToTraditional->m_xDictionary;
 446     }
 447
 448     updateButtons();
 449 }
 450
 451 IMPL_LINK_NOARG(ChineseDictionaryDialog, EditFieldsListBoxHdl, weld::ComboBox&, void)
 452 {
 453     updateButtons();
 454 }
 455
 456 IMPL_LINK_NOARG(ChineseDictionaryDialog, EditFieldsHdl, weld::Entry&, void)
 457 {
 458     updateButtons();
 459 }
 460
 461 IMPL_LINK_NOARG(ChineseDictionaryDialog, MappingSelectHdl, weld::TreeView&, void)
 462 {
 463     DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry();
 464     if (pE)
 465     {
 466         m_xED_Term->set_text( pE->m_aTerm );
 467         m_xED_Mapping->set_text( pE->m_aMapping );
 468         sal_Int16 nPos = pE->m_nConversionPropertyType-1;
 469         if (nPos<0 || nPos>=m_xLB_Property->get_count())
 470             nPos=0;
 471         if (m_xLB_Property->get_count())
 472             m_xLB_Property->set_active(nPos);
 473     }
 474
 475     updateButtons();
 476 }
 477
 478 bool ChineseDictionaryDialog::isEditFieldsHaveContent() const
 479 {
 480     return !m_xED_Term->get_text().isEmpty() && !m_xED_Mapping->get_text().isEmpty();
 481 }
 482
 483 bool ChineseDictionaryDialog::isEditFieldsContentEqualsSelectedListContent() const
 484 {
 485     DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry();
 486     if( pE )
 487     {
 488         if (pE->m_aTerm != m_xED_Term->get_text())
 489             return false;
 490         if (pE->m_aMapping != m_xED_Mapping->get_text())
 491             return false;
 492         if (pE->m_nConversionPropertyType != m_xLB_Property->get_active() + 1)
 493             return false;
 494         return true;
 495     }
 496     return false;
 497 }
 498
 499 const DictionaryList& ChineseDictionaryDialog::getActiveDictionary() const
 500 {
 501     if( m_xRB_To_Traditional->get_active() )
 502         return *m_xCT_DictionaryToTraditional;
 503     return *m_xCT_DictionaryToSimplified;
 504 }
 505
 506 DictionaryList& ChineseDictionaryDialog::getActiveDictionary()
 507 {
 508     if( m_xRB_To_Traditional->get_active() )
 509         return *m_xCT_DictionaryToTraditional;
 510     return *m_xCT_DictionaryToSimplified;
 511 }
 512
 513 const DictionaryList& ChineseDictionaryDialog::getReverseDictionary() const
 514 {
 515     if( m_xRB_To_Traditional->get_active() )
 516         return *m_xCT_DictionaryToSimplified;
 517     return *m_xCT_DictionaryToTraditional;
 518 }
 519
 520 DictionaryList& ChineseDictionaryDialog::getReverseDictionary()
 521 {
 522     if( m_xRB_To_Traditional->get_active() )
 523         return *m_xCT_DictionaryToSimplified;
 524     return *m_xCT_DictionaryToTraditional;
 525 }
 526
 527 void ChineseDictionaryDialog::updateButtons()
 528 {
 529     bool bAdd = isEditFieldsHaveContent() && !getActiveDictionary().hasTerm(m_xED_Term->get_text());
 530     m_xPB_Add->set_sensitive( bAdd );
 531
 532     m_xPB_Delete->set_sensitive(!bAdd && getActiveDictionary().get_selected_index() != -1);
 533
 534     bool bModify = false;
 535     {
 536         DictionaryEntry* pFirstSelectedEntry = getActiveDictionary().getFirstSelectedEntry();
 537         bModify = !bAdd && pFirstSelectedEntry && pFirstSelectedEntry->m_aTerm == m_xED_Term->get_text();
 538         if( bModify && isEditFieldsContentEqualsSelectedListContent() )
 539             bModify = false;
 540     }
 541     m_xPB_Modify->set_sensitive( bModify );
 542 }
 543
 544 IMPL_LINK_NOARG(ChineseDictionaryDialog, AddHdl, weld::Button&, void)
 545 {
 546     if( !isEditFieldsHaveContent() )
 547         return;
 548
 549     sal_Int16 nConversionPropertyType = m_xLB_Property->get_active() + 1;
 550
 551     getActiveDictionary().addEntry( m_xED_Term->get_text(), m_xED_Mapping->get_text(), nConversionPropertyType );
 552
 553     if( m_xCB_Reverse->get_active() )
 554     {
 555         getReverseDictionary().deleteEntries( m_xED_Mapping->get_text() );
 556         getReverseDictionary().addEntry( m_xED_Mapping->get_text(), m_xED_Term->get_text(), nConversionPropertyType );
 557     }
 558
 559     updateButtons();
 560 }
 561
 562 IMPL_LINK_NOARG(ChineseDictionaryDialog, ModifyHdl, weld::Button&, void)
 563 {
 564     OUString aTerm( m_xED_Term->get_text() );
 565     OUString aMapping( m_xED_Mapping->get_text() );
 566     sal_Int16 nConversionPropertyType = m_xLB_Property->get_active() + 1;
 567
 568     DictionaryList& rActive  = getActiveDictionary();
 569     DictionaryList& rReverse = getReverseDictionary();
 570
 571     DictionaryEntry* pE = rActive.getFirstSelectedEntry();
 572     if( pE && pE->m_aTerm != aTerm )
 573         return;
 574
 575     if( pE )
 576     {
 577         if( pE->m_aMapping != aMapping || pE->m_nConversionPropertyType != nConversionPropertyType )
 578         {
 579             if( m_xCB_Reverse->get_active() )
 580             {
 581                 rReverse.deleteEntries( pE->m_aMapping );
 582                 int nPos = rReverse.deleteEntries( aMapping );
 583                 rReverse.addEntry( aMapping, aTerm, nConversionPropertyType, nPos );
 584             }
 585
 586             int nPos = rActive.deleteEntries( aTerm );
 587             rActive.addEntry( aTerm, aMapping, nConversionPropertyType, nPos );
 588         }
 589     }
 590
 591     updateButtons();
 592 }
 593
 594 IMPL_LINK_NOARG(ChineseDictionaryDialog, DeleteHdl, weld::Button&, void)
 595 {
 596     DictionaryList& rActive  = getActiveDictionary();
 597     DictionaryList& rReverse = getReverseDictionary();
 598
 599     int nEntry = rActive.get_selected_index();
 600     if (nEntry != -1)
 601     {
 602         DictionaryEntry* pEntry = rActive.getEntryOnPos(nEntry);
 603         if (pEntry)
 604         {
 605             OUString aMapping = pEntry->m_aMapping;
 606             rActive.deleteEntryOnPos(nEntry);
 607             if (m_xCB_Reverse->get_active())
 608                 rReverse.deleteEntries(aMapping);
 609         }
 610     }
 611
 612     updateButtons();
 613 }
 614
 615 short ChineseDictionaryDialog::run()
 616 {
 617     sal_Int32 nTextConversionOptions = m_nTextConversionOptions;
 618     if(m_nTextConversionOptions & i18n::TextConversionOption::USE_CHARACTER_VARIANTS )
 619         nTextConversionOptions = nTextConversionOptions^i18n::TextConversionOption::USE_CHARACTER_VARIANTS ;
 620
 621     m_xCT_DictionaryToSimplified->refillFromDictionary( nTextConversionOptions );
 622     m_xCT_DictionaryToTraditional->refillFromDictionary( m_nTextConversionOptions );
 623
 624     short nRet = GenericDialogController::run();
 625
 626     if( nRet == RET_OK )
 627     {
 628         //save settings to configuration
 629         SvtLinguConfig  aLngCfg;
 630         aLngCfg.SetProperty( UPN_IS_REVERSE_MAPPING, uno::Any(m_xCB_Reverse->get_active()) );
 631
 632         m_xCT_DictionaryToSimplified->save();
 633         m_xCT_DictionaryToTraditional->save();
 634     }
 635
 636     m_xCT_DictionaryToSimplified->deleteAll();
 637     m_xCT_DictionaryToTraditional->deleteAll();
 638
 639     return nRet;
 640 }
 641
 642 void ChineseDictionaryDialog::HeaderBarClick(DictionaryList& rList, int nColumn)
 643 {
 644     bool bSortAtoZ = rList.get_sort_order();
 645
 646     //set new arrow positions in headerbar
 647     if (nColumn == rList.get_sort_column())
 648     {
 649         bSortAtoZ = !bSortAtoZ;
 650         rList.set_sort_order(bSortAtoZ);
 651     }
 652     else
 653     {
 654         rList.set_sort_indicator(TRISTATE_INDET, rList.get_sort_column());
 655         rList.set_sort_column(nColumn);
 656     }
 657
 658     //sort lists
 659     rList.set_sort_indicator(bSortAtoZ ? TRISTATE_TRUE : TRISTATE_FALSE, nColumn);
 660 }
 661
 662 IMPL_LINK(ChineseDictionaryDialog, ToSimplifiedHeaderBarClick, int, nColumn, void)
 663 {
 664     HeaderBarClick(*m_xCT_DictionaryToSimplified, nColumn);
 665 }
 666
 667 IMPL_LINK(ChineseDictionaryDialog, ToTraditionalHeaderBarClick, int, nColumn, void)
 668 {
 669     HeaderBarClick(*m_xCT_DictionaryToTraditional, nColumn);
 670 }
 671
 672 } //end namespace
 673
 674 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */