vcl/source/window/mnemonic.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
  21 #include <string.h>
  22 #include <vcl/svapp.hxx>
  23 #include <vcl/settings.hxx>
  24 #include <vcl/mnemonic.hxx>
  25
  26 #include <vcl/unohelp.hxx>
  27 #include <com/sun/star/i18n/XCharacterClassification.hpp>
  28 #include <i18nlangtag/mslangid.hxx>
  29
  30 using namespace ::com::sun::star;
  31
  32
  33 // =======================================================================
  34
  35 MnemonicGenerator::MnemonicGenerator()
  36 {
  37     memset( maMnemonics, 1, sizeof( maMnemonics ) );
  38 }
  39
  40 // -----------------------------------------------------------------------
  41
  42 sal_uInt16 MnemonicGenerator::ImplGetMnemonicIndex( sal_Unicode c )
  43 {
  44     static sal_uInt16 const aImplMnemonicRangeTab[MNEMONIC_RANGES*2] =
  45     {
  46         MNEMONIC_RANGE_1_START, MNEMONIC_RANGE_1_END,
  47         MNEMONIC_RANGE_2_START, MNEMONIC_RANGE_2_END,
  48         MNEMONIC_RANGE_3_START, MNEMONIC_RANGE_3_END,
  49         MNEMONIC_RANGE_4_START, MNEMONIC_RANGE_4_END
  50     };
  51
  52     sal_uInt16 nMnemonicIndex = 0;
  53     for ( sal_uInt16 i = 0; i < MNEMONIC_RANGES; i++ )
  54     {
  55         if ( (c >= aImplMnemonicRangeTab[i*2]) &&
  56              (c <= aImplMnemonicRangeTab[i*2+1]) )
  57             return nMnemonicIndex+c-aImplMnemonicRangeTab[i*2];
  58
  59         nMnemonicIndex += aImplMnemonicRangeTab[i*2+1]-aImplMnemonicRangeTab[i*2];
  60     }
  61
  62     return MNEMONIC_INDEX_NOTFOUND;
  63 }
  64
  65 // -----------------------------------------------------------------------
  66
  67 sal_Unicode MnemonicGenerator::ImplFindMnemonic( const OUString& rKey )
  68 {
  69     sal_Int32 nIndex = 0;
  70     while ( (nIndex = rKey.indexOf( MNEMONIC_CHAR, nIndex )) != -1 )
  71     {
  72         sal_Unicode cMnemonic = rKey[ nIndex+1 ];
  73         if ( cMnemonic != MNEMONIC_CHAR )
  74             return cMnemonic;
  75         nIndex += 2;
  76     }
  77
  78     return 0;
  79 }
  80
  81 // -----------------------------------------------------------------------
  82
  83 void MnemonicGenerator::RegisterMnemonic( const OUString& rKey )
  84 {
  85     const ::com::sun::star::lang::Locale& rLocale = Application::GetSettings().GetUILanguageTag().getLocale();
  86     uno::Reference < i18n::XCharacterClassification > xCharClass = GetCharClass();
  87
  88     // Don't crash even when we don't have access to i18n service
  89     if ( !xCharClass.is() )
  90         return;
  91
  92     OUString aKey = xCharClass->toUpper( rKey, 0, rKey.getLength(), rLocale );
  93
  94     // If we find a Mnemonic, set the flag. In other case count the
  95     // characters, because we need this to set most as possible
  96     // Mnemonics
  97     sal_Unicode cMnemonic = ImplFindMnemonic( aKey );
  98     if ( cMnemonic )
  99     {
 100         sal_uInt16 nMnemonicIndex = ImplGetMnemonicIndex( cMnemonic );
 101         if ( nMnemonicIndex != MNEMONIC_INDEX_NOTFOUND )
 102             maMnemonics[nMnemonicIndex] = 0;
 103     }
 104     else
 105     {
 106         sal_Int32 nIndex = 0;
 107         sal_Int32 nLen = aKey.getLength();
 108         while ( nIndex < nLen )
 109         {
 110             sal_Unicode c = aKey[ nIndex ];
 111
 112             sal_uInt16 nMnemonicIndex = ImplGetMnemonicIndex( c );
 113             if ( nMnemonicIndex != MNEMONIC_INDEX_NOTFOUND )
 114             {
 115                 if ( maMnemonics[nMnemonicIndex] && (maMnemonics[nMnemonicIndex] < 0xFF) )
 116                     maMnemonics[nMnemonicIndex]++;
 117             }
 118
 119             nIndex++;
 120         }
 121     }
 122 }
 123
 124 // -----------------------------------------------------------------------
 125
 126 OUString MnemonicGenerator::CreateMnemonic( const OUString& _rKey )
 127 {
 128     if ( _rKey.isEmpty() || ImplFindMnemonic( _rKey ) )
 129         return _rKey;
 130
 131     const ::com::sun::star::lang::Locale& rLocale = Application::GetSettings().GetUILanguageTag().getLocale();
 132     uno::Reference < i18n::XCharacterClassification > xCharClass = GetCharClass();
 133
 134     // Don't crash even when we don't have access to i18n service
 135     if ( !xCharClass.is() )
 136         return _rKey;
 137
 138     OUString aKey = xCharClass->toUpper( _rKey, 0, _rKey.getLength(), rLocale );
 139
 140     sal_Bool bChanged = sal_False;
 141     sal_Int32 nLen = aKey.getLength();
 142
 143     bool bCJK = MsLangId::isCJK(Application::GetSettings().GetUILanguageTag().getLanguageType());
 144
 145     // #107889# in CJK versions ALL strings (even those that contain latin characters)
 146     // will get mnemonics in the form: xyz (M)
 147     // thus steps 1) and 2) are skipped for CJK locales
 148
 149     // #110720#, avoid CJK-style mnemonics for latin-only strings that do not contain useful mnemonic chars
 150     if( bCJK )
 151     {
 152         bool bLatinOnly = true;
 153         bool bMnemonicIndexFound = false;
 154         sal_Unicode     c;
 155         sal_Int32       nIndex;
 156
 157         for( nIndex=0; nIndex < nLen; nIndex++ )
 158         {
 159             c = aKey[ nIndex ];
 160             if ( ((c >= 0x3000) && (c <= 0xD7FF)) ||    // cjk
 161                  ((c >= 0xFF61) && (c <= 0xFFDC)) )     // halfwidth forms
 162             {
 163                 bLatinOnly = false;
 164                 break;
 165             }
 166             if( ImplGetMnemonicIndex( c ) != MNEMONIC_INDEX_NOTFOUND )
 167                 bMnemonicIndexFound = true;
 168         }
 169         if( bLatinOnly && !bMnemonicIndexFound )
 170             return _rKey;
 171     }
 172
 173     OUString        rKey(_rKey);
 174     int             nCJK = 0;
 175     sal_uInt16      nMnemonicIndex;
 176     sal_Unicode     c;
 177     sal_Int32       nIndex = 0;
 178     if( !bCJK )
 179     {
 180         // 1) first try the first character of a word
 181         do
 182         {
 183             c = aKey[ nIndex ];
 184
 185             if ( nCJK != 2 )
 186             {
 187                 if ( ((c >= 0x3000) && (c <= 0xD7FF)) ||    // cjk
 188                     ((c >= 0xFF61) && (c <= 0xFFDC)) )     // halfwidth forms
 189                     nCJK = 1;
 190                 else if ( ((c >= 0x0030) && (c <= 0x0039)) || // digits
 191                         ((c >= 0x0041) && (c <= 0x005A)) || // latin capitals
 192                         ((c >= 0x0061) && (c <= 0x007A)) || // latin small
 193                         ((c >= 0x0370) && (c <= 0x037F)) || // greek numeral signs
 194                         ((c >= 0x0400) && (c <= 0x04FF)) )  // cyrillic
 195                     nCJK = 2;
 196             }
 197
 198             nMnemonicIndex = ImplGetMnemonicIndex( c );
 199             if ( nMnemonicIndex != MNEMONIC_INDEX_NOTFOUND )
 200             {
 201                 if ( maMnemonics[nMnemonicIndex] )
 202                 {
 203                     maMnemonics[nMnemonicIndex] = 0;
 204                     rKey = rKey.replaceAt( nIndex, 0, OUString(MNEMONIC_CHAR) );
 205                     bChanged = sal_True;
 206                     break;
 207                 }
 208             }
 209
 210             // Search for next word
 211             nIndex++;
 212             while ( nIndex < nLen )
 213             {
 214                 c = aKey[ nIndex ];
 215                 if ( c == ' ' )
 216                     break;
 217                 nIndex++;
 218             }
 219             nIndex++;
 220         }
 221         while ( nIndex < nLen );
 222
 223         // 2) search for a unique/uncommon character
 224         if ( !bChanged )
 225         {
 226             sal_uInt16      nBestCount = 0xFFFF;
 227             sal_uInt16      nBestMnemonicIndex = 0;
 228             sal_Int32       nBestIndex = 0;
 229             nIndex = 0;
 230             do
 231             {
 232                 c = aKey[ nIndex ];
 233                 nMnemonicIndex = ImplGetMnemonicIndex( c );
 234                 if ( nMnemonicIndex != MNEMONIC_INDEX_NOTFOUND )
 235                 {
 236                     if ( maMnemonics[nMnemonicIndex] )
 237                     {
 238                         if ( maMnemonics[nMnemonicIndex] < nBestCount )
 239                         {
 240                             nBestCount = maMnemonics[nMnemonicIndex];
 241                             nBestIndex = nIndex;
 242                             nBestMnemonicIndex = nMnemonicIndex;
 243                             if ( nBestCount == 2 )
 244                                 break;
 245                         }
 246                     }
 247                 }
 248
 249                 nIndex++;
 250             }
 251             while ( nIndex < nLen );
 252
 253             if ( nBestCount != 0xFFFF )
 254             {
 255                 maMnemonics[nBestMnemonicIndex] = 0;
 256                 rKey = rKey.replaceAt( nBestIndex, 0, OUString(MNEMONIC_CHAR) );
 257                 bChanged = sal_True;
 258             }
 259         }
 260     }
 261     else
 262         nCJK = 1;
 263
 264     // 3) Add English Mnemonic for CJK Text
 265     if ( !bChanged && (nCJK == 1) && !rKey.isEmpty() )
 266     {
 267         // Append Ascii Mnemonic
 268         for ( c = MNEMONIC_RANGE_2_START; c <= MNEMONIC_RANGE_2_END; c++ )
 269         {
 270             nMnemonicIndex = ImplGetMnemonicIndex( c );
 271             if ( nMnemonicIndex != MNEMONIC_INDEX_NOTFOUND )
 272             {
 273                 if ( maMnemonics[nMnemonicIndex] )
 274                 {
 275                     maMnemonics[nMnemonicIndex] = 0;
 276                     OUString aStr = OUStringBuffer().
 277                         append('(').append(MNEMONIC_CHAR).append(c).
 278                         append(')').makeStringAndClear();
 279                     nIndex = rKey.getLength();
 280                     if( nIndex >= 2 )
 281                     {
 282                         if ( ( rKey[nIndex-2] == '>'    && rKey[nIndex-1] == '>' ) ||
 283                              ( rKey[nIndex-2] == 0xFF1E && rKey[nIndex-1] == 0xFF1E ) )
 284                             nIndex -= 2;
 285                     }
 286                     if( nIndex >= 3 )
 287                     {
 288                         if ( ( rKey[nIndex-3] == '.'    && rKey[nIndex-2] == '.'    && rKey[nIndex-1] == '.' ) ||
 289                              ( rKey[nIndex-3] == 0xFF0E && rKey[nIndex-2] == 0xFF0E && rKey[nIndex-1] == 0xFF0E ) )
 290                             nIndex -= 3;
 291                     }
 292                     if( nIndex >= 1)
 293                     {
 294                         sal_Unicode cLastChar = rKey[ nIndex-1 ];
 295                         if ( (cLastChar == ':') || (cLastChar == 0xFF1A) ||
 296                             (cLastChar == '.') || (cLastChar == 0xFF0E) ||
 297                             (cLastChar == '?') || (cLastChar == 0xFF1F) ||
 298                             (cLastChar == ' ') )
 299                             nIndex--;
 300                     }
 301                     rKey = rKey.replaceAt( nIndex, 0, aStr );
 302                     bChanged = sal_True;
 303                     break;
 304                 }
 305             }
 306         }
 307     }
 308
 309 // #i87415# Duplicates mnemonics are bad for consistent keyboard accessibility
 310 // It's probably better to not have mnemonics for some widgets, than to have ambiguous ones.
 311 //    if( ! bChanged )
 312 //    {
 313 //        /*
 314 //         *  #97809# if all else fails use the first character of a word
 315 //         *  anyway and live with duplicate mnemonics
 316 //         */
 317 //        nIndex = 0;
 318 //        do
 319 //        {
 320 //            c = aKey.GetChar( nIndex );
 321 //
 322 //            nMnemonicIndex = ImplGetMnemonicIndex( c );
 323 //            if ( nMnemonicIndex != MNEMONIC_INDEX_NOTFOUND )
 324 //            {
 325 //                maMnemonics[nMnemonicIndex] = 0;
 326 //                rKey.Insert( MNEMONIC_CHAR, nIndex );
 327 //                bChanged = sal_True;
 328 //                break;
 329 //            }
 330 //
 331 //            // Search for next word
 332 //            do
 333 //            {
 334 //                nIndex++;
 335 //                c = aKey.GetChar( nIndex );
 336 //                if ( c == ' ' )
 337 //                    break;
 338 //            }
 339 //            while ( nIndex < nLen );
 340 //            nIndex++;
 341 //        }
 342 //        while ( nIndex < nLen );
 343 //    }
 344
 345     return rKey;
 346 }
 347
 348 // -----------------------------------------------------------------------
 349
 350 uno::Reference< i18n::XCharacterClassification > MnemonicGenerator::GetCharClass()
 351 {
 352     if ( !mxCharClass.is() )
 353         mxCharClass = vcl::unohelper::CreateCharacterClassification();
 354     return mxCharClass;
 355 }
 356
 357 // -----------------------------------------------------------------------
 358
 359 OUString MnemonicGenerator::EraseAllMnemonicChars( const OUString& rStr )
 360 {
 361     OUString    aStr = rStr;
 362     sal_Int32   nLen = aStr.getLength();
 363     sal_Int32   i    = 0;
 364
 365     while ( i < nLen )
 366     {
 367         if ( aStr[ i ] == '~' )
 368         {
 369             // check for CJK-style mnemonic
 370             if( i > 0 && (i+2) < nLen )
 371             {
 372                 sal_Unicode c = aStr[i+1];
 373                 if( aStr[ i-1 ] == '(' &&
 374                     aStr[ i+2 ] == ')' &&
 375                     c >= MNEMONIC_RANGE_2_START && c <= MNEMONIC_RANGE_2_END )
 376                 {
 377                     aStr = aStr.replaceAt( i-1, 4, "" );
 378                     nLen -= 4;
 379                     i--;
 380                     continue;
 381                 }
 382             }
 383
 384             // remove standard mnemonics
 385             aStr = aStr.replaceAt( i, 1, "" );
 386             nLen--;
 387         }
 388         else
 389             i++;
 390     }
 391
 392     return aStr;
 393 }
 394
 395 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */