linguistic/source/gciterator.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/macros.h>
  21 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
  22 #include <com/sun/star/container/XEnumeration.hpp>
  23 #include <com/sun/star/container/XNameAccess.hpp>
  24 #include <com/sun/star/container/XNameContainer.hpp>
  25 #include <com/sun/star/container/XNameReplace.hpp>
  26 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  27 #include <com/sun/star/i18n/BreakIterator.hpp>
  28 #include <com/sun/star/lang/XComponent.hpp>
  29 #include <com/sun/star/lang/XServiceInfo.hpp>
  30 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  31 #include <com/sun/star/linguistic2/XSupportedLocales.hpp>
  32 #include <com/sun/star/linguistic2/XProofreader.hpp>
  33 #include <com/sun/star/linguistic2/XProofreadingIterator.hpp>
  34 #include <com/sun/star/linguistic2/SingleProofreadingError.hpp>
  35 #include <com/sun/star/linguistic2/ProofreadingResult.hpp>
  36 #include <com/sun/star/linguistic2/LinguServiceEvent.hpp>
  37 #include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp>
  38 #include <com/sun/star/registry/XRegistryKey.hpp>
  39 #include <com/sun/star/text/TextMarkupType.hpp>
  40 #include <com/sun/star/text/TextMarkupDescriptor.hpp>
  41 #include <com/sun/star/text/XTextMarkup.hpp>
  42 #include <com/sun/star/text/XMultiTextMarkup.hpp>
  43 #include <com/sun/star/text/XFlatParagraph.hpp>
  44 #include <com/sun/star/text/XFlatParagraphIterator.hpp>
  45 #include <com/sun/star/uno/XComponentContext.hpp>
  46 #include <com/sun/star/lang/XSingleComponentFactory.hpp>
  47 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  48
  49 #include <sal/config.h>
  50 #include <sal/log.hxx>
  51 #include <osl/conditn.hxx>
  52 #include <osl/thread.hxx>
  53 #include <cppuhelper/implementationentry.hxx>
  54 #include <cppuhelper/interfacecontainer.h>
  55 #include <cppuhelper/factory.hxx>
  56 #include <cppuhelper/supportsservice.hxx>
  57 #include <i18nlangtag/languagetag.hxx>
  58 #include <comphelper/processfactory.hxx>
  59 #include <comphelper/propertysequence.hxx>
  60 #include <tools/debug.hxx>
  61 #include <tools/diagnose_ex.h>
  62
  63 #include <deque>
  64 #include <map>
  65 #include <vector>
  66
  67 #include <linguistic/misc.hxx>
  68 #include "defs.hxx"
  69 #include "lngopt.hxx"
  70 #include "lngreg.hxx"
  71
  72 #include "gciterator.hxx"
  73
  74 using namespace linguistic;
  75 using namespace ::com::sun::star;
  76
  77 static OUString GrammarCheckingIterator_getImplementationName() throw();
  78 static uno::Sequence< OUString > GrammarCheckingIterator_getSupportedServiceNames() throw();
  79
  80 // white space list: obtained from the fonts.config.txt of a Linux system.
  81 static const sal_Unicode aWhiteSpaces[] =
  82 {
  83     0x0020,   /* SPACE */
  84     0x00a0,   /* NO-BREAK SPACE */
  85     0x00ad,   /* SOFT HYPHEN */
  86     0x115f,   /* HANGUL CHOSEONG FILLER */
  87     0x1160,   /* HANGUL JUNGSEONG FILLER */
  88     0x1680,   /* OGHAM SPACE MARK */
  89     0x2000,   /* EN QUAD */
  90     0x2001,   /* EM QUAD */
  91     0x2002,   /* EN SPACE */
  92     0x2003,   /* EM SPACE */
  93     0x2004,   /* THREE-PER-EM SPACE */
  94     0x2005,   /* FOUR-PER-EM SPACE */
  95     0x2006,   /* SIX-PER-EM SPACE */
  96     0x2007,   /* FIGURE SPACE */
  97     0x2008,   /* PUNCTUATION SPACE */
  98     0x2009,   /* THIN SPACE */
  99     0x200a,   /* HAIR SPACE */
 100     0x200b,   /* ZERO WIDTH SPACE */
 101     0x200c,   /* ZERO WIDTH NON-JOINER */
 102     0x200d,   /* ZERO WIDTH JOINER */
 103     0x200e,   /* LEFT-TO-RIGHT MARK */
 104     0x200f,   /* RIGHT-TO-LEFT MARK */
 105     0x2028,   /* LINE SEPARATOR */
 106     0x2029,   /* PARAGRAPH SEPARATOR */
 107     0x202a,   /* LEFT-TO-RIGHT EMBEDDING */
 108     0x202b,   /* RIGHT-TO-LEFT EMBEDDING */
 109     0x202c,   /* POP DIRECTIONAL FORMATTING */
 110     0x202d,   /* LEFT-TO-RIGHT OVERRIDE */
 111     0x202e,   /* RIGHT-TO-LEFT OVERRIDE */
 112     0x202f,   /* NARROW NO-BREAK SPACE */
 113     0x205f,   /* MEDIUM MATHEMATICAL SPACE */
 114     0x2060,   /* WORD JOINER */
 115     0x2061,   /* FUNCTION APPLICATION */
 116     0x2062,   /* INVISIBLE TIMES */
 117     0x2063,   /* INVISIBLE SEPARATOR */
 118     0x206A,   /* INHIBIT SYMMETRIC SWAPPING */
 119     0x206B,   /* ACTIVATE SYMMETRIC SWAPPING */
 120     0x206C,   /* INHIBIT ARABIC FORM SHAPING */
 121     0x206D,   /* ACTIVATE ARABIC FORM SHAPING */
 122     0x206E,   /* NATIONAL DIGIT SHAPES */
 123     0x206F,   /* NOMINAL DIGIT SHAPES */
 124     0x3000,   /* IDEOGRAPHIC SPACE */
 125     0x3164,   /* HANGUL FILLER */
 126     0xfeff,   /* ZERO WIDTH NO-BREAK SPACE */
 127     0xffa0,   /* HALFWIDTH HANGUL FILLER */
 128     0xfff9,   /* INTERLINEAR ANNOTATION ANCHOR */
 129     0xfffa,   /* INTERLINEAR ANNOTATION SEPARATOR */
 130     0xfffb    /* INTERLINEAR ANNOTATION TERMINATOR */
 131 };
 132
 133 static const int nWhiteSpaces = SAL_N_ELEMENTS( aWhiteSpaces );
 134
 135 static bool lcl_IsWhiteSpace( sal_Unicode cChar )
 136 {
 137     bool bFound = false;
 138     for (int i = 0;  i < nWhiteSpaces && !bFound;  ++i)
 139     {
 140         if (cChar == aWhiteSpaces[i])
 141             bFound = true;
 142     }
 143     return bFound;
 144 }
 145
 146 static sal_Int32 lcl_SkipWhiteSpaces( const OUString &rText, sal_Int32 nStartPos )
 147 {
 148     // note having nStartPos point right behind the string is OK since that one
 149     // is a correct end-of-sentence position to be returned from a grammar checker...
 150
 151     const sal_Int32 nLen = rText.getLength();
 152     bool bIllegalArgument = false;
 153     if (nStartPos < 0)
 154     {
 155         bIllegalArgument = true;
 156         nStartPos = 0;
 157     }
 158     if (nStartPos > nLen)
 159     {
 160         bIllegalArgument = true;
 161         nStartPos = nLen;
 162     }
 163     if (bIllegalArgument)
 164     {
 165         SAL_WARN( "linguistic", "lcl_SkipWhiteSpaces: illegal arguments" );
 166     }
 167
 168     sal_Int32 nRes = nStartPos;
 169     if (0 <= nStartPos && nStartPos < nLen)
 170     {
 171         const sal_Unicode* const pEnd = rText.getStr() + nLen;
 172         const sal_Unicode *pText = rText.getStr() + nStartPos;
 173         while (pText != pEnd && lcl_IsWhiteSpace(*pText))
 174             ++pText;
 175         nRes = pText - rText.getStr();
 176     }
 177
 178     DBG_ASSERT( 0 <= nRes && nRes <= nLen, "lcl_SkipWhiteSpaces return value out of range" );
 179     return nRes;
 180 }
 181
 182 static sal_Int32 lcl_BacktraceWhiteSpaces( const OUString &rText, sal_Int32 nStartPos )
 183 {
 184     // note: having nStartPos point right behind the string is OK since that one
 185     // is a correct end-of-sentence position to be returned from a grammar checker...
 186
 187     const sal_Int32 nLen = rText.getLength();
 188     bool bIllegalArgument = false;
 189     if (nStartPos < 0)
 190     {
 191         bIllegalArgument = true;
 192         nStartPos = 0;
 193     }
 194     if (nStartPos > nLen)
 195     {
 196         bIllegalArgument = true;
 197         nStartPos = nLen;
 198     }
 199     if (bIllegalArgument)
 200     {
 201         SAL_WARN( "linguistic", "lcl_BacktraceWhiteSpaces: illegal arguments" );
 202     }
 203
 204     sal_Int32 nRes = nStartPos;
 205     sal_Int32 nPosBefore = nStartPos - 1;
 206     const sal_Unicode *pStart = rText.getStr();
 207     if (0 <= nPosBefore && nPosBefore < nLen && lcl_IsWhiteSpace( pStart[ nPosBefore ] ))
 208     {
 209         nStartPos = nPosBefore;
 210         const sal_Unicode *pText = rText.getStr() + nStartPos;
 211         while (pText > pStart && lcl_IsWhiteSpace( *pText ))
 212             --pText;
 213         // now add 1 since we want to point to the first char after the last char in the sentence...
 214         nRes = pText - pStart + 1;
 215     }
 216
 217     DBG_ASSERT( 0 <= nRes && nRes <= nLen, "lcl_BacktraceWhiteSpaces return value out of range" );
 218     return nRes;
 219 }
 220
 221
 222 extern "C" {
 223
 224 static void lcl_workerfunc (void * gci)
 225 {
 226     osl_setThreadName("GrammarCheckingIterator");
 227
 228     static_cast<GrammarCheckingIterator*>(gci)->DequeueAndCheck();
 229 }
 230
 231 }
 232
 233 static lang::Locale lcl_GetPrimaryLanguageOfSentence(
 234     const uno::Reference< text::XFlatParagraph >& xFlatPara,
 235     sal_Int32 nStartIndex )
 236 {
 237     //get the language of the first word
 238     return xFlatPara->getLanguageOfText( nStartIndex, 1 );
 239 }
 240
 241
 242 LngXStringKeyMap::LngXStringKeyMap() {}
 243
 244 void SAL_CALL LngXStringKeyMap::insertValue(const OUString& aKey, const css::uno::Any& aValue)
 245 {
 246     std::map<OUString, css::uno::Any>::const_iterator aIter = maMap.find(aKey);
 247     if (aIter != maMap.end())
 248         throw css::container::ElementExistException();
 249
 250     maMap[aKey] = aValue;
 251 }
 252
 253 css::uno::Any SAL_CALL LngXStringKeyMap::getValue(const OUString& aKey)
 254 {
 255     std::map<OUString, css::uno::Any>::const_iterator aIter = maMap.find(aKey);
 256     if (aIter == maMap.end())
 257         throw css::container::NoSuchElementException();
 258
 259     return (*aIter).second;
 260 }
 261
 262 sal_Bool SAL_CALL LngXStringKeyMap::hasValue(const OUString& aKey)
 263 {
 264     return maMap.find(aKey) != maMap.end();
 265 }
 266
 267 ::sal_Int32 SAL_CALL LngXStringKeyMap::getCount() { return maMap.size(); }
 268
 269 OUString SAL_CALL LngXStringKeyMap::getKeyByIndex(::sal_Int32 nIndex)
 270 {
 271     if (static_cast<sal_uInt32>(nIndex) >= maMap.size())
 272         throw css::lang::IndexOutOfBoundsException();
 273
 274     return OUString();
 275 }
 276
 277 css::uno::Any SAL_CALL LngXStringKeyMap::getValueByIndex(::sal_Int32 nIndex)
 278 {
 279     if (static_cast<sal_uInt32>(nIndex) >= maMap.size())
 280         throw css::lang::IndexOutOfBoundsException();
 281
 282     return css::uno::Any();
 283 }
 284
 285
 286 GrammarCheckingIterator::GrammarCheckingIterator() :
 287     m_bEnd( false ),
 288     m_aCurCheckedDocId(),
 289     m_bGCServicesChecked( false ),
 290     m_nDocIdCounter( 0 ),
 291     m_aEventListeners( MyMutex::get() ),
 292     m_aNotifyListeners( MyMutex::get() )
 293 {
 294     m_thread = nullptr;
 295 }
 296
 297
 298 GrammarCheckingIterator::~GrammarCheckingIterator()
 299 {
 300     TerminateThread();
 301 }
 302
 303 void GrammarCheckingIterator::TerminateThread()
 304 {
 305     oslThread t;
 306     {
 307         ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 308         t = m_thread;
 309         m_thread = nullptr;
 310         m_bEnd = true;
 311         m_aWakeUpThread.set();
 312     }
 313     if (t != nullptr)
 314     {
 315         osl_joinWithThread(t);
 316         osl_destroyThread(t);
 317     }
 318 }
 319
 320 sal_Int32 GrammarCheckingIterator::NextDocId()
 321 {
 322     ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 323     m_nDocIdCounter += 1;
 324     return m_nDocIdCounter;
 325 }
 326
 327
 328 OUString GrammarCheckingIterator::GetOrCreateDocId(
 329     const uno::Reference< lang::XComponent > &xComponent )
 330 {
 331     // internal method; will always be called with locked mutex
 332
 333     OUString aRes;
 334     if (xComponent.is())
 335     {
 336         if (m_aDocIdMap.find( xComponent.get() ) != m_aDocIdMap.end())
 337         {
 338             // return already existing entry
 339             aRes = m_aDocIdMap[ xComponent.get() ];
 340         }
 341         else // add new entry
 342         {
 343             sal_Int32 nRes = NextDocId();
 344             aRes = OUString::number( nRes );
 345             m_aDocIdMap[ xComponent.get() ] = aRes;
 346             xComponent->addEventListener( this );
 347         }
 348     }
 349     return aRes;
 350 }
 351
 352
 353 void GrammarCheckingIterator::AddEntry(
 354     const uno::WeakReference< text::XFlatParagraphIterator >& xFlatParaIterator,
 355     const uno::WeakReference< text::XFlatParagraph >& xFlatPara,
 356     const OUString & rDocId,
 357     sal_Int32 nStartIndex,
 358     bool bAutomatic )
 359 {
 360     // we may not need/have a xFlatParaIterator (e.g. if checkGrammarAtPos was called)
 361     // but we always need a xFlatPara...
 362     uno::Reference< text::XFlatParagraph > xPara( xFlatPara );
 363     if (xPara.is())
 364     {
 365         FPEntry aNewFPEntry;
 366         aNewFPEntry.m_xParaIterator = xFlatParaIterator;
 367         aNewFPEntry.m_xPara         = xFlatPara;
 368         aNewFPEntry.m_aDocId        = rDocId;
 369         aNewFPEntry.m_nStartIndex   = nStartIndex;
 370         aNewFPEntry.m_bAutomatic    = bAutomatic;
 371
 372         // add new entry to the end of this queue
 373         ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 374         if (!m_thread)
 375             m_thread = osl_createThread( lcl_workerfunc, this );
 376         m_aFPEntriesQueue.push_back( aNewFPEntry );
 377
 378         // wake up the thread in order to do grammar checking
 379         m_aWakeUpThread.set();
 380     }
 381 }
 382
 383
 384 void GrammarCheckingIterator::ProcessResult(
 385     const linguistic2::ProofreadingResult &rRes,
 386     const uno::Reference< text::XFlatParagraphIterator > &rxFlatParagraphIterator,
 387     bool bIsAutomaticChecking )
 388 {
 389     DBG_ASSERT( rRes.xFlatParagraph.is(), "xFlatParagraph is missing" );
 390      //no guard necessary as no members are used
 391     bool bContinueWithNextPara = false;
 392     if (!rRes.xFlatParagraph.is() || rRes.xFlatParagraph->isModified())
 393     {
 394         // if paragraph was modified/deleted meanwhile continue with the next one...
 395         bContinueWithNextPara = true;
 396     }
 397     else    // paragraph is still unchanged...
 398     {
 399         // mark found errors...
 400
 401         sal_Int32 nTextLen = rRes.aText.getLength();
 402         bool bBoundariesOk = 0 <= rRes.nStartOfSentencePosition     && rRes.nStartOfSentencePosition <= nTextLen &&
 403                              0 <= rRes.nBehindEndOfSentencePosition && rRes.nBehindEndOfSentencePosition <= nTextLen &&
 404                              0 <= rRes.nStartOfNextSentencePosition && rRes.nStartOfNextSentencePosition <= nTextLen &&
 405                              rRes.nStartOfSentencePosition      <= rRes.nBehindEndOfSentencePosition &&
 406                              rRes.nBehindEndOfSentencePosition  <= rRes.nStartOfNextSentencePosition;
 407         DBG_ASSERT( bBoundariesOk, "inconsistent sentence boundaries" );
 408
 409         uno::Reference< text::XMultiTextMarkup > xMulti( rRes.xFlatParagraph, uno::UNO_QUERY );
 410         if (xMulti.is())    // use new API for markups
 411         {
 412             try
 413             {
 414                 // length = number of found errors + 1 sentence markup
 415                 sal_Int32 nErrors = rRes.aErrors.getLength();
 416                 uno::Sequence< text::TextMarkupDescriptor > aDescriptors( nErrors + 1 );
 417                 text::TextMarkupDescriptor * pDescriptors = aDescriptors.getArray();
 418
 419                 // at pos 0 .. nErrors-1 -> all grammar errors
 420                 for (const linguistic2::SingleProofreadingError &rError : rRes.aErrors)
 421                 {
 422                     text::TextMarkupDescriptor &rDesc = *pDescriptors++;
 423
 424                     rDesc.nType   = rError.nErrorType;
 425                     rDesc.nOffset = rError.nErrorStart;
 426                     rDesc.nLength = rError.nErrorLength;
 427
 428                     // the proofreader may return SPELLING but right now our core
 429                     // does only handle PROOFREADING if the result is from the proofreader...
 430                     // (later on we may wish to color spelling errors found by the proofreader
 431                     // differently for example. But no special handling right now.
 432                     if (rDesc.nType == text::TextMarkupType::SPELLCHECK)
 433                         rDesc.nType = text::TextMarkupType::PROOFREADING;
 434
 435                     uno::Reference< container::XStringKeyMap > xKeyMap(
 436                         new LngXStringKeyMap());
 437                     for( const beans::PropertyValue& rProperty : rError.aProperties )
 438                     {
 439                         if ( rProperty.Name == "LineColor" )
 440                         {
 441                             xKeyMap->insertValue(rProperty.Name,
 442                                                  rProperty.Value);
 443                             rDesc.xMarkupInfoContainer = xKeyMap;
 444                         }
 445                         else if ( rProperty.Name == "LineType" )
 446                         {
 447                             xKeyMap->insertValue(rProperty.Name,
 448                                                  rProperty.Value);
 449                             rDesc.xMarkupInfoContainer = xKeyMap;
 450                         }
 451                     }
 452                 }
 453
 454                 // at pos nErrors -> sentence markup
 455                 // nSentenceLength: includes the white-spaces following the sentence end...
 456                 const sal_Int32 nSentenceLength = rRes.nStartOfNextSentencePosition - rRes.nStartOfSentencePosition;
 457                 pDescriptors->nType   = text::TextMarkupType::SENTENCE;
 458                 pDescriptors->nOffset = rRes.nStartOfSentencePosition;
 459                 pDescriptors->nLength = nSentenceLength;
 460
 461                 xMulti->commitMultiTextMarkup( aDescriptors ) ;
 462             }
 463             catch (lang::IllegalArgumentException &)
 464             {
 465                 OSL_FAIL( "commitMultiTextMarkup: IllegalArgumentException exception caught" );
 466             }
 467         }
 468
 469         // other sentences left to be checked in this paragraph?
 470         if (rRes.nStartOfNextSentencePosition < rRes.aText.getLength())
 471         {
 472             AddEntry( rxFlatParagraphIterator, rRes.xFlatParagraph, rRes.aDocumentIdentifier, rRes.nStartOfNextSentencePosition, bIsAutomaticChecking );
 473         }
 474         else    // current paragraph finished
 475         {
 476             // set "already checked" flag for the current flat paragraph
 477             if (rRes.xFlatParagraph.is())
 478                 rRes.xFlatParagraph->setChecked( text::TextMarkupType::PROOFREADING, true );
 479
 480             bContinueWithNextPara = true;
 481         }
 482     }
 483
 484     if (bContinueWithNextPara)
 485     {
 486         // we need to continue with the next paragraph
 487         uno::Reference< text::XFlatParagraph > xFlatParaNext;
 488         if (rxFlatParagraphIterator.is())
 489             xFlatParaNext = rxFlatParagraphIterator->getNextPara();
 490         {
 491             AddEntry( rxFlatParagraphIterator, xFlatParaNext, rRes.aDocumentIdentifier, 0, bIsAutomaticChecking );
 492         }
 493     }
 494 }
 495
 496
 497 uno::Reference< linguistic2::XProofreader > GrammarCheckingIterator::GetGrammarChecker(
 498     const lang::Locale &rLocale )
 499 {
 500     uno::Reference< linguistic2::XProofreader > xRes;
 501
 502     // ---- THREAD SAFE START ----
 503     ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 504
 505     // check supported locales for each grammarchecker if not already done
 506     if (!m_bGCServicesChecked)
 507     {
 508         GetConfiguredGCSvcs_Impl();
 509         m_bGCServicesChecked = true;
 510     }
 511
 512     const LanguageType nLang = LanguageTag::convertToLanguageType( rLocale, false);
 513     GCImplNames_t::const_iterator aLangIt( m_aGCImplNamesByLang.find( nLang ) );
 514     if (aLangIt != m_aGCImplNamesByLang.end())  // matching configured language found?
 515     {
 516         OUString aSvcImplName( aLangIt->second );
 517         GCReferences_t::const_iterator aImplNameIt( m_aGCReferencesByService.find( aSvcImplName ) );
 518         if (aImplNameIt != m_aGCReferencesByService.end())  // matching impl name found?
 519         {
 520             xRes = aImplNameIt->second;
 521         }
 522         else    // the service is to be instantiated here for the first time...
 523         {
 524             try
 525             {
 526                 uno::Reference< uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );
 527                 uno::Reference< linguistic2::XProofreader > xGC(
 528                         xContext->getServiceManager()->createInstanceWithContext(aSvcImplName, xContext),
 529                         uno::UNO_QUERY_THROW );
 530                 uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xGC, uno::UNO_QUERY_THROW );
 531
 532                 if (xSuppLoc->hasLocale( rLocale ))
 533                 {
 534                     m_aGCReferencesByService[ aSvcImplName ] = xGC;
 535                     xRes = xGC;
 536
 537                     uno::Reference< linguistic2::XLinguServiceEventBroadcaster > xBC( xGC, uno::UNO_QUERY );
 538                     if (xBC.is())
 539                         xBC->addLinguServiceEventListener( this );
 540                 }
 541                 else
 542                 {
 543                     SAL_WARN( "linguistic", "grammar checker does not support required locale" );
 544                 }
 545             }
 546             catch (uno::Exception &)
 547             {
 548                 SAL_WARN( "linguistic", "instantiating grammar checker failed" );
 549             }
 550         }
 551     }
 552     // ---- THREAD SAFE END ----
 553
 554     return xRes;
 555 }
 556
 557 static uno::Sequence<beans::PropertyValue>
 558 lcl_makeProperties(uno::Reference<text::XFlatParagraph> const& xFlatPara)
 559 {
 560     uno::Reference<beans::XPropertySet> const xProps(
 561             xFlatPara, uno::UNO_QUERY_THROW);
 562     return comphelper::InitPropertySequence({
 563         { "FieldPositions", xProps->getPropertyValue("FieldPositions") },
 564         { "FootnotePositions", xProps->getPropertyValue("FootnotePositions") }
 565     });
 566 }
 567
 568 void GrammarCheckingIterator::DequeueAndCheck()
 569 {
 570     for (;;)
 571     {
 572         // ---- THREAD SAFE START ----
 573         bool bQueueEmpty = false;
 574         {
 575             ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 576             if (m_bEnd)
 577             {
 578                 break;
 579             }
 580             bQueueEmpty = m_aFPEntriesQueue.empty();
 581         }
 582         // ---- THREAD SAFE END ----
 583
 584         if (!bQueueEmpty)
 585         {
 586             uno::Reference< text::XFlatParagraphIterator > xFPIterator;
 587             uno::Reference< text::XFlatParagraph > xFlatPara;
 588             FPEntry aFPEntryItem;
 589             OUString aCurDocId;
 590             // ---- THREAD SAFE START ----
 591             {
 592                 ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 593                 aFPEntryItem        = m_aFPEntriesQueue.front();
 594                 xFPIterator         = aFPEntryItem.m_xParaIterator;
 595                 xFlatPara           = aFPEntryItem.m_xPara;
 596                 m_aCurCheckedDocId  = aFPEntryItem.m_aDocId;
 597                 aCurDocId = m_aCurCheckedDocId;
 598
 599                 m_aFPEntriesQueue.pop_front();
 600             }
 601             // ---- THREAD SAFE END ----
 602
 603             if (xFlatPara.is() && xFPIterator.is())
 604             {
 605                 try
 606                 {
 607                     OUString aCurTxt( xFlatPara->getText() );
 608                     lang::Locale aCurLocale = lcl_GetPrimaryLanguageOfSentence( xFlatPara, aFPEntryItem.m_nStartIndex );
 609
 610                     const bool bModified = xFlatPara->isModified();
 611                     if (!bModified)
 612                     {
 613                         linguistic2::ProofreadingResult aRes;
 614
 615                         // ---- THREAD SAFE START ----
 616                         {
 617                             osl::ClearableMutexGuard aGuard(MyMutex::get());
 618
 619                             sal_Int32 nStartPos = aFPEntryItem.m_nStartIndex;
 620                             sal_Int32 nSuggestedEnd
 621                                 = GetSuggestedEndOfSentence(aCurTxt, nStartPos, aCurLocale);
 622                             DBG_ASSERT((nSuggestedEnd == 0 && aCurTxt.isEmpty())
 623                                            || nSuggestedEnd > nStartPos,
 624                                        "nSuggestedEndOfSentencePos calculation failed?");
 625
 626                             uno::Reference<linguistic2::XProofreader> xGC =
 627                                 GetGrammarChecker(aCurLocale);
 628                             if (xGC.is())
 629                             {
 630                                 aGuard.clear();
 631                                 uno::Sequence<beans::PropertyValue> const aProps(
 632                                     lcl_makeProperties(xFlatPara));
 633                                 aRes = xGC->doProofreading(aCurDocId, aCurTxt, aCurLocale,
 634                                                            nStartPos, nSuggestedEnd, aProps);
 635
 636                                 //!! work-around to prevent looping if the grammar checker
 637                                 //!! failed to properly identify the sentence end
 638                                 if (aRes.nBehindEndOfSentencePosition <= nStartPos
 639                                     && aRes.nBehindEndOfSentencePosition != nSuggestedEnd)
 640                                 {
 641                                     SAL_WARN(
 642                                         "linguistic",
 643                                         "!! Grammarchecker failed to provide end of sentence !!");
 644                                     aRes.nBehindEndOfSentencePosition = nSuggestedEnd;
 645                                 }
 646
 647                                 aRes.xFlatParagraph = xFlatPara;
 648                                 aRes.nStartOfSentencePosition = nStartPos;
 649                             }
 650                             else
 651                             {
 652                                 // no grammar checker -> no error
 653                                 // but we need to provide the data below in order to continue with the next sentence
 654                                 aRes.aDocumentIdentifier = aCurDocId;
 655                                 aRes.xFlatParagraph = xFlatPara;
 656                                 aRes.aText = aCurTxt;
 657                                 aRes.aLocale = aCurLocale;
 658                                 aRes.nStartOfSentencePosition = nStartPos;
 659                                 aRes.nBehindEndOfSentencePosition = nSuggestedEnd;
 660                             }
 661                             aRes.nStartOfNextSentencePosition
 662                                 = lcl_SkipWhiteSpaces(aCurTxt, aRes.nBehindEndOfSentencePosition);
 663                             aRes.nBehindEndOfSentencePosition = lcl_BacktraceWhiteSpaces(
 664                                 aCurTxt, aRes.nStartOfNextSentencePosition);
 665
 666                             //guard has to be cleared as ProcessResult calls out of this class
 667                         }
 668                         // ---- THREAD SAFE END ----
 669                         ProcessResult( aRes, xFPIterator, aFPEntryItem.m_bAutomatic );
 670                     }
 671                     else
 672                     {
 673                         // the paragraph changed meanwhile... (and maybe is still edited)
 674                         // thus we simply continue to ask for the next to be checked.
 675                         uno::Reference< text::XFlatParagraph > xFlatParaNext( xFPIterator->getNextPara() );
 676                         AddEntry( xFPIterator, xFlatParaNext, aCurDocId, 0, aFPEntryItem.m_bAutomatic );
 677                     }
 678                 }
 679                 catch (css::uno::Exception &)
 680                 {
 681                     TOOLS_WARN_EXCEPTION("linguistic", "GrammarCheckingIterator::DequeueAndCheck ignoring");
 682                 }
 683             }
 684
 685             // ---- THREAD SAFE START ----
 686             {
 687                 ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 688                 m_aCurCheckedDocId.clear();
 689             }
 690             // ---- THREAD SAFE END ----
 691         }
 692         else
 693         {
 694             // ---- THREAD SAFE START ----
 695             {
 696                 ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 697                 if (m_bEnd)
 698                 {
 699                     break;
 700                 }
 701                 // Check queue state again
 702                 if (m_aFPEntriesQueue.empty())
 703                     m_aWakeUpThread.reset();
 704             }
 705             // ---- THREAD SAFE END ----
 706
 707             //if the queue is empty
 708             // IMPORTANT: Don't call condition.wait() with locked
 709             // mutex. Otherwise you would keep out other threads
 710             // to add entries to the queue! A condition is thread-
 711             // safe implemented.
 712             m_aWakeUpThread.wait();
 713         }
 714     }
 715 }
 716
 717
 718 void SAL_CALL GrammarCheckingIterator::startProofreading(
 719     const uno::Reference< ::uno::XInterface > & xDoc,
 720     const uno::Reference< text::XFlatParagraphIteratorProvider > & xIteratorProvider )
 721 {
 722     // get paragraph to start checking with
 723     const bool bAutomatic = true;
 724     uno::Reference<text::XFlatParagraphIterator> xFPIterator = xIteratorProvider->getFlatParagraphIterator(
 725             text::TextMarkupType::PROOFREADING, bAutomatic );
 726     uno::Reference< text::XFlatParagraph > xPara( xFPIterator.is()? xFPIterator->getFirstPara() : nullptr );
 727     uno::Reference< lang::XComponent > xComponent( xDoc, uno::UNO_QUERY );
 728
 729     // ---- THREAD SAFE START ----
 730     ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 731     if (xPara.is() && xComponent.is())
 732     {
 733         OUString aDocId = GetOrCreateDocId( xComponent );
 734
 735         // create new entry and add it to queue
 736         AddEntry( xFPIterator, xPara, aDocId, 0, bAutomatic );
 737     }
 738     // ---- THREAD SAFE END ----
 739 }
 740
 741
 742 linguistic2::ProofreadingResult SAL_CALL GrammarCheckingIterator::checkSentenceAtPosition(
 743     const uno::Reference< uno::XInterface >& xDoc,
 744     const uno::Reference< text::XFlatParagraph >& xFlatPara,
 745     const OUString& rText,
 746     const lang::Locale&,
 747     sal_Int32 nStartOfSentencePos,
 748     sal_Int32 nSuggestedEndOfSentencePos,
 749     sal_Int32 nErrorPosInPara )
 750 {
 751     // for the context menu...
 752
 753     linguistic2::ProofreadingResult aRes;
 754
 755     uno::Reference< lang::XComponent > xComponent( xDoc, uno::UNO_QUERY );
 756     if (xFlatPara.is() && xComponent.is() &&
 757         ( nErrorPosInPara < 0 || nErrorPosInPara < rText.getLength()))
 758     {
 759         // iterate through paragraph until we find the sentence we are interested in
 760         linguistic2::ProofreadingResult aTmpRes;
 761         sal_Int32 nStartPos = nStartOfSentencePos >= 0 ? nStartOfSentencePos : 0;
 762
 763         bool bFound = false;
 764         do
 765         {
 766             lang::Locale aCurLocale = lcl_GetPrimaryLanguageOfSentence( xFlatPara, nStartPos );
 767             sal_Int32 nOldStartOfSentencePos = nStartPos;
 768             uno::Reference< linguistic2::XProofreader > xGC;
 769             OUString aDocId;
 770
 771             // ---- THREAD SAFE START ----
 772             {
 773                 ::osl::ClearableGuard< ::osl::Mutex > aGuard( MyMutex::get() );
 774                 aDocId = GetOrCreateDocId( xComponent );
 775                 nSuggestedEndOfSentencePos = GetSuggestedEndOfSentence( rText, nStartPos, aCurLocale );
 776                 DBG_ASSERT( nSuggestedEndOfSentencePos > nStartPos, "nSuggestedEndOfSentencePos calculation failed?" );
 777
 778                 xGC = GetGrammarChecker( aCurLocale );
 779             }
 780             // ---- THREAD SAFE START ----
 781             sal_Int32 nEndPos = -1;
 782             if (xGC.is())
 783             {
 784                 uno::Sequence<beans::PropertyValue> const aProps(
 785                         lcl_makeProperties(xFlatPara));
 786                 aTmpRes = xGC->doProofreading( aDocId, rText,
 787                     aCurLocale, nStartPos, nSuggestedEndOfSentencePos, aProps );
 788
 789                 //!! work-around to prevent looping if the grammar checker
 790                 //!! failed to properly identify the sentence end
 791                 if (aTmpRes.nBehindEndOfSentencePosition <= nStartPos)
 792                 {
 793                     SAL_WARN( "linguistic", "!! Grammarchecker failed to provide end of sentence !!" );
 794                     aTmpRes.nBehindEndOfSentencePosition = nSuggestedEndOfSentencePos;
 795                 }
 796
 797                 aTmpRes.xFlatParagraph           = xFlatPara;
 798                 aTmpRes.nStartOfSentencePosition = nStartPos;
 799                 nEndPos = aTmpRes.nBehindEndOfSentencePosition;
 800
 801                 if ((nErrorPosInPara< 0 || nStartPos <= nErrorPosInPara) && nErrorPosInPara < nEndPos)
 802                     bFound = true;
 803             }
 804             if (nEndPos == -1) // no result from grammar checker
 805                 nEndPos = nSuggestedEndOfSentencePos;
 806             nStartPos = lcl_SkipWhiteSpaces( rText, nEndPos );
 807             aTmpRes.nBehindEndOfSentencePosition = nEndPos;
 808             aTmpRes.nStartOfNextSentencePosition = nStartPos;
 809             aTmpRes.nBehindEndOfSentencePosition = lcl_BacktraceWhiteSpaces( rText, aTmpRes.nStartOfNextSentencePosition );
 810
 811             // prevent endless loop by forcefully advancing if needs be...
 812             if (nStartPos <= nOldStartOfSentencePos)
 813             {
 814                 SAL_WARN( "linguistic", "end-of-sentence detection failed?" );
 815                 nStartPos = nOldStartOfSentencePos + 1;
 816             }
 817         }
 818         while (!bFound && nStartPos < rText.getLength());
 819
 820         if (bFound && !xFlatPara->isModified())
 821             aRes = aTmpRes;
 822     }
 823
 824     return aRes;
 825 }
 826
 827
 828 sal_Int32 GrammarCheckingIterator::GetSuggestedEndOfSentence(
 829     const OUString &rText,
 830     sal_Int32 nSentenceStartPos,
 831     const lang::Locale &rLocale )
 832 {
 833     // internal method; will always be called with locked mutex
 834
 835     if (!m_xBreakIterator.is())
 836     {
 837         uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 838         m_xBreakIterator = i18n::BreakIterator::create(xContext);
 839     }
 840     sal_Int32 nTextLen = rText.getLength();
 841     sal_Int32 nEndPosition(0);
 842     sal_Int32 nTmpStartPos = nSentenceStartPos;
 843     do
 844     {
 845         sal_Int32 const nPrevEndPosition(nEndPosition);
 846         nEndPosition = nTextLen;
 847         if (nTmpStartPos < nTextLen)
 848         {
 849             nEndPosition = m_xBreakIterator->endOfSentence( rText, nTmpStartPos, rLocale );
 850             if (nEndPosition <= nPrevEndPosition)
 851             {
 852                 // fdo#68750 if there's no progress at all then presumably
 853                 // there's no end of sentence in this paragraph so just
 854                 // set the end position to end of paragraph
 855                 nEndPosition = nTextLen;
 856             }
 857         }
 858         if (nEndPosition < 0)
 859             nEndPosition = nTextLen;
 860
 861         ++nTmpStartPos;
 862     }
 863     while (nEndPosition <= nSentenceStartPos && nEndPosition < nTextLen);
 864     if (nEndPosition > nTextLen)
 865         nEndPosition = nTextLen;
 866     return nEndPosition;
 867 }
 868
 869
 870 void SAL_CALL GrammarCheckingIterator::resetIgnoreRules(  )
 871 {
 872     for (auto const& elem : m_aGCReferencesByService)
 873     {
 874         uno::Reference< linguistic2::XProofreader > xGC(elem.second);
 875         if (xGC.is())
 876             xGC->resetIgnoreRules();
 877     }
 878 }
 879
 880
 881 sal_Bool SAL_CALL GrammarCheckingIterator::isProofreading(
 882     const uno::Reference< uno::XInterface >& xDoc )
 883 {
 884     // ---- THREAD SAFE START ----
 885     ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 886
 887     bool bRes = false;
 888
 889     uno::Reference< lang::XComponent > xComponent( xDoc, uno::UNO_QUERY );
 890     if (xComponent.is())
 891     {
 892         // if the component was already used in one of the two calls to check text
 893         // i.e. in startGrammarChecking or checkGrammarAtPos it will be found in the
 894         // m_aDocIdMap unless the document already disposed.
 895         // If it is not found then it is not yet being checked (or requested to being checked)
 896         const DocMap_t::const_iterator aIt( m_aDocIdMap.find( xComponent.get() ) );
 897         if (aIt != m_aDocIdMap.end())
 898         {
 899             // check in document is checked automatically in the background...
 900             OUString aDocId = aIt->second;
 901             if (!m_aCurCheckedDocId.isEmpty() && m_aCurCheckedDocId == aDocId)
 902             {
 903                 // an entry for that document was dequeued and is currently being checked.
 904                 bRes = true;
 905             }
 906             else
 907             {
 908                 // we need to check if there is an entry for that document in the queue...
 909                 // That is the document is going to be checked sooner or later.
 910
 911                 sal_Int32 nSize = m_aFPEntriesQueue.size();
 912                 for (sal_Int32 i = 0; i < nSize && !bRes; ++i)
 913                 {
 914                     if (aDocId == m_aFPEntriesQueue[i].m_aDocId)
 915                         bRes = true;
 916                 }
 917             }
 918         }
 919     }
 920     // ---- THREAD SAFE END ----
 921
 922     return bRes;
 923 }
 924
 925
 926 void SAL_CALL GrammarCheckingIterator::processLinguServiceEvent(
 927     const linguistic2::LinguServiceEvent& rLngSvcEvent )
 928 {
 929     if (rLngSvcEvent.nEvent == linguistic2::LinguServiceEventFlags::PROOFREAD_AGAIN)
 930     {
 931         try
 932         {
 933              uno::Reference< uno::XInterface > xThis( static_cast< OWeakObject * >(this) );
 934              linguistic2::LinguServiceEvent aEvent( xThis, linguistic2::LinguServiceEventFlags::PROOFREAD_AGAIN );
 935              m_aNotifyListeners.notifyEach(
 936                     &linguistic2::XLinguServiceEventListener::processLinguServiceEvent,
 937                     aEvent);
 938         }
 939         catch (uno::RuntimeException &)
 940         {
 941              throw;
 942         }
 943         catch (const ::uno::Exception &)
 944         {
 945             // ignore
 946             TOOLS_WARN_EXCEPTION("linguistic", "processLinguServiceEvent");
 947         }
 948     }
 949 }
 950
 951
 952 sal_Bool SAL_CALL GrammarCheckingIterator::addLinguServiceEventListener(
 953     const uno::Reference< linguistic2::XLinguServiceEventListener >& xListener )
 954 {
 955     if (xListener.is())
 956     {
 957         m_aNotifyListeners.addInterface( xListener );
 958     }
 959     return true;
 960 }
 961
 962
 963 sal_Bool SAL_CALL GrammarCheckingIterator::removeLinguServiceEventListener(
 964     const uno::Reference< linguistic2::XLinguServiceEventListener >& xListener )
 965 {
 966     if (xListener.is())
 967     {
 968         m_aNotifyListeners.removeInterface( xListener );
 969     }
 970     return true;
 971 }
 972
 973
 974 void SAL_CALL GrammarCheckingIterator::dispose()
 975 {
 976     lang::EventObject aEvt( static_cast<linguistic2::XProofreadingIterator *>(this) );
 977     m_aEventListeners.disposeAndClear( aEvt );
 978
 979     TerminateThread();
 980
 981     // ---- THREAD SAFE START ----
 982     {
 983         ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
 984
 985         // release all UNO references
 986
 987         m_xBreakIterator.clear();
 988
 989         // clear containers with UNO references AND have those references released
 990         GCReferences_t  aTmpEmpty1;
 991         DocMap_t        aTmpEmpty2;
 992         FPQueue_t       aTmpEmpty3;
 993         m_aGCReferencesByService.swap( aTmpEmpty1 );
 994         m_aDocIdMap.swap( aTmpEmpty2 );
 995         m_aFPEntriesQueue.swap( aTmpEmpty3 );
 996     }
 997     // ---- THREAD SAFE END ----
 998 }
 999
1000
1001 void SAL_CALL GrammarCheckingIterator::addEventListener(
1002     const uno::Reference< lang::XEventListener >& xListener )
1003 {
1004     if (xListener.is())
1005     {
1006         m_aEventListeners.addInterface( xListener );
1007     }
1008 }
1009
1010
1011 void SAL_CALL GrammarCheckingIterator::removeEventListener(
1012     const uno::Reference< lang::XEventListener >& xListener )
1013 {
1014     if (xListener.is())
1015     {
1016         m_aEventListeners.removeInterface( xListener );
1017     }
1018 }
1019
1020
1021 void SAL_CALL GrammarCheckingIterator::disposing( const lang::EventObject &rSource )
1022 {
1023     // if the component (document) is disposing release all references
1024     //!! There is no need to remove entries from the queue that are from this document
1025     //!! since the respectives xFlatParagraphs should become invalid (isModified() == true)
1026     //!! and the call to xFlatParagraphIterator->getNextPara() will result in an empty reference.
1027     //!! And if an entry is currently checked by a grammar checker upon return the results
1028     //!! should be ignored.
1029     //!! Also GetOrCreateDocId will not use that very same Id again...
1030     //!! All of the above resulting in that we only have to get rid of the implementation pointer here.
1031     uno::Reference< lang::XComponent > xDoc( rSource.Source, uno::UNO_QUERY );
1032     if (xDoc.is())
1033     {
1034         // ---- THREAD SAFE START ----
1035         ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
1036         m_aDocIdMap.erase( xDoc.get() );
1037         // ---- THREAD SAFE END ----
1038     }
1039 }
1040
1041
1042 uno::Reference< util::XChangesBatch > const & GrammarCheckingIterator::GetUpdateAccess() const
1043 {
1044     if (!m_xUpdateAccess.is())
1045     {
1046         try
1047         {
1048             // get configuration provider
1049             uno::Reference< uno::XComponentContext > xContext = comphelper::getProcessComponentContext();
1050             uno::Reference< lang::XMultiServiceFactory > xConfigurationProvider =
1051                     configuration::theDefaultProvider::get( xContext );
1052
1053             // get configuration update access
1054             beans::PropertyValue aValue;
1055             aValue.Name  = "nodepath";
1056             aValue.Value <<= OUString("org.openoffice.Office.Linguistic/ServiceManager");
1057             uno::Sequence< uno::Any > aProps(1);
1058             aProps[0] <<= aValue;
1059             m_xUpdateAccess.set(
1060                     xConfigurationProvider->createInstanceWithArguments(
1061                         "com.sun.star.configuration.ConfigurationUpdateAccess", aProps ),
1062                         uno::UNO_QUERY_THROW );
1063         }
1064         catch (uno::Exception &)
1065         {
1066         }
1067     }
1068
1069     return m_xUpdateAccess;
1070 }
1071
1072
1073 void GrammarCheckingIterator::GetConfiguredGCSvcs_Impl()
1074 {
1075     GCImplNames_t   aTmpGCImplNamesByLang;
1076
1077     try
1078     {
1079         // get node names (locale iso strings) for configured grammar checkers
1080         uno::Reference< container::XNameAccess > xNA( GetUpdateAccess(), uno::UNO_QUERY_THROW );
1081         xNA.set( xNA->getByName( "GrammarCheckerList" ), uno::UNO_QUERY_THROW );
1082         const uno::Sequence< OUString > aElementNames( xNA->getElementNames() );
1083
1084         for (const OUString& rElementName : aElementNames)
1085         {
1086             uno::Sequence< OUString > aImplNames;
1087             uno::Any aTmp( xNA->getByName( rElementName ) );
1088             if (aTmp >>= aImplNames)
1089             {
1090                 if (aImplNames.hasElements())
1091                 {
1092                     // only the first entry is used, there should be only one grammar checker per language
1093                     const OUString aImplName( aImplNames[0] );
1094                     const LanguageType nLang = LanguageTag::convertToLanguageType( rElementName );
1095                     aTmpGCImplNamesByLang[ nLang ] = aImplName;
1096                 }
1097             }
1098             else
1099             {
1100                 SAL_WARN( "linguistic", "failed to get aImplNames. Wrong type?" );
1101             }
1102         }
1103     }
1104     catch (uno::Exception const &)
1105     {
1106         TOOLS_WARN_EXCEPTION( "linguistic", "exception caught. Failed to get configured services" );
1107     }
1108
1109     {
1110         // ---- THREAD SAFE START ----
1111         ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
1112         m_aGCImplNamesByLang     = aTmpGCImplNamesByLang;
1113         // ---- THREAD SAFE END ----
1114     }
1115 }
1116
1117
1118 sal_Bool SAL_CALL GrammarCheckingIterator::supportsService(
1119     const OUString & rServiceName )
1120 {
1121     return cppu::supportsService(this, rServiceName);
1122 }
1123
1124
1125 OUString SAL_CALL GrammarCheckingIterator::getImplementationName(  )
1126 {
1127     return GrammarCheckingIterator_getImplementationName();
1128 }
1129
1130
1131 uno::Sequence< OUString > SAL_CALL GrammarCheckingIterator::getSupportedServiceNames(  )
1132 {
1133     return GrammarCheckingIterator_getSupportedServiceNames();
1134 }
1135
1136
1137 void GrammarCheckingIterator::SetServiceList(
1138     const lang::Locale &rLocale,
1139     const uno::Sequence< OUString > &rSvcImplNames )
1140 {
1141     ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
1142
1143     LanguageType nLanguage = LinguLocaleToLanguage( rLocale );
1144     OUString aImplName;
1145     if (rSvcImplNames.hasElements())
1146         aImplName = rSvcImplNames[0];   // there is only one grammar checker per language
1147
1148     if (!LinguIsUnspecified(nLanguage) && nLanguage != LANGUAGE_DONTKNOW)
1149     {
1150         if (!aImplName.isEmpty())
1151             m_aGCImplNamesByLang[ nLanguage ] = aImplName;
1152         else
1153             m_aGCImplNamesByLang.erase( nLanguage );
1154     }
1155 }
1156
1157
1158 uno::Sequence< OUString > GrammarCheckingIterator::GetServiceList(
1159     const lang::Locale &rLocale ) const
1160 {
1161     ::osl::Guard< ::osl::Mutex > aGuard( MyMutex::get() );
1162
1163     uno::Sequence< OUString > aRes(1);
1164
1165     OUString aImplName;     // there is only one grammar checker per language
1166     LanguageType nLang  = LinguLocaleToLanguage( rLocale );
1167     GCImplNames_t::const_iterator aIt( m_aGCImplNamesByLang.find( nLang ) );
1168     if (aIt != m_aGCImplNamesByLang.end())
1169         aImplName = aIt->second;
1170
1171     if (!aImplName.isEmpty())
1172         aRes[0] = aImplName;
1173     else
1174         aRes.realloc(0);
1175
1176     return aRes;
1177 }
1178
1179
1180 static OUString GrammarCheckingIterator_getImplementationName() throw()
1181 {
1182     return "com.sun.star.lingu2.ProofreadingIterator";
1183 }
1184
1185
1186 static uno::Sequence< OUString > GrammarCheckingIterator_getSupportedServiceNames() throw()
1187 {
1188     return { "com.sun.star.linguistic2.ProofreadingIterator" };
1189 }
1190
1191 /// @throws uno::Exception
1192 static uno::Reference< uno::XInterface > GrammarCheckingIterator_createInstance(
1193     const uno::Reference< lang::XMultiServiceFactory > & /*rxSMgr*/ )
1194 {
1195     return static_cast< ::cppu::OWeakObject * >(new GrammarCheckingIterator());
1196 }
1197
1198
1199 void * GrammarCheckingIterator_getFactory(
1200     const sal_Char *pImplName,
1201     lang::XMultiServiceFactory *pServiceManager )
1202 {
1203     void * pRet = nullptr;
1204     if ( GrammarCheckingIterator_getImplementationName().equalsAscii( pImplName ) )
1205     {
1206         uno::Reference< lang::XSingleServiceFactory > xFactory =
1207             cppu::createOneInstanceFactory(
1208                 pServiceManager,
1209                 GrammarCheckingIterator_getImplementationName(),
1210                 GrammarCheckingIterator_createInstance,
1211                 GrammarCheckingIterator_getSupportedServiceNames());
1212         // acquire, because we return an interface pointer instead of a reference
1213         xFactory->acquire();
1214         pRet = xFactory.get();
1215     }
1216     return pRet;
1217 }
1218
1219 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */