odk/examples/DevelopersGuide/OfficeDev/Linguistic/SampleSpellChecker.java

   1 /* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  the BSD license.
   6  *
   7  *  Copyright 2000, 2010 Oracle and/or its affiliates.
   8  *  All rights reserved.
   9  *
  10  *  Redistribution and use in source and binary forms, with or without
  11  *  modification, are permitted provided that the following conditions
  12  *  are met:
  13  *  1. Redistributions of source code must retain the above copyright
  14  *     notice, this list of conditions and the following disclaimer.
  15  *  2. Redistributions in binary form must reproduce the above copyright
  16  *     notice, this list of conditions and the following disclaimer in the
  17  *     documentation and/or other materials provided with the distribution.
  18  *  3. Neither the name of Sun Microsystems, Inc. nor the names of its
  19  *     contributors may be used to endorse or promote products derived
  20  *     from this software without specific prior written permission.
  21  *
  22  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  26  *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  29  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  30  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  31  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  32  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  *
  34  *************************************************************************/
  35
  36 // uno
  37 import com.sun.star.lib.uno.helper.ComponentBase;
  38 import com.sun.star.uno.UnoRuntime;
  39
  40 // factories
  41 import com.sun.star.lang.XSingleComponentFactory;
  42
  43 // supported Interfaces
  44 import com.sun.star.linguistic2.XSpellChecker;
  45 import com.sun.star.linguistic2.XLinguServiceEventBroadcaster;
  46 import com.sun.star.lang.XInitialization;
  47 import com.sun.star.lang.XServiceInfo;
  48 import com.sun.star.lang.XServiceDisplayName;
  49
  50 // Exceptions
  51 import com.sun.star.uno.Exception;
  52 import com.sun.star.lang.IllegalArgumentException;
  53
  54 //used Interfaces
  55 import com.sun.star.linguistic2.XLinguServiceEventListener;
  56 import com.sun.star.linguistic2.XSpellAlternatives;
  57 import com.sun.star.linguistic2.SpellFailure;
  58 import com.sun.star.lang.Locale;
  59 import com.sun.star.beans.XPropertySet;
  60 import com.sun.star.beans.PropertyValue;
  61 import com.sun.star.uno.AnyConverter;
  62 import java.util.ArrayList;
  63
  64 public class SampleSpellChecker extends ComponentBase implements
  65         XSpellChecker,
  66         XLinguServiceEventBroadcaster,
  67         XInitialization,
  68         XServiceDisplayName,
  69         XServiceInfo
  70 {
  71     PropChgHelper_Spell         aPropChgHelper;
  72     ArrayList<?>                   aEvtListeners;
  73     boolean                     bDisposing;
  74
  75     public SampleSpellChecker()
  76     {
  77         // names of relevant properties to be used
  78         String[] aProps = new String[]
  79             {
  80                 "IsIgnoreControlCharacters",
  81                 "IsUseDictionaryList",
  82                 "IsSpellUpperCase",
  83                 "IsSpellWithDigits",
  84             };
  85         aPropChgHelper  = new PropChgHelper_Spell( this, aProps );
  86         aEvtListeners   = new ArrayList<Object>();
  87         bDisposing      = false;
  88     }
  89
  90     private boolean IsEqual( Locale aLoc1, Locale aLoc2 )
  91     {
  92         return aLoc1.Language.equals( aLoc2.Language ) &&
  93                aLoc1.Country .equals( aLoc2.Country )  &&
  94                aLoc1.Variant .equals( aLoc2.Variant );
  95     }
  96
  97     private boolean GetValueToUse(
  98             String          aPropName,
  99             boolean         bDefaultVal,
 100             PropertyValue[] aProps )
 101     {
 102         boolean bRes = bDefaultVal;
 103
 104         try
 105         {
 106             // use temporary value if supplied
 107             for (int i = 0;  i < aProps.length;  ++i)
 108             {
 109                 if (aPropName.equals( aProps[i].Name ))
 110                 {
 111                     Object aObj = aProps[i].Value;
 112                     if (AnyConverter.isBoolean( aObj ))
 113                     {
 114                         bRes = AnyConverter.toBoolean( aObj );
 115                         return bRes;
 116                     }
 117                 }
 118             }
 119
 120             // otherwise use value from property set (if available)
 121             XPropertySet xPropSet = aPropChgHelper.GetPropSet();
 122             if (xPropSet != null)   // should always be the case
 123             {
 124                 Object aObj = xPropSet.getPropertyValue( aPropName );
 125                 if (AnyConverter.isBoolean( aObj ))
 126                     bRes = AnyConverter.toBoolean( aObj );
 127             }
 128         }
 129         catch (Exception e) {
 130             bRes = bDefaultVal;
 131         }
 132
 133         return bRes;
 134     }
 135
 136     private boolean IsUpper( String aWord, Locale aLocale )
 137     {
 138         java.util.Locale aLang = new java.util.Locale(
 139                 aLocale.Language, aLocale.Country, aLocale.Variant );
 140         return aWord.equals( aWord.toUpperCase( aLang ) );
 141     }
 142
 143     private boolean HasDigits( String aWord )
 144     {
 145         int nLen = aWord.length();
 146         for (int i = 0;  i < nLen;  ++i)
 147         {
 148             if (Character.isDigit( aWord.charAt(i) ))
 149                 return true;
 150         }
 151         return false;
 152     }
 153
 154     private short GetSpellFailure(
 155             String aWord,
 156             Locale aLocale,
 157             PropertyValue[] aProperties )
 158     {
 159         short nRes = -1;
 160
 161         //!! This code needs to be replaced by code calling the actual
 162         //!! implementation of your spellchecker
 163         if (IsEqual( aLocale, new Locale( "de", "DE", "" ) ))
 164         {
 165             if (aWord.equals( "Schiffahrt" ))
 166                 nRes = SpellFailure.SPELLING_ERROR;
 167         }
 168         else if (IsEqual( aLocale, new Locale( "en", "US", "" ) ))
 169         {
 170             // words with 'u', 'U' and 'arizona' are defined to be incorrect
 171             boolean bIsValid = !(aWord.indexOf( "u" ) != -1 || aWord.indexOf( "U" ) != -1)
 172                                  && !aWord.equals( "arizona" );
 173
 174             if (!bIsValid)
 175             {
 176                 // default value (no other SpellFailure type is applicable)
 177                 nRes = SpellFailure.SPELLING_ERROR;
 178
 179                 if (aWord.equals( "arizona" ))
 180                     nRes = SpellFailure.CAPTION_ERROR;
 181                 else if (aWord.equals( "house" ))
 182                     nRes = SpellFailure.SPELLING_ERROR;
 183                 else if (aWord.equals( "course" ))
 184                     nRes = SpellFailure.IS_NEGATIVE_WORD;
 185             }
 186         }
 187
 188         return nRes;
 189     }
 190
 191     private XSpellAlternatives GetProposals(
 192             String aWord,
 193             Locale aLocale,
 194             PropertyValue[] aProperties )
 195     {
 196         short    nType = SpellFailure.SPELLING_ERROR;
 197         String[] aProposals = null;
 198
 199         // get values of relevant properties that may be used.
 200         //! The values for 'IsIgnoreControlCharacters' and 'IsUseDictionaryList'
 201         //! are handled by the dispatcher! Thus there is no need to access
 202         //! them here.
 203         boolean bIsSpellWithDigits      = GetValueToUse( "IsSpellWithDigits", false, aProperties );
 204         boolean bIsSpellUpperCase       = GetValueToUse( "IsSpellUpperCase", false, aProperties );
 205
 206         //!! This code needs to be replaced by code calling the actual
 207         //!! implementation of your spellchecker
 208         if (IsEqual( aLocale, new Locale( "de", "DE", "" ) ))
 209         {
 210             if (aWord.equals( "Schiffahrt" ))
 211             {
 212                 nType = SpellFailure.SPELLING_ERROR;
 213                 aProposals = new String[]{ "Schifffahrt" };
 214             }
 215         }
 216         else if (IsEqual( aLocale, new Locale( "en", "US", "" ) ))
 217         {
 218             if (aWord.equals( "arizona" ))
 219             {
 220                 nType = SpellFailure.CAPTION_ERROR;
 221                 aProposals = new String[]{ "Arizona" };
 222             }
 223             else if (aWord.equals( "house" ))
 224             {
 225                 nType = SpellFailure.SPELLING_ERROR;
 226                 aProposals = new String[]{ "horse", "home" };
 227             }
 228             else if (aWord.equals( "course" ))
 229             {
 230                 nType = SpellFailure.IS_NEGATIVE_WORD;
 231                 aProposals = new String[]{ "line", "plan", "approach" };
 232             }
 233         }
 234
 235         // always return a result if word is incorrect,
 236         // proposals may be empty though.
 237         return new XSpellAlternatives_impl( aWord, aLocale,
 238                                             nType, aProposals );
 239     }
 240
 241     // __________ interface methods __________
 242
 243
 244
 245     //XSupportedLocales
 246
 247     public Locale[] getLocales()
 248         throws com.sun.star.uno.RuntimeException
 249     {
 250         Locale aLocales[] =
 251         {
 252             new Locale( "de", "DE", "" ),
 253             new Locale( "en", "US", "" )
 254         };
 255
 256         return aLocales;
 257     }
 258
 259     public boolean hasLocale( Locale aLocale )
 260         throws com.sun.star.uno.RuntimeException
 261     {
 262         boolean bRes = false;
 263         if ( IsEqual( aLocale, new Locale( "de", "DE", "" ) )  ||
 264              IsEqual( aLocale, new Locale( "en", "US", "" ) ))
 265             bRes = true;
 266         return bRes;
 267     }
 268
 269
 270
 271     //XSpellChecker
 272
 273     public boolean isValid(
 274             String aWord, Locale aLocale,
 275             PropertyValue[] aProperties )
 276         throws com.sun.star.uno.RuntimeException,
 277                IllegalArgumentException
 278     {
 279         if (IsEqual( aLocale, new Locale() ) || aWord.length() == 0)
 280             return true;
 281
 282         // linguistic is currently not allowed to throw exceptions
 283         // thus we return null which means 'word cannot be spelled'
 284         if (!hasLocale( aLocale ))
 285             return true;
 286
 287         // get values of relevant properties that may be used.
 288         //! The values for 'IsIgnoreControlCharacters' and 'IsUseDictionaryList'
 289         //! are handled by the dispatcher! Thus there is no need to access
 290         //! them here.
 291         boolean bIsSpellWithDigits      = GetValueToUse( "IsSpellWithDigits", false, aProperties );
 292         boolean bIsSpellUpperCase       = GetValueToUse( "IsSpellUpperCase", false, aProperties );
 293
 294         short nFailure = GetSpellFailure( aWord, aLocale, aProperties );
 295         if (nFailure != -1)
 296         {
 297             // postprocess result for errors that should be ignored
 298             if (   (!bIsSpellUpperCase  && IsUpper( aWord, aLocale ))
 299                 || (!bIsSpellWithDigits && HasDigits( aWord ))
 300             )
 301                 nFailure = -1;
 302         }
 303
 304         return nFailure == -1;
 305     }
 306
 307
 308     public XSpellAlternatives spell(
 309             String aWord, Locale aLocale,
 310             PropertyValue[] aProperties )
 311         throws com.sun.star.uno.RuntimeException,
 312                IllegalArgumentException
 313     {
 314         if (IsEqual( aLocale, new Locale() ) || aWord.length() == 0)
 315             return null;
 316
 317         // linguistic is currently not allowed to throw exceptions
 318         // thus we return null fwhich means 'word cannot be spelled'
 319         if (!hasLocale( aLocale ))
 320             return null;
 321
 322         XSpellAlternatives xRes = null;
 323         if (!isValid( aWord, aLocale, aProperties ))
 324         {
 325             xRes = GetProposals( aWord, aLocale, aProperties );
 326         }
 327         return xRes;
 328     }
 329
 330
 331
 332     //XLinguServiceEventBroadcaster
 333
 334     public boolean addLinguServiceEventListener (
 335             XLinguServiceEventListener xLstnr )
 336         throws com.sun.star.uno.RuntimeException
 337     {
 338         boolean bRes = false;
 339         if (!bDisposing && xLstnr != null)
 340             bRes = aPropChgHelper.addLinguServiceEventListener( xLstnr );
 341         return bRes;
 342     }
 343
 344     public boolean removeLinguServiceEventListener(
 345             XLinguServiceEventListener xLstnr )
 346         throws com.sun.star.uno.RuntimeException
 347     {
 348         boolean bRes = false;
 349         if (!bDisposing && xLstnr != null)
 350             bRes = aPropChgHelper.removeLinguServiceEventListener( xLstnr );
 351         return bRes;
 352     }
 353
 354
 355     // XServiceDisplayName
 356
 357     public String getServiceDisplayName( Locale aLocale )
 358         throws com.sun.star.uno.RuntimeException
 359     {
 360         return "Java Samples";
 361     }
 362
 363
 364     // XInitialization
 365
 366     public void initialize( Object[] aArguments )
 367         throws com.sun.star.uno.Exception,
 368                com.sun.star.uno.RuntimeException
 369     {
 370         int nLen = aArguments.length;
 371         if (2 == nLen)
 372         {
 373             XPropertySet xPropSet = UnoRuntime.queryInterface(
 374                                          XPropertySet.class, aArguments[0]);
 375             // start listening to property changes
 376             aPropChgHelper.AddAsListenerTo( xPropSet );
 377         }
 378     }
 379
 380
 381     // XServiceInfo
 382
 383     public boolean supportsService( String aServiceName )
 384         throws com.sun.star.uno.RuntimeException
 385     {
 386         String[] aServices = getSupportedServiceNames_Static();
 387         int i, nLength = aServices.length;
 388         boolean bResult = false;
 389
 390         for( i = 0; !bResult && i < nLength; ++i )
 391             bResult = aServiceName.equals( aServices[ i ] );
 392
 393         return bResult;
 394     }
 395
 396     public String getImplementationName()
 397         throws com.sun.star.uno.RuntimeException
 398     {
 399         return _aSvcImplName;
 400     }
 401
 402     public String[] getSupportedServiceNames()
 403         throws com.sun.star.uno.RuntimeException
 404     {
 405         return getSupportedServiceNames_Static();
 406     }
 407
 408     // __________ static things __________
 409
 410     public static String _aSvcImplName = SampleSpellChecker.class.getName();
 411
 412     public static String[] getSupportedServiceNames_Static()
 413     {
 414         String[] aResult = { "com.sun.star.linguistic2.SpellChecker" };
 415         return aResult;
 416     }
 417
 418
 419     /**
 420      * Returns a factory for creating the service.
 421      * This method is called by the <code>JavaLoader</code>
 422      * <p>
 423      * @return  returns a <code>XSingleComponentFactory</code> for creating the component
 424      * @param   aImplName     the name of the implementation for which a service is desired
 425      * @see                  com.sun.star.comp.loader.JavaLoader
 426      */
 427     public static XSingleComponentFactory __getComponentFactory(
 428         String aImplName )
 429     {
 430         XSingleComponentFactory xSingleComponentFactory = null;
 431         if( aImplName.equals( _aSvcImplName ) )
 432         {
 433             xSingleComponentFactory = new OneInstanceFactory(
 434                     SampleSpellChecker.class, _aSvcImplName,
 435                     getSupportedServiceNames_Static() );
 436         }
 437         return xSingleComponentFactory;
 438     }
 439 }
 440
 441 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */