linguistic/source/grammarchecker.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: grammarchecker.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #include "precompiled_linguistic.hxx"
  31
  32 #include <sal/config.h>
  33 #include <com/sun/star/uno/XComponentContext.hpp>
  34 #include <cppuhelper/implbase1.hxx>
  35 #include <com/sun/star/linguistic2/XGrammarChecker.hpp>
  36 #include <com/sun/star/i18n/XBreakIterator.hpp>
  37 #include <vcl/unohelp.hxx>
  38 #include <cppuhelper/implbase4.hxx>
  39 #include <com/sun/star/lang/XComponent.hpp>
  40 #include <com/sun/star/lang/XServiceInfo.hpp>
  41 #include "misc.hxx"
  42 #include "defs.hxx"
  43 #include <cppuhelper/factory.hxx>
  44 #include <com/sun/star/registry/XRegistryKey.hpp>
  45 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  46
  47 #include <cppuhelper/interfacecontainer.h>
  48 #include <com/sun/star/container/XContentEnumerationAccess.hpp>
  49 #include <com/sun/star/container/XEnumeration.hpp>
  50 #include <com/sun/star/linguistic2/XSupportedLocales.hpp>
  51 #include <com/sun/star/linguistic2/SingleGrammarError.hpp>
  52 #include <com/sun/star/linguistic2/GrammarCheckingResult.hpp>
  53 #include "lngopt.hxx"
  54 #include <cppuhelper/extract.hxx>
  55 #include <unotools/processfactory.hxx>
  56 #include <map>
  57 #include <com/sun/star/text/TextMarkupType.hpp>
  58
  59 #include "grammarchecker.hxx"
  60
  61 using namespace ::utl;
  62 using namespace ::rtl;
  63 using namespace ::com::sun::star;
  64
  65 ////////////////////////////////////////////////////////////
  66
  67 GrammarChecker::GrammarChecker( /*uno::Reference< uno::XComponentContext > const & context*/ )
  68     /*m_xContext(context)*/
  69 {}
  70
  71 GrammarChecker::~GrammarChecker()
  72 {
  73 }
  74
  75
  76 sal_Bool SAL_CALL GrammarChecker::isSpellChecker() throw (uno::RuntimeException)
  77 {
  78     osl::Guard< osl::Mutex > aGuard(GetMutex());
  79     return sal_False;
  80 }
  81
  82
  83 sal_Bool SAL_CALL GrammarChecker::hasLocale( const lang::Locale & aLocale ) throw (uno::RuntimeException)
  84 {
  85     osl::Guard< osl::Mutex > aGuard(GetMutex());
  86     (void) aLocale;
  87     return sal_False;
  88 }
  89
  90 uno::Sequence< lang::Locale > SAL_CALL GrammarChecker::getLocales(  ) throw (uno::RuntimeException)
  91 {
  92     osl::Guard< osl::Mutex > aGuard(GetMutex());
  93     return uno::Sequence< lang::Locale >();
  94 }
  95
  96
  97 void SAL_CALL GrammarChecker::startDocument(sal_Int32 nDocId)
  98     throw (uno::RuntimeException, lang::IllegalArgumentException)
  99 {
 100     osl::Guard< osl::Mutex > aGuard(GetMutex());
 101     (void) nDocId;
 102 }
 103
 104 void SAL_CALL GrammarChecker::startParagraph(sal_Int32 nDocId)
 105     throw (uno::RuntimeException, lang::IllegalArgumentException)
 106 {
 107     osl::Guard< osl::Mutex > aGuard(GetMutex());
 108     (void) nDocId;
 109 }
 110
 111 void SAL_CALL GrammarChecker::endParagraph( sal_Int32 nDocId )
 112     throw (uno::RuntimeException, lang::IllegalArgumentException)
 113 {
 114     osl::Guard< osl::Mutex > aGuard(GetMutex());
 115     (void) nDocId;
 116 }
 117
 118 void SAL_CALL GrammarChecker::endDocument(sal_Int32 nDocId)
 119     throw (uno::RuntimeException, lang::IllegalArgumentException)
 120 {
 121     osl::Guard< osl::Mutex > aGuard(GetMutex());
 122     (void) nDocId;
 123 }
 124
 125 linguistic2::GrammarCheckingResult SAL_CALL GrammarChecker::doGrammarChecking(
 126         sal_Int32 nDocId,
 127         const rtl::OUString& rText,
 128         const lang::Locale& rLocale,
 129         sal_Int32 nStartOfSentencePos,
 130         sal_Int32 nSuggestedSentenceEndPos,
 131         const uno::Sequence< ::sal_Int32 >& rLanguagePortions,
 132         const uno::Sequence< lang::Locale >& rLanguagePortionsLocales )
 133     throw (lang::IllegalArgumentException, uno::RuntimeException)
 134 {
 135     osl::Guard< osl::Mutex > aGuard(GetMutex());
 136
 137     (void) rLanguagePortions;
 138     (void) rLanguagePortionsLocales;
 139
 140     linguistic2::GrammarCheckingResult  aRes;
 141     aRes.nDocumentId                = nDocId;
 142     aRes.aText                      = rText;
 143     aRes.aLocale                    = rLocale;
 144     aRes.nEndOfSentencePos          = nSuggestedSentenceEndPos;
 145     aRes.xGrammarChecker            = this;
 146     aRes.aGrammarErrors             = GrammarCheckingInDummy( nDocId, rText, rLocale, nStartOfSentencePos, nSuggestedSentenceEndPos );;
 147
 148     return aRes;
 149 }
 150
 151 uno::Sequence< linguistic2::SingleGrammarError > GrammarChecker::GrammarCheckingInDummy(
 152     sal_Int32 nDocId,
 153     const OUString & rFlatParaText,
 154     const lang::Locale & rLocale,
 155     sal_Int32 nStartOfSentencePos,
 156     sal_Int32 nSuggestedSentenceEndPos )
 157 {
 158     (void) nDocId;
 159     (void) rFlatParaText;
 160     (void) rLocale;
 161     (void) nStartOfSentencePos;
 162     (void) nSuggestedSentenceEndPos;
 163
 164
 165     typedef std::map< OUString, uno::Sequence<OUString> > Error_t;
 166     Error_t aError;
 167     uno::Sequence< OUString > aSuggestion(1);
 168     OUString *pSeggestion = aSuggestion.getArray();
 169     pSeggestion[0] = OUString::createFromAscii("Modified");
 170
 171     aError[OUString::createFromAscii("GrammarError")]  = aSuggestion;
 172     aError[OUString::createFromAscii("Grammar Error")] = aSuggestion;
 173
 174     typedef std::vector< linguistic2::SingleGrammarError> ErrorVector_t;
 175     ErrorVector_t aErrorVector;
 176
 177     OUString aText = rFlatParaText.copy( nStartOfSentencePos, nSuggestedSentenceEndPos - nStartOfSentencePos );
 178     sal_Int32 nIndexOf = 0;
 179     for(Error_t::const_iterator it = aError.begin(); it != aError.end(); ++it)
 180     {
 181
 182         while(nIndexOf >= 0)
 183         {
 184             nIndexOf=aText.indexOf(it->first, nIndexOf);
 185             if(nIndexOf > -1)
 186             {
 187                 //error found
 188                 linguistic2::SingleGrammarError aErr;
 189                 aErr.nErrorStart        = nIndexOf + nStartOfSentencePos;
 190                 nIndexOf += it->first.getLength();
 191                 aErr.nErrorLength       = it->first.getLength();
 192                 aErr.nErrorType         = text::TextMarkupType::GRAMMAR;
 193                 aErr.nErrorLevel        = 0;
 194                 aErr.aShortComment      = OUString();
 195                 aErr.aFullComment       = OUString();
 196                 aErr.aNewLocale         = rLocale;
 197                 aErr.aSuggestions       = it->second;
 198
 199                 aErrorVector.push_back( aErr );
 200             }
 201         }
 202         nIndexOf = 0;
 203     }
 204
 205     sal_Int32 nCount = aErrorVector.size();
 206     uno::Sequence< linguistic2::SingleGrammarError > aErrors( nCount );
 207     if( nCount > 0 )
 208     {
 209         linguistic2::SingleGrammarError* pErrors = aErrors.getArray();
 210         for (sal_Int32 i=0; i < nCount; ++i)
 211         {
 212             pErrors[i] = aErrorVector[i];
 213         }
 214     }
 215     return aErrors;
 216 }
 217
 218
 219 sal_Bool SAL_CALL GrammarChecker::hasOptionsDialog(  ) throw (uno::RuntimeException)
 220 {
 221     osl::Guard< osl::Mutex > aGuard(GetMutex());
 222     return sal_False;
 223 }
 224
 225 void SAL_CALL GrammarChecker::runOptionsDialog()
 226     throw (uno::RuntimeException)
 227 {
 228     osl::Guard< osl::Mutex > aGuard(GetMutex());
 229 }
 230
 231 void SAL_CALL GrammarChecker::dispose(  ) throw (uno::RuntimeException)
 232 {
 233     osl::Guard< osl::Mutex > aGuard(GetMutex());
 234 }
 235
 236 void SAL_CALL GrammarChecker::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 237     throw (uno::RuntimeException)
 238 {
 239     osl::Guard< osl::Mutex > aGuard(GetMutex());
 240     (void) xListener;
 241 }
 242
 243 void SAL_CALL GrammarChecker::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 244     throw (uno::RuntimeException)
 245 {
 246     osl::Guard< osl::Mutex > aGuard(GetMutex());
 247     (void) xListener;
 248 }
 249
 250 sal_Bool SAL_CALL GrammarChecker::supportsService( const OUString& ServiceName ) throw(uno::RuntimeException)
 251 {
 252     osl::Guard< osl::Mutex > aGuard(GetMutex());
 253
 254     uno::Sequence< OUString > aSNL = getSupportedServiceNames();
 255     const OUString * pArray = aSNL.getConstArray();
 256     for( INT32 i = 0; i < aSNL.getLength(); ++i )
 257         if( pArray[i] == ServiceName )
 258             return TRUE;
 259     return FALSE;
 260 }
 261
 262 uno::Sequence< OUString > GrammarChecker::getSupportedServiceNames_Static(  ) throw()
 263 {
 264     //osl::Guard< osl::Mutex > aGuard(GetMutex());
 265
 266     uno::Sequence< OUString > aSNS( 1 );        // auch mehr als 1 Service moeglich
 267     aSNS.getArray()[0] = A2OU( "com.sun.star.linguistic2.GrammarChecker" );//SN_LINGU_SERVCICE_MANAGER
 268     return aSNS;
 269 }
 270
 271 uno::Sequence< OUString > SAL_CALL GrammarChecker::getSupportedServiceNames(  ) throw(uno::RuntimeException)
 272 {
 273     osl::Guard< osl::Mutex > aGuard(GetMutex());
 274     return getSupportedServiceNames_Static();
 275 }
 276
 277 OUString SAL_CALL GrammarChecker::getImplementationName(  ) throw(uno::RuntimeException)
 278 {
 279     osl::Guard< osl::Mutex > aGuard(GetMutex());
 280     return getImplementationName_Static();
 281 }
 282
 283 sal_Bool SAL_CALL GrammarChecker_writeInfo( void * /*pServiceManager*/, registry::XRegistryKey * pRegistryKey )
 284 {
 285     try
 286     {
 287         String aImpl( '/' );
 288         aImpl += GrammarChecker::getImplementationName_Static().getStr();
 289         aImpl.AppendAscii( "/UNO/SERVICES" );
 290         uno::Reference< registry::XRegistryKey > xNewKey =
 291             pRegistryKey->createKey( aImpl );
 292         uno::Sequence< OUString > aServices = GrammarChecker::getSupportedServiceNames_Static();
 293         for( INT32 i = 0; i < aServices.getLength(); ++i )
 294             xNewKey->createKey( aServices.getConstArray()[i] );
 295
 296         return sal_True;
 297     }
 298     catch(uno::Exception &)
 299     {
 300         return sal_False;
 301     }
 302 }
 303
 304 uno::Reference< uno::XInterface > SAL_CALL GrammarChecker_CreateInstance(
 305         const uno::Reference< lang::XMultiServiceFactory > & /*rSMgr*/ )
 306     throw(uno::Exception)
 307 {
 308     uno::Reference< uno::XInterface > xService = (cppu::OWeakObject*) new GrammarChecker;
 309     return xService;
 310 }
 311
 312 void * SAL_CALL GrammarChecker_getFactory( const sal_Char * pImplName, lang::XMultiServiceFactory * pServiceManager, void * /*pRegistryKey*/ )
 313 {
 314
 315     void * pRet = 0;
 316     if ( !GrammarChecker::getImplementationName_Static().compareToAscii( pImplName ) )
 317     {
 318         uno::Reference< lang::XSingleServiceFactory > xFactory =
 319             cppu::createOneInstanceFactory(
 320                 pServiceManager,
 321                 GrammarChecker::getImplementationName_Static(),
 322                 GrammarChecker_CreateInstance,
 323                 GrammarChecker::getSupportedServiceNames_Static());
 324         // acquire, because we return an interface pointer instead of a reference
 325         xFactory->acquire();
 326         pRet = xFactory.get();
 327     }
 328     return pRet;
 329 }
 330