|
1 /* |
|
2 * Copyright (c) 2005-2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Implementation for arabic peninput finger hwr |
|
15 * |
|
16 */ |
|
17 |
|
18 //SYSTEM INCLUDE |
|
19 #include <centralrepository.h> |
|
20 #include <settingsinternalcrkeys.h> |
|
21 |
|
22 //FEP INCLUDE |
|
23 #include <aknfeppeninputenums.h> |
|
24 #include <AknFepGlobalEnums.h> |
|
25 #include <AknFepInternalCRKeys.h> |
|
26 |
|
27 //USER INCLUDE |
|
28 #include "peninputfingerhwrarlayout.h" |
|
29 #include "peninputfingerhwrardatastore.h" |
|
30 #include "peninputfingerhwrarengine.h" |
|
31 #include "peninputpluginutils.h" |
|
32 #include "peninputfingerhwrarstoreconstants.h" |
|
33 #include <peninputfingerhwrarwnd.rsg> |
|
34 |
|
35 //CONSTANT DEFINATION HEADER |
|
36 |
|
37 |
|
38 // ---------------------------------------------------------------------------- |
|
39 // Symbian constructor |
|
40 // ---------------------------------------------------------------------------- |
|
41 // |
|
42 CPeninputFingerHwrArDataStore* CPeninputFingerHwrArDataStore::NewL( |
|
43 CPtiEngine* aPtiEngine, CPeninputFingerHwrArLayout* aLayout ) |
|
44 { |
|
45 CPeninputFingerHwrArDataStore* self = new ( ELeave ) |
|
46 CPeninputFingerHwrArDataStore(aLayout); |
|
47 |
|
48 CleanupStack::PushL( self ); |
|
49 self->ConstructL( aPtiEngine ); |
|
50 CleanupStack::Pop( self );//self |
|
51 |
|
52 return self; |
|
53 } |
|
54 |
|
55 // ---------------------------------------------------------------------------- |
|
56 // destructor |
|
57 // ---------------------------------------------------------------------------- |
|
58 // |
|
59 CPeninputFingerHwrArDataStore::~CPeninputFingerHwrArDataStore() |
|
60 { |
|
61 iCandidates.ResetAndDestroy(); |
|
62 iCandidates.Close(); |
|
63 |
|
64 |
|
65 iRangeStartPos.Close(); |
|
66 iPermittedRanges.Close(); |
|
67 iKeyMappingIdList.Close(); |
|
68 |
|
69 iKeyMappingStringList.ResetAndDestroy(); |
|
70 iKeyMappingStringList.Close(); |
|
71 |
|
72 delete iRepositoryFep; |
|
73 // delete iTriggerStr; |
|
74 delete iHwrEngine; |
|
75 delete iUserDefinedResource; |
|
76 |
|
77 if ( iDefaultNumberMapping ) |
|
78 { |
|
79 delete iDefaultNumberMapping; |
|
80 } |
|
81 iDefaultNumberMapping = NULL; |
|
82 |
|
83 } |
|
84 |
|
85 |
|
86 // ---------------------------------------------------------------------------- |
|
87 // Is valid candidate |
|
88 // ---------------------------------------------------------------------------- |
|
89 // |
|
90 TBool CPeninputFingerHwrArDataStore::IsValidCandidate( TInt aCandidateIndex ) const |
|
91 { |
|
92 return ( *iCandidates[aCandidateIndex] ).Length() > 0; |
|
93 } |
|
94 |
|
95 |
|
96 // ---------------------------------------------------------------------------- |
|
97 // Is English letter |
|
98 // ---------------------------------------------------------------------------- |
|
99 // |
|
100 TBool CPeninputFingerHwrArDataStore::IsEnglishLetter( const TDesC& aLetter) |
|
101 { |
|
102 TUint unicode = *((TUint16*) aLetter.Ptr()); |
|
103 |
|
104 const TUint ACode = 0x0041; // Letter "A" |
|
105 const TUint ZCode = 0x005A; // Letter "Z" |
|
106 const TUint aCode = 0x0061; // Letter "a" |
|
107 const TUint zCode = 0x007A; // Letter "z" |
|
108 |
|
109 if( ((ACode <= unicode) && (unicode <= ZCode))|| |
|
110 ((aCode <= unicode) && (unicode <= zCode)) ) |
|
111 { |
|
112 return ETrue; |
|
113 } |
|
114 else |
|
115 { |
|
116 return EFalse; |
|
117 } |
|
118 } |
|
119 |
|
120 // ---------------------------------------------------------------------------- |
|
121 // Do recoginize by engine for Chinese |
|
122 // ---------------------------------------------------------------------------- |
|
123 // |
|
124 void CPeninputFingerHwrArDataStore::DoRecognizeL( const RArray<TPoint>& aTraceData ) |
|
125 { |
|
126 iHwrEngine->DoRecognizeL( aTraceData, iCandidates ); |
|
127 ReorderCandidates(); |
|
128 } |
|
129 |
|
130 |
|
131 |
|
132 |
|
133 // ---------------------------------------------------------------------------- |
|
134 // Set fixed Chinese symbols |
|
135 // ---------------------------------------------------------------------------- |
|
136 // |
|
137 void CPeninputFingerHwrArDataStore::SetArabicSymbolL() |
|
138 { |
|
139 iCandidates.ResetAndDestroy(); |
|
140 // TInt symCount = sizeof( ChineseSymbolCode )/sizeof( TUint16 ); |
|
141 // |
|
142 // for( TInt i = 0; i < symCount; i++ ) |
|
143 // { |
|
144 // TBuf<1> charBuf; |
|
145 // charBuf.Append( ChineseSymbolCode[i] ); |
|
146 // |
|
147 // iCandidates.AppendL( charBuf.AllocL() ); |
|
148 // } |
|
149 |
|
150 } |
|
151 |
|
152 |
|
153 // ---------------------------------------------------------------------------- |
|
154 // Set fixed English symbols |
|
155 // ---------------------------------------------------------------------------- |
|
156 // |
|
157 void CPeninputFingerHwrArDataStore::SetFixEnglishSymbolL(TRowCount aRowCount) |
|
158 { |
|
159 TInt symCount = 0; |
|
160 |
|
161 switch(aRowCount) |
|
162 { |
|
163 case ERowOne: // only set one row dropdownlist |
|
164 { |
|
165 iCandidates.ResetAndDestroy(); |
|
166 symCount = sizeof( EnglishSymbolCodeOneRow )/sizeof( TUint16 ); |
|
167 for( TInt i = 0; i < symCount; i++ ) |
|
168 { |
|
169 TBuf<1> charBuf; |
|
170 charBuf.Append( EnglishSymbolCodeOneRow[i] ); |
|
171 iCandidates.AppendL( charBuf.AllocL() ); |
|
172 } |
|
173 } |
|
174 break; |
|
175 case ERowTwo: // Set two rows dropdownlist |
|
176 { |
|
177 iCandidates.ResetAndDestroy(); |
|
178 symCount = sizeof( EnglishSymbolCodeTwoRow )/sizeof( TUint16 ); |
|
179 |
|
180 for( TInt i = 0; i < symCount; i++ ) |
|
181 { |
|
182 TBuf<1> charBuf1; // the first row |
|
183 TBuf<2> charBuf2; // the second row |
|
184 |
|
185 charBuf1.Append( EnglishSymbolCodeOneRow[i] ); |
|
186 iCandidates.AppendL( charBuf1.AllocL() ); |
|
187 |
|
188 if(i > 2) // for smile symbol |
|
189 { |
|
190 charBuf2.Append(ColonSymbol); |
|
191 } |
|
192 charBuf2.Append( EnglishSymbolCodeTwoRow[i] ); |
|
193 |
|
194 } |
|
195 } |
|
196 break; |
|
197 default: |
|
198 break; |
|
199 } |
|
200 } |
|
201 |
|
202 |
|
203 |
|
204 // ---------------------------------------------------------------------------- |
|
205 // Set permitted ranges |
|
206 // ---------------------------------------------------------------------------- |
|
207 // |
|
208 void CPeninputFingerHwrArDataStore::SetPermittedRanges( TInt aPermittedRanges ) |
|
209 { |
|
210 if(aPermittedRanges == 0) |
|
211 return; |
|
212 |
|
213 iPermittedRanges.Reset(); |
|
214 |
|
215 //order can not be changed |
|
216 if ( aPermittedRanges & ERangeNative ) |
|
217 { |
|
218 iPermittedRanges.Append( ERangeNative ); |
|
219 } |
|
220 if ( aPermittedRanges & ERangeEnglish ) |
|
221 { |
|
222 iPermittedRanges.Append( ERangeEnglish ); |
|
223 } |
|
224 if ( aPermittedRanges & ERangeNumber ) |
|
225 { |
|
226 iPermittedRanges.Append( ERangeNumber ); |
|
227 } |
|
228 if ( aPermittedRanges & ERangeSymbol ) |
|
229 { |
|
230 iPermittedRanges.Append( ERangeSymbol ); |
|
231 } |
|
232 |
|
233 iIntRange = aPermittedRanges; |
|
234 |
|
235 // set primary and auxiliary ranges for hwr engine |
|
236 iHwrEngine->SetRanges( iPermittedRanges ); |
|
237 } |
|
238 |
|
239 |
|
240 // ---------------------------------------------------------------------------- |
|
241 // Set permitted cases |
|
242 // ---------------------------------------------------------------------------- |
|
243 // |
|
244 void CPeninputFingerHwrArDataStore::SetPermittedCases( TInt aPermittedCases ) |
|
245 { |
|
246 iPermittedCases = aPermittedCases; |
|
247 } |
|
248 |
|
249 // ---------------------------------------------------------------------------- |
|
250 // Set Primary range |
|
251 // ---------------------------------------------------------------------------- |
|
252 // |
|
253 void CPeninputFingerHwrArDataStore::SetPrimaryRange( TInt aPrimaryRange ) |
|
254 { |
|
255 const TInt oldIndex = iPermittedRanges.Find( aPrimaryRange ); |
|
256 |
|
257 // store the current range |
|
258 switch(aPrimaryRange) |
|
259 { |
|
260 case ERangeNative: |
|
261 { |
|
262 iCurrentRange = EFingerHwrNativeRange; |
|
263 } |
|
264 break; |
|
265 case ERangeEnglish: |
|
266 { |
|
267 iCurrentRange = EFingerHwrEnglishRange; |
|
268 } |
|
269 break; |
|
270 case ERangeNumber: |
|
271 { |
|
272 iCurrentRange = EFingerHwrNumberRange; |
|
273 } |
|
274 break; |
|
275 default: |
|
276 break; |
|
277 } |
|
278 |
|
279 if ( oldIndex > 0 ) |
|
280 { |
|
281 iPermittedRanges.Sort(); |
|
282 const TInt index = iPermittedRanges.Find( aPrimaryRange ); |
|
283 |
|
284 iPermittedRanges.Remove( index ); |
|
285 iPermittedRanges.Insert( aPrimaryRange, 0 ); |
|
286 |
|
287 // set primary range for hwr engine |
|
288 iHwrEngine->SetRanges( iPermittedRanges ); |
|
289 } |
|
290 } |
|
291 |
|
292 // ---------------------------------------------------------------------------- |
|
293 // get Primary range |
|
294 // ---------------------------------------------------------------------------- |
|
295 // |
|
296 TInt CPeninputFingerHwrArDataStore::PrimaryRange() |
|
297 { |
|
298 if( iPermittedRanges.Count() > 0 ) |
|
299 { |
|
300 return iPermittedRanges[0]; |
|
301 } |
|
302 return -1; |
|
303 } |
|
304 |
|
305 // ---------------------------------------------------------------------------- |
|
306 // get current range |
|
307 // ---------------------------------------------------------------------------- |
|
308 // |
|
309 TFingerHwrRange CPeninputFingerHwrArDataStore::CurrentRange() |
|
310 { |
|
311 return iCurrentRange; |
|
312 } |
|
313 |
|
314 // ---------------------------------------------------------------------------- |
|
315 // Set case |
|
316 // ---------------------------------------------------------------------------- |
|
317 // |
|
318 void CPeninputFingerHwrArDataStore::SetCase( TInt aCase ) |
|
319 { |
|
320 iCase = aCase; |
|
321 iHwrEngine->SetCase( iCase ); |
|
322 } |
|
323 |
|
324 // ---------------------------------------------------------------------------- |
|
325 // Set language |
|
326 // ---------------------------------------------------------------------------- |
|
327 // |
|
328 void CPeninputFingerHwrArDataStore::SetLanguageL( TInt aLanguage ) |
|
329 { |
|
330 if( iLanguage == aLanguage ) |
|
331 { |
|
332 return; |
|
333 } |
|
334 |
|
335 if ( !IsArabicLanguage( aLanguage ) && ( aLanguage != ELangEnglish ) ) |
|
336 { |
|
337 return; |
|
338 } |
|
339 |
|
340 if ( aLanguage == ELangEnglish ) |
|
341 { |
|
342 TLanguage displayLang = User::Language(); |
|
343 |
|
344 // set real language to a Arabic |
|
345 if ( !IsArabicLanguage( iLanguage ) ) |
|
346 { |
|
347 // original language is not Chinese |
|
348 if ( IsArabicLanguage( displayLang ) ) |
|
349 { |
|
350 iLanguage = displayLang; |
|
351 } |
|
352 else |
|
353 { |
|
354 iLanguage = ELangArabic; |
|
355 } |
|
356 |
|
357 SetEngineLanguageL( iLanguage ); |
|
358 } |
|
359 |
|
360 } |
|
361 else |
|
362 { |
|
363 // aLanguage is Chinese |
|
364 if ( iLanguage != aLanguage ) |
|
365 { |
|
366 iLanguage = aLanguage; |
|
367 |
|
368 SetEngineLanguageL( iLanguage ); |
|
369 } |
|
370 } |
|
371 } |
|
372 |
|
373 |
|
374 // ---------------------------------------------------------------------------- |
|
375 // Get first stroke flag |
|
376 // ---------------------------------------------------------------------------- |
|
377 // |
|
378 TBool CPeninputFingerHwrArDataStore::FirstStroke() |
|
379 { |
|
380 return iIsFirstStroke; |
|
381 } |
|
382 |
|
383 // ---------------------------------------------------------------------------- |
|
384 // Set first stroke flag |
|
385 // ---------------------------------------------------------------------------- |
|
386 // |
|
387 void CPeninputFingerHwrArDataStore::SetFirstStroke(const TBool aIsFirstStroke) |
|
388 { |
|
389 iIsFirstStroke = aIsFirstStroke; |
|
390 } |
|
391 |
|
392 // ---------------------------------------------------------------------------- |
|
393 // Get the candidate |
|
394 // ---------------------------------------------------------------------------- |
|
395 // |
|
396 const RPointerArray<HBufC>& CPeninputFingerHwrArDataStore::Candidate() const |
|
397 { |
|
398 return iCandidates; |
|
399 } |
|
400 |
|
401 |
|
402 |
|
403 // ---------------------------------------------------------------------------- |
|
404 // Set number mode for hwr engine |
|
405 // ---------------------------------------------------------------------------- |
|
406 // |
|
407 void CPeninputFingerHwrArDataStore::SetNumberMode( |
|
408 const TAknEditorNumericKeymap aNumberMode ) |
|
409 { |
|
410 iCurrentNumberMode = aNumberMode; |
|
411 iHwrEngine->SetNumberMode( aNumberMode ); |
|
412 iHwrEngine->SetRanges( iPermittedRanges ); |
|
413 } |
|
414 |
|
415 // ---------------------------------------------------------------------------- |
|
416 // Set number mode for hwr engine |
|
417 // ---------------------------------------------------------------------------- |
|
418 // |
|
419 void CPeninputFingerHwrArDataStore::SetCustomNumberModeL( const TDesC& aCustomMode ) |
|
420 { |
|
421 iHwrEngine->SetCustomKeymapL( aCustomMode ); |
|
422 |
|
423 delete iUserDefinedResource; |
|
424 iUserDefinedResource = NULL; |
|
425 iUserDefinedResource = HBufC::NewL( aCustomMode.Length() ); |
|
426 iUserDefinedResource->Des().Append( aCustomMode ); |
|
427 } |
|
428 |
|
429 // ---------------------------------------------------------------------------- |
|
430 // save range to repository if english or chinese |
|
431 // ---------------------------------------------------------------------------- |
|
432 // |
|
433 void CPeninputFingerHwrArDataStore::SaveRange( TInt aRange ) |
|
434 { |
|
435 if ( iRepositoryFep && ( aRange == ERangeNative || aRange == ERangeEnglish ) ) |
|
436 { |
|
437 iRepositoryFep->Set( KAknFepLastUsedRange, aRange ); |
|
438 } |
|
439 } |
|
440 |
|
441 |
|
442 // ------------------------------------------------------------------ |
|
443 // sync stroke end mark of writingbox with hwr engine. |
|
444 // ------------------------------------------------------------------- |
|
445 // |
|
446 void CPeninputFingerHwrArDataStore::SetStrokeEndMark() |
|
447 { |
|
448 iLayout->SyncHwrStrokeEndMark( iHwrEngine->StrokeEndMark() ); |
|
449 } |
|
450 |
|
451 // ---------------------------------------------------------------------------- |
|
452 // get stroke end mark from hwr engine |
|
453 // ---------------------------------------------------------------------------- |
|
454 // |
|
455 TPoint CPeninputFingerHwrArDataStore::StrokeEndMark() |
|
456 { |
|
457 return iHwrEngine->StrokeEndMark(); |
|
458 } |
|
459 |
|
460 // ---------------------------------------------------------------------------- |
|
461 // stroke end mark from control |
|
462 // ---------------------------------------------------------------------------- |
|
463 // |
|
464 TPoint CPeninputFingerHwrArDataStore::StrokeEndMarkFromControl() |
|
465 { |
|
466 return TPoint( KDefaultStrokeEndMarkX, KDefaultStrokeEndMarkY ); |
|
467 } |
|
468 |
|
469 // -------------------------------------------------------------------- |
|
470 // Get number keymapping string |
|
471 // -------------------------------------------------------------------- |
|
472 // |
|
473 HBufC* CPeninputFingerHwrArDataStore::KeyMappingStringL() const |
|
474 { |
|
475 TLocale locale; |
|
476 TBuf<KMaxNumericString> rs = KNumberString(); // copy "0123456789" |
|
477 const TInt index = iKeyMappingIdList.Find( iCurrentNumberMode ); |
|
478 |
|
479 if ( !( iPermittedRanges.Count() == 1 && iPermittedRanges[0] == ERangeNumber ) ) |
|
480 { |
|
481 rs.Append( *iDefaultNumberMapping ); //normal editor |
|
482 } |
|
483 else if ( iCurrentNumberMode == EKeymapFromResource ) |
|
484 { |
|
485 rs.Append( *iUserDefinedResource ); |
|
486 } |
|
487 else if ( index != KErrNotFound ) |
|
488 { |
|
489 HBufC* buf = iKeyMappingStringList[index]; |
|
490 |
|
491 rs.Append( *buf ); |
|
492 |
|
493 if ( ( iCurrentNumberMode == EAknEditorCalculatorNumberModeKeymap ) || |
|
494 ( iCurrentNumberMode == EAknEditorConverterNumberModeKeymap ) ) |
|
495 { |
|
496 rs.Append( locale.DecimalSeparator() ); |
|
497 } |
|
498 } |
|
499 |
|
500 return rs.AllocL(); |
|
501 } |
|
502 |
|
503 // ------------------------------------------------------------------------ |
|
504 // CPeninputFingerHwrArDataStore::IsSpecialDisplayChars |
|
505 // ------------------------------------------------------------------------ |
|
506 // |
|
507 TBool CPeninputFingerHwrArDataStore::IsSpecialDisplayChars( const TDesC& aChar ) const |
|
508 { |
|
509 if( aChar.Compare( KGestureEnter ) == 0 |
|
510 || aChar.Compare( KDisplayBackspace ) == 0 |
|
511 || aChar.Compare( KGestureSpace )== 0 ) |
|
512 { |
|
513 return ETrue; |
|
514 } |
|
515 |
|
516 return EFalse; |
|
517 } |
|
518 |
|
519 // ----------------------------------------------------------------------------- |
|
520 // CPeninputFingerHwrArDataStore::IsDirectlySentCandidate |
|
521 // ----------------------------------------------------------------------------- |
|
522 // |
|
523 TBool CPeninputFingerHwrArDataStore::IsDirectlySentCandidate( const TDesC& aChar ) const |
|
524 { |
|
525 |
|
526 if( aChar.Compare( KGestureEnter ) == 0 || |
|
527 aChar.Compare( KDisplayBackspace ) == 0) |
|
528 { |
|
529 return ETrue; |
|
530 } |
|
531 |
|
532 return EFalse; |
|
533 } |
|
534 |
|
535 // ------------------------------------------------------------------------ |
|
536 // CPeninputFingerHwrArDataStore::ConvertDisplayChars |
|
537 // ------------------------------------------------------------------------ |
|
538 // |
|
539 HBufC* CPeninputFingerHwrArDataStore::ConvertDisplayChars( const TDesC& aChar ) const |
|
540 { |
|
541 HBufC* convertedCan = NULL; |
|
542 TBuf<KSpecialConvertedCharCount> str; |
|
543 if( aChar.Compare( KGestureEnter ) == 0 ) |
|
544 { |
|
545 str.Append( EKeyEnter ); |
|
546 } |
|
547 else if( aChar.Compare( KDisplayBackspace ) == 0 ) |
|
548 { |
|
549 str.Append( EKeyBackspace ); |
|
550 } |
|
551 else if( aChar.Compare( KGestureSpace )== 0 ) |
|
552 { |
|
553 str.Append( EKeySpace ); |
|
554 } |
|
555 |
|
556 if( str.Length() > 0 ) |
|
557 { |
|
558 convertedCan = str.Alloc(); |
|
559 } |
|
560 |
|
561 return convertedCan; |
|
562 } |
|
563 |
|
564 // ----------------------------------------------------------------------------- |
|
565 // CPeninputFingerHwrArDataStore::StartCharacter |
|
566 // ----------------------------------------------------------------------------- |
|
567 // |
|
568 TBool CPeninputFingerHwrArDataStore::StartCharacter() |
|
569 { |
|
570 return iStartCharacter; |
|
571 } |
|
572 |
|
573 // ----------------------------------------------------------------------------- |
|
574 // CPeninputFingerHwrArDataStore::SetStartCharacter |
|
575 // ----------------------------------------------------------------------------- |
|
576 // |
|
577 void CPeninputFingerHwrArDataStore::SetStartCharacter(const TBool aStartCharacter) |
|
578 { |
|
579 iStartCharacter = aStartCharacter; |
|
580 } |
|
581 |
|
582 // ----------------------------------------------------------------------------- |
|
583 // CPeninputFingerHwrArDataStore::SetInputAreaSize |
|
584 // ----------------------------------------------------------------------------- |
|
585 // |
|
586 TInt CPeninputFingerHwrArDataStore::SetInputAreaSize(TSize& aSize) |
|
587 { |
|
588 return iHwrEngine->SetInputAreaSize(aSize); |
|
589 } |
|
590 |
|
591 // ----------------------------------------------------------------------------- |
|
592 // CPeninputFingerHwrArDataStore::SetScreenSize |
|
593 // ----------------------------------------------------------------------------- |
|
594 // |
|
595 TInt CPeninputFingerHwrArDataStore::SetScreenSize(TSize& aSize) |
|
596 { |
|
597 return iHwrEngine->SetScreenSize(aSize); |
|
598 } |
|
599 |
|
600 |
|
601 // ----------------------------------------------------------------------------- |
|
602 // CPeninputFingerHwrArDataStore::SetHighlight |
|
603 // ----------------------------------------------------------------------------- |
|
604 // |
|
605 void CPeninputFingerHwrArDataStore::SetHighlight(const TBool aIsHighlight) |
|
606 { |
|
607 iIsHighlightCell = aIsHighlight; |
|
608 } |
|
609 |
|
610 // ----------------------------------------------------------------------------- |
|
611 // CPeninputFingerHwrArDataStore::Highlight |
|
612 // ----------------------------------------------------------------------------- |
|
613 // |
|
614 TBool CPeninputFingerHwrArDataStore::Highlight() |
|
615 { |
|
616 return iIsHighlightCell; |
|
617 } |
|
618 |
|
619 // ----------------------------------------------------------------------------- |
|
620 // CPeninputFingerHwrArDataStore::RemoveDuplicateCand |
|
621 // ----------------------------------------------------------------------------- |
|
622 // |
|
623 TInt CPeninputFingerHwrArDataStore::RemoveDuplicateCand(const RPointerArray<HBufC>& aSrc, |
|
624 RPointerArray<HBufC>& aTgt, |
|
625 TInt aSrcStartIdx, |
|
626 TInt aTgtStartIdx) |
|
627 { |
|
628 TInt lastOverlapIdx = KInvalidIndex; |
|
629 |
|
630 // on the assumption that if candidate overlap, |
|
631 // it is overlap only once |
|
632 TInt srccandcnt = aSrc.Count(); |
|
633 |
|
634 for (TInt i = aSrcStartIdx; i < srccandcnt; i++) |
|
635 { |
|
636 for (TInt j = aTgtStartIdx; j < aTgt.Count(); j++) |
|
637 { |
|
638 if (aTgt[j]->Compare(*(aSrc[i])) == 0) |
|
639 { |
|
640 lastOverlapIdx = i; |
|
641 delete aTgt[j]; |
|
642 aTgt.Remove(j); |
|
643 j--; |
|
644 break; |
|
645 } |
|
646 } |
|
647 } |
|
648 |
|
649 return lastOverlapIdx; |
|
650 } |
|
651 |
|
652 // ---------------------------------------------------------------------------- |
|
653 // C++ constructor |
|
654 // ---------------------------------------------------------------------------- |
|
655 // |
|
656 CPeninputFingerHwrArDataStore::CPeninputFingerHwrArDataStore(CPeninputFingerHwrArLayout* aLayout) |
|
657 :iLayout( aLayout ) |
|
658 { |
|
659 iLanguage = ELangNone; |
|
660 iCurrentNumberMode = EAknEditorStandardNumberModeKeymap; |
|
661 iIsHighlightCell = ETrue; |
|
662 } |
|
663 |
|
664 // ---------------------------------------------------------------------------- |
|
665 // Second phase constructor |
|
666 // ---------------------------------------------------------------------------- |
|
667 // |
|
668 void CPeninputFingerHwrArDataStore::ConstructL( CPtiEngine* aPtiEngine ) |
|
669 { |
|
670 //create the repository for fep settings |
|
671 iRepositoryFep = CRepository::NewL( KCRUidAknFep ); |
|
672 |
|
673 //create the trigger string |
|
674 // iTriggerStr = new ( ELeave ) CAknFepHwrArTriggerStr(); |
|
675 |
|
676 //create the hwr engine |
|
677 iHwrEngine = CPeninputFingerHwrArEngine::NewL( aPtiEngine, this ); |
|
678 |
|
679 //initialize the key mapping list |
|
680 InitKeyMappingListL(); |
|
681 } |
|
682 |
|
683 // ---------------------------------------------------------------------------- |
|
684 // Initialize the key mapping list |
|
685 // ---------------------------------------------------------------------------- |
|
686 // |
|
687 void CPeninputFingerHwrArDataStore::InitKeyMappingListL() |
|
688 { |
|
689 CCoeEnv* env = CCoeEnv::Static(); |
|
690 |
|
691 //read default key mapping string from resource |
|
692 if ( iDefaultNumberMapping ) |
|
693 { |
|
694 delete iDefaultNumberMapping; |
|
695 iDefaultNumberMapping = NULL; |
|
696 } |
|
697 iDefaultNumberMapping = env->AllocReadResourceL( R_AKN_FEP_HWR_KEY_MAPPING_DEFAULT ); |
|
698 |
|
699 //read the key maping string from resource |
|
700 TResourceReader reader; |
|
701 env->CreateResourceReaderLC( reader, R_AKN_FEP_HWR_KEY_MAPPING_STRING_LIST ); |
|
702 |
|
703 const TInt count = reader.ReadInt16(); |
|
704 |
|
705 for ( TInt i = 0; i < count; i++ ) |
|
706 { |
|
707 iKeyMappingIdList.Append( reader.ReadInt16() ); |
|
708 TPtrC ptr = reader.ReadTPtrC(); |
|
709 iKeyMappingStringList.Append( ptr.Alloc() ); |
|
710 } |
|
711 iCurrentNumberMode = EAknEditorStandardNumberModeKeymap; |
|
712 |
|
713 CleanupStack::PopAndDestroy(); //reader |
|
714 } |
|
715 |
|
716 // ---------------------------------------------------------------------------- |
|
717 // Judge if a language is Arabic |
|
718 // ---------------------------------------------------------------------------- |
|
719 // |
|
720 TBool CPeninputFingerHwrArDataStore::IsArabicLanguage( TInt aLanguage ) |
|
721 { |
|
722 if( aLanguage == ELangArabic) |
|
723 { |
|
724 return ETrue; |
|
725 } |
|
726 |
|
727 return EFalse; |
|
728 } |
|
729 |
|
730 // ---------------------------------------------------------------------------- |
|
731 // Set real engine language |
|
732 // ---------------------------------------------------------------------------- |
|
733 // |
|
734 void CPeninputFingerHwrArDataStore::SetEngineLanguageL( TInt aLanguage ) |
|
735 { |
|
736 SetLanguageShowText( aLanguage ); |
|
737 iHwrEngine->SetLanguageL( aLanguage ); |
|
738 iHwrEngine->SetPrimaryCandidateNum( KCandidateCount ); |
|
739 } |
|
740 |
|
741 // ---------------------------------------------------------------------------- |
|
742 // Set language show text |
|
743 // ---------------------------------------------------------------------------- |
|
744 // |
|
745 void CPeninputFingerHwrArDataStore::SetLanguageShowText( TInt aLanguage ) |
|
746 { |
|
747 AknPenInputUtils::GetISOLanguageCode( TLanguage( aLanguage ), |
|
748 iLanguageShowText ); |
|
749 } |
|
750 |
|
751 |
|
752 // ---------------------------------------------------------------------------- |
|
753 // Reset key board type |
|
754 // ---------------------------------------------------------------------------- |
|
755 // |
|
756 void CPeninputFingerHwrArDataStore::ResetKeyboardType() |
|
757 { |
|
758 iHwrEngine->ResetKeyboardType(); |
|
759 } |
|
760 |
|
761 // ---------------------------------------------------------------------------- |
|
762 // Set key board type to Qwerty |
|
763 // ---------------------------------------------------------------------------- |
|
764 // |
|
765 void CPeninputFingerHwrArDataStore::SetKeyboardToQwerty() |
|
766 { |
|
767 iHwrEngine->SetKeyboardToQwerty(); |
|
768 } |
|
769 |
|
770 // ---------------------------------------------------------------------------- |
|
771 // Get key board type |
|
772 // ---------------------------------------------------------------------------- |
|
773 // |
|
774 void CPeninputFingerHwrArDataStore::GetKeyboardType() |
|
775 { |
|
776 iHwrEngine->GetKeyboardType(); |
|
777 } |
|
778 |
|
779 // ---------------------------------------------------------------------------- |
|
780 // CPeninputFingerHwrArDataStore::GetTopGuideLinePos |
|
781 // ---------------------------------------------------------------------------- |
|
782 // |
|
783 void CPeninputFingerHwrArDataStore::GetTopGuideLinePos(TInt& aPos) |
|
784 { |
|
785 iHwrEngine->GetTopGuideLinePos(aPos); |
|
786 } |
|
787 |
|
788 // ---------------------------------------------------------------------------- |
|
789 // CPeninputFingerHwrArDataStore::GetBottomGuideLinePos |
|
790 // ---------------------------------------------------------------------------- |
|
791 // |
|
792 void CPeninputFingerHwrArDataStore::GetBottomGuideLinePos(TInt& aPos) |
|
793 { |
|
794 iHwrEngine->GetBottomGuideLinePos(aPos); |
|
795 } |
|
796 |
|
797 // ---------------------------------------------------------------------------- |
|
798 // CPeninputFingerHwrArDataStore::SetFirstCandidateType |
|
799 // ---------------------------------------------------------------------------- |
|
800 // |
|
801 void CPeninputFingerHwrArDataStore::SetFirstCandidateType(TFirstCandidateType aFirstCandType) |
|
802 { |
|
803 iFirstCandidateType = aFirstCandType; |
|
804 } |
|
805 |
|
806 // ---------------------------------------------------------------------------- |
|
807 // CPeninputFingerHwrArDataStore::ReorderCandidates |
|
808 // ---------------------------------------------------------------------------- |
|
809 // |
|
810 void CPeninputFingerHwrArDataStore::ReorderCandidates() |
|
811 { |
|
812 TInt candCount = iCandidates.Count(); |
|
813 TInt insertPos = 0; |
|
814 if(iFirstCandidateType == ECandLatinCharFirst) |
|
815 { |
|
816 for(TInt i = 0; i < candCount; i++) |
|
817 { |
|
818 TUint16 unicode = (*iCandidates[i])[0]; |
|
819 if(IsLatinChar(unicode)) |
|
820 { |
|
821 if(insertPos < i) |
|
822 { |
|
823 iCandidates.Insert(iCandidates[i],insertPos); |
|
824 iCandidates.Remove(i+1); |
|
825 } |
|
826 insertPos++; |
|
827 } |
|
828 } |
|
829 } |
|
830 else if(iFirstCandidateType == ECandLatinNumFirst) |
|
831 { |
|
832 for(TInt i = 0; i < candCount; i++) |
|
833 { |
|
834 TUint16 unicode = (*iCandidates[i])[0]; |
|
835 if(IsLatinNumber(unicode)) |
|
836 { |
|
837 if(insertPos < i) |
|
838 { |
|
839 iCandidates.Insert(iCandidates[i],insertPos); |
|
840 iCandidates.Remove(i+1); |
|
841 } |
|
842 insertPos++; |
|
843 } |
|
844 } |
|
845 } |
|
846 else if(iFirstCandidateType == ECandArabicIndicNumFirst) |
|
847 { |
|
848 for(TInt i = 0; i < candCount; i++) |
|
849 { |
|
850 TUint16 unicode = (*iCandidates[i])[0]; |
|
851 if(IsArabicNumber(unicode)) |
|
852 { |
|
853 if(insertPos < i) |
|
854 { |
|
855 iCandidates.Insert(iCandidates[i],insertPos); |
|
856 iCandidates.Remove(i+1); |
|
857 } |
|
858 insertPos++; |
|
859 } |
|
860 } |
|
861 } |
|
862 else if(iFirstCandidateType == ECandArabicCharFirst) |
|
863 { |
|
864 for(TInt i = 0; i < candCount; i++) |
|
865 { |
|
866 TUint16 unicode = (*iCandidates[i])[0]; |
|
867 if(IsArabicChar(unicode)) |
|
868 { |
|
869 if(insertPos < i) |
|
870 { |
|
871 iCandidates.Insert(iCandidates[i],insertPos); |
|
872 iCandidates.Remove(i+1); |
|
873 } |
|
874 insertPos++; |
|
875 } |
|
876 } |
|
877 } |
|
878 } |
|
879 |
|
880 // ---------------------------------------------------------------------------- |
|
881 // CPeninputFingerHwrArDataStore::IsLatinNumber |
|
882 // ---------------------------------------------------------------------------- |
|
883 // |
|
884 TBool CPeninputFingerHwrArDataStore::IsLatinNumber(TUint16 aChar) |
|
885 { |
|
886 if(aChar >= 0x30 && aChar <= 0x39) |
|
887 { |
|
888 return ETrue; |
|
889 } |
|
890 |
|
891 return EFalse; |
|
892 } |
|
893 |
|
894 // ---------------------------------------------------------------------------- |
|
895 // CPeninputFingerHwrArDataStore::IsLatinChar |
|
896 // ---------------------------------------------------------------------------- |
|
897 // |
|
898 TBool CPeninputFingerHwrArDataStore::IsLatinChar(TUint16 aChar) |
|
899 { |
|
900 if(aChar >= 0x41 && aChar <= 0x5A |
|
901 || aChar >= 0x61 && aChar <= 0x7A) |
|
902 { |
|
903 return ETrue; |
|
904 } |
|
905 |
|
906 return EFalse; |
|
907 } |
|
908 |
|
909 // ---------------------------------------------------------------------------- |
|
910 // CPeninputFingerHwrArDataStore::IsArabicNumber |
|
911 // ---------------------------------------------------------------------------- |
|
912 // |
|
913 TBool CPeninputFingerHwrArDataStore::IsArabicNumber(TUint16 aChar) |
|
914 { |
|
915 if(aChar >= 0x0661 && aChar <= 0x0669) |
|
916 { |
|
917 return ETrue; |
|
918 } |
|
919 |
|
920 return EFalse; |
|
921 } |
|
922 |
|
923 // ---------------------------------------------------------------------------- |
|
924 // CPeninputFingerHwrArDataStore::IsArabicChar |
|
925 // ---------------------------------------------------------------------------- |
|
926 // |
|
927 TBool CPeninputFingerHwrArDataStore::IsArabicChar(TUint16 aChar) |
|
928 { |
|
929 if((aChar >= 0x0600 && aChar <= 0x06FF && !IsArabicNumber(aChar) && |
|
930 !IsArabicSymbol(aChar)) || |
|
931 (aChar >= 0x0750 && aChar <= 0x077F) || |
|
932 (aChar >= 0xFB50 && aChar <= 0xFDFF) || |
|
933 (aChar >= 0xFE70 && aChar <= 0xFEFF)) |
|
934 { |
|
935 return ETrue; |
|
936 } |
|
937 |
|
938 return EFalse; |
|
939 } |
|
940 |
|
941 // ---------------------------------------------------------------------------- |
|
942 // CPeninputFingerHwrArDataStore::IsArabicSymbol |
|
943 // ---------------------------------------------------------------------------- |
|
944 // |
|
945 TBool CPeninputFingerHwrArDataStore::IsArabicSymbol(TUint16 aChar) |
|
946 { |
|
947 if(aChar == 0x061B || aChar == 0x061F || |
|
948 aChar == 0x060C || aChar == 0x066A) |
|
949 { |
|
950 return ETrue; |
|
951 } |
|
952 |
|
953 return EFalse; |
|
954 } |
|
955 |
|
956 // End Of File |