summaryrefslogtreecommitdiffstats
path: root/lingucomponent/source/spellcheck
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
commit940b4d1848e8c70ab7642901a68594e8016caffc (patch)
treeeb72f344ee6c3d9b80a7ecc079ea79e9fba8676d /lingucomponent/source/spellcheck
parentInitial commit. (diff)
downloadlibreoffice-940b4d1848e8c70ab7642901a68594e8016caffc.tar.xz
libreoffice-940b4d1848e8c70ab7642901a68594e8016caffc.zip
Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'lingucomponent/source/spellcheck')
-rw-r--r--lingucomponent/source/spellcheck/macosxspell/MacOSXSpell.component25
-rw-r--r--lingucomponent/source/spellcheck/macosxspell/macspellimp.hxx131
-rw-r--r--lingucomponent/source/spellcheck/macosxspell/macspellimp.mm676
-rw-r--r--lingucomponent/source/spellcheck/spell/spell.component25
-rw-r--r--lingucomponent/source/spellcheck/spell/sspellimp.cxx674
-rw-r--r--lingucomponent/source/spellcheck/spell/sspellimp.hxx130
6 files changed, 1661 insertions, 0 deletions
diff --git a/lingucomponent/source/spellcheck/macosxspell/MacOSXSpell.component b/lingucomponent/source/spellcheck/macosxspell/MacOSXSpell.component
new file mode 100644
index 000000000..92807d4b3
--- /dev/null
+++ b/lingucomponent/source/spellcheck/macosxspell/MacOSXSpell.component
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ -->
+
+<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
+ prefix="MacOSXSpell" xmlns="http://openoffice.org/2010/uno-components">
+ <implementation name="org.openoffice.lingu.MacOSXSpellChecker">
+ <service name="com.sun.star.linguistic2.SpellChecker"/>
+ </implementation>
+</component>
diff --git a/lingucomponent/source/spellcheck/macosxspell/macspellimp.hxx b/lingucomponent/source/spellcheck/macosxspell/macspellimp.hxx
new file mode 100644
index 000000000..0adc1a1cb
--- /dev/null
+++ b/lingucomponent/source/spellcheck/macosxspell/macspellimp.hxx
@@ -0,0 +1,131 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_LINGUCOMPONENT_SOURCE_SPELLCHECK_MACOSXSPELL_MACSPELLIMP_HXX
+#define INCLUDED_LINGUCOMPONENT_SOURCE_SPELLCHECK_MACOSXSPELL_MACSPELLIMP_HXX
+
+#include <cppuhelper/implbase.hxx>
+
+#include <premac.h>
+#ifdef MACOSX
+#include <Carbon/Carbon.h>
+#import <Cocoa/Cocoa.h>
+#else
+#include <UIKit/UIKit.h>
+#endif
+#include <postmac.h>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/XServiceDisplayName.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/linguistic2/XSpellChecker.hpp>
+#include <com/sun/star/linguistic2/XLinguServiceEventBroadcaster.hpp>
+
+#include <linguistic/misc.hxx>
+#include <linguistic/lngprophelp.hxx>
+
+#include <lingutil.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::linguistic2;
+
+class MacSpellChecker :
+ public cppu::WeakImplHelper
+ <
+ XSpellChecker,
+ XLinguServiceEventBroadcaster,
+ XInitialization,
+ XComponent,
+ XServiceInfo,
+ XServiceDisplayName
+ >
+{
+ Sequence< Locale > aSuppLocales;
+ rtl_TextEncoding * aDEncs;
+ Locale * aDLocs;
+ OUString * aDNames;
+ sal_Int32 numdict;
+#ifdef MACOSX
+ int macTag; // unique tag for this doc
+#else
+ UITextChecker * pChecker;
+#endif
+ ::comphelper::OInterfaceContainerHelper2 aEvtListeners;
+ rtl::Reference< linguistic::PropertyHelper_Spell > xPropHelper;
+ bool bDisposing;
+
+ MacSpellChecker(const MacSpellChecker &) = delete;
+ MacSpellChecker & operator = (const MacSpellChecker &) = delete;
+
+ linguistic::PropertyHelper_Spell & GetPropHelper_Impl();
+ linguistic::PropertyHelper_Spell & GetPropHelper()
+ {
+ return xPropHelper.is() ? *xPropHelper : GetPropHelper_Impl();
+ }
+
+ sal_Int16 GetSpellFailure( const OUString &rWord, const Locale &rLocale );
+ Reference< XSpellAlternatives > GetProposals( const OUString &rWord, const Locale &rLocale );
+
+public:
+ MacSpellChecker();
+ virtual ~MacSpellChecker() override;
+
+ // XSupportedLocales (for XSpellChecker)
+ virtual Sequence< Locale > SAL_CALL getLocales() override;
+ virtual sal_Bool SAL_CALL hasLocale( const Locale& rLocale ) override;
+
+ // XSpellChecker
+ virtual sal_Bool SAL_CALL isValid( const OUString& rWord, const Locale& rLocale, const css::uno::Sequence<PropertyValue>& rProperties ) override;
+ virtual Reference< XSpellAlternatives > SAL_CALL spell( const OUString& rWord, const Locale& rLocale, const css::uno::Sequence<PropertyValue>& rProperties ) override;
+
+ // XLinguServiceEventBroadcaster
+ virtual sal_Bool SAL_CALL addLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) override;
+ virtual sal_Bool SAL_CALL removeLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) override;
+
+ // XServiceDisplayName
+ virtual OUString SAL_CALL getServiceDisplayName( const Locale& rLocale ) override;
+
+ // XInitialization
+ virtual void SAL_CALL initialize( const Sequence< Any >& rArguments ) override;
+
+ // XComponent
+ virtual void SAL_CALL dispose() override;
+ virtual void SAL_CALL addEventListener( const Reference< XEventListener >& rxListener ) override;
+ virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& rxListener ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) override;
+ virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+ static inline OUString getImplementationName_Static() throw();
+ static Sequence< OUString > getSupportedServiceNames_Static() throw();
+};
+
+inline OUString MacSpellChecker::getImplementationName_Static() throw()
+{
+ return "org.openoffice.lingu.MacOSXSpellChecker";
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lingucomponent/source/spellcheck/macosxspell/macspellimp.mm b/lingucomponent/source/spellcheck/macosxspell/macspellimp.mm
new file mode 100644
index 000000000..1d6f84fcc
--- /dev/null
+++ b/lingucomponent/source/spellcheck/macosxspell/macspellimp.mm
@@ -0,0 +1,676 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/uno/Reference.h>
+
+#include <com/sun/star/linguistic2/SpellFailure.hpp>
+#include <com/sun/star/linguistic2/XLinguProperties.hpp>
+#include <cppuhelper/factory.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <com/sun/star/registry/XRegistryKey.hpp>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <tools/debug.hxx>
+#include <osl/mutex.hxx>
+
+#include "macspellimp.hxx"
+
+#include <linguistic/spelldta.hxx>
+#include <unotools/pathoptions.hxx>
+#include <unotools/useroptions.hxx>
+#include <osl/file.hxx>
+#include <rtl/ustrbuf.hxx>
+
+using namespace utl;
+using namespace osl;
+using namespace com::sun::star;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::linguistic2;
+using namespace linguistic;
+
+MacSpellChecker::MacSpellChecker() :
+ aEvtListeners( GetLinguMutex() )
+{
+ aDEncs = nullptr;
+ aDLocs = nullptr;
+ aDNames = nullptr;
+ bDisposing = false;
+ numdict = 0;
+#ifndef IOS
+ NSApplicationLoad();
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+ macTag = [NSSpellChecker uniqueSpellDocumentTag];
+ [pool release];
+#else
+ pChecker = [[UITextChecker alloc] init];
+#endif
+}
+
+
+MacSpellChecker::~MacSpellChecker()
+{
+ numdict = 0;
+ if (aDEncs) delete[] aDEncs;
+ aDEncs = nullptr;
+ if (aDLocs) delete[] aDLocs;
+ aDLocs = nullptr;
+ if (aDNames) delete[] aDNames;
+ aDNames = nullptr;
+ if (xPropHelper.is())
+ xPropHelper->RemoveAsPropListener();
+}
+
+
+PropertyHelper_Spell & MacSpellChecker::GetPropHelper_Impl()
+{
+ if (!xPropHelper.is())
+ {
+ Reference< XLinguProperties > xPropSet( GetLinguProperties() );
+
+ xPropHelper = new PropertyHelper_Spell( static_cast<XSpellChecker *>(this), xPropSet );
+ xPropHelper->AddAsPropListener();
+ }
+ return *xPropHelper;
+}
+
+
+Sequence< Locale > SAL_CALL MacSpellChecker::getLocales()
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ // this routine should return the locales supported by the installed
+ // dictionaries. So here we need to parse both the user edited
+ // dictionary list and the shared dictionary list
+ // to see what dictionaries the admin/user has installed
+
+ int numshr; // number of shared dictionary entries
+ rtl_TextEncoding aEnc = RTL_TEXTENCODING_UTF8;
+
+ std::vector<NSString *> postspdict;
+
+ if (!numdict) {
+
+ // invoke a dictionary manager to get the user dictionary list
+ // TODO How on macOS?
+
+ // invoke a second dictionary manager to get the shared dictionary list
+#ifdef MACOSX
+ NSArray *aSpellCheckLanguages = [[NSSpellChecker sharedSpellChecker] availableLanguages];
+#else
+ NSArray *aSpellCheckLanguages = [UITextChecker availableLanguages];
+#endif
+
+ for (NSUInteger i = 0; i < [aSpellCheckLanguages count]; i++)
+ {
+ NSString* pLangStr = static_cast<NSString*>([aSpellCheckLanguages objectAtIndex:i]);
+
+ // Fix up generic languages (without territory code) and odd combinations that LO
+ // doesn't handle.
+ if ([pLangStr isEqualToString:@"da"])
+ {
+ postspdict.push_back( @"da_DK" );
+ }
+ else if ([pLangStr isEqualToString:@"de"])
+ {
+ const std::vector<NSString*> aDE
+ { @"AT", @"BE", @"CH", @"DE", @"LI", @"LU" };
+ for (auto c: aDE)
+ {
+ pLangStr = [@"de_" stringByAppendingString: c];
+ postspdict.push_back( pLangStr );
+ }
+ }
+#ifdef IOS
+ // iOS says it has specifically de_DE, but let's assume it is good enough for the other
+ // variants, too, for now.
+ else if ([pLangStr isEqualToString:@"de_DE"])
+ {
+ const std::vector<NSString*> aDE
+ { @"AT", @"BE", @"CH", @"DE", @"LI", @"LU" };
+ for (auto c: aDE)
+ {
+ pLangStr = [@"de_" stringByAppendingString: c];
+ postspdict.push_back( pLangStr );
+ }
+ }
+#endif
+ else if ([pLangStr isEqualToString:@"en"])
+ {
+ // System has en_AU, en_CA, en_GB, and en_IN. Add the rest.
+ const std::vector<NSString*> aEN
+ { @"BW", @"BZ", @"GH", @"GM", @"IE", @"JM", @"MU", @"MW", @"MY", @"NA",
+ @"NZ", @"PH", @"TT", @"US", @"ZA", @"ZW" };
+ for (auto c: aEN)
+ {
+ pLangStr = [@"en_" stringByAppendingString: c];
+ postspdict.push_back( pLangStr );
+ }
+ }
+ else if ([pLangStr isEqualToString:@"en_JP"]
+ || [pLangStr isEqualToString:@"en_SG"])
+ {
+ // Just skip, LO doesn't have those yet in this context.
+ }
+ else if ([pLangStr isEqualToString:@"es"])
+ {
+ const std::vector<NSString*> aES
+ { @"AR", @"BO", @"CL", @"CO", @"CR", @"CU", @"DO", @"EC", @"ES", @"GT",
+ @"HN", @"MX", @"NI", @"PA", @"PE", @"PR", @"PY", @"SV", @"UY", @"VE" };
+ for (auto c: aES)
+ {
+ pLangStr = [@"es_" stringByAppendingString: c];
+ postspdict.push_back( pLangStr );
+ }
+ }
+ else if ([pLangStr isEqualToString:@"fi"])
+ {
+ postspdict.push_back( @"fi_FI" );
+ }
+ else if ([pLangStr isEqualToString:@"fr"])
+ {
+ const std::vector<NSString*> aFR
+ { @"BE", @"BF", @"BJ", @"CA", @"CH", @"CI", @"FR", @"LU", @"MC", @"ML",
+ @"MU", @"NE", @"SN", @"TG" };
+ for (auto c: aFR)
+ {
+ pLangStr = [@"fr_" stringByAppendingString: c];
+ postspdict.push_back( pLangStr );
+ }
+ }
+ else if ([pLangStr isEqualToString:@"it"])
+ {
+ postspdict.push_back( @"it_CH" );
+ postspdict.push_back( @"it_IT" );
+ }
+ else if ([pLangStr isEqualToString:@"ko"])
+ {
+ postspdict.push_back( @"ko_KR" );
+ }
+ else if ([pLangStr isEqualToString:@"nl"])
+ {
+ postspdict.push_back( @"nl_BE" );
+ postspdict.push_back( @"nl_NL" );
+ }
+ else if ([pLangStr isEqualToString:@"nb"])
+ {
+ postspdict.push_back( @"nb_NO" );
+ }
+ else if ([pLangStr isEqualToString:@"pl"])
+ {
+ postspdict.push_back( @"pl_PL" );
+ }
+ else if ([pLangStr isEqualToString:@"ru"])
+ {
+ postspdict.push_back( @"ru_RU" );
+ }
+ else if ([pLangStr isEqualToString:@"sv"])
+ {
+ postspdict.push_back( @"sv_FI" );
+ postspdict.push_back( @"sv_SE" );
+ }
+#ifdef IOS
+ else if ([pLangStr isEqualToString:@"sv_SE"])
+ {
+ postspdict.push_back( @"sv_FI" );
+ postspdict.push_back( @"sv_SE" );
+ }
+#endif
+ else if ([pLangStr isEqualToString:@"tr"])
+ {
+ postspdict.push_back( @"tr_TR" );
+ }
+ else
+ postspdict.push_back( pLangStr );
+ }
+ // System has pt_BR and pt_PT, add pt_AO.
+ postspdict.push_back( @"pt_AO" );
+
+ numshr = postspdict.size();
+
+ // we really should merge these and remove duplicates but since
+ // users can name their dictionaries anything they want it would
+ // be impossible to know if a real duplication exists unless we
+ // add some unique key to each myspell dictionary
+ numdict = numshr;
+
+ if (numdict) {
+ aDLocs = new Locale [numdict];
+ aDEncs = new rtl_TextEncoding [numdict];
+ aDNames = new OUString [numdict];
+ aSuppLocales.realloc(numdict);
+ Locale * pLocale = aSuppLocales.getArray();
+ int numlocs = 0;
+ int newloc;
+ int i,j;
+ int k = 0;
+
+ //first add the user dictionaries
+ //TODO for MAC?
+
+ // now add the shared dictionaries
+ for (i = 0; i < numshr; i++) {
+ NSDictionary *aLocDict = [ NSLocale componentsFromLocaleIdentifier:postspdict[i] ];
+ NSString* aLang = [ aLocDict objectForKey:NSLocaleLanguageCode ];
+ NSString* aCountry = [ aLocDict objectForKey:NSLocaleCountryCode ];
+ OUString lang([aLang cStringUsingEncoding: NSUTF8StringEncoding], [aLang length], aEnc);
+ OUString country([ aCountry cStringUsingEncoding: NSUTF8StringEncoding], [aCountry length], aEnc);
+ Locale nLoc( lang, country, OUString() );
+ newloc = 1;
+ //eliminate duplicates (is this needed for MacOS?)
+ for (j = 0; j < numlocs; j++) {
+ if (nLoc == pLocale[j]) newloc = 0;
+ }
+ if (newloc) {
+ pLocale[numlocs] = nLoc;
+ numlocs++;
+ }
+ aDLocs[k] = nLoc;
+ aDEncs[k] = 0;
+ k++;
+ }
+
+ aSuppLocales.realloc(numlocs);
+
+ } else {
+ /* no dictionary.lst found so register no dictionaries */
+ numdict = 0;
+ aDEncs = nullptr;
+ aDLocs = nullptr;
+ aDNames = nullptr;
+ aSuppLocales.realloc(0);
+ }
+ }
+
+ return aSuppLocales;
+}
+
+
+
+sal_Bool SAL_CALL MacSpellChecker::hasLocale(const Locale& rLocale)
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ bool bRes = false;
+ if (!aSuppLocales.getLength())
+ getLocales();
+
+ sal_Int32 nLen = aSuppLocales.getLength();
+ for (sal_Int32 i = 0; i < nLen; ++i)
+ {
+ const Locale *pLocale = aSuppLocales.getConstArray();
+ if (rLocale == pLocale[i])
+ {
+ bRes = true;
+ break;
+ }
+ }
+ return bRes;
+}
+
+
+sal_Int16 MacSpellChecker::GetSpellFailure( const OUString &rWord, const Locale &rLocale )
+{
+ rtl_TextEncoding aEnc;
+
+ // initialize a myspell object for each dictionary once
+ // (note: mutex is held higher up in isValid)
+
+
+ sal_Int16 nRes = -1;
+
+ // first handle smart quotes both single and double
+ OUStringBuffer rBuf(rWord);
+ sal_Int32 n = rBuf.getLength();
+ sal_Unicode c;
+ for (sal_Int32 ix=0; ix < n; ix++) {
+ c = rBuf[ix];
+ if ((c == 0x201C) || (c == 0x201D)) rBuf[ix] = u'"';
+ if ((c == 0x2018) || (c == 0x2019)) rBuf[ix] = u'\'';
+ }
+ OUString nWord(rBuf.makeStringAndClear());
+
+ if (n)
+ {
+ aEnc = 0;
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+ NSString* aNSStr = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(nWord.getStr()) length: nWord.getLength()]autorelease];
+ NSString* aLang = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Language.getStr()) length: rLocale.Language.getLength()]autorelease];
+ if(rLocale.Country.getLength()>0)
+ {
+ NSString* aCountry = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Country.getStr()) length: rLocale.Country.getLength()]autorelease];
+ NSString* aTaggedCountry = [@"_" stringByAppendingString:aCountry];
+ aLang = [aLang stringByAppendingString:aTaggedCountry];
+ }
+
+#ifdef MACOSX
+ NSInteger aCount;
+ NSRange range = [[NSSpellChecker sharedSpellChecker] checkSpellingOfString:aNSStr startingAt:0 language:aLang wrap:false inSpellDocumentWithTag:macTag wordCount:&aCount];
+#else
+ NSRange range = [pChecker rangeOfMisspelledWordInString:aNSStr range:NSMakeRange(0, [aNSStr length]) startingAt:0 wrap:NO language:aLang];
+#endif
+ int rVal = 0;
+ if(range.length>0)
+ {
+ rVal = -1;
+ }
+ else
+ {
+ rVal = 1;
+ }
+ [pool release];
+ if (rVal != 1)
+ {
+ nRes = SpellFailure::SPELLING_ERROR;
+ } else {
+ return -1;
+ }
+ }
+ return nRes;
+}
+
+
+
+sal_Bool SAL_CALL
+ MacSpellChecker::isValid( const OUString& rWord, const Locale& rLocale,
+ const css::uno::Sequence<PropertyValue>& rProperties )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (rLocale == Locale() || !rWord.getLength())
+ return true;
+
+ if (!hasLocale( rLocale ))
+ return true;
+
+ // Get property values to be used.
+ // These are be the default values set in the SN_LINGU_PROPERTIES
+ // PropertySet which are overridden by the supplied ones from the
+ // last argument.
+ // You'll probably like to use a simpler solution than the provided
+ // one using the PropertyHelper_Spell.
+
+ PropertyHelper_Spell &rHelper = GetPropHelper();
+ rHelper.SetTmpPropVals( rProperties );
+
+ sal_Int16 nFailure = GetSpellFailure( rWord, rLocale );
+ if (nFailure != -1)
+ {
+ LanguageType nLang = LinguLocaleToLanguage( rLocale );
+ // postprocess result for errors that should be ignored
+ if ( (!rHelper.IsSpellUpperCase() && IsUpper( rWord, nLang ))
+ || (!rHelper.IsSpellWithDigits() && HasDigits( rWord ))
+ || (!rHelper.IsSpellCapitalization()
+ && nFailure == SpellFailure::CAPTION_ERROR)
+ )
+ nFailure = -1;
+ }
+
+ return (nFailure == -1);
+}
+
+Reference< XSpellAlternatives >
+ MacSpellChecker::GetProposals( const OUString &rWord, const Locale &rLocale )
+{
+ // Retrieves the return values for the 'spell' function call in case
+ // of a misspelled word.
+ // Especially it may give a list of suggested (correct) words:
+
+ Reference< XSpellAlternatives > xRes;
+ // note: mutex is held by higher up by spell which covers both
+
+ LanguageType nLang = LinguLocaleToLanguage( rLocale );
+ int count;
+ Sequence< OUString > aStr( 0 );
+
+ // first handle smart quotes (single and double)
+ OUStringBuffer rBuf(rWord);
+ sal_Int32 n = rBuf.getLength();
+ sal_Unicode c;
+ for (sal_Int32 ix=0; ix < n; ix++) {
+ c = rBuf[ix];
+ if ((c == 0x201C) || (c == 0x201D)) rBuf[ix] = u'"';
+ if ((c == 0x2018) || (c == 0x2019)) rBuf[ix] = u'\'';
+ }
+ OUString nWord(rBuf.makeStringAndClear());
+
+ if (n)
+ {
+ NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
+ NSString* aNSStr = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(nWord.getStr()) length: nWord.getLength()]autorelease];
+ NSString* aLang = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Language.getStr()) length: rLocale.Language.getLength()]autorelease];
+ if(rLocale.Country.getLength()>0)
+ {
+ NSString* aCountry = [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rLocale.Country.getStr()) length: rLocale.Country.getLength()]autorelease];
+ NSString* aTaggedCountry = [@"_" stringByAppendingString:aCountry];
+ aLang = [aLang stringByAppendingString:aTaggedCountry];
+ }
+#ifdef MACOSX
+ [[NSSpellChecker sharedSpellChecker] setLanguage:aLang];
+ NSArray *guesses = [[NSSpellChecker sharedSpellChecker] guessesForWordRange:NSMakeRange(0, [aNSStr length]) inString:aNSStr language:aLang inSpellDocumentWithTag:0];
+ (void) this; // avoid loplugin:staticmethods, the !MACOSX case uses 'this'
+#else
+ NSArray *guesses = [pChecker guessesForWordRange:NSMakeRange(0, [aNSStr length]) inString:aNSStr language:aLang];
+#endif
+ count = [guesses count];
+ if (count)
+ {
+ aStr.realloc( count );
+ OUString *pStr = aStr.getArray();
+ for (int ii=0; ii < count; ii++)
+ {
+ // if needed add: if (suglst[ii] == NULL) continue;
+ NSString* guess = [guesses objectAtIndex:ii];
+ OUString cvtwrd(reinterpret_cast<const sal_Unicode*>([guess cStringUsingEncoding:NSUnicodeStringEncoding]), static_cast<sal_Int32>([guess length]));
+ pStr[ii] = cvtwrd;
+ }
+ }
+ [pool release];
+ }
+
+ // now return an empty alternative for no suggestions or the list of alternatives if some found
+ SpellAlternatives *pAlt = new SpellAlternatives;
+ pAlt->SetWordLanguage( rWord, nLang );
+ pAlt->SetFailureType( SpellFailure::SPELLING_ERROR );
+ pAlt->SetAlternatives( aStr );
+ xRes = pAlt;
+ return xRes;
+
+}
+
+Reference< XSpellAlternatives > SAL_CALL
+ MacSpellChecker::spell( const OUString& rWord, const Locale& rLocale,
+ const css::uno::Sequence<PropertyValue>& rProperties )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (rLocale == Locale() || !rWord.getLength())
+ return nullptr;
+
+ if (!hasLocale( rLocale ))
+ return nullptr;
+
+ Reference< XSpellAlternatives > xAlt;
+ if (!isValid( rWord, rLocale, rProperties ))
+ {
+ xAlt = GetProposals( rWord, rLocale );
+ }
+ return xAlt;
+}
+
+/// @throws Exception
+static Reference< XInterface > MacSpellChecker_CreateInstance(
+ const Reference< XMultiServiceFactory > & /*rSMgr*/ )
+{
+
+ Reference< XInterface > xService = static_cast<cppu::OWeakObject*>(new MacSpellChecker);
+ return xService;
+}
+
+
+sal_Bool SAL_CALL
+ MacSpellChecker::addLinguServiceEventListener(
+ const Reference< XLinguServiceEventListener >& rxLstnr )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ bool bRes = false;
+ if (!bDisposing && rxLstnr.is())
+ {
+ bRes = GetPropHelper().addLinguServiceEventListener( rxLstnr );
+ }
+ return bRes;
+}
+
+
+sal_Bool SAL_CALL
+ MacSpellChecker::removeLinguServiceEventListener(
+ const Reference< XLinguServiceEventListener >& rxLstnr )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ bool bRes = false;
+ if (!bDisposing && rxLstnr.is())
+ {
+ DBG_ASSERT( xPropHelper.is(), "xPropHelper non existent" );
+ bRes = GetPropHelper().removeLinguServiceEventListener( rxLstnr );
+ }
+ return bRes;
+}
+
+
+OUString SAL_CALL
+ MacSpellChecker::getServiceDisplayName( const Locale& /*rLocale*/ )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+ return "macOS Spell Checker";
+}
+
+
+void SAL_CALL
+ MacSpellChecker::initialize( const Sequence< Any >& rArguments )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (!xPropHelper.is())
+ {
+ sal_Int32 nLen = rArguments.getLength();
+ if (2 == nLen)
+ {
+ Reference< XLinguProperties > xPropSet;
+ rArguments.getConstArray()[0] >>= xPropSet;
+ //rArguments.getConstArray()[1] >>= xDicList;
+
+ //! Pointer allows for access of the non-UNO functions.
+ //! And the reference to the UNO-functions while increasing
+ //! the ref-count and will implicitly free the memory
+ //! when the object is no longer used.
+ xPropHelper = new PropertyHelper_Spell( static_cast<XSpellChecker *>(this), xPropSet );
+ xPropHelper->AddAsPropListener();
+ }
+ else
+ OSL_FAIL( "wrong number of arguments in sequence" );
+
+ }
+}
+
+
+void SAL_CALL
+ MacSpellChecker::dispose()
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (!bDisposing)
+ {
+ bDisposing = true;
+ EventObject aEvtObj( static_cast<XSpellChecker *>(this) );
+ aEvtListeners.disposeAndClear( aEvtObj );
+ }
+}
+
+
+void SAL_CALL
+ MacSpellChecker::addEventListener( const Reference< XEventListener >& rxListener )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (!bDisposing && rxListener.is())
+ aEvtListeners.addInterface( rxListener );
+}
+
+
+void SAL_CALL
+ MacSpellChecker::removeEventListener( const Reference< XEventListener >& rxListener )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (!bDisposing && rxListener.is())
+ aEvtListeners.removeInterface( rxListener );
+}
+
+// Service specific part
+OUString SAL_CALL MacSpellChecker::getImplementationName()
+{
+ return getImplementationName_Static();
+}
+
+sal_Bool SAL_CALL MacSpellChecker::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+Sequence< OUString > SAL_CALL MacSpellChecker::getSupportedServiceNames()
+{
+ return getSupportedServiceNames_Static();
+}
+
+Sequence< OUString > MacSpellChecker::getSupportedServiceNames_Static()
+ throw()
+{
+ Sequence< OUString > aSNS { SN_SPELLCHECKER };
+ return aSNS;
+}
+
+extern "C"
+{
+
+SAL_DLLPUBLIC_EXPORT void * MacOSXSpell_component_getFactory(
+ const char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
+{
+ void * pRet = nullptr;
+ if ( MacSpellChecker::getImplementationName_Static().equalsAscii( pImplName ) )
+ {
+ Reference< XSingleServiceFactory > xFactory =
+ cppu::createOneInstanceFactory(
+ static_cast< XMultiServiceFactory * >( pServiceManager ),
+ MacSpellChecker::getImplementationName_Static(),
+ MacSpellChecker_CreateInstance,
+ MacSpellChecker::getSupportedServiceNames_Static());
+ // acquire, because we return an interface pointer instead of a reference
+ xFactory->acquire();
+ pRet = xFactory.get();
+ }
+ return pRet;
+}
+
+}
+
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lingucomponent/source/spellcheck/spell/spell.component b/lingucomponent/source/spellcheck/spell/spell.component
new file mode 100644
index 000000000..c11b7a7c3
--- /dev/null
+++ b/lingucomponent/source/spellcheck/spell/spell.component
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ -->
+
+<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
+ prefix="spell" xmlns="http://openoffice.org/2010/uno-components">
+ <implementation name="org.openoffice.lingu.MySpellSpellChecker">
+ <service name="com.sun.star.linguistic2.SpellChecker"/>
+ </implementation>
+</component>
diff --git a/lingucomponent/source/spellcheck/spell/sspellimp.cxx b/lingucomponent/source/spellcheck/spell/sspellimp.cxx
new file mode 100644
index 000000000..04fc7d8e2
--- /dev/null
+++ b/lingucomponent/source/spellcheck/spell/sspellimp.cxx
@@ -0,0 +1,674 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/uno/Reference.h>
+
+#include <com/sun/star/linguistic2/SpellFailure.hpp>
+#include <com/sun/star/linguistic2/XLinguProperties.hpp>
+#include <comphelper/lok.hxx>
+#include <comphelper/processfactory.hxx>
+#include <cppuhelper/factory.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <com/sun/star/lang/XSingleServiceFactory.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/registry/XRegistryKey.hpp>
+#include <tools/debug.hxx>
+#include <osl/mutex.hxx>
+#include <osl/thread.h>
+#include <com/sun/star/ucb/XSimpleFileAccess.hpp>
+
+#include <lingutil.hxx>
+#include <hunspell.hxx>
+#include "sspellimp.hxx"
+
+#include <linguistic/lngprops.hxx>
+#include <linguistic/spelldta.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <svtools/strings.hrc>
+#include <unotools/pathoptions.hxx>
+#include <unotools/lingucfg.hxx>
+#include <unotools/resmgr.hxx>
+#include <unotools/useroptions.hxx>
+#include <osl/file.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/textenc.h>
+#include <sal/log.hxx>
+
+#include <numeric>
+#include <utility>
+#include <vector>
+#include <set>
+#include <string.h>
+
+using namespace utl;
+using namespace osl;
+using namespace com::sun::star;
+using namespace com::sun::star::beans;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::uno;
+using namespace com::sun::star::linguistic2;
+using namespace linguistic;
+
+// XML-header of SPELLML queries
+#if !defined SPELL_XML
+#define SPELL_XML "<?xml?>"
+#endif
+
+// only available in hunspell >= 1.5
+#if !defined MAXWORDLEN
+#define MAXWORDLEN 176
+#endif
+
+SpellChecker::SpellChecker() :
+ m_aEvtListeners(GetLinguMutex()),
+ m_bDisposing(false)
+{
+}
+
+SpellChecker::DictItem::DictItem(OUString i_DName, Locale i_DLoc, rtl_TextEncoding i_DEnc)
+ : m_aDName(std::move(i_DName))
+ , m_aDLoc(std::move(i_DLoc))
+ , m_aDEnc(i_DEnc)
+{
+}
+
+SpellChecker::~SpellChecker()
+{
+ if (m_pPropHelper)
+ {
+ m_pPropHelper->RemoveAsPropListener();
+ }
+}
+
+PropertyHelper_Spelling & SpellChecker::GetPropHelper_Impl()
+{
+ if (!m_pPropHelper)
+ {
+ Reference< XLinguProperties > xPropSet = GetLinguProperties();
+
+ m_pPropHelper.reset( new PropertyHelper_Spelling( static_cast<XSpellChecker *>(this), xPropSet ) );
+ m_pPropHelper->AddAsPropListener(); //! after a reference is established
+ }
+ return *m_pPropHelper;
+}
+
+Sequence< Locale > SAL_CALL SpellChecker::getLocales()
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ // this routine should return the locales supported by the installed
+ // dictionaries.
+ if (m_DictItems.empty())
+ {
+ SvtLinguConfig aLinguCfg;
+
+ // get list of extension dictionaries-to-use
+ // (or better speaking: the list of dictionaries using the
+ // new configuration entries).
+ std::vector< SvtLinguConfigDictionaryEntry > aDics;
+ uno::Sequence< OUString > aFormatList;
+ aLinguCfg.GetSupportedDictionaryFormatsFor( "SpellCheckers",
+ "org.openoffice.lingu.MySpellSpellChecker", aFormatList );
+ for (auto const& format : std::as_const(aFormatList))
+ {
+ std::vector< SvtLinguConfigDictionaryEntry > aTmpDic(
+ aLinguCfg.GetActiveDictionariesByFormat(format) );
+ aDics.insert( aDics.end(), aTmpDic.begin(), aTmpDic.end() );
+ }
+
+ //!! for compatibility with old dictionaries (the ones not using extensions
+ //!! or new configuration entries, but still using the dictionary.lst file)
+ //!! Get the list of old style spell checking dictionaries to use...
+ std::vector< SvtLinguConfigDictionaryEntry > aOldStyleDics(
+ GetOldStyleDics( "DICT" ) );
+
+ // to prefer dictionaries with configuration entries we will only
+ // use those old style dictionaries that add a language that
+ // is not yet supported by the list of new style dictionaries
+ MergeNewStyleDicsAndOldStyleDics( aDics, aOldStyleDics );
+
+ if (!aDics.empty())
+ {
+ uno::Reference< lang::XMultiServiceFactory > xServiceFactory(comphelper::getProcessServiceFactory());
+ uno::Reference< ucb::XSimpleFileAccess > xAccess(xServiceFactory->createInstance("com.sun.star.ucb.SimpleFileAccess"), uno::UNO_QUERY);
+ // get supported locales from the dictionaries-to-use...
+ std::set<OUString> aLocaleNamesSet;
+ for (auto const& dict : aDics)
+ {
+ const uno::Sequence< OUString > aLocaleNames( dict.aLocaleNames );
+ uno::Sequence< OUString > aLocations( dict.aLocations );
+ SAL_WARN_IF(
+ aLocaleNames.hasElements() && !aLocations.hasElements(),
+ "lingucomponent", "no locations");
+ if (aLocations.hasElements())
+ {
+ if (xAccess.is() && xAccess->exists(aLocations[0]))
+ {
+ for (auto const& locale : aLocaleNames)
+ {
+ if (!comphelper::LibreOfficeKit::isWhitelistedLanguage(locale))
+ continue;
+
+ aLocaleNamesSet.insert(locale);
+ }
+ }
+ else
+ {
+ SAL_WARN(
+ "lingucomponent",
+ "missing <" << aLocations[0] << ">");
+ }
+ }
+ }
+ // ... and add them to the resulting sequence
+ m_aSuppLocales.realloc( aLocaleNamesSet.size() );
+ sal_Int32 k = 0;
+ for (auto const& localeName : aLocaleNamesSet)
+ {
+ Locale aTmp( LanguageTag::convertToLocale(localeName));
+ m_aSuppLocales[k++] = aTmp;
+ }
+
+ //! For each dictionary and each locale we need a separate entry.
+ //! If this results in more than one dictionary per locale than (for now)
+ //! it is undefined which dictionary gets used.
+ //! In the future the implementation should support using several dictionaries
+ //! for one locale.
+ sal_uInt32 nDictSize = std::accumulate(aDics.begin(), aDics.end(), sal_uInt32(0),
+ [](const sal_uInt32 nSum, const SvtLinguConfigDictionaryEntry& dict) {
+ return nSum + dict.aLocaleNames.getLength(); });
+
+ // add dictionary information
+ m_DictItems.reserve(nDictSize);
+ for (auto const& dict : aDics)
+ {
+ if (dict.aLocaleNames.hasElements() &&
+ dict.aLocations.hasElements())
+ {
+ const uno::Sequence< OUString > aLocaleNames( dict.aLocaleNames );
+
+ // currently only one language per dictionary is supported in the actual implementation...
+ // Thus here we work-around this by adding the same dictionary several times.
+ // Once for each of its supported locales.
+ for (auto const& localeName : aLocaleNames)
+ {
+ // also both files have to be in the same directory and the
+ // file names must only differ in the extension (.aff/.dic).
+ // Thus we use the first location only and strip the extension part.
+ OUString aLocation = dict.aLocations[0];
+ sal_Int32 nPos = aLocation.lastIndexOf( '.' );
+ aLocation = aLocation.copy( 0, nPos );
+
+ m_DictItems.emplace_back(aLocation, LanguageTag::convertToLocale(localeName), RTL_TEXTENCODING_DONTKNOW);
+ }
+ }
+ }
+ DBG_ASSERT( nDictSize == m_DictItems.size(), "index mismatch?" );
+ }
+ else
+ {
+ // no dictionary found so register no dictionaries
+ m_aSuppLocales.realloc(0);
+ }
+ }
+
+ return m_aSuppLocales;
+}
+
+sal_Bool SAL_CALL SpellChecker::hasLocale(const Locale& rLocale)
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ bool bRes = false;
+ if (!m_aSuppLocales.hasElements())
+ getLocales();
+
+ for (auto const& suppLocale : std::as_const(m_aSuppLocales))
+ {
+ if (rLocale == suppLocale)
+ {
+ bRes = true;
+ break;
+ }
+ }
+ return bRes;
+}
+
+sal_Int16 SpellChecker::GetSpellFailure(const OUString &rWord, const Locale &rLocale)
+{
+ if (rWord.getLength() > MAXWORDLEN)
+ return -1;
+
+ Hunspell * pMS = nullptr;
+ rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
+
+ // initialize a myspell object for each dictionary once
+ // (note: mutex is held higher up in isValid)
+
+ sal_Int16 nRes = -1;
+
+ // first handle smart quotes both single and double
+ OUStringBuffer rBuf(rWord);
+ sal_Int32 n = rBuf.getLength();
+ sal_Unicode c;
+ sal_Int32 extrachar = 0;
+
+ for (sal_Int32 ix=0; ix < n; ix++)
+ {
+ c = rBuf[ix];
+ if ((c == 0x201C) || (c == 0x201D))
+ rBuf[ix] = u'"';
+ else if ((c == 0x2018) || (c == 0x2019))
+ rBuf[ix] = u'\'';
+
+ // recognize words with Unicode ligatures and ZWNJ/ZWJ characters (only
+ // with 8-bit encoded dictionaries. For UTF-8 encoded dictionaries
+ // set ICONV and IGNORE aff file options, if needed.)
+ else if ((c == 0x200C) || (c == 0x200D) ||
+ ((c >= 0xFB00) && (c <= 0xFB04)))
+ extrachar = 1;
+ }
+ OUString nWord(rBuf.makeStringAndClear());
+
+ if (n)
+ {
+ for (auto& currDict : m_DictItems)
+ {
+ pMS = nullptr;
+ eEnc = RTL_TEXTENCODING_DONTKNOW;
+
+ if (rLocale == currDict.m_aDLoc)
+ {
+ if (!currDict.m_pDict)
+ {
+ OUString dicpath = currDict.m_aDName + ".dic";
+ OUString affpath = currDict.m_aDName + ".aff";
+ OUString dict;
+ OUString aff;
+ osl::FileBase::getSystemPathFromFileURL(dicpath,dict);
+ osl::FileBase::getSystemPathFromFileURL(affpath,aff);
+#if defined(_WIN32)
+ // workaround for Windows specific problem that the
+ // path length in calls to 'fopen' is limited to somewhat
+ // about 120+ characters which will usually be exceed when
+ // using dictionaries as extensions. (Hunspell waits UTF-8 encoded
+ // path with \\?\ long path prefix.)
+ OString aTmpaff = Win_AddLongPathPrefix(OUStringToOString(aff, RTL_TEXTENCODING_UTF8));
+ OString aTmpdict = Win_AddLongPathPrefix(OUStringToOString(dict, RTL_TEXTENCODING_UTF8));
+#else
+ OString aTmpaff(OU2ENC(aff,osl_getThreadTextEncoding()));
+ OString aTmpdict(OU2ENC(dict,osl_getThreadTextEncoding()));
+#endif
+
+ currDict.m_pDict = std::make_unique<Hunspell>(aTmpaff.getStr(),aTmpdict.getStr());
+#if defined(H_DEPRECATED)
+ currDict.m_aDEnc = getTextEncodingFromCharset(currDict.m_pDict->get_dict_encoding().c_str());
+#else
+ currDict.m_aDEnc = getTextEncodingFromCharset(currDict.m_pDict->get_dic_encoding());
+#endif
+ }
+ pMS = currDict.m_pDict.get();
+ eEnc = currDict.m_aDEnc;
+ }
+
+ if (pMS)
+ {
+ // 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)" );
+ if (eEnc == RTL_TEXTENCODING_DONTKNOW)
+ return -1;
+
+ OString aWrd(OU2ENC(nWord,eEnc));
+#if defined(H_DEPRECATED)
+ bool bVal = pMS->spell(std::string(aWrd.getStr()));
+#else
+ bool bVal = pMS->spell(aWrd.getStr()) != 0;
+#endif
+ if (!bVal) {
+ if (extrachar && (eEnc != RTL_TEXTENCODING_UTF8)) {
+ OUStringBuffer aBuf(nWord);
+ n = aBuf.getLength();
+ for (sal_Int32 ix=n-1; ix >= 0; ix--)
+ {
+ switch (aBuf[ix]) {
+ case 0xFB00: aBuf.remove(ix, 1); aBuf.insert(ix, "ff"); break;
+ case 0xFB01: aBuf.remove(ix, 1); aBuf.insert(ix, "fi"); break;
+ case 0xFB02: aBuf.remove(ix, 1); aBuf.insert(ix, "fl"); break;
+ case 0xFB03: aBuf.remove(ix, 1); aBuf.insert(ix, "ffi"); break;
+ case 0xFB04: aBuf.remove(ix, 1); aBuf.insert(ix, "ffl"); break;
+ case 0x200C:
+ case 0x200D: aBuf.remove(ix, 1); break;
+ }
+ }
+ OUString aWord(aBuf.makeStringAndClear());
+ OString bWrd(OU2ENC(aWord, eEnc));
+#if defined(H_DEPRECATED)
+ bVal = pMS->spell(std::string(bWrd.getStr()));
+#else
+ bVal = pMS->spell(bWrd.getStr()) != 0;
+#endif
+ if (bVal) return -1;
+ }
+ nRes = SpellFailure::SPELLING_ERROR;
+ } else {
+ return -1;
+ }
+ pMS = nullptr;
+ }
+ }
+ }
+
+ return nRes;
+}
+
+sal_Bool SAL_CALL SpellChecker::isValid( const OUString& rWord, const Locale& rLocale,
+ const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (rLocale == Locale() || rWord.isEmpty())
+ return true;
+
+ if (!hasLocale( rLocale ))
+ return true;
+
+ // return sal_False to process SPELLML requests (they are longer than the header)
+ if (rWord.match(SPELL_XML, 0) && (rWord.getLength() > 10)) return false;
+
+ // Get property values to be used.
+ // These are be the default values set in the SN_LINGU_PROPERTIES
+ // PropertySet which are overridden by the supplied ones from the
+ // last argument.
+ // You'll probably like to use a simpler solution than the provided
+ // one using the PropertyHelper_Spell.
+ PropertyHelper_Spelling& rHelper = GetPropHelper();
+ rHelper.SetTmpPropVals( rProperties );
+
+ sal_Int16 nFailure = GetSpellFailure( rWord, rLocale );
+ if (nFailure != -1 && !rWord.match(SPELL_XML, 0))
+ {
+ LanguageType nLang = LinguLocaleToLanguage( rLocale );
+ // postprocess result for errors that should be ignored
+ const bool bIgnoreError =
+ (!rHelper.IsSpellUpperCase() && IsUpper( rWord, nLang )) ||
+ (!rHelper.IsSpellWithDigits() && HasDigits( rWord )) ||
+ (!rHelper.IsSpellCapitalization() && nFailure == SpellFailure::CAPTION_ERROR);
+ if (bIgnoreError)
+ nFailure = -1;
+ }
+
+ return (nFailure == -1);
+}
+
+Reference< XSpellAlternatives >
+ SpellChecker::GetProposals( const OUString &rWord, const Locale &rLocale )
+{
+ // Retrieves the return values for the 'spell' function call in case
+ // of a misspelled word.
+ // Especially it may give a list of suggested (correct) words:
+ Reference< XSpellAlternatives > xRes;
+ // note: mutex is held by higher up by spell which covers both
+
+ Hunspell* pMS = nullptr;
+ rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
+
+ // first handle smart quotes (single and double)
+ OUStringBuffer rBuf(rWord);
+ sal_Int32 n = rBuf.getLength();
+ sal_Unicode c;
+ for (sal_Int32 ix=0; ix < n; ix++)
+ {
+ c = rBuf[ix];
+ if ((c == 0x201C) || (c == 0x201D))
+ rBuf[ix] = u'"';
+ if ((c == 0x2018) || (c == 0x2019))
+ rBuf[ix] = u'\'';
+ }
+ OUString nWord(rBuf.makeStringAndClear());
+
+ if (n)
+ {
+ LanguageType nLang = LinguLocaleToLanguage( rLocale );
+ int numsug = 0;
+
+ Sequence< OUString > aStr( 0 );
+ for (const auto& currDict : m_DictItems)
+ {
+ pMS = nullptr;
+ eEnc = RTL_TEXTENCODING_DONTKNOW;
+
+ if (rLocale == currDict.m_aDLoc)
+ {
+ pMS = currDict.m_pDict.get();
+ eEnc = currDict.m_aDEnc;
+ }
+
+ if (pMS)
+ {
+ OString aWrd(OU2ENC(nWord,eEnc));
+#if defined(H_DEPRECATED)
+ std::vector<std::string> suglst = pMS->suggest(std::string(aWrd.getStr()));
+ if (!suglst.empty())
+ {
+ aStr.realloc(numsug + suglst.size());
+ OUString *pStr = aStr.getArray();
+ for (size_t ii = 0; ii < suglst.size(); ++ii)
+ {
+ OUString cvtwrd(suglst[ii].c_str(), suglst[ii].size(), eEnc);
+ pStr[numsug + ii] = cvtwrd;
+ }
+ numsug += suglst.size();
+ }
+#else
+ char ** suglst = nullptr;
+ int count = pMS->suggest(&suglst, aWrd.getStr());
+ if (count)
+ {
+ aStr.realloc( numsug + count );
+ OUString *pStr = aStr.getArray();
+ for (int ii=0; ii < count; ++ii)
+ {
+ OUString cvtwrd(suglst[ii],strlen(suglst[ii]),eEnc);
+ pStr[numsug + ii] = cvtwrd;
+ }
+ numsug += count;
+ }
+ pMS->free_list(&suglst, count);
+#endif
+ }
+ }
+
+ // now return an empty alternative for no suggestions or the list of alternatives if some found
+ xRes = SpellAlternatives::CreateSpellAlternatives( rWord, nLang, SpellFailure::SPELLING_ERROR, aStr );
+ return xRes;
+ }
+ return xRes;
+}
+
+Reference< XSpellAlternatives > SAL_CALL SpellChecker::spell(
+ const OUString& rWord, const Locale& rLocale,
+ const css::uno::Sequence< css::beans::PropertyValue >& rProperties )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (rLocale == Locale() || rWord.isEmpty())
+ return nullptr;
+
+ if (!hasLocale( rLocale ))
+ return nullptr;
+
+ Reference< XSpellAlternatives > xAlt;
+ if (!isValid( rWord, rLocale, rProperties ))
+ {
+ xAlt = GetProposals( rWord, rLocale );
+ }
+ return xAlt;
+}
+
+/// @throws Exception
+static Reference< XInterface > SpellChecker_CreateInstance(
+ const Reference< XMultiServiceFactory > & /*rSMgr*/ )
+{
+
+ Reference< XInterface > xService = static_cast<cppu::OWeakObject*>(new SpellChecker);
+ return xService;
+}
+
+sal_Bool SAL_CALL SpellChecker::addLinguServiceEventListener(
+ const Reference< XLinguServiceEventListener >& rxLstnr )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ bool bRes = false;
+ if (!m_bDisposing && rxLstnr.is())
+ {
+ bRes = GetPropHelper().addLinguServiceEventListener( rxLstnr );
+ }
+ return bRes;
+}
+
+sal_Bool SAL_CALL SpellChecker::removeLinguServiceEventListener(
+ const Reference< XLinguServiceEventListener >& rxLstnr )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ bool bRes = false;
+ if (!m_bDisposing && rxLstnr.is())
+ {
+ bRes = GetPropHelper().removeLinguServiceEventListener( rxLstnr );
+ }
+ return bRes;
+}
+
+OUString SAL_CALL SpellChecker::getServiceDisplayName(const Locale& rLocale)
+{
+ std::locale loc(Translate::Create("svt", LanguageTag(rLocale)));
+ return Translate::get(STR_DESCRIPTION_HUNSPELL, loc);
+}
+
+void SAL_CALL SpellChecker::initialize( const Sequence< Any >& rArguments )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (m_pPropHelper)
+ return;
+
+ sal_Int32 nLen = rArguments.getLength();
+ if (2 == nLen)
+ {
+ Reference< XLinguProperties > xPropSet;
+ rArguments.getConstArray()[0] >>= xPropSet;
+ // rArguments.getConstArray()[1] >>= xDicList;
+
+ //! Pointer allows for access of the non-UNO functions.
+ //! And the reference to the UNO-functions while increasing
+ //! the ref-count and will implicitly free the memory
+ //! when the object is no longer used.
+ m_pPropHelper.reset( new PropertyHelper_Spelling( static_cast<XSpellChecker *>(this), xPropSet ) );
+ m_pPropHelper->AddAsPropListener(); //! after a reference is established
+ }
+ else {
+ OSL_FAIL( "wrong number of arguments in sequence" );
+ }
+}
+
+void SAL_CALL SpellChecker::dispose()
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (!m_bDisposing)
+ {
+ m_bDisposing = true;
+ EventObject aEvtObj( static_cast<XSpellChecker *>(this) );
+ m_aEvtListeners.disposeAndClear( aEvtObj );
+ if (m_pPropHelper)
+ {
+ m_pPropHelper->RemoveAsPropListener();
+ m_pPropHelper.reset();
+ }
+ }
+}
+
+void SAL_CALL SpellChecker::addEventListener( const Reference< XEventListener >& rxListener )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (!m_bDisposing && rxListener.is())
+ m_aEvtListeners.addInterface( rxListener );
+}
+
+void SAL_CALL SpellChecker::removeEventListener( const Reference< XEventListener >& rxListener )
+{
+ MutexGuard aGuard( GetLinguMutex() );
+
+ if (!m_bDisposing && rxListener.is())
+ m_aEvtListeners.removeInterface( rxListener );
+}
+
+// Service specific part
+OUString SAL_CALL SpellChecker::getImplementationName()
+{
+ return getImplementationName_Static();
+}
+
+sal_Bool SAL_CALL SpellChecker::supportsService( const OUString& ServiceName )
+{
+ return cppu::supportsService(this, ServiceName);
+}
+
+Sequence< OUString > SAL_CALL SpellChecker::getSupportedServiceNames()
+{
+ return getSupportedServiceNames_Static();
+}
+
+Sequence< OUString > SpellChecker::getSupportedServiceNames_Static()
+ throw()
+{
+ Sequence< OUString > aSNS { SN_SPELLCHECKER };
+ return aSNS;
+}
+
+extern "C"
+{
+
+SAL_DLLPUBLIC_EXPORT void * spell_component_getFactory(
+ const char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
+{
+ void * pRet = nullptr;
+ if ( SpellChecker::getImplementationName_Static().equalsAscii( pImplName ) )
+ {
+ Reference< XSingleServiceFactory > xFactory =
+ cppu::createOneInstanceFactory(
+ static_cast< XMultiServiceFactory * >( pServiceManager ),
+ SpellChecker::getImplementationName_Static(),
+ SpellChecker_CreateInstance,
+ SpellChecker::getSupportedServiceNames_Static());
+ // acquire, because we return an interface pointer instead of a reference
+ xFactory->acquire();
+ pRet = xFactory.get();
+ }
+ return pRet;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/lingucomponent/source/spellcheck/spell/sspellimp.hxx b/lingucomponent/source/spellcheck/spell/sspellimp.hxx
new file mode 100644
index 000000000..3c55d3c9f
--- /dev/null
+++ b/lingucomponent/source/spellcheck/spell/sspellimp.hxx
@@ -0,0 +1,130 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_LINGUCOMPONENT_SOURCE_SPELLCHECK_SPELL_SSPELLIMP_HXX
+#define INCLUDED_LINGUCOMPONENT_SOURCE_SPELLCHECK_SPELL_SSPELLIMP_HXX
+
+#include <cppuhelper/implbase.hxx>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/XServiceDisplayName.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/PropertyValues.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/linguistic2/XSpellChecker.hpp>
+#include <com/sun/star/linguistic2/XLinguServiceEventBroadcaster.hpp>
+
+#include <linguistic/misc.hxx>
+#include <linguistic/lngprophelp.hxx>
+
+#include <lingutil.hxx>
+#include <memory>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::linguistic2;
+
+class Hunspell;
+
+class SpellChecker :
+ public cppu::WeakImplHelper
+ <
+ XSpellChecker,
+ XLinguServiceEventBroadcaster,
+ XInitialization,
+ XComponent,
+ XServiceInfo,
+ XServiceDisplayName
+ >
+{
+ struct DictItem
+ {
+ OUString m_aDName;
+ Locale m_aDLoc;
+ std::unique_ptr<Hunspell> m_pDict;
+ rtl_TextEncoding m_aDEnc;
+
+ DictItem(OUString i_DName, Locale i_DLoc, rtl_TextEncoding i_DEnc);
+ };
+
+ std::vector<DictItem> m_DictItems;
+
+ Sequence< Locale > m_aSuppLocales;
+
+ ::comphelper::OInterfaceContainerHelper2 m_aEvtListeners;
+ std::unique_ptr<linguistic::PropertyHelper_Spelling> m_pPropHelper;
+ bool m_bDisposing;
+
+ SpellChecker(const SpellChecker &) = delete;
+ SpellChecker & operator = (const SpellChecker &) = delete;
+
+ linguistic::PropertyHelper_Spelling& GetPropHelper_Impl();
+ linguistic::PropertyHelper_Spelling& GetPropHelper()
+ {
+ return m_pPropHelper ? *m_pPropHelper : GetPropHelper_Impl();
+ }
+
+ sal_Int16 GetSpellFailure( const OUString &rWord, const Locale &rLocale );
+ Reference< XSpellAlternatives > GetProposals( const OUString &rWord, const Locale &rLocale );
+
+public:
+ SpellChecker();
+ virtual ~SpellChecker() override;
+
+ // XSupportedLocales (for XSpellChecker)
+ virtual Sequence< Locale > SAL_CALL getLocales() override;
+ virtual sal_Bool SAL_CALL hasLocale( const Locale& rLocale ) override;
+
+ // XSpellChecker
+ virtual sal_Bool SAL_CALL isValid( const OUString& rWord, const Locale& rLocale, const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
+ virtual Reference< XSpellAlternatives > SAL_CALL spell( const OUString& rWord, const Locale& rLocale, const css::uno::Sequence< css::beans::PropertyValue >& rProperties ) override;
+
+ // XLinguServiceEventBroadcaster
+ virtual sal_Bool SAL_CALL addLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) override;
+ virtual sal_Bool SAL_CALL removeLinguServiceEventListener( const Reference< XLinguServiceEventListener >& rxLstnr ) override;
+
+ // XServiceDisplayName
+ virtual OUString SAL_CALL getServiceDisplayName( const Locale& rLocale ) override;
+
+ // XInitialization
+ virtual void SAL_CALL initialize( const Sequence< Any >& rArguments ) override;
+
+ // XComponent
+ virtual void SAL_CALL dispose() override;
+ virtual void SAL_CALL addEventListener( const Reference< XEventListener >& rxListener ) override;
+ virtual void SAL_CALL removeEventListener( const Reference< XEventListener >& rxListener ) override;
+
+ // XServiceInfo
+ virtual OUString SAL_CALL getImplementationName() override;
+ virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) override;
+ virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+ static inline OUString getImplementationName_Static() throw();
+ static Sequence< OUString > getSupportedServiceNames_Static() throw();
+};
+
+inline OUString SpellChecker::getImplementationName_Static() throw()
+{
+ return "org.openoffice.lingu.MySpellSpellChecker";
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */