tdf#136306 offapi linguistic: add options to disable rule-based compounding

Add two new spell checking options to disable rule-based closed
and hyphenated compound word recognition with Hunspell dictionaries:

com::sun::star::linguistic2::XLinguProperties::IsSpellClosedCompound
com::sun::star::linguistic2::XLinguProperties::IsSpellHyphenatedCompound

For professional proofreaders, it can be more important to avoid
of the mistakes of the rule-based compound word recognition, than
to speed up proofreading. Disabling the following two new options
will report all rule-based closed compound words (default in
Dutch, German, Hungarian etc. dictionaries) and rule-based
hyphenated compound words (all languages with BREAK usage in
their Hunspell dictionaries):

- "Accept possible closed compound words"

- "Accept possible hyphenated compound words"

For example, disabling the second one, dictionary word "scot-free"
will be still correct word in English spell checking, but not
the previously accepted compound "arbitrary-word-with-hyphen".

Note: the second option works with the update to Hunspell 1.7.2.

Change-Id: Id879610927d5e8269fda5ad207c1c2fe1f57a0b6
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/144875
Tested-by: Jenkins
Reviewed-by: László Németh <nemeth@numbertext.org>

1 files changed, 42 insertions, 0 deletions

diff --git a/linguistic/source/lngprophelp.cxx b/linguistic/source/lngprophelp.cxx
index a14c96c9501e..543685dc33c4 100644
--- a/linguistic/source/lngprophelp.cxx
+++ b/linguistic/source/lngprophelp.cxx
@@ -292,6 +292,8 @@ PropertyHelper_Spell::PropertyHelper_Spell(
     rPropNames.push_back(UPN_IS_SPELL_UPPER_CASE);
     rPropNames.push_back(UPN_IS_SPELL_WITH_DIGITS);
     rPropNames.push_back(UPN_IS_SPELL_CAPITALIZATION);
+    rPropNames.push_back(UPN_IS_SPELL_CLOSED_COMPOUND);
+    rPropNames.push_back(UPN_IS_SPELL_HYPHENATED_COMPOUND);
     SetDefaultValues();
     GetCurrentValues();
 }
@@ -309,6 +311,8 @@ void PropertyHelper_Spell::SetDefaultValues()
     bResIsSpellUpperCase        = bIsSpellUpperCase         = false;
     bResIsSpellWithDigits       = bIsSpellWithDigits        = false;
     bResIsSpellCapitalization   = bIsSpellCapitalization    = true;
+    bResIsSpellClosedCompound   = bIsSpellClosedCompound    = true;
+    bResIsSpellHyphenatedCompound = bIsSpellHyphenatedCompound = true;
 }
 
 
@@ -340,6 +344,16 @@ void PropertyHelper_Spell::GetCurrentValues()
             pbVal    = &bIsSpellCapitalization;
             pbResVal = &bResIsSpellCapitalization;
         }
+        else if ( rPropName == UPN_IS_SPELL_CLOSED_COMPOUND )
+        {
+            pbVal    = &bIsSpellClosedCompound;
+            pbResVal = &bResIsSpellClosedCompound;
+        }
+        else if ( rPropName == UPN_IS_SPELL_HYPHENATED_COMPOUND )
+        {
+            pbVal    = &bIsSpellHyphenatedCompound;
+            pbResVal = &bResIsSpellHyphenatedCompound;
+        }
 
         if (pbVal && pbResVal)
         {
@@ -383,6 +397,20 @@ bool PropertyHelper_Spell::propertyChange_Impl( const PropertyChangeEvent& rEvt
                 bSWWA = !bSCWA;             // sal_True->sal_False change?
                 break;
             }
+            case UPH_IS_SPELL_CLOSED_COMPOUND     :
+            {
+                pbVal = &bIsSpellClosedCompound;
+                bSCWA = ! *pbVal;    // sal_False->sal_True change?
+                bSWWA = !bSCWA;             // sal_True->sal_False change?
+                break;
+            }
+            case UPH_IS_SPELL_HYPHENATED_COMPOUND :
+            {
+                pbVal = &bIsSpellHyphenatedCompound;
+                bSCWA = ! *pbVal;    // sal_False->sal_True change?
+                bSWWA = !bSCWA;             // sal_True->sal_False change?
+                break;
+            }
             default:
                 SAL_WARN( "linguistic", "unknown property" );
         }
@@ -425,6 +453,8 @@ void PropertyHelper_Spell::SetTmpPropVals( const PropertyValues &rPropVals )
     // temporary value
     bResIsSpellWithDigits       = bIsSpellWithDigits;
     bResIsSpellCapitalization   = bIsSpellCapitalization;
+    bResIsSpellClosedCompound   = bIsSpellClosedCompound;
+    bResIsSpellHyphenatedCompound = bIsSpellHyphenatedCompound;
     bResIsSpellUpperCase        = bIsSpellUpperCase;
 
     for (const PropertyValue& rVal : rPropVals)
@@ -441,6 +471,8 @@ void PropertyHelper_Spell::SetTmpPropVals( const PropertyValues &rPropVals )
                 case UPH_IS_SPELL_UPPER_CASE     : pbResVal = &bResIsSpellUpperCase; break;
                 case UPH_IS_SPELL_WITH_DIGITS    : pbResVal = &bResIsSpellWithDigits; break;
                 case UPH_IS_SPELL_CAPITALIZATION : pbResVal = &bResIsSpellCapitalization; break;
+                case UPH_IS_SPELL_CLOSED_COMPOUND : pbResVal = &bResIsSpellClosedCompound; break;
+                case UPH_IS_SPELL_HYPHENATED_COMPOUND : pbResVal = &bResIsSpellHyphenatedCompound; break;
                 default:
                     SAL_WARN( "linguistic", "unknown property" );
             }
@@ -731,6 +763,16 @@ bool PropertyHelper_Spelling::IsSpellCapitalization() const
     return mxPropHelper->IsSpellCapitalization();
 }
 
+bool PropertyHelper_Spelling::IsSpellClosedCompound() const
+{
+    return mxPropHelper->IsSpellClosedCompound();
+}
+
+bool PropertyHelper_Spelling::IsSpellHyphenatedCompound() const
+{
+    return mxPropHelper->IsSpellHyphenatedCompound();
+}
+
 bool PropertyHelper_Spelling::addLinguServiceEventListener(
                 const css::uno::Reference<
                     css::linguistic2::XLinguServiceEventListener >& rxListener )