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 <svtools/headbar.hxx>
  31 #include <svtools/svlbitm.hxx>
  32 #include "svtools/treelistentry.hxx"
  33 #include <vcl/msgbox.hxx>
  34 #include <vcl/settings.hxx>
  35 #include <unotools/lingucfg.hxx>
  36 #include <unotools/linguprops.hxx>
  37 #include <unotools/intlwrapper.hxx>
  38 #include <comphelper/processfactory.hxx>
  39 #include <vcl/svapp.hxx>
  40 #include "helpid.hrc"
  41
  42
  43 namespace textconversiondlgs
  44 {
  45
  46
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::uno;
  49
  50 #define HEADER_BAR_BITS ( HIB_LEFT | HIB_VCENTER | HIB_CLICKABLE | HIB_FIXED | HIB_FIXEDPOS )
  51
  52 DictionaryList::DictionaryList(SvSimpleTableContainer& rParent, WinBits nBits)
  53     : SvSimpleTable(rParent, nBits)
  54     , m_xDictionary(0)
  55     , m_pED_Term(0)
  56     , m_pED_Mapping(0)
  57     , m_pLB_Property(0)
  58     , m_aToBeDeleted()
  59     , m_nSortColumnIndex(0)
  60 {
  61 }
  62
  63 OUString DictionaryList::getPropertyTypeName( sal_Int16 nConversionPropertyType ) const
  64 {
  65     if(!m_pLB_Property || !m_pLB_Property->GetEntryCount())
  66         return OUString();
  67
  68     sal_uInt16 nPos = static_cast<sal_uInt16>( nConversionPropertyType )-1;
  69     if(nPos<m_pLB_Property->GetEntryCount())
  70         return m_pLB_Property->GetEntry(nPos);
  71     return m_pLB_Property->GetEntry(0);
  72 }
  73
  74 OUString DictionaryList::makeTabString( const DictionaryEntry& rEntry ) const
  75 {
  76     OUString aStr( rEntry.m_aTerm );
  77     aStr += "\t";
  78     aStr += rEntry.m_aMapping;
  79     aStr += "\t";
  80     aStr += getPropertyTypeName( rEntry.m_nConversionPropertyType );
  81     return aStr;
  82 }
  83
  84 void DictionaryList::save()
  85 {
  86     if( !m_xDictionary.is() )
  87         return;
  88
  89     Reference< linguistic2::XConversionPropertyType > xPropertyType( m_xDictionary, uno::UNO_QUERY );
  90
  91     sal_Int32 nN;
  92     DictionaryEntry* pE;
  93
  94     for( nN = m_aToBeDeleted.size(); nN--; )
  95     {
  96         pE = m_aToBeDeleted[nN];
  97         m_xDictionary->removeEntry( pE->m_aTerm, pE->m_aMapping );
  98     }
  99     for( nN = GetRowCount(); nN--; )
 100     {
 101         pE = getEntryOnPos( nN );
 102         if(pE->m_bNewEntry)
 103         {
 104             try
 105             {
 106                 m_xDictionary->addEntry( pE->m_aTerm, pE->m_aMapping );
 107                 xPropertyType->setPropertyType( pE->m_aTerm, pE->m_aMapping, pE->m_nConversionPropertyType );
 108             }
 109             catch( uno::Exception& )
 110             {
 111
 112             }
 113         }
 114     }
 115     Reference< util::XFlushable > xFlush( m_xDictionary, uno::UNO_QUERY );
 116     if( xFlush.is() )
 117         xFlush->flush();
 118 }
 119
 120 void DictionaryList::deleteAll()
 121 {
 122     sal_Int32 nN;
 123     for( nN = GetRowCount(); nN--; )
 124         deleteEntryOnPos( nN  );
 125     for( nN = m_aToBeDeleted.size(); nN--; )
 126     {
 127         DictionaryEntry* pE = m_aToBeDeleted[nN];
 128         delete pE;
 129     }
 130     m_aToBeDeleted.clear();
 131 }
 132
 133 void DictionaryList::refillFromDictionary( sal_Int32 nTextConversionOptions )
 134 {
 135     deleteAll();
 136
 137     if(!m_xDictionary.is())
 138         return;
 139
 140     Sequence< OUString > aLeftList(  m_xDictionary->getConversionEntries( linguistic2::ConversionDirection_FROM_LEFT ) );
 141     sal_Int32 nCount = aLeftList.getLength();
 142
 143     Reference< linguistic2::XConversionPropertyType > xPropertyType( m_xDictionary, uno::UNO_QUERY );
 144
 145     OUString aLeft, aRight;
 146     sal_Int16 nConversionPropertyType;
 147
 148     for(sal_Int32 nN=0; nN<nCount; nN++)
 149     {
 150         aLeft  = aLeftList[nN];
 151         Sequence< OUString > aRightList( m_xDictionary->getConversions(
 152             aLeft, 0, aLeft.getLength()
 153             , linguistic2::ConversionDirection_FROM_LEFT, nTextConversionOptions ) );
 154
 155         if(aRightList.getLength()!=1)
 156         {
 157             OSL_FAIL("The Chinese Translation Dictionary should have exactly one Mapping for each term.");
 158             continue;
 159         }
 160
 161         aRight = aRightList[0];
 162         nConversionPropertyType = linguistic2::ConversionPropertyType::OTHER;
 163         if(xPropertyType.is())
 164             nConversionPropertyType = xPropertyType->getPropertyType(aLeft, aRight);
 165
 166         DictionaryEntry* pEntry = new DictionaryEntry( aLeft, aRight, nConversionPropertyType );
 167         SvTreeListEntry* pLBEntry = InsertEntry( makeTabString( *pEntry ) );
 168         pLBEntry->SetUserData( pEntry );
 169     }
 170
 171     if( GetEntryCount() > 0 )
 172         SelectRow( 0 );
 173 }
 174
 175 DictionaryEntry* DictionaryList::getFirstSelectedEntry() const
 176 {
 177     DictionaryEntry* pRet=0;
 178     for( sal_Int32 nN=GetRowCount(); nN--; )
 179     {
 180         if( IsRowSelected( nN ) )
 181         {
 182             pRet = getEntryOnPos( nN );
 183             break;
 184         }
 185     }
 186     return pRet;
 187 }
 188
 189 DictionaryEntry* DictionaryList::getEntryOnPos( sal_Int32 nPos ) const
 190 {
 191     DictionaryEntry* pEntry=0;
 192     SvTreeListEntry* pLBEntry = GetEntryOnPos( nPos );
 193     if(pLBEntry)
 194         pEntry = (DictionaryEntry*)pLBEntry->GetUserData();
 195     return pEntry;
 196 }
 197
 198 DictionaryEntry* DictionaryList::getTermEntry( const OUString& rTerm ) const
 199 {
 200     DictionaryEntry* pE = 0;
 201     for( sal_Int32 nN=GetRowCount(); nN--; )
 202     {
 203         pE = getEntryOnPos( nN );
 204         if( pE && rTerm.equals( pE->m_aTerm ) )
 205             return pE;
 206     }
 207     return 0;
 208 }
 209
 210 bool DictionaryList::hasTerm( const OUString& rTerm ) const
 211 {
 212     return getTermEntry(rTerm) !=0 ;
 213 }
 214
 215 void DictionaryList::addEntry( const OUString& rTerm, const OUString& rMapping
 216                               , sal_Int16 nConversionPropertyType, sal_uIntPtr nPos )
 217 {
 218     if( hasTerm( rTerm ) )
 219         return;
 220
 221     DictionaryEntry* pEntry = new DictionaryEntry( rTerm, rMapping, nConversionPropertyType, true );
 222     SvTreeListEntry* pLBEntry = InsertEntryToColumn( makeTabString( *pEntry ), nPos );
 223     pLBEntry->SetUserData( pEntry );
 224     SelectRow( GetEntryPos( pLBEntry ) );
 225 }
 226
 227 void DictionaryList::deleteEntryOnPos( sal_Int32 nPos  )
 228 {
 229     SvTreeListEntry* pLBEntry = GetEntryOnPos( nPos );
 230     DictionaryEntry* pEntry = getEntryOnPos( nPos );
 231     if( pLBEntry )
 232         RemoveParentKeepChildren( pLBEntry );
 233     if( pEntry )
 234     {
 235         if( pEntry->m_bNewEntry )
 236             delete pEntry;
 237         else
 238             m_aToBeDeleted.push_back( pEntry );
 239     }
 240 }
 241
 242 sal_uIntPtr DictionaryList::deleteEntries( const OUString& rTerm )
 243 {
 244     sal_uIntPtr nPos = TREELIST_APPEND;
 245     for( sal_Int32 nN=GetRowCount(); nN--; )
 246     {
 247         DictionaryEntry* pCurEntry = getEntryOnPos( nN );
 248         if( rTerm.equals( pCurEntry->m_aTerm ) )
 249         {
 250             nPos = nN;
 251             SvTreeListEntry* pCurLBEntry = GetEntryOnPos( nN );
 252             RemoveParentKeepChildren( pCurLBEntry );
 253             if( pCurEntry->m_bNewEntry )
 254                 delete pCurEntry;
 255             else
 256                 m_aToBeDeleted.push_back( pCurEntry );
 257         }
 258     }
 259     return nPos;
 260 }
 261
 262 void DictionaryList::sortByColumn( sal_uInt16 nSortColumnIndex, bool bSortAtoZ )
 263 {
 264     m_nSortColumnIndex=nSortColumnIndex;
 265     if( nSortColumnIndex<3 )
 266     {
 267         if(bSortAtoZ)
 268             GetModel()->SetSortMode(SortAscending);
 269         else
 270             GetModel()->SetSortMode(SortDescending);
 271
 272         GetModel()->SetCompareHdl( LINK( this, DictionaryList, CompareHdl));
 273         GetModel()->Resort();
 274     }
 275     else
 276         GetModel()->SetSortMode(SortNone);
 277 }
 278
 279 sal_uInt16 DictionaryList::getSortColumn() const
 280 {
 281     return m_nSortColumnIndex;
 282 }
 283
 284 IMPL_LINK( DictionaryList, CompareHdl, SvSortData*, pData )
 285 {
 286     SvTreeListEntry* pLeft = (SvTreeListEntry*)(pData->pLeft );
 287     SvTreeListEntry* pRight = (SvTreeListEntry*)(pData->pRight );
 288     return (long) ColumnCompare(pLeft,pRight);
 289 }
 290
 291 sal_Int32 DictionaryList::ColumnCompare( SvTreeListEntry* pLeft, SvTreeListEntry* pRight )
 292 {
 293     sal_Int32 nCompare = 0;
 294
 295     SvLBoxItem* pLeftItem = getItemAtColumn( pLeft, m_nSortColumnIndex );
 296     SvLBoxItem* pRightItem = getItemAtColumn( pRight, m_nSortColumnIndex );
 297
 298     if(pLeftItem != NULL && pRightItem != NULL)
 299     {
 300         sal_uInt16 nLeftKind = pLeftItem->GetType();
 301         sal_uInt16 nRightKind = pRightItem->GetType();
 302
 303         if(nRightKind == SV_ITEM_ID_LBOXSTRING &&
 304             nLeftKind == SV_ITEM_ID_LBOXSTRING )
 305         {
 306             IntlWrapper aIntlWrapper( Application::GetSettings().GetLanguageTag() );
 307             const CollatorWrapper* pCollator = aIntlWrapper.getCaseCollator();
 308
 309             nCompare = pCollator->compareString( ((SvLBoxString*)pLeftItem)->GetText(),
 310                                     ((SvLBoxString*)pRightItem)->GetText());
 311
 312             if (nCompare == 0)
 313                 nCompare = -1;
 314         }
 315     }
 316     return nCompare;
 317 }
 318
 319 SvLBoxItem* DictionaryList::getItemAtColumn( SvTreeListEntry* pEntry, sal_uInt16 nColumn ) const
 320 {
 321     SvLBoxItem* pItem = NULL;
 322     if( pEntry )
 323     {
 324         sal_uInt16 nCount = pEntry->ItemCount();
 325         nColumn++;
 326         if( nTreeFlags & TREEFLAG_CHKBTN )
 327             nColumn++;
 328            if( nColumn < nCount )
 329             pItem = pEntry->GetItem( nColumn );
 330     }
 331     return pItem;
 332 }
 333
 334
 335
 336
 337
 338 DictionaryEntry::DictionaryEntry( const OUString& rTerm, const OUString& rMapping
 339                     , sal_Int16 nConversionPropertyType
 340                     , bool bNewEntry )
 341         : m_aTerm( rTerm )
 342         , m_aMapping( rMapping )
 343         , m_nConversionPropertyType( nConversionPropertyType )
 344         , m_bNewEntry( bNewEntry )
 345 {
 346     if( m_nConversionPropertyType == 0 )
 347         m_nConversionPropertyType = 1;
 348 }
 349
 350 DictionaryEntry::~DictionaryEntry()
 351 {
 352 }
 353
 354 bool DictionaryEntry::operator==( const DictionaryEntry& rE ) const
 355 {
 356     return m_aTerm == rE.m_aTerm
 357             && m_aMapping == rE.m_aMapping
 358             && m_nConversionPropertyType == rE.m_nConversionPropertyType;
 359 }
 360
 361 void DictionaryList::setColSizes()
 362 {
 363     HeaderBar &rBar = GetTheHeaderBar();
 364     if (rBar.GetItemCount() < 3)
 365         return;
 366
 367     long nWidth1 = m_pED_Term->get_preferred_size().Width();
 368     long nWidth2 = m_pED_Mapping->get_preferred_size().Width();
 369     long nWidth3 = m_pLB_Property->get_preferred_size().Width();
 370
 371     long nWidth = GetSizePixel().Width();
 372     long nPos3 = nWidth - nWidth3;
 373     long nRemainder = nWidth - (nWidth1 + nWidth2 + nWidth3);
 374
 375     long aStaticTabs[] = { 3, 0, nWidth1 + (nRemainder/2), nPos3 };
 376     SvSimpleTable::SetTabs(aStaticTabs, MAP_PIXEL);
 377 }
 378
 379 void DictionaryList::Resize()
 380 {
 381     SvSimpleTable::Resize();
 382     setColSizes();
 383 }
 384
 385 void DictionaryList::init(const Reference< linguistic2::XConversionDictionary>& xDictionary,
 386     Window *pED_Term, Window *pED_Mapping, ListBox *pLB_Property,
 387     Window *pFT_Term, Window *pFT_Mapping, Window *pFT_Property)
 388 {
 389     SetStyle( WB_VSCROLL | WB_TABSTOP );
 390     SetSelectionMode( SINGLE_SELECTION );
 391     SetBorderStyle( WINDOW_BORDER_MONO );
 392     SetHighlightRange();
 393
 394     if (m_xDictionary.is())
 395         return;
 396
 397     m_xDictionary = xDictionary;
 398
 399     m_pED_Term = pED_Term;
 400     m_pED_Mapping = pED_Mapping;
 401     m_pLB_Property = pLB_Property;
 402
 403     HeaderBar& rHeaderBar = GetTheHeaderBar();
 404
 405     OUString aColumn1( OutputDevice::GetNonMnemonicString( pFT_Term->GetText() ) );
 406     OUString aColumn2( OutputDevice::GetNonMnemonicString( pFT_Mapping->GetText() ) );
 407     OUString aColumn3( OutputDevice::GetNonMnemonicString( pFT_Property->GetText() ) );
 408
 409     long nWidth1 = m_pED_Term->get_preferred_size().Width();
 410     long nWidth2 = m_pED_Mapping->get_preferred_size().Width();
 411     long nWidth3 = m_pLB_Property->get_preferred_size().Width();
 412
 413     HeaderBarItemBits nBits = HEADER_BAR_BITS;
 414     rHeaderBar.InsertItem( 1, aColumn1, nWidth1, nBits | HIB_UPARROW );
 415     rHeaderBar.InsertItem( 2, aColumn2, nWidth2, nBits );
 416     rHeaderBar.InsertItem( 3, aColumn3, nWidth3, nBits );
 417
 418     long pTabs[] = { 3, 0, nWidth1, nWidth1 + nWidth2 };
 419     SetTabs( &pTabs[0], MAP_PIXEL );
 420 }
 421
 422 void ChineseDictionaryDialog::initDictionaryControl(DictionaryList *pList,
 423     const Reference< linguistic2::XConversionDictionary>& xDictionary)
 424 {
 425     //init HeaderBar and set tabs
 426     HeaderBar& rHeaderBar = pList->GetTheHeaderBar();
 427     //set hdl
 428     rHeaderBar.SetSelectHdl( LINK( this, ChineseDictionaryDialog, HeaderBarClick ) );
 429     //set widgets to track the width of for columns
 430     pList->init(xDictionary,
 431         m_pED_Term, m_pED_Mapping, m_pLB_Property,
 432         m_pFT_Term, m_pFT_Mapping, m_pFT_Property);
 433 }
 434
 435 ChineseDictionaryDialog::ChineseDictionaryDialog( Window* pParent )
 436     : ModalDialog(pParent, "ChineseDictionaryDialog",
 437          "svx/ui/chinesedictionary.ui")
 438     , m_nTextConversionOptions(i18n::TextConversionOption::NONE)
 439     , m_xContext(0)
 440 {
 441     get(m_pRB_To_Simplified, "tradtosimple");
 442     get(m_pRB_To_Traditional, "simpletotrad");
 443     get(m_pCB_Reverse, "reverse");
 444     get(m_pFT_Term, "termft");
 445     get(m_pED_Term, "term");
 446     get(m_pFT_Mapping, "mappingft");
 447     get(m_pED_Mapping, "mapping");
 448     get(m_pFT_Property, "propertyft");
 449     get(m_pLB_Property, "property");
 450
 451     get(m_pPB_Add, "add");
 452     get(m_pPB_Modify, "modify");
 453     get(m_pPB_Delete, "delete");
 454
 455     get(mpToSimplifiedContainer, "tradtosimpleview");
 456     mpToSimplifiedContainer->set_height_request(mpToSimplifiedContainer->GetTextHeight() * 8);
 457     m_pCT_DictionaryToSimplified = new DictionaryList(*mpToSimplifiedContainer, 0);
 458     get(mpToTraditionalContainer, "simpletotradview");
 459     mpToTraditionalContainer->set_height_request(mpToTraditionalContainer->GetTextHeight() * 8);
 460     m_pCT_DictionaryToTraditional = new DictionaryList(*mpToTraditionalContainer, 0);
 461
 462     SvtLinguConfig  aLngCfg;
 463     bool bValue;
 464     Any aAny( aLngCfg.GetProperty( OUString( UPN_IS_REVERSE_MAPPING ) ) );
 465     if( aAny >>= bValue )
 466         m_pCB_Reverse->Check( bValue );
 467
 468     m_pLB_Property->SetDropDownLineCount( m_pLB_Property->GetEntryCount() );
 469     m_pLB_Property->SelectEntryPos(0);
 470
 471     Reference< linguistic2::XConversionDictionary > xDictionary_To_Simplified(0);
 472     Reference< linguistic2::XConversionDictionary > xDictionary_To_Traditional(0);
 473     //get dictionaries
 474     {
 475         if(!m_xContext.is())
 476             m_xContext = Reference< XComponentContext >( ::cppu::defaultBootstrap_InitialComponentContext() );
 477         if(m_xContext.is())
 478         {
 479             Reference< linguistic2::XConversionDictionaryList > xDictionaryList = linguistic2::ConversionDictionaryList::create(m_xContext);
 480             Reference< container::XNameContainer > xContainer( xDictionaryList->getDictionaryContainer() );
 481             if(xContainer.is())
 482             {
 483                 try
 484                 {
 485                     OUString aNameTo_Simplified("ChineseT2S");
 486                     OUString aNameTo_Traditional("ChineseS2T");
 487                     lang::Locale aLocale;
 488                     aLocale.Language = "zh";
 489
 490                     if( xContainer->hasByName( aNameTo_Simplified ) )
 491                         xDictionary_To_Simplified = Reference< linguistic2::XConversionDictionary >(
 492                                 xContainer->getByName( aNameTo_Simplified ), UNO_QUERY );
 493                     else
 494                     {
 495                         aLocale.Country = "TW";
 496                         xDictionary_To_Simplified = Reference< linguistic2::XConversionDictionary >(
 497                                 xDictionaryList->addNewDictionary( aNameTo_Simplified
 498                                 , aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE
 499                                     ), UNO_QUERY );
 500                     }
 501                     if (xDictionary_To_Simplified.is())
 502                         xDictionary_To_Simplified->setActive( sal_True );
 503
 504
 505                     if( xContainer->hasByName( aNameTo_Traditional ) )
 506                         xDictionary_To_Traditional = Reference< linguistic2::XConversionDictionary >(
 507                                 xContainer->getByName( aNameTo_Traditional ), UNO_QUERY );
 508                     else
 509                     {
 510                         aLocale.Country = "CN";
 511                         xDictionary_To_Traditional = Reference< linguistic2::XConversionDictionary >(
 512                                 xDictionaryList->addNewDictionary( aNameTo_Traditional
 513                                 , aLocale, linguistic2::ConversionDictionaryType::SCHINESE_TCHINESE
 514                                     ), UNO_QUERY );
 515                     }
 516                     if (xDictionary_To_Traditional.is())
 517                         xDictionary_To_Traditional->setActive( sal_True );
 518
 519                 }
 520                 catch(const uno::Exception& )
 521                 {
 522                 }
 523             }
 524         }
 525     }
 526
 527     //init dictionary controls
 528     initDictionaryControl(m_pCT_DictionaryToSimplified, xDictionary_To_Simplified);
 529     initDictionaryControl(m_pCT_DictionaryToTraditional, xDictionary_To_Traditional);
 530
 531     updateAfterDirectionChange();
 532
 533     m_pED_Term->SetModifyHdl( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) );
 534     m_pED_Mapping->SetModifyHdl( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) );
 535     m_pLB_Property->SetSelectHdl( LINK( this, ChineseDictionaryDialog, EditFieldsHdl ) );
 536
 537     m_pRB_To_Simplified->SetClickHdl( LINK( this, ChineseDictionaryDialog, DirectionHdl ) );
 538     m_pRB_To_Traditional->SetClickHdl( LINK( this, ChineseDictionaryDialog, DirectionHdl ) );
 539
 540     m_pCT_DictionaryToSimplified->SetSelectHdl( LINK( this, ChineseDictionaryDialog, MappingSelectHdl ));
 541     m_pCT_DictionaryToTraditional->SetSelectHdl( LINK( this, ChineseDictionaryDialog, MappingSelectHdl ));
 542
 543     m_pPB_Add->SetClickHdl( LINK( this, ChineseDictionaryDialog, AddHdl ) );
 544     m_pPB_Modify->SetClickHdl( LINK( this, ChineseDictionaryDialog, ModifyHdl ) );
 545     m_pPB_Delete->SetClickHdl( LINK( this, ChineseDictionaryDialog, DeleteHdl ) );
 546 }
 547
 548 ChineseDictionaryDialog::~ChineseDictionaryDialog()
 549 {
 550     m_xContext=0;
 551     delete m_pCT_DictionaryToSimplified;
 552     delete m_pCT_DictionaryToTraditional;
 553 }
 554
 555 void ChineseDictionaryDialog::setDirectionAndTextConversionOptions( bool bDirectionToSimplified, sal_Int32 nTextConversionOptions /*i18n::TextConversionOption*/ )
 556 {
 557     if( bDirectionToSimplified == bool(m_pRB_To_Simplified->IsChecked())
 558         && nTextConversionOptions == m_nTextConversionOptions )
 559         return;
 560
 561     m_nTextConversionOptions = nTextConversionOptions;
 562
 563     if( bDirectionToSimplified )
 564         m_pRB_To_Simplified->Check();
 565     else
 566         m_pRB_To_Traditional->Check();
 567     updateAfterDirectionChange();
 568 }
 569
 570 IMPL_LINK_NOARG(ChineseDictionaryDialog, DirectionHdl)
 571 {
 572     updateAfterDirectionChange();
 573     return 0;
 574 }
 575
 576 void ChineseDictionaryDialog::updateAfterDirectionChange()
 577 {
 578     Reference< linguistic2::XConversionDictionary > xDictionary(0);
 579
 580     if( m_pRB_To_Simplified->IsChecked() )
 581     {
 582         mpToTraditionalContainer->Hide();
 583         mpToSimplifiedContainer->Show();
 584         xDictionary = m_pCT_DictionaryToSimplified->m_xDictionary;
 585     }
 586     else
 587     {
 588         mpToSimplifiedContainer->Hide();
 589         mpToTraditionalContainer->Show();
 590         xDictionary = m_pCT_DictionaryToTraditional->m_xDictionary;
 591     }
 592
 593     updateButtons();
 594 }
 595
 596 IMPL_LINK_NOARG(ChineseDictionaryDialog, EditFieldsHdl)
 597 {
 598     updateButtons();
 599     return 0;
 600 }
 601 IMPL_LINK_NOARG(ChineseDictionaryDialog, MappingSelectHdl)
 602 {
 603     DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry();
 604     if(pE)
 605     {
 606         m_pED_Term->SetText( pE->m_aTerm );
 607         m_pED_Mapping->SetText( pE->m_aMapping );
 608         sal_Int16 nPos = pE->m_nConversionPropertyType-1;
 609         if( nPos<0 || nPos>=m_pLB_Property->GetEntryCount() )
 610             nPos=0;
 611         if( m_pLB_Property->GetEntryCount() )
 612             m_pLB_Property->SelectEntryPos(nPos);
 613     }
 614
 615     updateButtons();
 616     return 0;
 617 }
 618
 619 bool ChineseDictionaryDialog::isEditFieldsHaveContent() const
 620 {
 621     return !m_pED_Term->GetText().isEmpty() && !m_pED_Mapping->GetText().isEmpty();
 622 }
 623
 624 bool ChineseDictionaryDialog::isEditFieldsContentEqualsSelectedListContent() const
 625 {
 626     DictionaryEntry* pE = getActiveDictionary().getFirstSelectedEntry();
 627     if( pE )
 628     {
 629         if( pE->m_aTerm != OUString( m_pED_Term->GetText() ) )
 630             return false;
 631         if( pE->m_aMapping != OUString( m_pED_Mapping->GetText() ) )
 632             return false;
 633         if( pE->m_nConversionPropertyType != m_pLB_Property->GetSelectEntryPos()+1 )
 634             return false;
 635         return true;
 636     }
 637     return false;
 638 }
 639
 640 const DictionaryList& ChineseDictionaryDialog::getActiveDictionary() const
 641 {
 642     if( m_pRB_To_Traditional->IsChecked() )
 643         return *m_pCT_DictionaryToTraditional;
 644     return *m_pCT_DictionaryToSimplified;
 645 }
 646
 647 DictionaryList& ChineseDictionaryDialog::getActiveDictionary()
 648 {
 649     if( m_pRB_To_Traditional->IsChecked() )
 650         return *m_pCT_DictionaryToTraditional;
 651     return *m_pCT_DictionaryToSimplified;
 652 }
 653
 654 const DictionaryList& ChineseDictionaryDialog::getReverseDictionary() const
 655 {
 656     if( m_pRB_To_Traditional->IsChecked() )
 657         return *m_pCT_DictionaryToSimplified;
 658     return *m_pCT_DictionaryToTraditional;
 659 }
 660
 661 DictionaryList& ChineseDictionaryDialog::getReverseDictionary()
 662 {
 663     if( m_pRB_To_Traditional->IsChecked() )
 664         return *m_pCT_DictionaryToSimplified;
 665     return *m_pCT_DictionaryToTraditional;
 666 }
 667
 668 void ChineseDictionaryDialog::updateButtons()
 669 {
 670     bool bAdd = isEditFieldsHaveContent() && !getActiveDictionary().hasTerm( m_pED_Term->GetText() );
 671     m_pPB_Add->Enable( bAdd );
 672
 673     m_pPB_Delete->Enable( !bAdd && getActiveDictionary().GetSelectedRowCount()>0 );
 674
 675 //    DictionaryEntry* pFirstSelectedEntry = getActiveDictionary().getFirstSelectedEntry();
 676
 677     bool bModify = false;
 678     {
 679         DictionaryEntry* pFirstSelectedEntry = getActiveDictionary().getFirstSelectedEntry();
 680         bModify = !bAdd && getActiveDictionary().GetSelectedRowCount()==1
 681                         && pFirstSelectedEntry && pFirstSelectedEntry->m_aTerm.equals( m_pED_Term->GetText() );
 682         if( bModify && isEditFieldsContentEqualsSelectedListContent() )
 683             bModify = false;
 684     }
 685     m_pPB_Modify->Enable( bModify );
 686 }
 687
 688 IMPL_LINK_NOARG(ChineseDictionaryDialog, AddHdl)
 689 {
 690     if( !isEditFieldsHaveContent() )
 691         return 0;
 692
 693     sal_Int16 nConversionPropertyType = m_pLB_Property->GetSelectEntryPos()+1;
 694
 695     getActiveDictionary().addEntry( m_pED_Term->GetText(), m_pED_Mapping->GetText(), nConversionPropertyType );
 696
 697     if( m_pCB_Reverse->IsChecked() )
 698     {
 699         getReverseDictionary().deleteEntries( m_pED_Mapping->GetText() );
 700         getReverseDictionary().addEntry( m_pED_Mapping->GetText(), m_pED_Term->GetText(), nConversionPropertyType );
 701     }
 702
 703     updateButtons();
 704     return 0;
 705 }
 706 IMPL_LINK_NOARG(ChineseDictionaryDialog, ModifyHdl)
 707 {
 708     OUString aTerm( m_pED_Term->GetText() );
 709     OUString aMapping( m_pED_Mapping->GetText() );
 710     sal_Int16 nConversionPropertyType = m_pLB_Property->GetSelectEntryPos()+1;
 711
 712     DictionaryList& rActive  = getActiveDictionary();
 713     DictionaryList& rReverse = getReverseDictionary();
 714
 715     DictionaryEntry* pE = rActive.getFirstSelectedEntry();
 716     if( pE && pE->m_aTerm != aTerm )
 717         return 0;
 718
 719     if( pE )
 720     {
 721         if( pE->m_aMapping != aMapping || pE->m_nConversionPropertyType != nConversionPropertyType )
 722         {
 723             if( m_pCB_Reverse->IsChecked() )
 724             {
 725                 sal_uIntPtr nPos = rReverse.deleteEntries( pE->m_aMapping );
 726                 nPos = rReverse.deleteEntries( aMapping );
 727                 rReverse.addEntry( aMapping, aTerm, nConversionPropertyType, nPos );
 728             }
 729
 730             sal_uIntPtr nPos = rActive.deleteEntries( aTerm );
 731             rActive.addEntry( aTerm, aMapping, nConversionPropertyType, nPos );
 732         }
 733     }
 734
 735     updateButtons();
 736     return 0;
 737 }
 738
 739 IMPL_LINK_NOARG(ChineseDictionaryDialog, DeleteHdl)
 740 {
 741     DictionaryList& rActive  = getActiveDictionary();
 742     DictionaryList& rReverse = getReverseDictionary();
 743
 744     if( rActive.GetSelectedRowCount()>0)
 745     {
 746         DictionaryEntry* pEntry;
 747
 748         OUString aMapping;
 749         for( sal_Int32 nN=rActive.GetRowCount(); nN--; )
 750         {
 751             if( rActive.IsRowSelected( nN ) )
 752             {
 753                 pEntry = rActive.getEntryOnPos( nN );
 754                 if(pEntry)
 755                 {
 756                     aMapping = pEntry->m_aMapping;
 757                     rActive.deleteEntryOnPos( nN );
 758                     if( m_pCB_Reverse->IsChecked() )
 759                         rReverse.deleteEntries( aMapping  );
 760                 }
 761                 break;
 762             }
 763         }
 764     }
 765
 766     updateButtons();
 767     return 0;
 768 }
 769
 770 short ChineseDictionaryDialog::Execute()
 771 {
 772     sal_Int32 nTextConversionOptions = m_nTextConversionOptions;
 773     if(m_nTextConversionOptions & i18n::TextConversionOption::USE_CHARACTER_VARIANTS )
 774         nTextConversionOptions = nTextConversionOptions^i18n::TextConversionOption::USE_CHARACTER_VARIANTS ;
 775
 776     m_pCT_DictionaryToSimplified->refillFromDictionary( nTextConversionOptions );
 777     m_pCT_DictionaryToTraditional->refillFromDictionary( m_nTextConversionOptions );
 778
 779     short nRet = ModalDialog::Execute();
 780
 781     if( nRet == RET_OK )
 782     {
 783         //save settings to configuration
 784         SvtLinguConfig  aLngCfg;
 785         Any aAny;
 786         aAny <<= m_pCB_Reverse->IsChecked();
 787         aLngCfg.SetProperty( OUString( UPN_IS_REVERSE_MAPPING ), aAny );
 788
 789         m_pCT_DictionaryToSimplified->save();
 790         m_pCT_DictionaryToTraditional->save();
 791     }
 792
 793     m_pCT_DictionaryToSimplified->deleteAll();
 794     m_pCT_DictionaryToTraditional->deleteAll();
 795
 796     return nRet;
 797 }
 798
 799 IMPL_LINK(ChineseDictionaryDialog, HeaderBarClick, HeaderBar*, pHeaderBar)
 800 {
 801     sal_uInt16 nId = pHeaderBar->GetCurItemId();
 802     HeaderBarItemBits nBits = pHeaderBar->GetItemBits(nId);
 803     if( nBits & HIB_CLICKABLE )
 804     {
 805         //set new arrow positions in headerbar
 806         pHeaderBar->SetItemBits( getActiveDictionary().getSortColumn()+1, HEADER_BAR_BITS );
 807         if( nBits & HIB_UPARROW )
 808             pHeaderBar->SetItemBits( nId, HEADER_BAR_BITS | HIB_DOWNARROW );
 809         else
 810             pHeaderBar->SetItemBits( nId, HEADER_BAR_BITS | HIB_UPARROW );
 811
 812         //sort lists
 813         nBits = pHeaderBar->GetItemBits(nId);
 814         bool bSortAtoZ = nBits & HIB_UPARROW;
 815         getActiveDictionary().sortByColumn(nId-1,bSortAtoZ);
 816         getReverseDictionary().sortByColumn(nId-1,bSortAtoZ);
 817     }
 818
 819     return 0;
 820 }
 821
 822
 823 } //end namespace
 824
 825
 826 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */