LCOV - code coverage report
Current view: top level - libreoffice/editeng/source/misc - unolingu.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 127 331 38.4 %
Date: 2012-12-17 Functions: 34 65 52.3 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10