mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cws tl82: #i113293# unify encoding detection for linguistic components

Browse Source
This commit is contained in:
Thomas Lange [tl]
2010-07-21 16:29:56 +02:00
parent 16ae4c1524
commit c7896e24ec
10 changed files with 906 additions and 1020 deletions
Download Patch File Download Diff File Expand all files Collapse all files

813
lingucomponent/source/hyphenator/altlinuxhyph/hyphen/hyphenimp.cxx
View File

File diff suppressed because it is too large Load Diff

92
lingucomponent/source/hyphenator/altlinuxhyph/hyphen/hyphenimp.hxx Normal file → Executable file
View File

@@ -65,7 +65,7 @@ struct HDInfo {
HyphenDict * aPtr; HyphenDict * aPtr;
OUString aName; OUString aName;
Locale aLoc; Locale aLoc;
rtl_TextEncoding aEnc; rtl_TextEncoding eEnc;
CharClass * apCC; CharClass * apCC;
}; };
@@ -83,12 +83,12 @@ class Hyphenator :
> >
{ {
Sequence< Locale > aSuppLocales; Sequence< Locale > aSuppLocales;
HDInfo * aDicts; HDInfo * aDicts;
sal_Int32 numdict; sal_Int32 numdict;
::cppu::OInterfaceContainerHelper aEvtListeners; ::cppu::OInterfaceContainerHelper aEvtListeners;
Reference< XPropertyChangeListener > xPropHelper; Reference< XPropertyChangeListener > xPropHelper;
Reference< XMultiServiceFactory > rSMgr; Reference< XMultiServiceFactory > rSMgr;
linguistic::PropertyHelper_Hyphen * pPropHelper; linguistic::PropertyHelper_Hyphen * pPropHelper;
BOOL bDisposing; BOOL bDisposing;
@@ -108,87 +108,37 @@ public:
virtual ~Hyphenator(); virtual ~Hyphenator();
// XSupportedLocales (for XHyphenator) // XSupportedLocales (for XHyphenator)
virtual Sequence< Locale > SAL_CALL getLocales() virtual Sequence< Locale > SAL_CALL getLocales() throw(RuntimeException);
throw(RuntimeException); virtual sal_Bool SAL_CALL hasLocale( const Locale& rLocale ) throw(RuntimeException);
virtual sal_Bool SAL_CALL hasLocale( const Locale& rLocale )
throw(RuntimeException);
// XHyphenator // XHyphenator
virtual ::com::sun::star::uno::Reference< ::com::sun::star::linguistic2::XHyphenatedWord > SAL_CALL virtual ::com::sun::star::uno::Reference< ::com::sun::star::linguistic2::XHyphenatedWord > SAL_CALL hyphenate( const ::rtl::OUString& aWord, const ::com::sun::star::lang::Locale& aLocale, sal_Int16 nMaxLeading, const ::com::sun::star::beans::PropertyValues& aProperties ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
hyphenate( const ::rtl::OUString& aWord, virtual ::com::sun::star::uno::Reference< ::com::sun::star::linguistic2::XHyphenatedWord > SAL_CALL queryAlternativeSpelling( const ::rtl::OUString& aWord, const ::com::sun::star::lang::Locale& aLocale, sal_Int16 nIndex, const ::com::sun::star::beans::PropertyValues& aProperties ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
const ::com::sun::star::lang::Locale& aLocale, virtual ::com::sun::star::uno::Reference< ::com::sun::star::linguistic2::XPossibleHyphens > SAL_CALL createPossibleHyphens( const ::rtl::OUString& aWord, const ::com::sun::star::lang::Locale& aLocale, const ::com::sun::star::beans::PropertyValues& aProperties ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
sal_Int16 nMaxLeading,
const ::com::sun::star::beans::PropertyValues& aProperties )
throw(::com::sun::star::lang::IllegalArgumentException,
::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Reference< ::com::sun::star::linguistic2::XHyphenatedWord > SAL_CALL
queryAlternativeSpelling( const ::rtl::OUString& aWord,
const ::com::sun::star::lang::Locale& aLocale,
sal_Int16 nIndex,
const ::com::sun::star::beans::PropertyValues& aProperties )
throw(::com::sun::star::lang::IllegalArgumentException,
::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Reference< ::com::sun::star::linguistic2::XPossibleHyphens > SAL_CALL
createPossibleHyphens( const ::rtl::OUString& aWord,
const ::com::sun::star::lang::Locale& aLocale,
const ::com::sun::star::beans::PropertyValues& aProperties )
throw(::com::sun::star::lang::IllegalArgumentException,
::com::sun::star::uno::RuntimeException);
// XLinguServiceEventBroadcaster // XLinguServiceEventBroadcaster
virtual sal_Bool SAL_CALL virtual sal_Bool SAL_CALL addLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) throw(RuntimeException);
addLinguServiceEventListener( virtual sal_Bool SAL_CALL removeLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) throw(RuntimeException);
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException);
virtual sal_Bool SAL_CALL
removeLinguServiceEventListener(
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException);
// XServiceDisplayName // XServiceDisplayName
virtual OUString SAL_CALL virtual OUString SAL_CALL getServiceDisplayName( const Locale& rLocale ) throw(RuntimeException);
getServiceDisplayName( const Locale& rLocale )
throw(RuntimeException);
// XInitialization // XInitialization
virtual void SAL_CALL virtual void SAL_CALL initialize( const Sequence< Any >& rArguments ) throw(Exception, RuntimeException);
initialize( const Sequence< Any >& rArguments )
throw(Exception, RuntimeException);
// XComponent // XComponent
virtual void SAL_CALL virtual void SAL_CALL dispose() throw(RuntimeException);
dispose() virtual void SAL_CALL addEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
throw(RuntimeException); virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
virtual void SAL_CALL
addEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
virtual void SAL_CALL
removeEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
////////////////////////////////////////////////////////////
// Service specific part
//
// XServiceInfo // XServiceInfo
virtual OUString SAL_CALL virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
getImplementationName() virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) throw(RuntimeException);
throw(RuntimeException); virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw(RuntimeException);
virtual sal_Bool SAL_CALL
supportsService( const OUString& rServiceName )
throw(RuntimeException);
virtual Sequence< OUString > SAL_CALL
getSupportedServiceNames()
throw(RuntimeException);
static inline OUString static inline OUString getImplementationName_Static() throw();
getImplementationName_Static() throw(); static Sequence< OUString > getSupportedServiceNames_Static() throw();
static Sequence< OUString >
getSupportedServiceNames_Static() throw();
private: private:

21
lingucomponent/source/lingutil/lingutil.cxx Normal file → Executable file
View File

@@ -50,6 +50,7 @@
#include <unotools/pathoptions.hxx> #include <unotools/pathoptions.hxx>
#include <rtl/ustring.hxx> #include <rtl/ustring.hxx>
#include <rtl/string.hxx> #include <rtl/string.hxx>
#include <rtl/tencinfo.h>
#include <linguistic/misc.hxx> #include <linguistic/misc.hxx>
#include <set> #include <set>
@@ -268,5 +269,25 @@ void MergeNewStyleDicsAndOldStyleDics(
} }
} }
rtl_TextEncoding getTextEncodingFromCharset(const sal_Char* pCharset)
{
// default result: used to indicate that we failed to get the proper encoding
rtl_TextEncoding eRet = RTL_TEXTENCODING_DONTKNOW;
if (pCharset)
{
eRet = rtl_getTextEncodingFromMimeCharset(pCharset);
if (eRet == RTL_TEXTENCODING_DONTKNOW)
eRet = rtl_getTextEncodingFromUnixCharset(pCharset);
if (eRet == RTL_TEXTENCODING_DONTKNOW)
{
if (strcmp("ISCII-DEVANAGARI", pCharset) == 0)
eRet = RTL_TEXTENCODING_ISCII_DEVANAGARI;
}
}
return eRet;
}
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////

8
lingucomponent/source/lingutil/lingutil.hxx
View File

@@ -101,5 +101,13 @@ void MergeNewStyleDicsAndOldStyleDics( std::list< SvtLinguConfigDictionaryEntry
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
//Find an encoding from a charset string, using
//rtl_getTextEncodingFromMimeCharset and falling back to
//rtl_getTextEncodingFromUnixCharset with the addition of
//ISCII-DEVANAGARI. On failure will return final fallback of
//RTL_TEXTENCODING_ISO_8859_1
rtl_TextEncoding getTextEncodingFromCharset(const sal_Char* pCharset);
#endif #endif

89
lingucomponent/source/spellcheck/macosxspell/macspellimp.hxx Normal file → Executable file
View File

@@ -75,14 +75,14 @@ class MacSpellChecker :
XServiceDisplayName XServiceDisplayName
> >
{ {
Sequence< Locale > aSuppLocales; Sequence< Locale > aSuppLocales;
// Hunspell ** aDicts; // Hunspell ** aDicts;
rtl_TextEncoding * aDEncs; rtl_TextEncoding * aDEncs;
Locale * aDLocs; Locale * aDLocs;
OUString * aDNames; OUString * aDNames;
sal_Int32 numdict; sal_Int32 numdict;
NSSpellChecker * macSpell; NSSpellChecker * macSpell;
int macTag; //unique tag for this doc int macTag; //unique tag for this doc
::cppu::OInterfaceContainerHelper aEvtListeners; ::cppu::OInterfaceContainerHelper aEvtListeners;
Reference< XPropertyChangeListener > xPropHelper; Reference< XPropertyChangeListener > xPropHelper;
@@ -100,84 +100,43 @@ class MacSpellChecker :
} }
INT16 GetSpellFailure( const OUString &rWord, const Locale &rLocale ); INT16 GetSpellFailure( const OUString &rWord, const Locale &rLocale );
Reference< XSpellAlternatives > Reference< XSpellAlternatives > GetProposals( const OUString &rWord, const Locale &rLocale );
GetProposals( const OUString &rWord, const Locale &rLocale );
public: public:
MacSpellChecker(); MacSpellChecker();
virtual ~MacSpellChecker(); virtual ~MacSpellChecker();
// XSupportedLocales (for XSpellChecker) // XSupportedLocales (for XSpellChecker)
virtual Sequence< Locale > SAL_CALL virtual Sequence< Locale > SAL_CALL getLocales() throw(RuntimeException);
getLocales() virtual sal_Bool SAL_CALL hasLocale( const Locale& rLocale ) throw(RuntimeException);
throw(RuntimeException);
virtual sal_Bool SAL_CALL
hasLocale( const Locale& rLocale )
throw(RuntimeException);
// XSpellChecker // XSpellChecker
virtual sal_Bool SAL_CALL virtual sal_Bool SAL_CALL isValid( const OUString& rWord, const Locale& rLocale, const PropertyValues& rProperties ) throw(IllegalArgumentException, RuntimeException);
isValid( const OUString& rWord, const Locale& rLocale, virtual Reference< XSpellAlternatives > SAL_CALL spell( const OUString& rWord, const Locale& rLocale, const PropertyValues& rProperties ) throw(IllegalArgumentException, RuntimeException);
const PropertyValues& rProperties )
throw(IllegalArgumentException,
RuntimeException);
virtual Reference< XSpellAlternatives > SAL_CALL
spell( const OUString& rWord, const Locale& rLocale,
const PropertyValues& rProperties )
throw(IllegalArgumentException,
RuntimeException);
// XLinguServiceEventBroadcaster // XLinguServiceEventBroadcaster
virtual sal_Bool SAL_CALL virtual sal_Bool SAL_CALL addLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) throw(RuntimeException);
addLinguServiceEventListener( virtual sal_Bool SAL_CALL removeLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) throw(RuntimeException);
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException);
virtual sal_Bool SAL_CALL
removeLinguServiceEventListener(
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException);
// XServiceDisplayName // XServiceDisplayName
virtual OUString SAL_CALL virtual OUString SAL_CALL getServiceDisplayName( const Locale& rLocale ) throw(RuntimeException);
getServiceDisplayName( const Locale& rLocale )
throw(RuntimeException);
// XInitialization // XInitialization
virtual void SAL_CALL virtual void SAL_CALL initialize( const Sequence< Any >& rArguments ) throw(Exception, RuntimeException);
initialize( const Sequence< Any >& rArguments )
throw(Exception, RuntimeException);
// XComponent // XComponent
virtual void SAL_CALL virtual void SAL_CALL dispose() throw(RuntimeException);
dispose() virtual void SAL_CALL addEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
throw(RuntimeException); virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
virtual void SAL_CALL
addEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
virtual void SAL_CALL
removeEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
////////////////////////////////////////////////////////////
// Service specific part
//
// XServiceInfo // XServiceInfo
virtual OUString SAL_CALL virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
getImplementationName() virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) throw(RuntimeException);
throw(RuntimeException); virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw(RuntimeException);
virtual sal_Bool SAL_CALL
supportsService( const OUString& rServiceName )
throw(RuntimeException);
virtual Sequence< OUString > SAL_CALL
getSupportedServiceNames()
throw(RuntimeException);
static inline OUString static inline OUString getImplementationName_Static() throw();
getImplementationName_Static() throw(); static Sequence< OUString > getSupportedServiceNames_Static() throw();
static Sequence< OUString >
getSupportedServiceNames_Static() throw();
}; };
inline OUString MacSpellChecker::getImplementationName_Static() throw() inline OUString MacSpellChecker::getImplementationName_Static() throw()

296
lingucomponent/source/spellcheck/spell/sspellimp.cxx Normal file → Executable file
View File

@@ -27,6 +27,7 @@
// MARKER(update_precomp.py): autogen include statement, do not remove // MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_lingucomponent.hxx" #include "precompiled_lingucomponent.hxx"
#include <com/sun/star/uno/Reference.h> #include <com/sun/star/uno/Reference.h>
#include <com/sun/star/linguistic2/XSearchableDictionaryList.hpp> #include <com/sun/star/linguistic2/XSearchableDictionaryList.hpp>
@@ -37,12 +38,10 @@
#include <unotools/processfactory.hxx> #include <unotools/processfactory.hxx>
#include <osl/mutex.hxx> #include <osl/mutex.hxx>
#include <lingutil.hxx>
#include <hunspell.hxx> #include <hunspell.hxx>
#include <dictmgr.hxx> #include <dictmgr.hxx>
#ifndef _SPELLIMP_HXX
#include <sspellimp.hxx> #include <sspellimp.hxx>
#endif
#include <linguistic/lngprops.hxx> #include <linguistic/lngprops.hxx>
#include <linguistic/spelldta.hxx> #include <linguistic/spelldta.hxx>
@@ -53,8 +52,6 @@
#include <osl/file.hxx> #include <osl/file.hxx>
#include <rtl/ustrbuf.hxx> #include <rtl/ustrbuf.hxx>
#include <lingutil.hxx>
#include <list> #include <list>
#include <set> #include <set>
#include <string.h> #include <string.h>
@@ -77,35 +74,37 @@ using namespace linguistic;
SpellChecker::SpellChecker() : SpellChecker::SpellChecker() :
aEvtListeners ( GetLinguMutex() ) aEvtListeners ( GetLinguMutex() )
{ {
aDicts = NULL; aDicts = NULL;
aDEncs = NULL; aDEncs = NULL;
aDLocs = NULL; aDLocs = NULL;
aDNames = NULL; aDNames = NULL;
bDisposing = FALSE; bDisposing = FALSE;
pPropHelper = NULL; pPropHelper = NULL;
numdict = 0; numdict = 0;
} }
SpellChecker::~SpellChecker() SpellChecker::~SpellChecker()
{ {
if (aDicts) { if (aDicts)
for (int i = 0; i < numdict; i++) { {
for (int i = 0; i < numdict; i++)
{
if (aDicts[i]) delete aDicts[i]; if (aDicts[i]) delete aDicts[i];
aDicts[i] = NULL; aDicts[i] = NULL;
} }
delete[] aDicts; delete[] aDicts;
} }
aDicts = NULL; aDicts = NULL;
numdict = 0; numdict = 0;
if (aDEncs) delete[] aDEncs; if (aDEncs) delete[] aDEncs;
aDEncs = NULL; aDEncs = NULL;
if (aDLocs) delete[] aDLocs; if (aDLocs) delete[] aDLocs;
aDLocs = NULL; aDLocs = NULL;
if (aDNames) delete[] aDNames; if (aDNames) delete[] aDNames;
aDNames = NULL; aDNames = NULL;
if (pPropHelper) if (pPropHelper)
pPropHelper->RemoveAsPropListener(); pPropHelper->RemoveAsPropListener();
} }
@@ -217,7 +216,7 @@ Sequence< Locale > SAL_CALL SpellChecker::getLocales()
for (sal_Int32 i = 0; i < nLocales; ++i) for (sal_Int32 i = 0; i < nLocales; ++i)
{ {
aDicts[k] = NULL; aDicts[k] = NULL;
aDEncs[k] = 0; aDEncs[k] = RTL_TEXTENCODING_DONTKNOW;
aDLocs[k] = MsLangId::convertLanguageToLocale( aDLocs[k] = MsLangId::convertLanguageToLocale(
MsLangId::convertIsoStringToLanguage( aLocaleNames[i] )); MsLangId::convertIsoStringToLanguage( aLocaleNames[i] ));
// also both files have to be in the same directory and the // also both files have to be in the same directory and the
@@ -272,84 +271,86 @@ sal_Bool SAL_CALL SpellChecker::hasLocale(const Locale& rLocale)
return bRes; return bRes;
} }
INT16 SpellChecker::GetSpellFailure( const OUString &rWord, const Locale &rLocale ) INT16 SpellChecker::GetSpellFailure( const OUString &rWord, const Locale &rLocale )
{ {
Hunspell * pMS; Hunspell * pMS = NULL;
rtl_TextEncoding aEnc; rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
// initialize a myspell object for each dictionary once // initialize a myspell object for each dictionary once
// (note: mutex is held higher up in isValid) // (note: mutex is held higher up in isValid)
INT16 nRes = -1; INT16 nRes = -1;
// first handle smart quotes both single and double // first handle smart quotes both single and double
OUStringBuffer rBuf(rWord); OUStringBuffer rBuf(rWord);
sal_Int32 n = rBuf.getLength(); sal_Int32 n = rBuf.getLength();
sal_Unicode c; sal_Unicode c;
for (sal_Int32 ix=0; ix < n; ix++) { for (sal_Int32 ix=0; ix < n; ix++)
{
c = rBuf.charAt(ix); c = rBuf.charAt(ix);
if ((c == 0x201C) || (c == 0x201D)) rBuf.setCharAt(ix,(sal_Unicode)0x0022); if ((c == 0x201C) || (c == 0x201D))
if ((c == 0x2018) || (c == 0x2019)) rBuf.setCharAt(ix,(sal_Unicode)0x0027); rBuf.setCharAt(ix,(sal_Unicode)0x0022);
} if ((c == 0x2018) || (c == 0x2019))
OUString nWord(rBuf.makeStringAndClear()); rBuf.setCharAt(ix,(sal_Unicode)0x0027);
}
OUString nWord(rBuf.makeStringAndClear());
if (n) if (n)
{ {
for (sal_Int32 i = 0; i < numdict; ++i) { for (sal_Int32 i = 0; i < numdict; ++i)
{
pMS = NULL; pMS = NULL;
aEnc = 0; eEnc = RTL_TEXTENCODING_DONTKNOW;
if (rLocale == aDLocs[i]) if (rLocale == aDLocs[i])
{ {
if (!aDicts[i]) if (!aDicts[i])
{ {
OUString dicpath = aDNames[i] + A2OU(".dic"); OUString dicpath = aDNames[i] + A2OU(".dic");
OUString affpath = aDNames[i] + A2OU(".aff"); OUString affpath = aDNames[i] + A2OU(".aff");
OUString dict; OUString dict;
OUString aff; OUString aff;
osl::FileBase::getSystemPathFromFileURL(dicpath,dict); osl::FileBase::getSystemPathFromFileURL(dicpath,dict);
osl::FileBase::getSystemPathFromFileURL(affpath,aff); osl::FileBase::getSystemPathFromFileURL(affpath,aff);
OString aTmpaff(OU2ENC(aff,osl_getThreadTextEncoding())); OString aTmpaff(OU2ENC(aff,osl_getThreadTextEncoding()));
OString aTmpdict(OU2ENC(dict,osl_getThreadTextEncoding())); OString aTmpdict(OU2ENC(dict,osl_getThreadTextEncoding()));
#if defined(WNT) #if defined(WNT)
// workaround for Windows specifc problem that the // workaround for Windows specifc problem that the
// path length in calls to 'fopen' is limted to somewhat // path length in calls to 'fopen' is limted to somewhat
// about 120+ characters which will usually be exceed when // about 120+ characters which will usually be exceed when
// using dictionaries as extensions. // using dictionaries as extensions.
aTmpaff = Win_GetShortPathName( aff ); aTmpaff = Win_GetShortPathName( aff );
aTmpdict = Win_GetShortPathName( dict ); aTmpdict = Win_GetShortPathName( dict );
#endif #endif
aDicts[i] = new Hunspell(aTmpaff.getStr(),aTmpdict.getStr()); aDicts[i] = new Hunspell(aTmpaff.getStr(),aTmpdict.getStr());
aDEncs[i] = 0; aDEncs[i] = RTL_TEXTENCODING_DONTKNOW;
if (aDicts[i]) { if (aDicts[i])
char * dic_encoding = aDicts[i]->get_dic_encoding(); aDEncs[i] = getTextEncodingFromCharset(aDicts[i]->get_dic_encoding());
aDEncs[i] = rtl_getTextEncodingFromUnixCharset(aDicts[i]->get_dic_encoding()); }
if (aDEncs[i] == RTL_TEXTENCODING_DONTKNOW) { pMS = aDicts[i];
if (strcmp("ISCII-DEVANAGARI", dic_encoding) == 0) { eEnc = aDEncs[i];
aDEncs[i] = RTL_TEXTENCODING_ISCII_DEVANAGARI; }
} else if (strcmp("UTF-8", dic_encoding) == 0) {
aDEncs[i] = RTL_TEXTENCODING_UTF8; // we don't want to work with a default text encoding since following incorrect
} // results may occur only for specific text and thus may be hard to notice.
} // Thus better always make a clean exit here if the text encoding is in question.
} // Hopefully something not working at all will raise proper attention quickly. ;-)
} DBG_ASSERT( eEnc != RTL_TEXTENCODING_DONTKNOW, "failed to get text encoding! (maybe incorrect encoding string in file)" );
pMS = aDicts[i]; if (eEnc == RTL_TEXTENCODING_DONTKNOW)
aEnc = aDEncs[i]; return -1;
}
if (pMS) if (pMS)
{ {
OString aWrd(OU2ENC(nWord,aEnc)); OString aWrd(OU2ENC(nWord,eEnc));
int rVal = pMS->spell((char*)aWrd.getStr()); int rVal = pMS->spell((char*)aWrd.getStr());
if (rVal != 1) if (rVal != 1)
{ nRes = SpellFailure::SPELLING_ERROR;
nRes = SpellFailure::SPELLING_ERROR; else
} else { return -1;
return -1; pMS = NULL;
}
pMS = NULL;
} }
} }
} }
@@ -358,8 +359,7 @@ INT16 SpellChecker::GetSpellFailure( const OUString &rWord, const Locale &rLocal
} }
sal_Bool SAL_CALL sal_Bool SAL_CALL SpellChecker::isValid( const OUString& rWord, const Locale& rLocale,
SpellChecker::isValid( const OUString& rWord, const Locale& rLocale,
const PropertyValues& rProperties ) const PropertyValues& rProperties )
throw(IllegalArgumentException, RuntimeException) throw(IllegalArgumentException, RuntimeException)
{ {
@@ -390,11 +390,11 @@ sal_Bool SAL_CALL
{ {
INT16 nLang = LocaleToLanguage( rLocale ); INT16 nLang = LocaleToLanguage( rLocale );
// postprocess result for errors that should be ignored // postprocess result for errors that should be ignored
if ( (!rHelper.IsSpellUpperCase() && IsUpper( rWord, nLang )) const bool bIgnoreError =
|| (!rHelper.IsSpellWithDigits() && HasDigits( rWord )) (!rHelper.IsSpellUpperCase() && IsUpper( rWord, nLang )) ||
|| (!rHelper.IsSpellCapitalization() (!rHelper.IsSpellWithDigits() && HasDigits( rWord )) ||
&& nFailure == SpellFailure::CAPTION_ERROR) (!rHelper.IsSpellCapitalization() && nFailure == SpellFailure::CAPTION_ERROR);
) if (bIgnoreError)
nFailure = -1; nFailure = -1;
} }
@@ -410,23 +410,26 @@ Reference< XSpellAlternatives >
// Especially it may give a list of suggested (correct) words: // Especially it may give a list of suggested (correct) words:
Reference< XSpellAlternatives > xRes; Reference< XSpellAlternatives > xRes;
// note: mutex is held by higher up by spell which covers both // note: mutex is held by higher up by spell which covers both
Hunspell* pMS; Hunspell* pMS = NULL;
rtl_TextEncoding aEnc; rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
int count; int count = 0;
int numsug = 0; int numsug = 0;
// first handle smart quotes (single and double) // first handle smart quotes (single and double)
OUStringBuffer rBuf(rWord); OUStringBuffer rBuf(rWord);
sal_Int32 n = rBuf.getLength(); sal_Int32 n = rBuf.getLength();
sal_Unicode c; sal_Unicode c;
for (sal_Int32 ix=0; ix < n; ix++) { for (sal_Int32 ix=0; ix < n; ix++)
c = rBuf.charAt(ix); {
if ((c == 0x201C) || (c == 0x201D)) rBuf.setCharAt(ix,(sal_Unicode)0x0022); c = rBuf.charAt(ix);
if ((c == 0x2018) || (c == 0x2019)) rBuf.setCharAt(ix,(sal_Unicode)0x0027); if ((c == 0x201C) || (c == 0x201D))
} rBuf.setCharAt(ix,(sal_Unicode)0x0022);
OUString nWord(rBuf.makeStringAndClear()); if ((c == 0x2018) || (c == 0x2019))
rBuf.setCharAt(ix,(sal_Unicode)0x0027);
}
OUString nWord(rBuf.makeStringAndClear());
if (n) if (n)
{ {
@@ -434,59 +437,57 @@ Reference< XSpellAlternatives >
Sequence< OUString > aStr( 0 ); Sequence< OUString > aStr( 0 );
for (int i =0; i < numdict; i++) { for (int i =0; i < numdict; i++)
{
pMS = NULL; pMS = NULL;
aEnc = 0; eEnc = RTL_TEXTENCODING_DONTKNOW;
count = 0; count = 0;
if (rLocale == aDLocs[i]) if (rLocale == aDLocs[i])
{ {
pMS = aDicts[i]; pMS = aDicts[i];
aEnc = aDEncs[i]; eEnc = aDEncs[i];
} }
if (pMS) if (pMS)
{ {
char ** suglst = NULL; char ** suglst = NULL;
OString aWrd(OU2ENC(nWord,aEnc)); OString aWrd(OU2ENC(nWord,eEnc));
count = pMS->suggest(&suglst, (const char *) aWrd.getStr()); count = pMS->suggest(&suglst, (const char *) aWrd.getStr());
if (count) { if (count)
{
aStr.realloc( numsug + count ); aStr.realloc( numsug + count );
OUString *pStr = aStr.getArray(); OUString *pStr = aStr.getArray();
for (int ii=0; ii < count; ii++) for (int ii=0; ii < count; ii++)
{ {
// if needed add: if (suglst[ii] == NULL) continue; // if needed add: if (suglst[ii] == NULL) continue;
OUString cvtwrd(suglst[ii],strlen(suglst[ii]),aEnc); OUString cvtwrd(suglst[ii],strlen(suglst[ii]),eEnc);
pStr[numsug + ii] = cvtwrd; pStr[numsug + ii] = cvtwrd;
free(suglst[ii]); free(suglst[ii]);
}
free(suglst);
numsug += count;
} }
} free(suglst);
numsug += count;
}
}
} }
// now return an empty alternative for no suggestions or the list of alternatives if some found // now return an empty alternative for no suggestions or the list of alternatives if some found
SpellAlternatives *pAlt = new SpellAlternatives; SpellAlternatives *pAlt = new SpellAlternatives;
String aTmp(rWord); String aTmp(rWord);
pAlt->SetWordLanguage( aTmp, nLang ); pAlt->SetWordLanguage( aTmp, nLang );
pAlt->SetFailureType( SpellFailure::SPELLING_ERROR ); pAlt->SetFailureType( SpellFailure::SPELLING_ERROR );
pAlt->SetAlternatives( aStr ); pAlt->SetAlternatives( aStr );
xRes = pAlt; xRes = pAlt;
return xRes;
}
return xRes; return xRes;
}
return xRes;
} }
Reference< XSpellAlternatives > SAL_CALL SpellChecker::spell(
const OUString& rWord, const Locale& rLocale,
Reference< XSpellAlternatives > SAL_CALL const PropertyValues& rProperties )
SpellChecker::spell( const OUString& rWord, const Locale& rLocale,
const PropertyValues& rProperties )
throw(IllegalArgumentException, RuntimeException) throw(IllegalArgumentException, RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -511,7 +512,7 @@ Reference< XSpellAlternatives > SAL_CALL
Reference< XInterface > SAL_CALL SpellChecker_CreateInstance( Reference< XInterface > SAL_CALL SpellChecker_CreateInstance(
const Reference< XMultiServiceFactory > & /*rSMgr*/ ) const Reference< XMultiServiceFactory > & /*rSMgr*/ )
throw(Exception) throw(Exception)
{ {
@@ -520,9 +521,8 @@ Reference< XInterface > SAL_CALL SpellChecker_CreateInstance(
} }
sal_Bool SAL_CALL sal_Bool SAL_CALL SpellChecker::addLinguServiceEventListener(
SpellChecker::addLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr )
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -536,9 +536,8 @@ sal_Bool SAL_CALL
} }
sal_Bool SAL_CALL sal_Bool SAL_CALL SpellChecker::removeLinguServiceEventListener(
SpellChecker::removeLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr )
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -553,8 +552,7 @@ sal_Bool SAL_CALL
} }
OUString SAL_CALL OUString SAL_CALL SpellChecker::getServiceDisplayName( const Locale& /*rLocale*/ )
SpellChecker::getServiceDisplayName( const Locale& /*rLocale*/ )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -562,8 +560,7 @@ OUString SAL_CALL
} }
void SAL_CALL void SAL_CALL SpellChecker::initialize( const Sequence< Any >& rArguments )
SpellChecker::initialize( const Sequence< Any >& rArguments )
throw(Exception, RuntimeException) throw(Exception, RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -585,16 +582,15 @@ void SAL_CALL
xPropHelper = pPropHelper; xPropHelper = pPropHelper;
pPropHelper->AddAsPropListener(); //! after a reference is established pPropHelper->AddAsPropListener(); //! after a reference is established
} }
else { else
{
DBG_ERROR( "wrong number of arguments in sequence" ); DBG_ERROR( "wrong number of arguments in sequence" );
} }
} }
} }
void SAL_CALL void SAL_CALL SpellChecker::dispose()
SpellChecker::dispose()
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -608,8 +604,7 @@ void SAL_CALL
} }
void SAL_CALL void SAL_CALL SpellChecker::addEventListener( const Reference< XEventListener >& rxListener )
SpellChecker::addEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -619,8 +614,7 @@ void SAL_CALL
} }
void SAL_CALL void SAL_CALL SpellChecker::removeEventListener( const Reference< XEventListener >& rxListener )
SpellChecker::removeEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );

86
lingucomponent/source/spellcheck/spell/sspellimp.hxx Normal file → Executable file
View File

@@ -69,11 +69,11 @@ class SpellChecker :
> >
{ {
Sequence< Locale > aSuppLocales; Sequence< Locale > aSuppLocales;
Hunspell ** aDicts; Hunspell ** aDicts;
rtl_TextEncoding * aDEncs; rtl_TextEncoding * aDEncs;
Locale * aDLocs; Locale * aDLocs;
OUString * aDNames; OUString * aDNames;
sal_Int32 numdict; sal_Int32 numdict;
::cppu::OInterfaceContainerHelper aEvtListeners; ::cppu::OInterfaceContainerHelper aEvtListeners;
Reference< XPropertyChangeListener > xPropHelper; Reference< XPropertyChangeListener > xPropHelper;
@@ -91,84 +91,43 @@ class SpellChecker :
} }
INT16 GetSpellFailure( const OUString &rWord, const Locale &rLocale ); INT16 GetSpellFailure( const OUString &rWord, const Locale &rLocale );
Reference< XSpellAlternatives > Reference< XSpellAlternatives > GetProposals( const OUString &rWord, const Locale &rLocale );
GetProposals( const OUString &rWord, const Locale &rLocale );
public: public:
SpellChecker(); SpellChecker();
virtual ~SpellChecker(); virtual ~SpellChecker();
// XSupportedLocales (for XSpellChecker) // XSupportedLocales (for XSpellChecker)
virtual Sequence< Locale > SAL_CALL virtual Sequence< Locale > SAL_CALL getLocales() throw(RuntimeException);
getLocales() virtual sal_Bool SAL_CALL hasLocale( const Locale& rLocale ) throw(RuntimeException);
throw(RuntimeException);
virtual sal_Bool SAL_CALL
hasLocale( const Locale& rLocale )
throw(RuntimeException);
// XSpellChecker // XSpellChecker
virtual sal_Bool SAL_CALL virtual sal_Bool SAL_CALL isValid( const OUString& rWord, const Locale& rLocale, const PropertyValues& rProperties ) throw(IllegalArgumentException, RuntimeException);
isValid( const OUString& rWord, const Locale& rLocale, virtual Reference< XSpellAlternatives > SAL_CALL spell( const OUString& rWord, const Locale& rLocale, const PropertyValues& rProperties ) throw(IllegalArgumentException, RuntimeException);
const PropertyValues& rProperties )
throw(IllegalArgumentException,
RuntimeException);
virtual Reference< XSpellAlternatives > SAL_CALL
spell( const OUString& rWord, const Locale& rLocale,
const PropertyValues& rProperties )
throw(IllegalArgumentException,
RuntimeException);
// XLinguServiceEventBroadcaster // XLinguServiceEventBroadcaster
virtual sal_Bool SAL_CALL virtual sal_Bool SAL_CALL addLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) throw(RuntimeException);
addLinguServiceEventListener( virtual sal_Bool SAL_CALL removeLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) throw(RuntimeException);
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException);
virtual sal_Bool SAL_CALL
removeLinguServiceEventListener(
const Reference< XLinguServiceEventListener >& rxLstnr )
throw(RuntimeException);
// XServiceDisplayName // XServiceDisplayName
virtual OUString SAL_CALL virtual OUString SAL_CALL getServiceDisplayName( const Locale& rLocale ) throw(RuntimeException);
getServiceDisplayName( const Locale& rLocale )
throw(RuntimeException);
// XInitialization // XInitialization
virtual void SAL_CALL virtual void SAL_CALL initialize( const Sequence< Any >& rArguments ) throw(Exception, RuntimeException);
initialize( const Sequence< Any >& rArguments )
throw(Exception, RuntimeException);
// XComponent // XComponent
virtual void SAL_CALL virtual void SAL_CALL dispose() throw(RuntimeException);
dispose() virtual void SAL_CALL addEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
throw(RuntimeException); virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
virtual void SAL_CALL
addEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
virtual void SAL_CALL
removeEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
////////////////////////////////////////////////////////////
// Service specific part
//
// XServiceInfo // XServiceInfo
virtual OUString SAL_CALL virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
getImplementationName() virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) throw(RuntimeException);
throw(RuntimeException); virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw(RuntimeException);
virtual sal_Bool SAL_CALL
supportsService( const OUString& rServiceName )
throw(RuntimeException);
virtual Sequence< OUString > SAL_CALL
getSupportedServiceNames()
throw(RuntimeException);
static inline OUString static inline OUString getImplementationName_Static() throw();
getImplementationName_Static() throw(); static Sequence< OUString > getSupportedServiceNames_Static() throw();
static Sequence< OUString >
getSupportedServiceNames_Static() throw();
}; };
inline OUString SpellChecker::getImplementationName_Static() throw() inline OUString SpellChecker::getImplementationName_Static() throw()
@@ -177,7 +136,6 @@ inline OUString SpellChecker::getImplementationName_Static() throw()
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
#endif #endif

22
lingucomponent/source/thesaurus/libnth/nthesdta.hxx Normal file → Executable file
View File

@@ -48,11 +48,11 @@ class Meaning :
{ {
::com::sun::star::uno::Sequence< ::rtl::OUString > aSyn; // list of synonyms, may be empty. ::com::sun::star::uno::Sequence< ::rtl::OUString > aSyn; // list of synonyms, may be empty.
::rtl::OUString aTerm; ::rtl::OUString aTerm;
INT16 nLanguage; INT16 nLanguage;
#if 0 #if 0
// this is for future use by a German thesaurus // this is for future use by a German thesaurus
BOOL bIsGermanPreReform; BOOL bIsGermanPreReform;
#endif #endif
// disallow copy-constructor and assignment-operator for now // disallow copy-constructor and assignment-operator for now
@@ -68,22 +68,12 @@ public:
virtual ~Meaning(); virtual ~Meaning();
// XMeaning // XMeaning
virtual ::rtl::OUString SAL_CALL virtual ::rtl::OUString SAL_CALL getMeaning() throw(::com::sun::star::uno::RuntimeException);
getMeaning() virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL querySynonyms() throw(::com::sun::star::uno::RuntimeException);
throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL
querySynonyms()
throw(::com::sun::star::uno::RuntimeException);
// non-interface specific functions // non-interface specific functions
void SetSynonyms( void SetSynonyms( const ::com::sun::star::uno::Sequence< ::rtl::OUString > &rSyn );
const ::com::sun::star::uno::Sequence< ::rtl::OUString > void SetMeaning( const ::rtl::OUString &rTerm );
&rSyn );
void SetMeaning(const ::rtl::OUString &rTerm );
}; };

