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