linguistic/source/convdic.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: convdic.cxx,v $
  10  * $Revision: 1.13 $
  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 <i18npool/lang.h>
  34 #include <tools/urlobj.hxx>
  35 #include <tools/debug.hxx>
  36 #include <tools/fsys.hxx>
  37 #include <tools/stream.hxx>
  38 #include <tools/string.hxx>
  39 #include <tools/stream.hxx>
  40 #include <sfx2/docfile.hxx>
  41 #include <osl/mutex.hxx>
  42 #include <unotools/processfactory.hxx>
  43 #include <ucbhelper/content.hxx>
  44
  45 #include <cppuhelper/factory.hxx>   // helper for factories
  46 #include <com/sun/star/linguistic2/XConversionDictionary.hpp>
  47 #include <com/sun/star/linguistic2/ConversionDictionaryType.hpp>
  48 #include <com/sun/star/linguistic2/XConversionPropertyType.hpp>
  49 #include <com/sun/star/linguistic2/ConversionPropertyType.hpp>
  50 #include <com/sun/star/util/XFlushable.hpp>
  51 #include <com/sun/star/lang/Locale.hpp>
  52 #include <com/sun/star/lang/EventObject.hpp>
  53 #ifndef _COM_SUN_STAR_UNO_REFERENCE_HPP_
  54 #include <com/sun/star/uno/Reference.h>
  55 #endif
  56 #include <com/sun/star/registry/XRegistryKey.hpp>
  57 #include <com/sun/star/util/XFlushListener.hpp>
  58 #include <com/sun/star/io/XActiveDataSource.hpp>
  59 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
  60 #include <com/sun/star/document/XFilter.hpp>
  61 #include <com/sun/star/beans/PropertyValue.hpp>
  62 #include <com/sun/star/xml/sax/InputSource.hpp>
  63 #include <com/sun/star/xml/sax/XParser.hpp>
  64 #include <unotools/streamwrap.hxx>
  65
  66
  67 #include "convdic.hxx"
  68 #include "convdicxml.hxx"
  69 #include "misc.hxx"
  70 #include "defs.hxx"
  71
  72 using namespace std;
  73 using namespace utl;
  74 using namespace osl;
  75 using namespace rtl;
  76 using namespace com::sun::star;
  77 using namespace com::sun::star::lang;
  78 using namespace com::sun::star::uno;
  79 using namespace com::sun::star::linguistic2;
  80 using namespace linguistic;
  81
  82 #define SN_CONV_DICTIONARY      "com.sun.star.linguistic2.ConversionDictionary"
  83 #define SN_HCD_CONV_DICTIONARY  "com.sun.star.linguistic2.HangulHanjaConversionDictionary"
  84
  85
  86 ///////////////////////////////////////////////////////////////////////////
  87
  88 void ReadThroughDic( const String &rMainURL, ConvDicXMLImport &rImport )
  89 {
  90     if (rMainURL.Len() == 0)
  91         return;
  92
  93     // get stream to be used
  94     DBG_ASSERT(!INetURLObject( rMainURL ).HasError(), "invalid URL");
  95     SfxMedium aMedium( rMainURL, STREAM_READ | STREAM_SHARE_DENYWRITE, FALSE );
  96     SvStream *pStream = aMedium.GetInStream();
  97     DBG_ASSERT( pStream, "input stream missing" );
  98     if (!pStream || pStream->GetError())
  99         return;
 100
 101     uno::Reference< lang::XMultiServiceFactory > xServiceFactory(
 102             utl::getProcessServiceFactory() );
 103     DBG_ASSERT( xServiceFactory.is(), "XMLReader::Read: got no service manager" );
 104     if (!xServiceFactory.is())
 105         return;
 106
 107     uno::Reference< io::XInputStream > xIn = new utl::OInputStreamWrapper( *pStream );
 108     DBG_ASSERT( xIn.is(), "input stream missing" );
 109
 110     ULONG nError = sal::static_int_cast< ULONG >(-1);
 111
 112     // prepare ParserInputSource
 113     xml::sax::InputSource aParserInput;
 114     aParserInput.aInputStream = xIn;
 115
 116     // get parser
 117     uno::Reference< xml::sax::XParser > xParser;
 118     try
 119     {
 120         xParser = uno::Reference< xml::sax::XParser >( xServiceFactory->createInstance(
 121             A2OU( "com.sun.star.xml.sax.Parser" ) ), UNO_QUERY );
 122     }
 123     catch (uno::Exception &)
 124     {
 125     }
 126     DBG_ASSERT( xParser.is(), "Can't create parser" );
 127     if (!xParser.is())
 128         return;
 129
 130     // get filter
 131     //ConvDicXMLImport *pImport = new ConvDicXMLImport( this, rMainURL );
 132     //!! keep a reference until everything is done to
 133     //!! ensure the proper lifetime of the object
 134     uno::Reference < xml::sax::XDocumentHandler > xFilter(
 135             (xml::sax::XExtendedDocumentHandler *) &rImport, UNO_QUERY );
 136
 137     // connect parser and filter
 138     xParser->setDocumentHandler( xFilter );
 139
 140     // finally, parser the stream
 141     try
 142     {
 143         xParser->parseStream( aParserInput );   // implicitly calls ConvDicXMLImport::CreateContext
 144         if (rImport.GetSuccess())
 145             nError = 0;
 146     }
 147     catch( xml::sax::SAXParseException& )
 148     {
 149 //        if( bEncrypted )
 150 //            nError = ERRCODE_SFX_WRONGPASSWORD;
 151     }
 152     catch( xml::sax::SAXException& )
 153     {
 154 //        if( bEncrypted )
 155 //            nError = ERRCODE_SFX_WRONGPASSWORD;
 156     }
 157     catch( io::IOException& )
 158     {
 159     }
 160 }
 161
 162
 163 BOOL IsConvDic( const String &rFileURL, INT16 &nLang, sal_Int16 &nConvType )
 164 {
 165     BOOL bRes = FALSE;
 166
 167     if (rFileURL.Len() == 0)
 168         return bRes;
 169
 170     // check if file extension matches CONV_DIC_EXT
 171     String aExt;
 172     xub_StrLen nPos = rFileURL.SearchBackward( '.' );
 173     if (STRING_NOTFOUND != nPos)
 174         aExt = rFileURL.Copy( nPos + 1 );
 175     aExt.ToLowerAscii();
 176     if (!aExt.EqualsAscii( CONV_DIC_EXT ))
 177         return bRes;
 178
 179     // first argument being 0 should stop the file from being parsed
 180     // up to the end (reading all entries) when the required
 181     // data (language, conversion type) is found.
 182     ConvDicXMLImport *pImport = new ConvDicXMLImport( 0, rFileURL );
 183
 184     //!! keep a first reference to ensure the lifetime of the object !!
 185     uno::Reference< XInterface > xRef( (document::XFilter *) pImport, UNO_QUERY );
 186
 187     ReadThroughDic( rFileURL, *pImport );    // will implicitly add the entries
 188     bRes =  pImport->GetLanguage() != LANGUAGE_NONE &&
 189             pImport->GetConversionType() != -1;
 190     DBG_ASSERT( bRes, "conversion dictionary corrupted?" );
 191
 192     if (bRes)
 193     {
 194         nLang       = pImport->GetLanguage();
 195         nConvType   = pImport->GetConversionType();
 196     }
 197
 198     return bRes;
 199 }
 200
 201
 202 ///////////////////////////////////////////////////////////////////////////
 203
 204 ConvDic::ConvDic(
 205         const String &rName,
 206         INT16 nLang,
 207         sal_Int16 nConvType,
 208              BOOL bBiDirectional,
 209         const String &rMainURL) :
 210     aFlushListeners( GetLinguMutex() )
 211 {
 212     aName           = rName;
 213     nLanguage       = nLang;
 214     nConversionType = nConvType;
 215     aMainURL        = rMainURL;
 216
 217     if (bBiDirectional)
 218         pFromRight = std::auto_ptr< ConvMap >( new ConvMap );
 219     if (nLang == LANGUAGE_CHINESE_SIMPLIFIED || nLang == LANGUAGE_CHINESE_TRADITIONAL)
 220         pConvPropType = std::auto_ptr< PropTypeMap >( new PropTypeMap );
 221
 222     nMaxLeftCharCount = nMaxRightCharCount = 0;
 223     bMaxCharCountIsValid = TRUE;
 224
 225     bNeedEntries = TRUE;
 226     bIsModified  = bIsActive = FALSE;
 227     bIsReadonly = FALSE;
 228
 229     if( rMainURL.Len() > 0 )
 230     {
 231         BOOL bExists = FALSE;
 232         bIsReadonly = IsReadOnly( rMainURL, &bExists );
 233
 234         if( !bExists )  // new empty dictionary
 235         {
 236             bNeedEntries = FALSE;
 237             //! create physical representation of an **empty** dictionary
 238             //! that could be found by the dictionary-list implementation
 239             // (Note: empty dictionaries are not just empty files!)
 240             Save();
 241             bIsReadonly = IsReadOnly( rMainURL );   // will be FALSE if Save was succesfull
 242         }
 243     }
 244     else
 245     {
 246         bNeedEntries = FALSE;
 247     }
 248 }
 249
 250
 251 ConvDic::~ConvDic()
 252 {
 253 }
 254
 255
 256 void ConvDic::Load()
 257 {
 258     DBG_ASSERT( !bIsModified, "dictionary is modified. Really do 'Load'?" );
 259
 260     //!! prevent function from being called recursively via HasEntry, AddEntry
 261     bNeedEntries = FALSE;
 262
 263     ConvDicXMLImport *pImport = new ConvDicXMLImport( this, aMainURL );
 264     //!! keep a first reference to ensure the lifetime of the object !!
 265     uno::Reference< XInterface > xRef( (document::XFilter *) pImport, UNO_QUERY );
 266     ReadThroughDic( aMainURL, *pImport );    // will implicitly add the entries
 267
 268     bIsModified = FALSE;
 269 }
 270
 271
 272 void ConvDic::Save()
 273 {
 274     DBG_ASSERT( !bNeedEntries, "saving while entries missing" );
 275     if (aMainURL.Len() == 0 || bNeedEntries)
 276         return;
 277
 278     DBG_ASSERT(!INetURLObject( aMainURL ).HasError(), "invalid URL");
 279     SfxMedium   aMedium( aMainURL, STREAM_WRITE | STREAM_TRUNC | STREAM_SHARE_DENYALL,
 280                          FALSE );
 281     aMedium.CreateTempFile();   // use temp file to write to...
 282
 283     SvStream *pStream = aMedium.GetOutStream();
 284     DBG_ASSERT( pStream, "output stream missing" );
 285     if (!pStream || pStream->GetError())
 286         return;
 287     uno::Reference< io::XOutputStream > xOut(
 288             new utl::OOutputStreamWrapper( *pStream ) );
 289     DBG_ASSERT( xOut.is(), "output stream missing" );
 290
 291     // get XML writer
 292     uno::Reference< lang::XMultiServiceFactory > xServiceFactory(
 293             utl::getProcessServiceFactory() );
 294     uno::Reference< io::XActiveDataSource > xSaxWriter;
 295     if (xServiceFactory.is())
 296     {
 297         try
 298         {
 299             xSaxWriter = uno::Reference< io::XActiveDataSource >(
 300                     xServiceFactory->createInstance(
 301                     OUString::createFromAscii( "com.sun.star.xml.sax.Writer" ) ), UNO_QUERY );
 302         }
 303         catch (uno::Exception &)
 304         {
 305         }
 306     }
 307     DBG_ASSERT( xSaxWriter.is(), "can't instantiate XML writer" );
 308
 309     if (xSaxWriter.is() && xOut.is())
 310     {
 311         // connect XML writer to output stream
 312         xSaxWriter->setOutputStream( xOut );
 313
 314         // prepare arguments (prepend doc handler to given arguments)
 315         uno::Reference< xml::sax::XDocumentHandler > xDocHandler( xSaxWriter, UNO_QUERY );
 316
 317         ConvDicXMLExport *pExport = new ConvDicXMLExport( *this, aMainURL, xDocHandler );
 318         //!! keep a first(!) reference until everything is done to
 319         //!! ensure the proper lifetime of the object
 320         uno::Reference< document::XFilter > aRef( (document::XFilter *) pExport );
 321         sal_Bool bRet = pExport->Export( aMedium );     // write entries to file
 322         DBG_ASSERT( !pStream->GetError(), "I/O error while writing to stream" );
 323         if (bRet)
 324         {
 325             // flush file, close it and release any lock
 326             aMedium.Close();
 327             aMedium.Commit();
 328             bIsModified = FALSE;
 329         }
 330     }
 331     DBG_ASSERT( !bIsModified, "dictionary still modified after save. Save failed?" );
 332 }
 333
 334
 335 ConvMap::iterator ConvDic::GetEntry( ConvMap &rMap, const rtl::OUString &rFirstText, const rtl::OUString &rSecondText )
 336 {
 337     pair< ConvMap::iterator, ConvMap::iterator > aRange =
 338             rMap.equal_range( rFirstText );
 339     ConvMap::iterator aPos = rMap.end();
 340     for (ConvMap::iterator aIt = aRange.first;
 341          aIt != aRange.second  &&  aPos == rMap.end();
 342          ++aIt)
 343     {
 344         if ((*aIt).second == rSecondText)
 345             aPos = aIt;
 346     }
 347     return aPos;
 348 }
 349
 350
 351 BOOL ConvDic::HasEntry( const OUString &rLeftText, const OUString &rRightText )
 352 {
 353     if (bNeedEntries)
 354         Load();
 355     ConvMap::iterator aIt = GetEntry( aFromLeft, rLeftText, rRightText );
 356     return aIt != aFromLeft.end();
 357 }
 358
 359
 360 void ConvDic::AddEntry( const OUString &rLeftText, const OUString &rRightText )
 361 {
 362     if (bNeedEntries)
 363         Load();
 364
 365     DBG_ASSERT(!HasEntry( rLeftText, rRightText), "entry already exists" );
 366     aFromLeft .insert( ConvMap::value_type( rLeftText, rRightText ) );
 367     if (pFromRight.get())
 368         pFromRight->insert( ConvMap::value_type( rRightText, rLeftText ) );
 369
 370     if (bMaxCharCountIsValid)
 371     {
 372         if (rLeftText.getLength() > nMaxLeftCharCount)
 373             nMaxLeftCharCount   = (sal_Int16) rLeftText.getLength();
 374         if (pFromRight.get() && rRightText.getLength() > nMaxRightCharCount)
 375             nMaxRightCharCount  = (sal_Int16) rRightText.getLength();
 376     }
 377
 378     bIsModified = TRUE;
 379 }
 380
 381
 382 void ConvDic::RemoveEntry( const OUString &rLeftText, const OUString &rRightText )
 383 {
 384     if (bNeedEntries)
 385         Load();
 386
 387     ConvMap::iterator aLeftIt  = GetEntry( aFromLeft,  rLeftText,  rRightText );
 388     DBG_ASSERT( aLeftIt  != aFromLeft.end(),  "left map entry missing" );
 389     aFromLeft .erase( aLeftIt );
 390
 391     if (pFromRight.get())
 392     {
 393         ConvMap::iterator aRightIt = GetEntry( *pFromRight, rRightText, rLeftText );
 394         DBG_ASSERT( aRightIt != pFromRight->end(), "right map entry missing" );
 395         pFromRight->erase( aRightIt );
 396     }
 397
 398     bIsModified = TRUE;
 399     bMaxCharCountIsValid = FALSE;
 400 }
 401
 402
 403 OUString SAL_CALL ConvDic::getName(  )
 404     throw (RuntimeException)
 405 {
 406     MutexGuard  aGuard( GetLinguMutex() );
 407     return aName;
 408 }
 409
 410
 411 Locale SAL_CALL ConvDic::getLocale(  )
 412     throw (RuntimeException)
 413 {
 414     MutexGuard  aGuard( GetLinguMutex() );
 415     return CreateLocale( nLanguage );
 416 }
 417
 418
 419 sal_Int16 SAL_CALL ConvDic::getConversionType(  )
 420     throw (RuntimeException)
 421 {
 422     MutexGuard  aGuard( GetLinguMutex() );
 423     return nConversionType;
 424 }
 425
 426
 427 void SAL_CALL ConvDic::setActive( sal_Bool bActivate )
 428     throw (RuntimeException)
 429 {
 430     MutexGuard  aGuard( GetLinguMutex() );
 431     bIsActive = bActivate;
 432 }
 433
 434
 435 sal_Bool SAL_CALL ConvDic::isActive(  )
 436     throw (RuntimeException)
 437 {
 438     MutexGuard  aGuard( GetLinguMutex() );
 439     return bIsActive;
 440 }
 441
 442
 443 void SAL_CALL ConvDic::clear(  )
 444     throw (RuntimeException)
 445 {
 446     MutexGuard  aGuard( GetLinguMutex() );
 447     aFromLeft .clear();
 448     if (pFromRight.get())
 449         pFromRight->clear();
 450     bNeedEntries    = FALSE;
 451     bIsModified     = TRUE;
 452     nMaxLeftCharCount       = 0;
 453     nMaxRightCharCount      = 0;
 454     bMaxCharCountIsValid    = TRUE;
 455 }
 456
 457
 458 uno::Sequence< OUString > SAL_CALL ConvDic::getConversions(
 459         const OUString& aText,
 460         sal_Int32 nStartPos,
 461         sal_Int32 nLength,
 462         ConversionDirection eDirection,
 463         sal_Int32 /*nTextConversionOptions*/ )
 464     throw (IllegalArgumentException, RuntimeException)
 465 {
 466     MutexGuard  aGuard( GetLinguMutex() );
 467
 468     if (!pFromRight.get() && eDirection == ConversionDirection_FROM_RIGHT)
 469         return uno::Sequence< OUString >();
 470
 471     if (bNeedEntries)
 472         Load();
 473
 474     OUString aLookUpText( aText.copy(nStartPos, nLength) );
 475     ConvMap &rConvMap = eDirection == ConversionDirection_FROM_LEFT ?
 476                                 aFromLeft : *pFromRight;
 477     pair< ConvMap::iterator, ConvMap::iterator > aRange =
 478             rConvMap.equal_range( aLookUpText );
 479
 480     INT32 nCount = 0;
 481     ConvMap::iterator aIt;
 482     for (aIt = aRange.first;  aIt != aRange.second;  ++aIt)
 483         ++nCount;
 484
 485     uno::Sequence< OUString > aRes( nCount );
 486     OUString *pRes = aRes.getArray();
 487     INT32 i = 0;
 488     for (aIt = aRange.first;  aIt != aRange.second;  ++aIt)
 489         pRes[i++] = (*aIt).second;
 490
 491     return aRes;
 492 }
 493
 494
 495 static BOOL lcl_SeqHasEntry(
 496     const OUString *pSeqStart,  // first element to check
 497     INT32 nToCheck,             // number of elements to check
 498     const OUString &rText)
 499 {
 500     BOOL bRes = FALSE;
 501     if (pSeqStart && nToCheck > 0)
 502     {
 503         const OUString *pDone = pSeqStart + nToCheck;   // one behind last to check
 504         while (!bRes && pSeqStart != pDone)
 505         {
 506             if (*pSeqStart++ == rText)
 507                 bRes = TRUE;
 508         }
 509     }
 510     return bRes;
 511 }
 512
 513 uno::Sequence< OUString > SAL_CALL ConvDic::getConversionEntries(
 514         ConversionDirection eDirection )
 515     throw (RuntimeException)
 516 {
 517     MutexGuard  aGuard( GetLinguMutex() );
 518
 519     if (!pFromRight.get() && eDirection == ConversionDirection_FROM_RIGHT)
 520         return uno::Sequence< OUString >();
 521
 522     if (bNeedEntries)
 523         Load();
 524
 525     ConvMap &rConvMap = eDirection == ConversionDirection_FROM_LEFT ?
 526                                 aFromLeft : *pFromRight;
 527     uno::Sequence< OUString > aRes( rConvMap.size() );
 528     OUString *pRes = aRes.getArray();
 529     ConvMap::iterator aIt = rConvMap.begin();
 530     INT32 nIdx = 0;
 531     while (aIt != rConvMap.end())
 532     {
 533         OUString aCurEntry( (*aIt).first );
 534         // skip duplicate entries ( duplicate = duplicate entries
 535         // respective to the evaluated side (FROM_LEFT or FROM_RIGHT).
 536         // Thus if FROM_LEFT is evaluated for pairs (A,B) and (A,C)
 537         // only one entry for A will be returned in the result)
 538         if (nIdx == 0 || !lcl_SeqHasEntry( pRes, nIdx, aCurEntry ))
 539             pRes[ nIdx++ ] = aCurEntry;
 540         ++aIt;
 541     }
 542     aRes.realloc( nIdx );
 543
 544     return aRes;
 545 }
 546
 547
 548 void SAL_CALL ConvDic::addEntry(
 549         const OUString& aLeftText,
 550         const OUString& aRightText )
 551     throw (IllegalArgumentException, container::ElementExistException, RuntimeException)
 552 {
 553     MutexGuard  aGuard( GetLinguMutex() );
 554     if (bNeedEntries)
 555         Load();
 556     if (HasEntry( aLeftText, aRightText ))
 557         throw container::ElementExistException();
 558     AddEntry( aLeftText, aRightText );
 559 }
 560
 561
 562 void SAL_CALL ConvDic::removeEntry(
 563         const OUString& aLeftText,
 564         const OUString& aRightText )
 565     throw (container::NoSuchElementException, RuntimeException)
 566 {
 567     MutexGuard  aGuard( GetLinguMutex() );
 568     if (bNeedEntries)
 569         Load();
 570     if (!HasEntry( aLeftText, aRightText ))
 571         throw container::NoSuchElementException();
 572     RemoveEntry( aLeftText, aRightText );
 573 }
 574
 575
 576 sal_Int16 SAL_CALL ConvDic::getMaxCharCount( ConversionDirection eDirection )
 577     throw (RuntimeException)
 578 {
 579     MutexGuard  aGuard( GetLinguMutex() );
 580
 581     if (!pFromRight.get() && eDirection == ConversionDirection_FROM_RIGHT)
 582     {
 583         DBG_ASSERT( nMaxRightCharCount == 0, "max right char count should be 0" );
 584         return 0;
 585     }
 586
 587     if (bNeedEntries)
 588         Load();
 589
 590     if (!bMaxCharCountIsValid)
 591     {
 592         nMaxLeftCharCount   = 0;
 593         ConvMap::iterator aIt = aFromLeft.begin();
 594         while (aIt != aFromLeft.end())
 595         {
 596             sal_Int16 nTmp = (sal_Int16) (*aIt).first.getLength();
 597             if (nTmp > nMaxLeftCharCount)
 598                 nMaxLeftCharCount = nTmp;
 599             ++aIt;
 600         }
 601
 602         nMaxRightCharCount  = 0;
 603         if (pFromRight.get())
 604         {
 605             aIt = pFromRight->begin();
 606             while (aIt != pFromRight->end())
 607             {
 608                 sal_Int16 nTmp = (sal_Int16) (*aIt).first.getLength();
 609                 if (nTmp > nMaxRightCharCount)
 610                     nMaxRightCharCount = nTmp;
 611                 ++aIt;
 612             }
 613         }
 614
 615         bMaxCharCountIsValid = TRUE;
 616     }
 617     sal_Int16 nRes = eDirection == ConversionDirection_FROM_LEFT ?
 618             nMaxLeftCharCount : nMaxRightCharCount;
 619     DBG_ASSERT( nRes >= 0, "invalid MaxCharCount" );
 620     return nRes;
 621 }
 622
 623
 624 void SAL_CALL ConvDic::setPropertyType(
 625         const OUString& rLeftText,
 626         const OUString& rRightText,
 627         sal_Int16 nPropertyType )
 628     throw (container::NoSuchElementException, IllegalArgumentException, RuntimeException)
 629 {
 630     sal_Bool bHasElement = HasEntry( rLeftText, rRightText);
 631     if (!bHasElement)
 632         throw container::NoSuchElementException();
 633
 634     // currently we assume that entries with the same left text have the
 635     // same PropertyType even if the right text is different...
 636     if (pConvPropType.get())
 637         pConvPropType->insert( PropTypeMap::value_type( rLeftText, nPropertyType ) );
 638     bIsModified = sal_True;
 639 }
 640
 641
 642 sal_Int16 SAL_CALL ConvDic::getPropertyType(
 643         const OUString& rLeftText,
 644         const OUString& rRightText )
 645     throw (container::NoSuchElementException, RuntimeException)
 646 {
 647     sal_Bool bHasElement = HasEntry( rLeftText, rRightText);
 648     if (!bHasElement)
 649         throw container::NoSuchElementException();
 650
 651     sal_Int16 nRes = ConversionPropertyType::NOT_DEFINED;
 652     if (pConvPropType.get())
 653     {
 654         // still assuming that entries with same left text have same PropertyType
 655         // even if they have different right text...
 656         PropTypeMap::iterator aIt = pConvPropType->find( rLeftText );
 657         if (aIt != pConvPropType->end())
 658             nRes = (*aIt).second;
 659     }
 660     return nRes;
 661 }
 662
 663
 664 void SAL_CALL ConvDic::flush(  )
 665     throw (RuntimeException)
 666 {
 667     MutexGuard  aGuard( GetLinguMutex() );
 668
 669     if (!bIsModified)
 670         return;
 671
 672     Save();
 673
 674     // notify listeners
 675     EventObject aEvtObj;
 676     aEvtObj.Source = uno::Reference< XFlushable >( this );
 677     cppu::OInterfaceIteratorHelper aIt( aFlushListeners );
 678     while (aIt.hasMoreElements())
 679     {
 680         uno::Reference< util::XFlushListener > xRef( aIt.next(), UNO_QUERY );
 681         if (xRef.is())
 682             xRef->flushed( aEvtObj );
 683     }
 684 }
 685
 686
 687 void SAL_CALL ConvDic::addFlushListener(
 688         const uno::Reference< util::XFlushListener >& rxListener )
 689     throw (RuntimeException)
 690 {
 691     MutexGuard  aGuard( GetLinguMutex() );
 692     if (rxListener.is())
 693         aFlushListeners.addInterface( rxListener );
 694 }
 695
 696
 697 void SAL_CALL ConvDic::removeFlushListener(
 698         const uno::Reference< util::XFlushListener >& rxListener )
 699     throw (RuntimeException)
 700 {
 701     MutexGuard  aGuard( GetLinguMutex() );
 702     if (rxListener.is())
 703         aFlushListeners.removeInterface( rxListener );
 704 }
 705
 706
 707 OUString SAL_CALL ConvDic::getImplementationName(  )
 708     throw (RuntimeException)
 709 {
 710     MutexGuard  aGuard( GetLinguMutex() );
 711     return getImplementationName_Static();
 712 }
 713
 714
 715 sal_Bool SAL_CALL ConvDic::supportsService( const OUString& rServiceName )
 716     throw (RuntimeException)
 717 {
 718     MutexGuard  aGuard( GetLinguMutex() );
 719     sal_Bool bRes = sal_False;
 720     if (rServiceName.equalsAscii( SN_CONV_DICTIONARY ))
 721         bRes = sal_True;
 722     return bRes;
 723 }
 724
 725
 726 uno::Sequence< OUString > SAL_CALL ConvDic::getSupportedServiceNames(  )
 727     throw (RuntimeException)
 728 {
 729     MutexGuard  aGuard( GetLinguMutex() );
 730     return getSupportedServiceNames_Static();
 731 }
 732
 733
 734 uno::Sequence< OUString > ConvDic::getSupportedServiceNames_Static()
 735     throw()
 736 {
 737     uno::Sequence< OUString > aSNS( 1 );
 738     aSNS.getArray()[0] = A2OU( SN_CONV_DICTIONARY );
 739     return aSNS;
 740 }
 741
 742 ///////////////////////////////////////////////////////////////////////////
 743
 744