446
lingucomponent/source/thesaurus/libnth/nthesimp.cxx Normal file → Executable file
View File

@@ -28,9 +28,7 @@
// MARKER(update_precomp.py): autogen include statement, do not remove // MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_lingucomponent.hxx" #include "precompiled_lingucomponent.hxx"
// include <stdio.h>
#include <com/sun/star/uno/Reference.h> #include <com/sun/star/uno/Reference.h>
#include <cppuhelper/factory.hxx> // helper for factories #include <cppuhelper/factory.hxx> // helper for factories
#include <com/sun/star/registry/XRegistryKey.hpp> #include <com/sun/star/registry/XRegistryKey.hpp>
#include <com/sun/star/beans/XPropertySet.hpp> #include <com/sun/star/beans/XPropertySet.hpp>
@@ -100,23 +98,27 @@ Thesaurus::Thesaurus() :
aTEncs = NULL; aTEncs = NULL;
aTLocs = NULL; aTLocs = NULL;
aTNames = NULL; aTNames = NULL;
numthes = 0; numthes = 0;
} }
Thesaurus::~Thesaurus() Thesaurus::~Thesaurus()
{ {
if (aThes) { if (aThes)
for (int i = 0; i < numthes; i++) { {
for (int i = 0; i < numthes; i++)
{
if (aThes[i]) delete aThes[i]; if (aThes[i]) delete aThes[i];
aThes[i] = NULL; aThes[i] = NULL;
} }
delete[] aThes; delete[] aThes;
} }
aThes = NULL; aThes = NULL;
if (aCharSetInfo) { if (aCharSetInfo)
for (int i = 0; i < numthes; i++) { {
for (int i = 0; i < numthes; i++)
{
if (aCharSetInfo[i]) delete aCharSetInfo[i]; if (aCharSetInfo[i]) delete aCharSetInfo[i];
aCharSetInfo[i] = NULL; aCharSetInfo[i] = NULL;
} }
@@ -244,7 +246,7 @@ Sequence< Locale > SAL_CALL Thesaurus::getLocales()
for (sal_Int32 i = 0; i < nLocales; ++i) for (sal_Int32 i = 0; i < nLocales; ++i)
{ {
aThes[k] = NULL; aThes[k] = NULL;
aTEncs[k] = 0; aTEncs[k] = RTL_TEXTENCODING_DONTKNOW;
aTLocs[k] = MsLangId::convertLanguageToLocale( aTLocs[k] = MsLangId::convertLanguageToLocale(
MsLangId::convertIsoStringToLanguage( aDictIt->aLocaleNames[i] )); MsLangId::convertIsoStringToLanguage( aDictIt->aLocaleNames[i] ));
aCharSetInfo[k] = new CharClass( aTLocs[k] ); aCharSetInfo[k] = new CharClass( aTLocs[k] );
@@ -302,28 +304,28 @@ sal_Bool SAL_CALL Thesaurus::hasLocale(const Locale& rLocale)
} }
Sequence < Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL Sequence < Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL Thesaurus::queryMeanings(
Thesaurus::queryMeanings( const OUString& qTerm, const Locale& rLocale, const OUString& qTerm, const Locale& rLocale,
const PropertyValues& rProperties) const PropertyValues& rProperties)
throw(IllegalArgumentException, RuntimeException) throw(IllegalArgumentException, RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
uno::Sequence< Reference< XMeaning > > aMeanings( 1 ); uno::Sequence< Reference< XMeaning > > aMeanings( 1 );
uno::Sequence< Reference< XMeaning > > noMeanings( 0 ); uno::Sequence< Reference< XMeaning > > noMeanings( 0 );
uno::Reference< XLinguServiceManager > xLngSvcMgr( GetLngSvcMgr_Impl() ); uno::Reference< XLinguServiceManager > xLngSvcMgr( GetLngSvcMgr_Impl() );
uno::Reference< XSpellChecker1 > xSpell; uno::Reference< XSpellChecker1 > xSpell;
OUString rTerm(qTerm); OUString rTerm(qTerm);
OUString pTerm(qTerm); OUString pTerm(qTerm);
sal_uInt16 ct = CAPTYPE_UNKNOWN; sal_uInt16 ct = CAPTYPE_UNKNOWN;
sal_Int32 stem = 0; sal_Int32 stem = 0;
sal_Int32 stem2 = 0; sal_Int32 stem2 = 0;
INT16 nLanguage = LocaleToLanguage( rLocale ); INT16 nLanguage = LocaleToLanguage( rLocale );
if (nLanguage == LANGUAGE_NONE || !rTerm.getLength()) if (nLanguage == LANGUAGE_NONE || !rTerm.getLength())
return noMeanings; return noMeanings;
if (!hasLocale( rLocale )) if (!hasLocale( rLocale ))
#ifdef LINGU_EXCEPTIONS #ifdef LINGU_EXCEPTIONS
@@ -332,195 +334,202 @@ Sequence < Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL
return noMeanings; return noMeanings;
#endif #endif
if (prevTerm == qTerm && prevLocale == nLanguage) return prevMeanings; if (prevTerm == qTerm && prevLocale == nLanguage)
return prevMeanings;
mentry * pmean = NULL; mentry * pmean = NULL;
sal_Int32 nmean = 0; sal_Int32 nmean = 0;
PropertyHelper_Thes &rHelper = GetPropHelper(); PropertyHelper_Thes &rHelper = GetPropHelper();
rHelper.SetTmpPropVals( rProperties ); rHelper.SetTmpPropVals( rProperties );
MyThes * pTH = NULL; MyThes * pTH = NULL;
rtl_TextEncoding aEnc = 0; rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
CharClass * pCC = NULL; CharClass * pCC = NULL;
// find the first thesaurus that matches the locale // find the first thesaurus that matches the locale
for (int i =0; i < numthes; i++) { for (int i =0; i < numthes; i++)
if (rLocale == aTLocs[i]) {
if (rLocale == aTLocs[i])
{
// open up and intialize this thesaurus if need be
if (!aThes[i])
{ {
// open up and intialize this thesaurus if need be OUString datpath = aTNames[i] + A2OU(".dat");
if (!aThes[i]) OUString idxpath = aTNames[i] + A2OU(".idx");
{ OUString ndat;
OUString datpath = aTNames[i] + A2OU(".dat"); OUString nidx;
OUString idxpath = aTNames[i] + A2OU(".idx"); osl::FileBase::getSystemPathFromFileURL(datpath,ndat);
OUString ndat; osl::FileBase::getSystemPathFromFileURL(idxpath,nidx);
OUString nidx; OString aTmpidx(OU2ENC(nidx,osl_getThreadTextEncoding()));
osl::FileBase::getSystemPathFromFileURL(datpath,ndat); OString aTmpdat(OU2ENC(ndat,osl_getThreadTextEncoding()));
osl::FileBase::getSystemPathFromFileURL(idxpath,nidx);
OString aTmpidx(OU2ENC(nidx,osl_getThreadTextEncoding()));
OString aTmpdat(OU2ENC(ndat,osl_getThreadTextEncoding()));
#if defined(WNT) #if defined(WNT)
// workaround for Windows specifc problem that the // workaround for Windows specifc problem that the
// path length in calls to 'fopen' is limted to somewhat // path length in calls to 'fopen' is limted to somewhat
// about 120+ characters which will usually be exceed when // about 120+ characters which will usually be exceed when
// using dictionaries as extensions. // using dictionaries as extensions.
aTmpidx = Win_GetShortPathName( nidx ); aTmpidx = Win_GetShortPathName( nidx );
aTmpdat = Win_GetShortPathName( ndat ); aTmpdat = Win_GetShortPathName( ndat );
#endif #endif
aThes[i] = new MyThes(aTmpidx.getStr(),aTmpdat.getStr()); aThes[i] = new MyThes(aTmpidx.getStr(),aTmpdat.getStr());
if (aThes[i]) { if (aThes[i])
const char * enc_string = aThes[i]->get_th_encoding(); aTEncs[i] = getTextEncodingFromCharset(aThes[i]->get_th_encoding());
if (!enc_string) { }
aTEncs[i] = rtl_getTextEncodingFromUnixCharset("ISO8859-1"); pTH = aThes[i];
} else { eEnc = aTEncs[i];
aTEncs[i] = rtl_getTextEncodingFromUnixCharset(enc_string); pCC = aCharSetInfo[i];
if (aTEncs[i] == RTL_TEXTENCODING_DONTKNOW) {
if (strcmp("ISCII-DEVANAGARI", enc_string) == 0) {
aTEncs[i] = RTL_TEXTENCODING_ISCII_DEVANAGARI;
} else if (strcmp("UTF-8", enc_string) == 0) {
aTEncs[i] = RTL_TEXTENCODING_UTF8;
}
}
}
}
}
pTH = aThes[i];
aEnc = aTEncs[i];
pCC = aCharSetInfo[i];
if (pTH) if (pTH)
break; break;
} }
} }
while (pTH) { // we don't want to work with a default text encoding since following incorrect
// convert word to all lower case for searching // results may occur only for specific text and thus may be hard to notice.
if (!stem) ct = capitalType(rTerm, pCC); // Thus better always make a clean exit here if the text encoding is in question.
OUString nTerm(makeLowerCase(rTerm, pCC)); // Hopefully something not working at all will raise proper attention quickly. ;-)
OString aTmp( OU2ENC(nTerm, aEnc) ); DBG_ASSERT( eEnc != RTL_TEXTENCODING_DONTKNOW, "failed to get text encoding! (maybe incorrect encoding string in file)" );
nmean = pTH->Lookup(aTmp.getStr(),aTmp.getLength(),&pmean); if (eEnc == RTL_TEXTENCODING_DONTKNOW)
return noMeanings;
if (nmean) aMeanings.realloc( nmean ); while (pTH)
{
// convert word to all lower case for searching
if (!stem)
ct = capitalType(rTerm, pCC);
OUString nTerm(makeLowerCase(rTerm, pCC));
OString aTmp( OU2ENC(nTerm, eEnc) );
nmean = pTH->Lookup(aTmp.getStr(),aTmp.getLength(),&pmean);
mentry * pe = pmean; if (nmean)
OUString codeTerm = qTerm; aMeanings.realloc( nmean );
Reference< XSpellAlternatives > xTmpRes2;
if (stem) { mentry * pe = pmean;
xTmpRes2 = xSpell->spell( A2OU("<?xml?><query type='analyze'><word>") + OUString codeTerm = qTerm;
Reference< XSpellAlternatives > xTmpRes2;
if (stem)
{
xTmpRes2 = xSpell->spell( A2OU("<?xml?><query type='analyze'><word>") +
pTerm + A2OU("</word></query>"), nLanguage, rProperties ); pTerm + A2OU("</word></query>"), nLanguage, rProperties );
if (xTmpRes2.is()) { if (xTmpRes2.is())
Sequence<OUString>seq = xTmpRes2->getAlternatives(); {
if (seq.getLength() > 0) { Sequence<OUString>seq = xTmpRes2->getAlternatives();
if (seq.getLength() > 0)
{
codeTerm = seq[0]; codeTerm = seq[0];
stem2 = 1; stem2 = 1;
} }
#if 0 #if 0
OString o = OUStringToOString(codeTerm, rtl_getTextEncodingFromUnixCharset("UTF-8")); OString o = OUStringToOString(codeTerm, RTL_TEXTENCODING_UTF8);
fprintf(stderr, "CODETERM: %s\n", o.pData->buffer); fprintf(stderr, "CODETERM: %s\n", o.pData->buffer);
#endif #endif
} }
} }
for (int j = 0; j < nmean; j++) { for (int j = 0; j < nmean; j++)
int count = pe->count; {
if (count) { int count = pe->count;
Sequence< OUString > aStr( count ); if (count)
OUString *pStr = aStr.getArray(); {
Sequence< OUString > aStr( count );
OUString *pStr = aStr.getArray();
for (int i=0; i < count; i++) { for (int i=0; i < count; i++)
OUString sTerm(pe->psyns[i],strlen(pe->psyns[i]),aEnc ); {
sal_Int32 catpos = sTerm.indexOf('('); OUString sTerm(pe->psyns[i],strlen(pe->psyns[i]),eEnc );
sal_Int32 catpos2 = 0; sal_Int32 catpos = sTerm.indexOf('(');
OUString catst; sal_Int32 catpos2 = 0;
OUString catst2; OUString catst;
if (catpos > 2) { OUString catst2;
// remove category name for affixation and casing if (catpos > 2)
catst = A2OU(" ") + sTerm.copy(catpos); {
sTerm = sTerm.copy(0, catpos); // remove category name for affixation and casing
sTerm = sTerm.trim(); catst = A2OU(" ") + sTerm.copy(catpos);
} sTerm = sTerm.copy(0, catpos);
// generate synonyms with affixes sTerm = sTerm.trim();
if (stem && stem2) { }
Reference< XSpellAlternatives > xTmpRes; // generate synonyms with affixes
xTmpRes = xSpell->spell( A2OU("<?xml?><query type='generate'><word>") + if (stem && stem2)
sTerm + A2OU("</word>") + codeTerm + A2OU("</query>"), nLanguage, rProperties ); {
if (xTmpRes.is()) { Reference< XSpellAlternatives > xTmpRes;
Sequence<OUString>seq = xTmpRes->getAlternatives(); xTmpRes = xSpell->spell( A2OU("<?xml?><query type='generate'><word>") +
for (int k = 0; k < seq.getLength(); k++) { sTerm + A2OU("</word>") + codeTerm + A2OU("</query>"), nLanguage, rProperties );
OString o = OUStringToOString(seq[k], rtl_getTextEncodingFromUnixCharset("UTF-8")); if (xTmpRes.is())
} {
if (seq.getLength() > 0) sTerm = seq[0]; Sequence<OUString>seq = xTmpRes->getAlternatives();
} if (seq.getLength() > 0)
} sTerm = seq[0];
if (catpos2) sTerm = catst2 + sTerm; }
}
if (catpos2)
sTerm = catst2 + sTerm;
sal_uInt16 ct1 = capitalType(sTerm, pCC); sal_uInt16 ct1 = capitalType(sTerm, pCC);
if (CAPTYPE_MIXED == ct1) if (CAPTYPE_MIXED == ct1)
ct = ct1; ct = ct1;
OUString cTerm; OUString cTerm;
switch (ct) { switch (ct)
case CAPTYPE_ALLCAP: {
{ case CAPTYPE_ALLCAP:
cTerm = makeUpperCase(sTerm, pCC); cTerm = makeUpperCase(sTerm, pCC);
break; break;
} case CAPTYPE_INITCAP:
case CAPTYPE_INITCAP: cTerm = makeInitCap(sTerm, pCC);
{ break;
cTerm = makeInitCap(sTerm, pCC); default:
break; cTerm = sTerm;
} break;
default: }
{ OUString aAlt( cTerm + catst);
cTerm = sTerm; pStr[i] = aAlt;
break; }
}
}
OUString aAlt( cTerm + catst);
pStr[i] = aAlt;
}
#if 0 #if 0
Meaning * pMn = new Meaning(rTerm,nLanguage,rHelper); Meaning * pMn = new Meaning(rTerm,nLanguage,rHelper);
#endif #endif
Meaning * pMn = new Meaning(rTerm,nLanguage); Meaning * pMn = new Meaning(rTerm,nLanguage);
OUString dTerm(pe->defn,strlen(pe->defn),aEnc ); OUString dTerm(pe->defn,strlen(pe->defn),eEnc );
pMn->SetMeaning(dTerm); pMn->SetMeaning(dTerm);
pMn->SetSynonyms(aStr); pMn->SetSynonyms(aStr);
Reference<XMeaning>* pMeaning = aMeanings.getArray(); Reference<XMeaning>* pMeaning = aMeanings.getArray();
pMeaning[j] = pMn; pMeaning[j] = pMn;
} }
pe++; pe++;
} }
pTH->CleanUpAfterLookup(&pmean,nmean); pTH->CleanUpAfterLookup(&pmean,nmean);
if (nmean) { if (nmean)
{
prevTerm = qTerm; prevTerm = qTerm;
prevMeanings = aMeanings; prevMeanings = aMeanings;
prevLocale = nLanguage; prevLocale = nLanguage;
return aMeanings; return aMeanings;
} }
if (stem || !xLngSvcMgr.is()) return noMeanings; if (stem || !xLngSvcMgr.is())
return noMeanings;
stem = 1; stem = 1;
xSpell = uno::Reference< XSpellChecker1 >( xLngSvcMgr->getSpellChecker(), UNO_QUERY ); xSpell = uno::Reference< XSpellChecker1 >( xLngSvcMgr->getSpellChecker(), UNO_QUERY );
if (!xSpell.is() || !xSpell->isValid( A2OU(SPELLML_SUPPORT), nLanguage, rProperties )) { if (!xSpell.is() || !xSpell->isValid( A2OU(SPELLML_SUPPORT), nLanguage, rProperties ))
return noMeanings; return noMeanings;
}
Reference< XSpellAlternatives > xTmpRes; Reference< XSpellAlternatives > xTmpRes;
xTmpRes = xSpell->spell( A2OU("<?xml?><query type='stem'><word>") + xTmpRes = xSpell->spell( A2OU("<?xml?><query type='stem'><word>") +
rTerm + A2OU("</word></query>"), nLanguage, rProperties ); rTerm + A2OU("</word></query>"), nLanguage, rProperties );
if (xTmpRes.is()) { if (xTmpRes.is())
{
Sequence<OUString>seq = xTmpRes->getAlternatives(); Sequence<OUString>seq = xTmpRes->getAlternatives();
#if 0 #if 0
for (int i = 0; i < seq.getLength(); i++) { for (int i = 0; i < seq.getLength(); i++)
OString o = OUStringToOString(seq[i], rtl_getTextEncodingFromUnixCharset("UTF-8")); {
OString o = OUStringToOString(seq[i], RTL_TEXTENCODING_UTF8);
fprintf(stderr, "%d: %s\n", i + 1, o.pData->buffer); fprintf(stderr, "%d: %s\n", i + 1, o.pData->buffer);
} }
#endif #endif
if (seq.getLength() > 0) { if (seq.getLength() > 0)
{
rTerm = seq[0]; // XXX Use only the first stem rTerm = seq[0]; // XXX Use only the first stem
continue; continue;
} }
@@ -529,17 +538,21 @@ Sequence < Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL
// stem the last word of the synonym (for categories after affixation) // stem the last word of the synonym (for categories after affixation)
rTerm = rTerm.trim(); rTerm = rTerm.trim();
sal_Int32 pos = rTerm.lastIndexOf(' '); sal_Int32 pos = rTerm.lastIndexOf(' ');
if (!pos) return noMeanings; if (!pos)
return noMeanings;
xTmpRes = xSpell->spell( A2OU("<?xml?><query type='stem'><word>") + xTmpRes = xSpell->spell( A2OU("<?xml?><query type='stem'><word>") +
rTerm.copy(pos + 1) + A2OU("</word></query>"), nLanguage, rProperties ); rTerm.copy(pos + 1) + A2OU("</word></query>"), nLanguage, rProperties );
if (xTmpRes.is()) { if (xTmpRes.is())
{
Sequence<OUString>seq = xTmpRes->getAlternatives(); Sequence<OUString>seq = xTmpRes->getAlternatives();
if (seq.getLength() > 0) { if (seq.getLength() > 0)
{
pTerm = rTerm.copy(pos + 1); pTerm = rTerm.copy(pos + 1);
rTerm = rTerm.copy(0, pos + 1) + seq[0]; rTerm = rTerm.copy(0, pos + 1) + seq[0];
#if 0 #if 0
for (int i = 0; i < seq.getLength(); i++) { for (int i = 0; i < seq.getLength(); i++)
OString o = OUStringToOString(seq[i], rtl_getTextEncodingFromUnixCharset("UTF-8")); {
OString o = OUStringToOString(seq[i], RTL_TEXTENCODING_UTF8);
fprintf(stderr, "%d: %s\n", i + 1, o.pData->buffer); fprintf(stderr, "%d: %s\n", i + 1, o.pData->buffer);
} }
#endif #endif
@@ -547,12 +560,11 @@ Sequence < Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL
} }
} }
break; break;
} }
return noMeanings; return noMeanings;
} }
Reference< XInterface > SAL_CALL Thesaurus_CreateInstance( Reference< XInterface > SAL_CALL Thesaurus_CreateInstance(
const Reference< XMultiServiceFactory > & /*rSMgr*/ ) const Reference< XMultiServiceFactory > & /*rSMgr*/ )
throw(Exception) throw(Exception)
@@ -562,8 +574,7 @@ Reference< XInterface > SAL_CALL Thesaurus_CreateInstance(
} }
OUString SAL_CALL OUString SAL_CALL Thesaurus::getServiceDisplayName( const Locale& /*rLocale*/ )
Thesaurus::getServiceDisplayName( const Locale& /*rLocale*/ )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -571,8 +582,7 @@ OUString SAL_CALL
} }
void SAL_CALL void SAL_CALL Thesaurus::initialize( const Sequence< Any >& rArguments )
Thesaurus::initialize( const Sequence< Any >& rArguments )
throw(Exception, RuntimeException) throw(Exception, RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -603,24 +613,26 @@ void SAL_CALL
sal_uInt16 SAL_CALL Thesaurus::capitalType(const OUString& aTerm, CharClass * pCC) sal_uInt16 SAL_CALL Thesaurus::capitalType(const OUString& aTerm, CharClass * pCC)
{ {
sal_Int32 tlen = aTerm.getLength(); sal_Int32 tlen = aTerm.getLength();
if ((pCC) && (tlen)) { if ((pCC) && (tlen))
String aStr(aTerm); {
sal_Int32 nc = 0; String aStr(aTerm);
for (USHORT tindex = 0; tindex < tlen; tindex++) { sal_Int32 nc = 0;
if (pCC->getCharacterType(aStr,tindex) & for (USHORT tindex = 0; tindex < tlen; tindex++)
::com::sun::star::i18n::KCharacterType::UPPER) nc++; {
} if (pCC->getCharacterType(aStr,tindex) &
::com::sun::star::i18n::KCharacterType::UPPER) nc++;
}
if (nc == 0) return (sal_uInt16) CAPTYPE_NOCAP; if (nc == 0)
return (sal_uInt16) CAPTYPE_NOCAP;
if (nc == tlen)
return (sal_uInt16) CAPTYPE_ALLCAP;
if ((nc == 1) && (pCC->getCharacterType(aStr,0) &
::com::sun::star::i18n::KCharacterType::UPPER))
return (sal_uInt16) CAPTYPE_INITCAP;
if (nc == tlen) return (sal_uInt16) CAPTYPE_ALLCAP; return (sal_uInt16) CAPTYPE_MIXED;
}
if ((nc == 1) && (pCC->getCharacterType(aStr,0) &
::com::sun::star::i18n::KCharacterType::UPPER))
return (sal_uInt16) CAPTYPE_INITCAP;
return (sal_uInt16) CAPTYPE_MIXED;
}
return (sal_uInt16) CAPTYPE_UNKNOWN; return (sal_uInt16) CAPTYPE_UNKNOWN;
} }
@@ -628,38 +640,40 @@ sal_uInt16 SAL_CALL Thesaurus::capitalType(const OUString& aTerm, CharClass * pC
OUString SAL_CALL Thesaurus::makeLowerCase(const OUString& aTerm, CharClass * pCC) OUString SAL_CALL Thesaurus::makeLowerCase(const OUString& aTerm, CharClass * pCC)
{ {
if (pCC) if (pCC)
return pCC->toLower_rtl(aTerm, 0, aTerm.getLength()); return pCC->toLower_rtl(aTerm, 0, aTerm.getLength());
return aTerm; return aTerm;
} }
OUString SAL_CALL Thesaurus::makeUpperCase(const OUString& aTerm, CharClass * pCC) OUString SAL_CALL Thesaurus::makeUpperCase(const OUString& aTerm, CharClass * pCC)
{ {
if (pCC) if (pCC)
return pCC->toUpper_rtl(aTerm, 0, aTerm.getLength()); return pCC->toUpper_rtl(aTerm, 0, aTerm.getLength());
return aTerm; return aTerm;
} }
OUString SAL_CALL Thesaurus::makeInitCap(const OUString& aTerm, CharClass * pCC) OUString SAL_CALL Thesaurus::makeInitCap(const OUString& aTerm, CharClass * pCC)
{ {
sal_Int32 tlen = aTerm.getLength(); sal_Int32 tlen = aTerm.getLength();
if ((pCC) && (tlen)) { if ((pCC) && (tlen))
OUString bTemp = aTerm.copy(0,1); {
if (tlen > 1) OUString bTemp = aTerm.copy(0,1);
return ( pCC->toUpper_rtl(bTemp, 0, 1) if (tlen > 1)
+ pCC->toLower_rtl(aTerm,1,(tlen-1)) ); {
return ( pCC->toUpper_rtl(bTemp, 0, 1)
+ pCC->toLower_rtl(aTerm,1,(tlen-1)) );
}
return pCC->toUpper_rtl(bTemp, 0, 1); return pCC->toUpper_rtl(bTemp, 0, 1);
} }
return aTerm; return aTerm;
} }
void SAL_CALL void SAL_CALL Thesaurus::dispose()
Thesaurus::dispose()
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -673,8 +687,7 @@ void SAL_CALL
} }
void SAL_CALL void SAL_CALL Thesaurus::addEventListener( const Reference< XEventListener >& rxListener )
Thesaurus::addEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );
@@ -684,8 +697,7 @@ void SAL_CALL
} }
void SAL_CALL void SAL_CALL Thesaurus::removeEventListener( const Reference< XEventListener >& rxListener )
Thesaurus::removeEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException) throw(RuntimeException)
{ {
MutexGuard aGuard( GetLinguMutex() ); MutexGuard aGuard( GetLinguMutex() );

53
lingucomponent/source/thesaurus/libnth/nthesimp.hxx Normal file → Executable file
View File

@@ -116,55 +116,27 @@ public:
virtual ~Thesaurus(); virtual ~Thesaurus();
// XSupportedLocales (for XThesaurus) // XSupportedLocales (for XThesaurus)
virtual Sequence< Locale > SAL_CALL virtual Sequence< Locale > SAL_CALL getLocales() throw(RuntimeException);
getLocales() virtual sal_Bool SAL_CALL hasLocale( const Locale& rLocale ) throw(RuntimeException);
throw(RuntimeException);
virtual sal_Bool SAL_CALL
hasLocale( const Locale& rLocale )
throw(RuntimeException);
// XThesaurus // XThesaurus
virtual Sequence< Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL virtual Sequence< Reference < ::com::sun::star::linguistic2::XMeaning > > SAL_CALL queryMeanings( const OUString& rTerm, const Locale& rLocale, const PropertyValues& rProperties ) throw(IllegalArgumentException, RuntimeException);
queryMeanings( const OUString& rTerm, const Locale& rLocale,
const PropertyValues& rProperties )
throw(IllegalArgumentException,
RuntimeException);
// XServiceDisplayName // XServiceDisplayName
virtual OUString SAL_CALL virtual OUString SAL_CALL getServiceDisplayName( const Locale& rLocale ) throw(RuntimeException);
getServiceDisplayName( const Locale& rLocale )
throw(RuntimeException);
// XInitialization // XInitialization
virtual void SAL_CALL virtual void SAL_CALL initialize( const Sequence< Any >& rArguments ) throw(Exception, RuntimeException);
initialize( const Sequence< Any >& rArguments )
throw(Exception, RuntimeException);
// XComponent // XComponent
virtual void SAL_CALL virtual void SAL_CALL dispose() throw(RuntimeException);
dispose() virtual void SAL_CALL addEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
throw(RuntimeException); virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& rxListener ) throw(RuntimeException);
virtual void SAL_CALL
addEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
virtual void SAL_CALL
removeEventListener( const Reference< XEventListener >& rxListener )
throw(RuntimeException);
////////////////////////////////////////////////////////////
// Service specific part
//
// XServiceInfo // XServiceInfo
virtual OUString SAL_CALL virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
getImplementationName() virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) throw(RuntimeException);
throw(RuntimeException); virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw(RuntimeException);
virtual sal_Bool SAL_CALL
supportsService( const OUString& rServiceName )
throw(RuntimeException);
virtual Sequence< OUString > SAL_CALL
getSupportedServiceNames()
throw(RuntimeException);
static inline OUString static inline OUString
@@ -183,8 +155,7 @@ private:
static ::com::sun::star::uno::Reference< static ::com::sun::star::uno::Reference<
::com::sun::star::linguistic2::XSpellChecker1 > xSpell; ::com::sun::star::linguistic2::XSpellChecker1 > xSpell;
*/ */
static ::com::sun::star::uno::Reference< static ::com::sun::star::uno::Reference< ::com::sun::star::linguistic2::XLinguServiceManager > GetLngSvcMgr();
::com::sun::star::linguistic2::XLinguServiceManager > GetLngSvcMgr();
}; };