editeng/source/misc/unolingu.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 <memory>
  22 #include <editeng/unolingu.hxx>
  23 #include <com/sun/star/frame/Desktop.hpp>
  24 #include <com/sun/star/frame/XStorable.hpp>
  25 #include <com/sun/star/lang/XEventListener.hpp>
  26 #include <com/sun/star/linguistic2/XHyphenatedWord.hpp>
  27 #include <com/sun/star/linguistic2/DictionaryList.hpp>
  28 #include <com/sun/star/linguistic2/LinguServiceManager.hpp>
  29 #include <com/sun/star/linguistic2/LinguProperties.hpp>
  30 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
  31
  32 #include <comphelper/processfactory.hxx>
  33 #include <cppuhelper/implbase.hxx>
  34 #include <i18nlangtag/languagetag.hxx>
  35 #include <unotools/lingucfg.hxx>
  36 #include <vcl/svapp.hxx>
  37 #include <vcl/weld.hxx>
  38 #include <linguistic/misc.hxx>
  39 #include <editeng/eerdll.hxx>
  40 #include <editeng/editrids.hrc>
  41 #include <svtools/strings.hrc>
  42 #include <unotools/resmgr.hxx>
  43 #include <sal/log.hxx>
  44 #include <osl/diagnose.h>
  45
  46 using namespace ::comphelper;
  47 using namespace ::linguistic;
  48 using namespace ::com::sun::star;
  49 using namespace ::com::sun::star::util;
  50 using namespace ::com::sun::star::uno;
  51 using namespace ::com::sun::star::lang;
  52 using namespace ::com::sun::star::beans;
  53 using namespace ::com::sun::star::frame;
  54 using namespace ::com::sun::star::linguistic2;
  55
  56 static uno::Reference< XLinguServiceManager2 > GetLngSvcMgr_Impl()
  57 {
  58     uno::Reference< XComponentContext > xContext = comphelper::getProcessComponentContext();
  59     uno::Reference< XLinguServiceManager2 > xRes = LinguServiceManager::create(xContext);
  60     return xRes;
  61 }
  62
  63 namespace {
  64
  65 //! Dummy implementation in order to avoid loading of lingu DLL
  66 //! when only the XSupportedLocales interface is used.
  67 //! The dummy accesses the real implementation (and thus loading the DLL)
  68 //! when "real" work needs to be done only.
  69 class ThesDummy_Impl :
  70     public cppu::WeakImplHelper< XThesaurus >
  71 {
  72     uno::Reference< XThesaurus >              xThes;      // the real one...
  73     std::unique_ptr<Sequence< lang::Locale >> pLocaleSeq;
  74
  75     void GetCfgLocales();
  76
  77     void GetThes_Impl();
  78
  79 public:
  80     ThesDummy_Impl() {}
  81
  82     // XSupportedLocales
  83     virtual css::uno::Sequence< css::lang::Locale > SAL_CALL
  84         getLocales() override;
  85     virtual sal_Bool SAL_CALL
  86         hasLocale( const css::lang::Locale& rLocale ) override;
  87
  88     // XThesaurus
  89     virtual css::uno::Sequence<
  90             css::uno::Reference< css::linguistic2::XMeaning > > SAL_CALL
  91         queryMeanings( const OUString& rTerm,
  92                 const css::lang::Locale& rLocale,
  93                 const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
  94 };
  95
  96 }
  97
  98 void ThesDummy_Impl::GetCfgLocales()
  99 {
 100     if (pLocaleSeq)
 101         return;
 102
 103     SvtLinguConfig aCfg;
 104     Sequence < OUString > aNodeNames( aCfg.GetNodeNames( "ServiceManager/ThesaurusList" ) );
 105     const OUString *pNodeNames = aNodeNames.getConstArray();
 106     sal_Int32 nLen = aNodeNames.getLength();
 107     pLocaleSeq.reset( new Sequence< lang::Locale >( nLen ) );
 108     lang::Locale *pLocale = pLocaleSeq->getArray();
 109     for (sal_Int32 i = 0;  i < nLen;  ++i)
 110     {
 111         pLocale[i] = LanguageTag::convertToLocaleWithFallback( pNodeNames[i] );
 112     }
 113 }
 114
 115
 116 void ThesDummy_Impl::GetThes_Impl()
 117 {
 118     if (!xThes.is())
 119     {
 120         uno::Reference< XLinguServiceManager2 > xLngSvcMgr( GetLngSvcMgr_Impl() );
 121         xThes = xLngSvcMgr->getThesaurus();
 122
 123         if (xThes.is())
 124         {
 125             // no longer needed...
 126             pLocaleSeq.reset();
 127         }
 128     }
 129 }
 130
 131
 132 uno::Sequence< lang::Locale > SAL_CALL
 133         ThesDummy_Impl::getLocales()
 134 {
 135     GetThes_Impl();
 136     if (xThes.is())
 137         return xThes->getLocales();
 138     else if (!pLocaleSeq)       // if not already loaded save startup time by avoiding loading them now
 139         GetCfgLocales();
 140     return *pLocaleSeq;
 141 }
 142
 143
 144 sal_Bool SAL_CALL
 145         ThesDummy_Impl::hasLocale( const lang::Locale& rLocale )
 146 {
 147     GetThes_Impl();
 148     if (xThes.is())
 149         return xThes->hasLocale( rLocale );
 150     else if (!pLocaleSeq)       // if not already loaded save startup time by avoiding loading them now
 151         GetCfgLocales();
 152     bool bFound = false;
 153     sal_Int32 nLen = pLocaleSeq->getLength();
 154     const lang::Locale *pLocale = pLocaleSeq->getConstArray();
 155     const lang::Locale *pEnd = pLocale + nLen;
 156     for ( ;  pLocale < pEnd  &&  !bFound;  ++pLocale)
 157     {
 158         bFound = pLocale->Language == rLocale.Language  &&
 159                  pLocale->Country  == rLocale.Country   &&
 160                  pLocale->Variant  == rLocale.Variant;
 161     }
 162     return bFound;
 163 }
 164
 165
 166 uno::Sequence< uno::Reference< linguistic2::XMeaning > > SAL_CALL
 167         ThesDummy_Impl::queryMeanings(
 168                 const OUString& rTerm,
 169                 const lang::Locale& rLocale,
 170                 const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
 171 {
 172     GetThes_Impl();
 173     uno::Sequence< uno::Reference< linguistic2::XMeaning > > aRes;
 174     OSL_ENSURE( xThes.is(), "Thesaurus missing" );
 175     if (xThes.is())
 176         aRes = xThes->queryMeanings( rTerm, rLocale, rProperties );
 177     return aRes;
 178 }
 179
 180 namespace {
 181
 182 //! Dummy implementation in order to avoid loading of lingu DLL.
 183 //! The dummy accesses the real implementation (and thus loading the DLL)
 184 //! when it needs to be done only.
 185 class SpellDummy_Impl :
 186     public cppu::WeakImplHelper< XSpellChecker1 >
 187 {
 188     uno::Reference< XSpellChecker1 >     xSpell;      // the real one...
 189
 190     void    GetSpell_Impl();
 191
 192 public:
 193
 194     // XSupportedLanguages (for XSpellChecker1)
 195     virtual css::uno::Sequence< sal_Int16 > SAL_CALL
 196         getLanguages() override;
 197     virtual sal_Bool SAL_CALL
 198         hasLanguage( sal_Int16 nLanguage ) override;
 199
 200     // XSpellChecker1 (same as XSpellChecker but sal_Int16 for language)
 201     virtual sal_Bool SAL_CALL
 202         isValid( const OUString& rWord, sal_Int16 nLanguage,
 203                 const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
 204     virtual css::uno::Reference< css::linguistic2::XSpellAlternatives > SAL_CALL
 205         spell( const OUString& rWord, sal_Int16 nLanguage,
 206                 const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
 207 };
 208
 209 }
 210
 211 void SpellDummy_Impl::GetSpell_Impl()
 212 {
 213     if (!xSpell.is())
 214     {
 215         uno::Reference< XLinguServiceManager2 > xLngSvcMgr( GetLngSvcMgr_Impl() );
 216         xSpell.set( xLngSvcMgr->getSpellChecker(), UNO_QUERY );
 217     }
 218 }
 219
 220
 221 uno::Sequence< sal_Int16 > SAL_CALL
 222     SpellDummy_Impl::getLanguages()
 223 {
 224     GetSpell_Impl();
 225     if (xSpell.is())
 226         return xSpell->getLanguages();
 227     else
 228         return uno::Sequence< sal_Int16 >();
 229 }
 230
 231
 232 sal_Bool SAL_CALL
 233     SpellDummy_Impl::hasLanguage( sal_Int16 nLanguage )
 234 {
 235     GetSpell_Impl();
 236     bool bRes = false;
 237     if (xSpell.is())
 238         bRes = xSpell->hasLanguage( nLanguage );
 239     return bRes;
 240 }
 241
 242
 243 sal_Bool SAL_CALL
 244     SpellDummy_Impl::isValid( const OUString& rWord, sal_Int16 nLanguage,
 245             const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
 246 {
 247     GetSpell_Impl();
 248     bool bRes = true;
 249     if (xSpell.is())
 250         bRes = xSpell->isValid( rWord, nLanguage, rProperties );
 251     return bRes;
 252 }
 253
 254
 255 uno::Reference< linguistic2::XSpellAlternatives > SAL_CALL
 256     SpellDummy_Impl::spell( const OUString& rWord, sal_Int16 nLanguage,
 257             const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
 258 {
 259     GetSpell_Impl();
 260     uno::Reference< linguistic2::XSpellAlternatives > xRes;
 261     if (xSpell.is())
 262         xRes = xSpell->spell( rWord, nLanguage, rProperties );
 263     return xRes;
 264 }
 265
 266 namespace {
 267
 268 //! Dummy implementation in order to avoid loading of lingu DLL.
 269 //! The dummy accesses the real implementation (and thus loading the DLL)
 270 //! when it needs to be done only.
 271 class HyphDummy_Impl :
 272     public cppu::WeakImplHelper< XHyphenator >
 273 {
 274     uno::Reference< XHyphenator >     xHyph;      // the real one...
 275
 276     void    GetHyph_Impl();
 277
 278 public:
 279
 280     // XSupportedLocales
 281     virtual css::uno::Sequence<
 282             css::lang::Locale > SAL_CALL
 283         getLocales() override;
 284     virtual sal_Bool SAL_CALL
 285         hasLocale( const css::lang::Locale& rLocale ) override;
 286
 287     // XHyphenator
 288     virtual css::uno::Reference<
 289             css::linguistic2::XHyphenatedWord > SAL_CALL
 290         hyphenate( const OUString& rWord,
 291                 const css::lang::Locale& rLocale,
 292                 sal_Int16 nMaxLeading,
 293                 const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
 294     virtual css::uno::Reference<
 295             css::linguistic2::XHyphenatedWord > SAL_CALL
 296         queryAlternativeSpelling( const OUString& rWord,
 297                 const css::lang::Locale& rLocale,
 298                 sal_Int16 nIndex,
 299                 const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
 300     virtual css::uno::Reference<
 301             css::linguistic2::XPossibleHyphens > SAL_CALL
 302         createPossibleHyphens(
 303                 const OUString& rWord,
 304                 const css::lang::Locale& rLocale,
 305                 const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
 306 };
 307
 308 }
 309
 310 void HyphDummy_Impl::GetHyph_Impl()
 311 {
 312     if (!xHyph.is())
 313     {
 314         uno::Reference< XLinguServiceManager2 > xLngSvcMgr( GetLngSvcMgr_Impl() );
 315         xHyph = xLngSvcMgr->getHyphenator();
 316     }
 317 }
 318
 319
 320 uno::Sequence< lang::Locale > SAL_CALL
 321     HyphDummy_Impl::getLocales()
 322 {
 323     GetHyph_Impl();
 324     if (xHyph.is())
 325         return xHyph->getLocales();
 326     else
 327         return uno::Sequence< lang::Locale >();
 328 }
 329
 330
 331 sal_Bool SAL_CALL
 332     HyphDummy_Impl::hasLocale( const lang::Locale& rLocale )
 333 {
 334     GetHyph_Impl();
 335     bool bRes = false;
 336     if (xHyph.is())
 337         bRes = xHyph->hasLocale( rLocale );
 338     return bRes;
 339 }
 340
 341
 342 uno::Reference< linguistic2::XHyphenatedWord > SAL_CALL
 343     HyphDummy_Impl::hyphenate(
 344             const OUString& rWord,
 345             const lang::Locale& rLocale,
 346             sal_Int16 nMaxLeading,
 347             const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
 348 {
 349     GetHyph_Impl();
 350     uno::Reference< linguistic2::XHyphenatedWord > xRes;
 351     if (xHyph.is())
 352         xRes = xHyph->hyphenate( rWord, rLocale, nMaxLeading, rProperties );
 353     return xRes;
 354 }
 355
 356
 357 uno::Reference< linguistic2::XHyphenatedWord > SAL_CALL
 358     HyphDummy_Impl::queryAlternativeSpelling(
 359             const OUString& rWord,
 360             const lang::Locale& rLocale,
 361             sal_Int16 nIndex,
 362             const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
 363 {
 364     GetHyph_Impl();
 365     uno::Reference< linguistic2::XHyphenatedWord > xRes;
 366     if (xHyph.is())
 367         xRes = xHyph->queryAlternativeSpelling( rWord, rLocale, nIndex, rProperties );
 368     return xRes;
 369 }
 370
 371
 372 uno::Reference< linguistic2::XPossibleHyphens > SAL_CALL
 373     HyphDummy_Impl::createPossibleHyphens(
 374             const OUString& rWord,
 375             const lang::Locale& rLocale,
 376             const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
 377 {
 378     GetHyph_Impl();
 379     uno::Reference< linguistic2::XPossibleHyphens > xRes;
 380     if (xHyph.is())
 381         xRes = xHyph->createPossibleHyphens( rWord, rLocale, rProperties );
 382     return xRes;
 383 }
 384
 385 class LinguMgrExitLstnr : public cppu::WeakImplHelper<XEventListener>
 386 {
 387     uno::Reference< XDesktop2 >        xDesktop;
 388
 389     static void AtExit();
 390
 391 public:
 392     LinguMgrExitLstnr();
 393     virtual ~LinguMgrExitLstnr() override;
 394
 395     // lang::XEventListener
 396     virtual void    SAL_CALL disposing(const EventObject& rSource) override;
 397 };
 398
 399 LinguMgrExitLstnr::LinguMgrExitLstnr()
 400 {
 401     // add object to frame::Desktop EventListeners in order to properly call
 402     // the AtExit function at application exit.
 403
 404     uno::Reference< XComponentContext >  xContext = getProcessComponentContext();
 405     xDesktop = Desktop::create( xContext );
 406     xDesktop->addEventListener( this );
 407 }
 408
 409 LinguMgrExitLstnr::~LinguMgrExitLstnr()
 410 {
 411     if (xDesktop.is())
 412     {
 413         xDesktop->removeEventListener( this );
 414         xDesktop = nullptr;    //! release reference to desktop
 415     }
 416     OSL_ENSURE(!xDesktop.is(), "reference to desktop should be released");
 417 }
 418
 419 void LinguMgrExitLstnr::disposing(const EventObject& rSource)
 420 {
 421     if (xDesktop.is()  &&  rSource.Source == xDesktop)
 422     {
 423         xDesktop->removeEventListener( this );
 424         xDesktop = nullptr;    //! release reference to desktop
 425
 426         AtExit();
 427     }
 428 }
 429
 430 void LinguMgrExitLstnr::AtExit()
 431 {
 432     SolarMutexGuard g;
 433
 434     // release references
 435     LinguMgr::xLngSvcMgr    = nullptr;
 436     LinguMgr::xSpell        = nullptr;
 437     LinguMgr::xHyph         = nullptr;
 438     LinguMgr::xThes         = nullptr;
 439     LinguMgr::xDicList      = nullptr;
 440     LinguMgr::xProp         = nullptr;
 441     LinguMgr::xIgnoreAll    = nullptr;
 442     LinguMgr::xChangeAll    = nullptr;
 443
 444     LinguMgr::bExiting      = true;
 445
 446     LinguMgr::pExitLstnr    = nullptr;
 447 }
 448
 449
 450 LinguMgrExitLstnr *             LinguMgr::pExitLstnr    = nullptr;
 451 bool                            LinguMgr::bExiting      = false;
 452 uno::Reference< XLinguServiceManager2 >  LinguMgr::xLngSvcMgr;
 453 uno::Reference< XSpellChecker1 >    LinguMgr::xSpell;
 454 uno::Reference< XHyphenator >       LinguMgr::xHyph;
 455 uno::Reference< XThesaurus >        LinguMgr::xThes;
 456 uno::Reference< XSearchableDictionaryList >   LinguMgr::xDicList;
 457 uno::Reference< XLinguProperties >  LinguMgr::xProp;
 458 uno::Reference< XDictionary >       LinguMgr::xIgnoreAll;
 459 uno::Reference< XDictionary >       LinguMgr::xChangeAll;
 460
 461
 462 uno::Reference< XLinguServiceManager2 > LinguMgr::GetLngSvcMgr()
 463 {
 464     if (bExiting)
 465         return nullptr;
 466
 467     if (!pExitLstnr)
 468         pExitLstnr = new LinguMgrExitLstnr;
 469
 470     if (!xLngSvcMgr.is())
 471         xLngSvcMgr = GetLngSvcMgr_Impl();
 472
 473     return xLngSvcMgr;
 474 }
 475
 476
 477 uno::Reference< XSpellChecker1 > LinguMgr::GetSpellChecker()
 478 {
 479     return xSpell.is() ? xSpell : GetSpell();
 480 }
 481
 482 uno::Reference< XHyphenator > LinguMgr::GetHyphenator()
 483 {
 484     return xHyph.is() ? xHyph : GetHyph();
 485 }
 486
 487 uno::Reference< XThesaurus > LinguMgr::GetThesaurus()
 488 {
 489     return xThes.is() ? xThes : GetThes();
 490 }
 491
 492 uno::Reference< XSearchableDictionaryList > LinguMgr::GetDictionaryList()
 493 {
 494     return xDicList.is() ? xDicList : GetDicList();
 495 }
 496
 497 uno::Reference< linguistic2::XLinguProperties > LinguMgr::GetLinguPropertySet()
 498 {
 499     return xProp.is() ? xProp : GetProp();
 500 }
 501
 502 uno::Reference< XDictionary > LinguMgr::GetStandardDic()
 503 {
 504     //! don't hold reference to this
 505     //! (it may be removed from dictionary list and needs to be
 506     //! created empty if accessed again)
 507     return GetStandard();
 508 }
 509
 510 uno::Reference< XDictionary > LinguMgr::GetIgnoreAllList()
 511 {
 512     return xIgnoreAll.is() ? xIgnoreAll : GetIgnoreAll();
 513 }
 514
 515 uno::Reference< XDictionary > LinguMgr::GetChangeAllList()
 516 {
 517     return xChangeAll.is() ? xChangeAll : GetChangeAll();
 518 }
 519
 520 uno::Reference< XSpellChecker1 > LinguMgr::GetSpell()
 521 {
 522     if (bExiting)
 523         return nullptr;
 524
 525     if (!pExitLstnr)
 526         pExitLstnr = new LinguMgrExitLstnr;
 527
 528     //! use dummy implementation in order to avoid loading of lingu DLL
 529     xSpell = new SpellDummy_Impl;
 530     return xSpell;
 531 }
 532
 533 uno::Reference< XHyphenator > LinguMgr::GetHyph()
 534 {
 535     if (bExiting)
 536         return nullptr;
 537
 538     if (!pExitLstnr)
 539         pExitLstnr = new LinguMgrExitLstnr;
 540
 541     //! use dummy implementation in order to avoid loading of lingu DLL
 542     xHyph = new HyphDummy_Impl;
 543     return xHyph;
 544 }
 545
 546 uno::Reference< XThesaurus > LinguMgr::GetThes()
 547 {
 548     if (bExiting)
 549         return nullptr;
 550
 551     if (!pExitLstnr)
 552         pExitLstnr = new LinguMgrExitLstnr;
 553
 554     //! use dummy implementation in order to avoid loading of lingu DLL
 555     //! when only the XSupportedLocales interface is used.
 556     //! The dummy accesses the real implementation (and thus loading the DLL)
 557     //! when "real" work needs to be done only.
 558     xThes = new ThesDummy_Impl;
 559     return xThes;
 560 }
 561
 562 uno::Reference< XSearchableDictionaryList > LinguMgr::GetDicList()
 563 {
 564     if (bExiting)
 565         return nullptr;
 566
 567     if (!pExitLstnr)
 568         pExitLstnr = new LinguMgrExitLstnr;
 569
 570     xDicList = linguistic2::DictionaryList::create( getProcessComponentContext() );
 571     return xDicList;
 572 }
 573
 574 uno::Reference< linguistic2::XLinguProperties > LinguMgr::GetProp()
 575 {
 576     if (bExiting)
 577         return nullptr;
 578
 579     if (!pExitLstnr)
 580         pExitLstnr = new LinguMgrExitLstnr;
 581
 582     xProp = linguistic2::LinguProperties::create( getProcessComponentContext()  );
 583     return xProp;
 584 }
 585
 586 uno::Reference< XDictionary > LinguMgr::GetIgnoreAll()
 587 {
 588     if (bExiting)
 589         return nullptr;
 590
 591     if (!pExitLstnr)
 592         pExitLstnr = new LinguMgrExitLstnr;
 593
 594     uno::Reference< XSearchableDictionaryList >  xTmpDicList( GetDictionaryList() );
 595     if (xTmpDicList.is())
 596     {
 597         std::locale loc(Translate::Create("svt"));
 598         xIgnoreAll = xTmpDicList->getDictionaryByName(
 599                                     Translate::get(STR_DESCRIPTION_IGNOREALLLIST, loc) );
 600     }
 601     return xIgnoreAll;
 602 }
 603
 604 uno::Reference< XDictionary > LinguMgr::GetChangeAll()
 605 {
 606     if (bExiting)
 607         return nullptr;
 608
 609     if (!pExitLstnr)
 610         pExitLstnr = new LinguMgrExitLstnr;
 611
 612     uno::Reference< XSearchableDictionaryList > _xDicList = GetDictionaryList();
 613     if (_xDicList.is())
 614     {
 615         xChangeAll = _xDicList->createDictionary(
 616                             "ChangeAllList",
 617                             LanguageTag::convertToLocale( LANGUAGE_NONE ),
 618                             DictionaryType_NEGATIVE, OUString() );
 619     }
 620     return xChangeAll;
 621 }
 622
 623 uno::Reference< XDictionary > LinguMgr::GetStandard()
 624 {
 625     // Tries to return a dictionary which may hold positive entries is
 626     // persistent and not read-only.
 627
 628     if (bExiting)
 629         return nullptr;
 630
 631     uno::Reference< XSearchableDictionaryList >  xTmpDicList( GetDictionaryList() );
 632     if (!xTmpDicList.is())
 633         return nullptr;
 634
 635     const OUString aDicName( "standard.dic" );
 636     uno::Reference< XDictionary > xDic = xTmpDicList->getDictionaryByName( aDicName );
 637     if (!xDic.is())
 638     {
 639         // try to create standard dictionary
 640         uno::Reference< XDictionary >    xTmp;
 641         try
 642         {
 643             xTmp =  xTmpDicList->createDictionary( aDicName,
 644                         LanguageTag::convertToLocale( LANGUAGE_NONE ),
 645                         DictionaryType_POSITIVE,
 646                         linguistic::GetWritableDictionaryURL( aDicName ) );
 647         }
 648         catch(const css::uno::Exception &)
 649         {
 650         }
 651
 652         // add new dictionary to list
 653         if (xTmp.is())
 654         {
 655             xTmpDicList->addDictionary( xTmp );
 656             xTmp->setActive( true );
 657         }
 658         xDic = xTmp;
 659     }
 660 #if OSL_DEBUG_LEVEL > 1
 661     uno::Reference< XStorable >      xStor( xDic, UNO_QUERY );
 662     OSL_ENSURE( xDic.is() && xDic->getDictionaryType() == DictionaryType_POSITIVE,
 663             "wrong dictionary type");
 664     OSL_ENSURE( xDic.is() && LanguageTag( xDic->getLocale() ).getLanguageType() == LANGUAGE_NONE,
 665             "wrong dictionary language");
 666     OSL_ENSURE( !xStor.is() || (xStor->hasLocation() && !xStor->isReadonly()),
 667             "dictionary not editable" );
 668 #endif
 669
 670     return xDic;
 671 }
 672
 673 SvxAlternativeSpelling SvxGetAltSpelling(
 674         const css::uno::Reference< css::linguistic2::XHyphenatedWord > & rHyphWord )
 675 {
 676     SvxAlternativeSpelling aRes;
 677     if (rHyphWord.is() && rHyphWord->isAlternativeSpelling())
 678     {
 679         OUString aWord( rHyphWord->getWord() ),
 680                  aAltWord( rHyphWord->getHyphenatedWord() );
 681         sal_Int16   nHyphenationPos     = rHyphWord->getHyphenationPos(),
 682                 nHyphenPos          = rHyphWord->getHyphenPos();
 683         sal_Int16   nLen    = static_cast<sal_Int16>(aWord.getLength());
 684         sal_Int16   nAltLen = static_cast<sal_Int16>(aAltWord.getLength());
 685         const sal_Unicode *pWord    = aWord.getStr(),
 686                           *pAltWord = aAltWord.getStr();
 687
 688         // count number of chars from the left to the
 689         // hyphenation pos / hyphen pos that are equal
 690         sal_Int16 nL = 0;
 691         while (nL <= nHyphenationPos && nL <= nHyphenPos
 692                && pWord[ nL ] == pAltWord[ nL ])
 693             ++nL;
 694         // count number of chars from the right to the
 695         // hyphenation pos / hyphen pos that are equal
 696         sal_Int16 nR = 0;
 697         sal_Int32 nIdx    = nLen - 1;
 698         sal_Int32 nAltIdx = nAltLen - 1;
 699         while (nIdx > nHyphenationPos && nAltIdx > nHyphenPos
 700                && pWord[ nIdx-- ] == pAltWord[ nAltIdx-- ])
 701             ++nR;
 702
 703         aRes.aReplacement       = aAltWord.copy( nL, nAltLen - nL - nR );
 704         aRes.nChangedPos        = nL;
 705         aRes.nChangedLength     = nLen - nL - nR;
 706         aRes.bIsAltSpelling     = true;
 707     }
 708     return aRes;
 709 }
 710
 711
 712 SvxDicListChgClamp::SvxDicListChgClamp( uno::Reference< XSearchableDictionaryList > const &rxDicList ) :
 713     xDicList    ( rxDicList )
 714 {
 715     if (xDicList.is())
 716     {
 717         xDicList->beginCollectEvents();
 718     }
 719 }
 720
 721 SvxDicListChgClamp::~SvxDicListChgClamp()
 722 {
 723     if (xDicList.is())
 724     {
 725         xDicList->endCollectEvents();
 726     }
 727 }
 728
 729 short SvxDicError(weld::Window *pParent, linguistic::DictionaryError nError)
 730 {
 731     short nRes = 0;
 732     if (linguistic::DictionaryError::NONE != nError)
 733     {
 734         const char* pRid;
 735         switch (nError)
 736         {
 737             case linguistic::DictionaryError::FULL     : pRid = RID_SVXSTR_DIC_ERR_FULL;  break;
 738             case linguistic::DictionaryError::READONLY : pRid = RID_SVXSTR_DIC_ERR_READONLY;  break;
 739             default:
 740                 pRid = RID_SVXSTR_DIC_ERR_UNKNOWN;
 741                 SAL_WARN("editeng", "unexpected case");
 742         }
 743         std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(pParent,
 744                                                       VclMessageType::Info, VclButtonsType::Ok,
 745                                                       EditResId(pRid)));
 746         nRes = xInfoBox->run();
 747
 748     }
 749     return nRes;
 750 }
 751
 752
 753 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */