linguistic/source/convdiclist.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: convdiclist.cxx,v $
  10  * $Revision: 1.11 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_linguistic.hxx"
  33 #include <tools/fsys.hxx>
  34 #include <tools/stream.hxx>
  35 #include <tools/urlobj.hxx>
  36 #include <svtools/pathoptions.hxx>
  37 #include <svtools/useroptions.hxx>
  38 #include <svtools/lingucfg.hxx>
  39 #include <sfx2/docfile.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <rtl/instance.hxx>
  42 #include <cppuhelper/factory.hxx>       // helper for factories
  43 #include <unotools/localfilehelper.hxx>
  44 #include <com/sun/star/linguistic2/XConversionDictionaryList.hpp>
  45 #include <com/sun/star/linguistic2/XConversionDictionary.hpp>
  46 #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
  47 #include <com/sun/star/util/XFlushable.hpp>
  48 #include <com/sun/star/lang/Locale.hpp>
  49 #ifndef _COM_SUN_STAR_UNO_REFERENCE_HPP_
  50 #include <com/sun/star/uno/Reference.h>
  51 #endif
  52 #include <com/sun/star/registry/XRegistryKey.hpp>
  53 #include <com/sun/star/container/XNameContainer.hpp>
  54
  55 #include <ucbhelper/content.hxx>
  56
  57 #include "convdiclist.hxx"
  58 #include "convdic.hxx"
  59 #include "hhconvdic.hxx"
  60 #include "misc.hxx"
  61 #include "defs.hxx"
  62
  63 //using namespace utl;
  64 using namespace osl;
  65 using namespace rtl;
  66 using namespace com::sun::star;
  67 using namespace com::sun::star::lang;
  68 using namespace com::sun::star::uno;
  69 using namespace com::sun::star::container;
  70 using namespace com::sun::star::linguistic2;
  71 using namespace linguistic;
  72
  73 #define SN_CONV_DICTIONARY_LIST  "com.sun.star.linguistic2.ConversionDictionaryList"
  74
  75
  76 ///////////////////////////////////////////////////////////////////////////
  77
  78 bool operator == ( const Locale &r1, const Locale &r2 )
  79 {
  80     return  r1.Language == r2.Language &&
  81             r1.Country  == r2.Country  &&
  82             r1.Variant  == r2.Variant;
  83 }
  84
  85 ///////////////////////////////////////////////////////////////////////////
  86
  87 String GetConvDicMainURL( const String &rDicName, const String &rDirectoryURL )
  88 {
  89     // build URL to use for new (persistent) dictionaries
  90
  91     String aFullDicName( rDicName );
  92     aFullDicName.AppendAscii( CONV_DIC_DOT_EXT );
  93
  94     INetURLObject aURLObj;
  95     aURLObj.SetSmartProtocol( INET_PROT_FILE );
  96     aURLObj.SetSmartURL( rDirectoryURL );
  97     aURLObj.Append( aFullDicName, INetURLObject::ENCODE_ALL );
  98     DBG_ASSERT(!aURLObj.HasError(), "invalid URL");
  99     if (aURLObj.HasError())
 100         return String();
 101     else
 102         return aURLObj.GetMainURL( INetURLObject::DECODE_TO_IURI );
 103 }
 104
 105 ///////////////////////////////////////////////////////////////////////////
 106
 107 class ConvDicNameContainer :
 108     public cppu::WeakImplHelper1
 109     <
 110         ::com::sun::star::container::XNameContainer
 111     >
 112 {
 113     uno::Sequence< uno::Reference< XConversionDictionary > >   aConvDics;
 114     ConvDicList     &rConvDicList;
 115
 116     // disallow copy-constructor and assignment-operator for now
 117     ConvDicNameContainer(const ConvDicNameContainer &);
 118     ConvDicNameContainer & operator = (const ConvDicNameContainer &);
 119
 120     INT32 GetIndexByName_Impl( const OUString& rName );
 121
 122 public:
 123     ConvDicNameContainer( ConvDicList &rMyConvDicList );
 124     virtual ~ConvDicNameContainer();
 125
 126     // XElementAccess
 127     virtual ::com::sun::star::uno::Type SAL_CALL getElementType(  ) throw (::com::sun::star::uno::RuntimeException);
 128     virtual sal_Bool SAL_CALL hasElements(  ) throw (::com::sun::star::uno::RuntimeException);
 129
 130     // XNameAccess
 131     virtual ::com::sun::star::uno::Any SAL_CALL getByName( const ::rtl::OUString& aName ) throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 132     virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getElementNames(  ) throw (::com::sun::star::uno::RuntimeException);
 133     virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& aName ) throw (::com::sun::star::uno::RuntimeException);
 134
 135     // XNameReplace
 136     virtual void SAL_CALL replaceByName( const ::rtl::OUString& aName, const ::com::sun::star::uno::Any& aElement ) throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 137
 138     // XNameContainer
 139     virtual void SAL_CALL insertByName( const ::rtl::OUString& aName, const ::com::sun::star::uno::Any& aElement ) throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::container::ElementExistException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 140     virtual void SAL_CALL removeByName( const ::rtl::OUString& Name ) throw (::com::sun::star::container::NoSuchElementException, ::com::sun::star::lang::WrappedTargetException, ::com::sun::star::uno::RuntimeException);
 141
 142
 143     // looks for conversion dictionaries with the specified extension
 144     // in the directory and adds them to the container
 145     void AddConvDics( const String &rSearchDirPathURL, const String &rExtension );
 146
 147     // calls Flush for the dictionaries that support XFlushable
 148     void    FlushDics() const;
 149
 150     INT32   GetCount() const    { return aConvDics.getLength(); }
 151     uno::Reference< XConversionDictionary > GetByName( const OUString& rName );
 152
 153     const uno::Reference< XConversionDictionary >    GetByIndex( INT32 nIdx )
 154     {
 155         return aConvDics.getConstArray()[nIdx];
 156     }
 157 };
 158
 159
 160 ConvDicNameContainer::ConvDicNameContainer( ConvDicList &rMyConvDicList ) :
 161     rConvDicList( rMyConvDicList )
 162 {
 163 }
 164
 165
 166 ConvDicNameContainer::~ConvDicNameContainer()
 167 {
 168 }
 169
 170
 171 void ConvDicNameContainer::FlushDics() const
 172 {
 173     INT32 nLen = aConvDics.getLength();
 174     const uno::Reference< XConversionDictionary > *pDic = aConvDics.getConstArray();
 175     for (INT32 i = 0;  i < nLen;  ++i)
 176     {
 177         uno::Reference< util::XFlushable > xFlush( pDic[i] , UNO_QUERY );
 178         if (xFlush.is())
 179         {
 180             try
 181             {
 182                 xFlush->flush();
 183             }
 184             catch(Exception &)
 185             {
 186                 DBG_ERROR( "flushing of conversion dictionary failed" );
 187             }
 188         }
 189     }
 190 }
 191
 192
 193 INT32 ConvDicNameContainer::GetIndexByName_Impl(
 194         const OUString& rName )
 195 {
 196     INT32 nRes = -1;
 197     INT32 nLen = aConvDics.getLength();
 198     const uno::Reference< XConversionDictionary > *pDic = aConvDics.getConstArray();
 199     for (INT32 i = 0;  i < nLen && nRes == -1;  ++i)
 200     {
 201         if (rName == pDic[i]->getName())
 202             nRes = i;
 203     }
 204     return nRes;
 205 }
 206
 207
 208 uno::Reference< XConversionDictionary > ConvDicNameContainer::GetByName(
 209         const OUString& rName )
 210 {
 211     uno::Reference< XConversionDictionary > xRes;
 212     INT32 nIdx = GetIndexByName_Impl( rName );
 213     if ( nIdx != -1)
 214         xRes = aConvDics.getArray()[nIdx];
 215     return xRes;
 216 }
 217
 218
 219 uno::Type SAL_CALL ConvDicNameContainer::getElementType(  )
 220     throw (RuntimeException)
 221 {
 222     MutexGuard  aGuard( GetLinguMutex() );
 223     return uno::Type( ::getCppuType( (uno::Reference< XConversionDictionary > *) 0) );
 224 }
 225
 226
 227 sal_Bool SAL_CALL ConvDicNameContainer::hasElements(  )
 228     throw (RuntimeException)
 229 {
 230     MutexGuard  aGuard( GetLinguMutex() );
 231     return aConvDics.getLength() > 0;
 232 }
 233
 234
 235 uno::Any SAL_CALL ConvDicNameContainer::getByName( const OUString& rName )
 236     throw (NoSuchElementException, WrappedTargetException, RuntimeException)
 237 {
 238     MutexGuard  aGuard( GetLinguMutex() );
 239     uno::Reference< XConversionDictionary > xRes( GetByName( rName ) );
 240     if (!xRes.is())
 241         throw NoSuchElementException();
 242     return makeAny( xRes );
 243 }
 244
 245
 246 uno::Sequence< OUString > SAL_CALL ConvDicNameContainer::getElementNames(  )
 247     throw (RuntimeException)
 248 {
 249     MutexGuard  aGuard( GetLinguMutex() );
 250
 251     INT32 nLen = aConvDics.getLength();
 252     uno::Sequence< OUString > aRes( nLen );
 253     OUString *pName = aRes.getArray();
 254     const uno::Reference< XConversionDictionary > *pDic = aConvDics.getConstArray();
 255     for (INT32 i = 0;  i < nLen;  ++i)
 256         pName[i] = pDic[i]->getName();
 257     return aRes;
 258 }
 259
 260
 261 sal_Bool SAL_CALL ConvDicNameContainer::hasByName( const OUString& rName )
 262     throw (RuntimeException)
 263 {
 264     MutexGuard  aGuard( GetLinguMutex() );
 265     return GetByName( rName ).is();
 266 }
 267
 268
 269 void SAL_CALL ConvDicNameContainer::replaceByName(
 270         const OUString& rName,
 271         const uno::Any& rElement )
 272     throw (IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException)
 273 {
 274     MutexGuard  aGuard( GetLinguMutex() );
 275
 276     INT32 nRplcIdx = GetIndexByName_Impl( rName );
 277     if (nRplcIdx == -1)
 278         throw NoSuchElementException();
 279     uno::Reference< XConversionDictionary > xNew;
 280     rElement >>= xNew;
 281     if (!xNew.is() || xNew->getName() != rName)
 282         throw IllegalArgumentException();
 283     aConvDics.getArray()[ nRplcIdx ] = xNew;
 284 }
 285
 286
 287 void SAL_CALL ConvDicNameContainer::insertByName(
 288         const OUString& rName,
 289         const Any& rElement )
 290     throw (IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException)
 291 {
 292     MutexGuard  aGuard( GetLinguMutex() );
 293
 294     if (GetByName( rName ).is())
 295         throw ElementExistException();
 296     uno::Reference< XConversionDictionary > xNew;
 297     rElement >>= xNew;
 298     if (!xNew.is() || xNew->getName() != rName)
 299         throw IllegalArgumentException();
 300
 301     INT32 nLen = aConvDics.getLength();
 302     aConvDics.realloc( nLen + 1 );
 303     aConvDics.getArray()[ nLen ] = xNew;
 304 }
 305
 306
 307 void SAL_CALL ConvDicNameContainer::removeByName( const OUString& rName )
 308     throw (NoSuchElementException, WrappedTargetException, RuntimeException)
 309 {
 310     MutexGuard  aGuard( GetLinguMutex() );
 311
 312     INT32 nRplcIdx = GetIndexByName_Impl( rName );
 313     if (nRplcIdx == -1)
 314         throw NoSuchElementException();
 315
 316     // physically remove dictionary
 317     uno::Reference< XConversionDictionary > xDel = aConvDics.getArray()[nRplcIdx];
 318     String aName( xDel->getName() );
 319     String aDicMainURL( GetConvDicMainURL( aName, GetDictionaryWriteablePath() ) );
 320     INetURLObject aObj( aDicMainURL );
 321     DBG_ASSERT( aObj.GetProtocol() == INET_PROT_FILE, "+HangulHanjaOptionsDialog::OkHdl(): non-file URLs cannot be deleted" );
 322     if( aObj.GetProtocol() == INET_PROT_FILE )
 323     {
 324         try
 325         {
 326             ::ucbhelper::Content        aCnt( aObj.GetMainURL( INetURLObject::NO_DECODE ),
 327                                     uno::Reference< ::com::sun::star::ucb::XCommandEnvironment > () );
 328             aCnt.executeCommand( OUString::createFromAscii( "delete" ), makeAny( sal_Bool( sal_True ) ) );
 329         }
 330         catch( ::com::sun::star::ucb::CommandAbortedException& )
 331         {
 332             DBG_ERRORFILE( "HangulHanjaOptionsDialog::OkHdl(): CommandAbortedException" );
 333         }
 334         catch( ... )
 335         {
 336             DBG_ERRORFILE( "HangulHanjaOptionsDialog::OkHdl(): Any other exception" );
 337         }
 338     }
 339
 340     INT32 nLen = aConvDics.getLength();
 341     uno::Reference< XConversionDictionary > *pDic = aConvDics.getArray();
 342     for (INT32 i = nRplcIdx;  i < nLen - 1;  ++i)
 343         pDic[i] = pDic[i + 1];
 344     aConvDics.realloc( nLen - 1 );
 345 }
 346
 347
 348 void ConvDicNameContainer::AddConvDics(
 349         const String &rSearchDirPathURL,
 350         const String &rExtension )
 351 {
 352     const Sequence< OUString > aDirCnt(
 353                 utl::LocalFileHelper::GetFolderContents( rSearchDirPathURL, FALSE ) );
 354     const OUString *pDirCnt = aDirCnt.getConstArray();
 355     INT32 nEntries = aDirCnt.getLength();
 356
 357     for (INT32 i = 0;  i < nEntries;  ++i)
 358     {
 359         String  aURL( pDirCnt[i] );
 360
 361         xub_StrLen nPos  = aURL.SearchBackward('.');
 362         String  aExt(aURL.Copy(nPos + 1));
 363         aExt.ToLowerAscii();
 364         String  aSearchExt( rExtension );
 365         aSearchExt.ToLowerAscii();
 366         if(aExt != aSearchExt)
 367             continue;          // skip other files
 368
 369         INT16 nLang;
 370         sal_Int16 nConvType;
 371         if (IsConvDic( aURL, nLang, nConvType ))
 372         {
 373             // get decoded dictionary file name
 374             INetURLObject aURLObj( aURL );
 375             String aDicName = aURLObj.getBase( INetURLObject::LAST_SEGMENT,
 376                         true, INetURLObject::DECODE_WITH_CHARSET,
 377                         RTL_TEXTENCODING_UTF8 );
 378
 379             uno::Reference < XConversionDictionary > xDic;
 380             if (nLang == LANGUAGE_KOREAN &&
 381                 nConvType == ConversionDictionaryType::HANGUL_HANJA)
 382             {
 383                 xDic = new HHConvDic( aDicName, aURL );
 384             }
 385             else if ((nLang == LANGUAGE_CHINESE_SIMPLIFIED || nLang == LANGUAGE_CHINESE_TRADITIONAL) &&
 386                       nConvType == ConversionDictionaryType::SCHINESE_TCHINESE)
 387             {
 388                 xDic = new ConvDic( aDicName, nLang, nConvType, FALSE, aURL );
 389             }
 390
 391             if (xDic.is())
 392             {
 393                 uno::Any aAny;
 394                 aAny <<= xDic;
 395                 insertByName( xDic->getName(), aAny );
 396             }
 397         }
 398     }
 399 }
 400
 401 ///////////////////////////////////////////////////////////////////////////
 402
 403 namespace
 404 {
 405 template<typename T, typename InitData,
 406          typename Unique = InitData, typename Data = T>
 407 class StaticWithInit_ {
 408 public:
 409     /** Gets the static.  Mutual exclusion is performed using the
 410         osl global mutex.
 411
 412         @return
 413                 static variable
 414     */
 415     static T & get() {
 416         return *rtl_Instance<
 417             T, StaticInstanceWithInit,
 418             ::osl::MutexGuard, ::osl::GetGlobalMutex,
 419             Data, InitData >::create( StaticInstanceWithInit(),
 420                                       ::osl::GetGlobalMutex(),
 421                                       InitData() );
 422     }
 423 private:
 424     struct StaticInstanceWithInit {
 425         T * operator () ( Data d ) {
 426             static T instance(d);
 427             return &instance;
 428         }
 429     };
 430 };
 431
 432 //after src680m62 you can replace StaticWithInit_ with rtl::StaticWithInit and remove the above definition of StaticWithInit_
 433
 434 struct StaticConvDicList : public StaticWithInit_<
 435     uno::Reference<XInterface>, StaticConvDicList> {
 436     uno::Reference<XInterface> operator () () {
 437         return (cppu::OWeakObject *) new ConvDicList;
 438     }
 439 };
 440 }
 441
 442
 443 void ConvDicList::MyAppExitListener::AtExit()
 444 {
 445     rMyDicList.FlushDics();
 446     StaticConvDicList::get().clear();
 447 }
 448
 449 ConvDicList::ConvDicList() :
 450     aEvtListeners( GetLinguMutex() )
 451 {
 452     pNameContainer = 0;
 453     bDisposing = FALSE;
 454
 455     pExitListener = new MyAppExitListener( *this );
 456     xExitListener = pExitListener;
 457     pExitListener->Activate();
 458 }
 459
 460
 461 ConvDicList::~ConvDicList()
 462 {
 463     // NameContainer will deleted when the reference xNameContainer
 464     // is destroyed.
 465     // delete pNameContainer;
 466
 467     if (!bDisposing && pNameContainer)
 468         pNameContainer->FlushDics();
 469
 470     pExitListener->Deactivate();
 471 }
 472
 473
 474 void ConvDicList::FlushDics()
 475 {
 476     // check only pointer to avoid creating the container when
 477     // the dictionaries were not accessed yet
 478     if (pNameContainer)
 479         pNameContainer->FlushDics();
 480 }
 481
 482
 483 ConvDicNameContainer & ConvDicList::GetNameContainer()
 484 {
 485     if (!pNameContainer)
 486     {
 487         pNameContainer = new ConvDicNameContainer( *this );
 488         pNameContainer->AddConvDics( GetDictionaryWriteablePath(),
 489                                      A2OU( CONV_DIC_EXT ) );
 490         xNameContainer = pNameContainer;
 491
 492         // access list of text conversion dictionaries to activate
 493         SvtLinguOptions aOpt;
 494         SvtLinguConfig().GetOptions( aOpt );
 495         INT32 nLen = aOpt.aActiveConvDics.getLength();
 496         const OUString *pActiveConvDics = aOpt.aActiveConvDics.getConstArray();
 497         for (INT32 i = 0;  i < nLen;  ++i)
 498         {
 499             uno::Reference< XConversionDictionary > xDic =
 500                     pNameContainer->GetByName( pActiveConvDics[i] );
 501             if (xDic.is())
 502                 xDic->setActive( sal_True );
 503         }
 504
 505         // since there is no UI to active/deactivate the dictionaries
 506         // for chinese text conversion they should be activated by default
 507         uno::Reference< XConversionDictionary > xS2TDic(
 508                     pNameContainer->GetByName( A2OU("ChineseS2T") ), UNO_QUERY );
 509         uno::Reference< XConversionDictionary > xT2SDic(
 510                     pNameContainer->GetByName( A2OU("ChineseT2S") ), UNO_QUERY );
 511             if (xS2TDic.is())
 512                 xS2TDic->setActive( sal_True );
 513             if (xT2SDic.is())
 514                 xT2SDic->setActive( sal_True );
 515
 516     }
 517     return *pNameContainer;
 518 }
 519
 520
 521 uno::Reference< container::XNameContainer > SAL_CALL ConvDicList::getDictionaryContainer(  ) throw (RuntimeException)
 522 {
 523     MutexGuard  aGuard( GetLinguMutex() );
 524     GetNameContainer();
 525     DBG_ASSERT( xNameContainer.is(), "missing name container" );
 526     return xNameContainer;
 527 }
 528
 529
 530 uno::Reference< XConversionDictionary > SAL_CALL ConvDicList::addNewDictionary(
 531         const OUString& rName,
 532         const Locale& rLocale,
 533         sal_Int16 nConvDicType )
 534     throw (NoSupportException, ElementExistException, RuntimeException)
 535 {
 536     MutexGuard  aGuard( GetLinguMutex() );
 537
 538     INT16 nLang = LocaleToLanguage( rLocale );
 539
 540     if (GetNameContainer().hasByName( rName ))
 541         throw ElementExistException();
 542
 543     uno::Reference< XConversionDictionary > xRes;
 544     String aDicMainURL( GetConvDicMainURL( rName, GetDictionaryWriteablePath() ) );
 545     if (nLang == LANGUAGE_KOREAN &&
 546         nConvDicType == ConversionDictionaryType::HANGUL_HANJA)
 547     {
 548         xRes = new HHConvDic( rName, aDicMainURL );
 549     }
 550     else if ((nLang == LANGUAGE_CHINESE_SIMPLIFIED || nLang == LANGUAGE_CHINESE_TRADITIONAL) &&
 551               nConvDicType == ConversionDictionaryType::SCHINESE_TCHINESE)
 552     {
 553         xRes = new ConvDic( rName, nLang, nConvDicType, FALSE, aDicMainURL );
 554     }
 555
 556     if (!xRes.is())
 557         throw NoSupportException();
 558     else
 559     {
 560         xRes->setActive( sal_True );
 561         uno::Any aAny;
 562         aAny <<= xRes;
 563         GetNameContainer().insertByName( rName, aAny );
 564     }
 565     return xRes;
 566 }
 567
 568
 569 uno::Sequence< OUString > SAL_CALL ConvDicList::queryConversions(
 570         const OUString& rText,
 571         sal_Int32 nStartPos,
 572         sal_Int32 nLength,
 573         const Locale& rLocale,
 574         sal_Int16 nConversionDictionaryType,
 575         ConversionDirection eDirection,
 576         sal_Int32 nTextConversionOptions )
 577     throw (IllegalArgumentException, NoSupportException, RuntimeException)
 578 {
 579     MutexGuard  aGuard( GetLinguMutex() );
 580
 581     /*INT16 nLang = LocaleToLanguage( rLocale );*/
 582
 583     INT32 nCount = 0;
 584     uno::Sequence< OUString > aRes( 20 );
 585     OUString *pRes = aRes.getArray();
 586
 587     sal_Bool bSupported = sal_False;
 588     INT32 nLen = GetNameContainer().GetCount();
 589     for (INT32 i = 0;  i < nLen;  ++i)
 590     {
 591         const uno::Reference< XConversionDictionary > xDic( GetNameContainer().GetByIndex(i) );
 592         sal_Bool bMatch =   xDic.is()  &&
 593                             xDic->getLocale() == rLocale  &&
 594                             xDic->getConversionType() == nConversionDictionaryType;
 595         bSupported |= bMatch;
 596         if (bMatch  &&  xDic->isActive())
 597         {
 598             Sequence< OUString > aNewConv( xDic->getConversions(
 599                                 rText, nStartPos, nLength,
 600                                 eDirection, nTextConversionOptions ) );
 601             INT32 nNewLen = aNewConv.getLength();
 602             if (nNewLen > 0)
 603             {
 604                 if (nCount + nNewLen > aRes.getLength())
 605                 {
 606                     aRes.realloc( nCount + nNewLen + 20 );
 607                     pRes = aRes.getArray();
 608                 }
 609                 const OUString *pNewConv = aNewConv.getConstArray();
 610                 for (INT32 k = 0;  k < nNewLen;  ++k)
 611                     pRes[nCount++] = pNewConv[k];
 612             }
 613         }
 614     }
 615
 616     if (!bSupported)
 617         throw NoSupportException();
 618
 619     aRes.realloc( nCount );
 620     return aRes;
 621 }
 622
 623
 624 sal_Int16 SAL_CALL ConvDicList::queryMaxCharCount(
 625         const Locale& rLocale,
 626         sal_Int16 nConversionDictionaryType,
 627         ConversionDirection eDirection )
 628     throw (RuntimeException)
 629 {
 630     MutexGuard  aGuard( GetLinguMutex() );
 631
 632     sal_Int16 nRes = 0;
 633     GetNameContainer();
 634     INT32 nLen = GetNameContainer().GetCount();
 635     for (INT32 i = 0;  i < nLen;  ++i)
 636     {
 637         const uno::Reference< XConversionDictionary > xDic( GetNameContainer().GetByIndex(i) );
 638         if (xDic.is()  &&
 639             xDic->getLocale() == rLocale  &&
 640             xDic->getConversionType() == nConversionDictionaryType)
 641         {
 642             sal_Int16 nC = xDic->getMaxCharCount( eDirection );
 643             if (nC > nRes)
 644                 nRes = nC;
 645         }
 646     }
 647     return nRes;
 648 }
 649
 650
 651 void SAL_CALL ConvDicList::dispose(  )
 652     throw (RuntimeException)
 653 {
 654     MutexGuard  aGuard( GetLinguMutex() );
 655     if (!bDisposing)
 656     {
 657         bDisposing = TRUE;
 658         EventObject aEvtObj( (XConversionDictionaryList *) this );
 659         aEvtListeners.disposeAndClear( aEvtObj );
 660
 661         FlushDics();
 662     }
 663 }
 664
 665
 666 void SAL_CALL ConvDicList::addEventListener(
 667         const uno::Reference< XEventListener >& rxListener )
 668     throw (RuntimeException)
 669 {
 670     MutexGuard  aGuard( GetLinguMutex() );
 671     if (!bDisposing && rxListener.is())
 672         aEvtListeners.addInterface( rxListener );
 673 }
 674
 675
 676 void SAL_CALL ConvDicList::removeEventListener(
 677         const uno::Reference< XEventListener >& rxListener )
 678     throw (RuntimeException)
 679 {
 680     MutexGuard  aGuard( GetLinguMutex() );
 681     if (!bDisposing && rxListener.is())
 682         aEvtListeners.removeInterface( rxListener );
 683 }
 684
 685
 686 OUString SAL_CALL ConvDicList::getImplementationName(  )
 687     throw (RuntimeException)
 688 {
 689     MutexGuard  aGuard( GetLinguMutex() );
 690     return getImplementationName_Static();
 691 }
 692
 693
 694 sal_Bool SAL_CALL ConvDicList::supportsService( const OUString& rServiceName )
 695     throw (RuntimeException)
 696 {
 697     MutexGuard  aGuard( GetLinguMutex() );
 698     return rServiceName.equalsAscii( SN_CONV_DICTIONARY_LIST );
 699 }
 700
 701
 702 uno::Sequence< OUString > SAL_CALL ConvDicList::getSupportedServiceNames(  )
 703     throw (RuntimeException)
 704 {
 705     MutexGuard  aGuard( GetLinguMutex() );
 706     return getSupportedServiceNames_Static();
 707 }
 708
 709
 710 uno::Sequence< OUString > ConvDicList::getSupportedServiceNames_Static()
 711     throw()
 712 {
 713     uno::Sequence< OUString > aSNS( 1 );
 714     aSNS.getArray()[0] = A2OU( SN_CONV_DICTIONARY_LIST );
 715     return aSNS;
 716 }
 717
 718
 719 ///////////////////////////////////////////////////////////////////////////
 720
 721 uno::Reference< uno::XInterface > SAL_CALL ConvDicList_CreateInstance(
 722         const uno::Reference< XMultiServiceFactory > & /*rSMgr*/ )
 723     throw(Exception)
 724 {
 725     return StaticConvDicList::get();
 726 }
 727
 728
 729 sal_Bool SAL_CALL ConvDicList_writeInfo(
 730     void * /*pServiceManager*/, registry::XRegistryKey * pRegistryKey )
 731 {
 732     try
 733     {
 734         String aImpl( '/' );
 735         aImpl += ConvDicList::getImplementationName_Static().getStr();
 736         aImpl.AppendAscii( "/UNO/SERVICES" );
 737         uno::Reference< registry::XRegistryKey > xNewKey =
 738                 pRegistryKey->createKey(aImpl );
 739         uno::Sequence< OUString > aServices =
 740                 ConvDicList::getSupportedServiceNames_Static();
 741         for( INT32 i = 0; i < aServices.getLength(); i++ )
 742             xNewKey->createKey( aServices.getConstArray()[i]);
 743
 744         return sal_True;
 745     }
 746     catch(Exception &)
 747     {
 748         return sal_False;
 749     }
 750 }
 751
 752
 753 void * SAL_CALL ConvDicList_getFactory(
 754         const sal_Char * pImplName,
 755         XMultiServiceFactory * pServiceManager, void *  )
 756 {
 757     void * pRet = 0;
 758     if ( !ConvDicList::getImplementationName_Static().compareToAscii( pImplName ) )
 759     {
 760         uno::Reference< XSingleServiceFactory > xFactory =
 761             cppu::createOneInstanceFactory(
 762                 pServiceManager,
 763                 ConvDicList::getImplementationName_Static(),
 764                 ConvDicList_CreateInstance,
 765                 ConvDicList::getSupportedServiceNames_Static());
 766         // acquire, because we return an interface pointer instead of a reference
 767         xFactory->acquire();
 768         pRet = xFactory.get();
 769     }
 770     return pRet;
 771 }
 772
 773 ///////////////////////////////////////////////////////////////////////////
 774