1 /* |
|
2 * Copyright (c) 2009 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: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 #include "aknfepzhuyinkeyhandler.h" |
|
22 |
|
23 const TInt KBTLoopLength1 = 3; |
|
24 const TInt KBTLoopLength2 = 4; |
|
25 const TInt KBTLoopLength3 = 5; |
|
26 |
|
27 const TInt KBTLoopLength = 5; |
|
28 |
|
29 const TInt KCLKCount1 = 1; |
|
30 const TInt KCLKCount2 = 2; |
|
31 const TInt KCLKCount3 = 3; |
|
32 const TInt KCLKCount4 = 4; |
|
33 const TInt KCLKCount5 = 5; |
|
34 |
|
35 const TInt KTimerOut = 700000; |
|
36 |
|
37 _LIT(KPtiKey1_1, "\x3105"); |
|
38 _LIT(KPtiKey1_2, "\x3106"); |
|
39 _LIT(KPtiKey1_3, "\x3107"); |
|
40 _LIT(KPtiKey1_4, "\x3108"); |
|
41 |
|
42 _LIT(KPtiKey2_1, "\x3109"); |
|
43 _LIT(KPtiKey2_2, "\x310A"); |
|
44 _LIT(KPtiKey2_3, "\x310B"); |
|
45 _LIT(KPtiKey2_4, "\x310C"); |
|
46 |
|
47 _LIT(KPtiKey3_1, "\x310D"); |
|
48 _LIT(KPtiKey3_2, "\x310E"); |
|
49 _LIT(KPtiKey3_3, "\x310F"); |
|
50 |
|
51 _LIT(KPtiKey4_1, "\x3110"); |
|
52 _LIT(KPtiKey4_2, "\x3111"); |
|
53 _LIT(KPtiKey4_3, "\x3112"); |
|
54 |
|
55 _LIT(KPtiKey5_1, "\x3113"); |
|
56 _LIT(KPtiKey5_2, "\x3114"); |
|
57 _LIT(KPtiKey5_3, "\x3115"); |
|
58 _LIT(KPtiKey5_4, "\x3116"); |
|
59 |
|
60 _LIT(KPtiKey6_1, "\x3117"); |
|
61 _LIT(KPtiKey6_2, "\x3118"); |
|
62 _LIT(KPtiKey6_3, "\x3119"); |
|
63 |
|
64 _LIT(KPtiKey7_1, "\x311A"); |
|
65 _LIT(KPtiKey7_2, "\x311B"); |
|
66 _LIT(KPtiKey7_3, "\x311C"); |
|
67 _LIT(KPtiKey7_4, "\x311D"); |
|
68 |
|
69 _LIT(KPtiKey8_1, "\x311E"); |
|
70 _LIT(KPtiKey8_2, "\x311F"); |
|
71 _LIT(KPtiKey8_3, "\x3120"); |
|
72 _LIT(KPtiKey8_4, "\x3121"); |
|
73 |
|
74 _LIT(KPtiKey9_1, "\x3122"); |
|
75 _LIT(KPtiKey9_2, "\x3123"); |
|
76 _LIT(KPtiKey9_3, "\x3124"); |
|
77 _LIT(KPtiKey9_4, "\x3125"); |
|
78 _LIT(KPtiKey9_5, "\x3126"); |
|
79 |
|
80 _LIT(KPtiKey0_1, "\x3127"); |
|
81 _LIT(KPtiKey0_2, "\x3128"); |
|
82 _LIT(KPtiKey0_3, "\x3129"); |
|
83 |
|
84 _LIT(KPtiKeyStar_1, "\x0020"); |
|
85 _LIT(KPtiKeyStar_2, "\x02CA"); |
|
86 _LIT(KPtiKeyStar_3, "\x02C7"); |
|
87 _LIT(KPtiKeyStar_4, "\x02CB"); |
|
88 _LIT(KPtiKeyStar_5, "\x02D9"); |
|
89 |
|
90 |
|
91 // --------------------------------------------------------- |
|
92 // C++ constructor. |
|
93 // --------------------------------------------------------- |
|
94 // |
|
95 ZhuyinKeyTable::ZhuyinKeyTable() |
|
96 { |
|
97 } |
|
98 |
|
99 // --------------------------------------------------------- |
|
100 // Cancel and destroy. |
|
101 // --------------------------------------------------------- |
|
102 // |
|
103 ZhuyinKeyTable::~ZhuyinKeyTable() |
|
104 { |
|
105 } |
|
106 |
|
107 // --------------------------------------------------------- |
|
108 // Get butten loop length. |
|
109 // --------------------------------------------------------- |
|
110 // |
|
111 TInt ZhuyinKeyTable::GetBtLoopLength ( TPtiKey aKey ) |
|
112 { |
|
113 switch ( aKey ) |
|
114 { |
|
115 case EPtiKey0: |
|
116 case EPtiKey3: |
|
117 case EPtiKey4: |
|
118 case EPtiKey6: |
|
119 { |
|
120 return KBTLoopLength1; |
|
121 } |
|
122 case EPtiKey1: |
|
123 case EPtiKey2: |
|
124 case EPtiKey5: |
|
125 case EPtiKey7: |
|
126 case EPtiKey8: |
|
127 { |
|
128 return KBTLoopLength2; |
|
129 } |
|
130 case EPtiKey9: |
|
131 case EPtiKeyStar: |
|
132 { |
|
133 return KBTLoopLength3; |
|
134 } |
|
135 default: |
|
136 return 0; |
|
137 } |
|
138 } |
|
139 |
|
140 // --------------------------------------------------------- |
|
141 // Get zhuyin symbol. |
|
142 // --------------------------------------------------------- |
|
143 // |
|
144 TBool ZhuyinKeyTable::GetUnicode ( TPtiKey aKey, TInt aClkCount, TDes& aOutput ) |
|
145 { |
|
146 aOutput.Zero(); |
|
147 switch ( aKey ) |
|
148 { |
|
149 case EPtiKey0: |
|
150 { |
|
151 switch ( aClkCount ) |
|
152 { |
|
153 case KCLKCount1: |
|
154 aOutput.Append(KPtiKey0_1); |
|
155 return ETrue; |
|
156 case KCLKCount2: |
|
157 aOutput.Append(KPtiKey0_2); |
|
158 return ETrue; |
|
159 case KCLKCount3: |
|
160 aOutput.Append(KPtiKey0_3); |
|
161 return ETrue; |
|
162 default: |
|
163 return EFalse; |
|
164 } |
|
165 } |
|
166 case EPtiKey1: |
|
167 switch ( aClkCount ) |
|
168 { |
|
169 case KCLKCount1: |
|
170 aOutput.Append(KPtiKey1_1); |
|
171 return ETrue; |
|
172 case KCLKCount2: |
|
173 aOutput.Append(KPtiKey1_2); |
|
174 return ETrue; |
|
175 case KCLKCount3: |
|
176 aOutput.Append(KPtiKey1_3); |
|
177 return ETrue; |
|
178 case KCLKCount4: |
|
179 aOutput.Append(KPtiKey1_4); |
|
180 return ETrue; |
|
181 default: |
|
182 return EFalse; |
|
183 } |
|
184 case EPtiKey2: |
|
185 switch ( aClkCount ) |
|
186 { |
|
187 case KCLKCount1: |
|
188 aOutput.Append(KPtiKey2_1); |
|
189 return ETrue; |
|
190 case KCLKCount2: |
|
191 aOutput.Append(KPtiKey2_2); |
|
192 return ETrue; |
|
193 case KCLKCount3: |
|
194 aOutput.Append(KPtiKey2_3); |
|
195 return ETrue; |
|
196 case KCLKCount4: |
|
197 aOutput.Append(KPtiKey2_4); |
|
198 return ETrue; |
|
199 default: |
|
200 return EFalse; |
|
201 } |
|
202 case EPtiKey3: |
|
203 { |
|
204 switch ( aClkCount ) |
|
205 { |
|
206 case KCLKCount1: |
|
207 aOutput.Append(KPtiKey3_1); |
|
208 return ETrue; |
|
209 case KCLKCount2: |
|
210 aOutput.Append(KPtiKey3_2); |
|
211 return ETrue; |
|
212 case KCLKCount3: |
|
213 aOutput.Append(KPtiKey3_3); |
|
214 return ETrue; |
|
215 default: |
|
216 return EFalse; |
|
217 } |
|
218 } |
|
219 case EPtiKey4: |
|
220 { |
|
221 switch ( aClkCount ) |
|
222 { |
|
223 case KCLKCount1: |
|
224 aOutput.Append(KPtiKey4_1); |
|
225 return ETrue; |
|
226 case KCLKCount2: |
|
227 aOutput.Append(KPtiKey4_2); |
|
228 return ETrue; |
|
229 case KCLKCount3: |
|
230 aOutput.Append(KPtiKey4_3); |
|
231 return ETrue; |
|
232 default: |
|
233 return EFalse; |
|
234 } |
|
235 } |
|
236 case EPtiKey5: |
|
237 { |
|
238 switch ( aClkCount ) |
|
239 { |
|
240 case KCLKCount1: |
|
241 aOutput.Append(KPtiKey5_1); |
|
242 return ETrue; |
|
243 case KCLKCount2: |
|
244 aOutput.Append(KPtiKey5_2); |
|
245 return ETrue; |
|
246 case KCLKCount3: |
|
247 aOutput.Append(KPtiKey5_3); |
|
248 return ETrue; |
|
249 case KCLKCount4: |
|
250 aOutput.Append(KPtiKey5_4); |
|
251 return ETrue; |
|
252 default: |
|
253 return EFalse; |
|
254 } |
|
255 } |
|
256 case EPtiKey6: |
|
257 { |
|
258 switch ( aClkCount ) |
|
259 { |
|
260 case KCLKCount1: |
|
261 aOutput.Append(KPtiKey6_1); |
|
262 return ETrue; |
|
263 case KCLKCount2: |
|
264 aOutput.Append(KPtiKey6_2); |
|
265 return ETrue; |
|
266 case KCLKCount3: |
|
267 aOutput.Append(KPtiKey6_3); |
|
268 return ETrue; |
|
269 default: |
|
270 return EFalse; |
|
271 } |
|
272 } |
|
273 case EPtiKey7: |
|
274 { |
|
275 switch ( aClkCount ) |
|
276 { |
|
277 case KCLKCount1: |
|
278 aOutput.Append(KPtiKey7_1); |
|
279 return ETrue; |
|
280 case KCLKCount2: |
|
281 aOutput.Append(KPtiKey7_2); |
|
282 return ETrue; |
|
283 case KCLKCount3: |
|
284 aOutput.Append(KPtiKey7_3); |
|
285 return ETrue; |
|
286 case KCLKCount4: |
|
287 aOutput.Append(KPtiKey7_4); |
|
288 return ETrue; |
|
289 default: |
|
290 return EFalse; |
|
291 } |
|
292 } |
|
293 case EPtiKey8: |
|
294 { |
|
295 switch ( aClkCount ) |
|
296 { |
|
297 case KCLKCount1: |
|
298 aOutput.Append(KPtiKey8_1); |
|
299 return ETrue; |
|
300 case KCLKCount2: |
|
301 aOutput.Append(KPtiKey8_2); |
|
302 return ETrue; |
|
303 case KCLKCount3: |
|
304 aOutput.Append(KPtiKey8_3); |
|
305 return ETrue; |
|
306 case KCLKCount4: |
|
307 aOutput.Append(KPtiKey8_4); |
|
308 return ETrue; |
|
309 default: |
|
310 return EFalse; |
|
311 } |
|
312 } |
|
313 case EPtiKey9: |
|
314 { |
|
315 switch ( aClkCount ) |
|
316 { |
|
317 case KCLKCount1: |
|
318 aOutput.Append(KPtiKey9_1); |
|
319 return ETrue; |
|
320 case KCLKCount2: |
|
321 aOutput.Append(KPtiKey9_2); |
|
322 return ETrue; |
|
323 case KCLKCount3: |
|
324 aOutput.Append(KPtiKey9_3); |
|
325 return ETrue; |
|
326 case KCLKCount4: |
|
327 aOutput.Append(KPtiKey9_4); |
|
328 return ETrue; |
|
329 case KCLKCount5: |
|
330 aOutput.Append(KPtiKey9_5); |
|
331 return ETrue; |
|
332 default: |
|
333 return EFalse; |
|
334 } |
|
335 } |
|
336 case EPtiKeyStar: |
|
337 { |
|
338 switch ( aClkCount ) |
|
339 { |
|
340 case KCLKCount1: |
|
341 aOutput.Append(KPtiKeyStar_1); |
|
342 return ETrue; |
|
343 case KCLKCount2: |
|
344 aOutput.Append(KPtiKeyStar_2); |
|
345 return ETrue; |
|
346 case KCLKCount3: |
|
347 aOutput.Append(KPtiKeyStar_3); |
|
348 return ETrue; |
|
349 case KCLKCount4: |
|
350 aOutput.Append(KPtiKeyStar_4); |
|
351 return ETrue; |
|
352 case KCLKCount5: |
|
353 aOutput.Append(KPtiKeyStar_5); |
|
354 return ETrue; |
|
355 default: |
|
356 return EFalse; |
|
357 } |
|
358 } |
|
359 default: |
|
360 return EFalse; |
|
361 } |
|
362 } |
|
363 |
|
364 // --------------------------------------------------------- |
|
365 // C++ constructor |
|
366 // --------------------------------------------------------- |
|
367 // |
|
368 CZhuyinKeyHandler::CZhuyinKeyHandler( ) : |
|
369 CActive ( EPriorityStandard ), // Standard priority |
|
370 iLastKey ( EPtiKeyNone ), |
|
371 iTimeOut ( ETrue ), |
|
372 iBtClickNum ( 0 ), |
|
373 iBtLoopLength ( 1 ), |
|
374 iState( 0 ), |
|
375 iStatusChgFlag(EInit) |
|
376 { |
|
377 } |
|
378 |
|
379 // --------------------------------------------------------- |
|
380 // Two-phased constructor. |
|
381 // --------------------------------------------------------- |
|
382 // |
|
383 CZhuyinKeyHandler* CZhuyinKeyHandler::NewLC() |
|
384 { |
|
385 CZhuyinKeyHandler* self = new ( ELeave ) CZhuyinKeyHandler(); |
|
386 CleanupStack::PushL( self ); |
|
387 self->ConstructL( ); |
|
388 return self; |
|
389 } |
|
390 |
|
391 // --------------------------------------------------------- |
|
392 // Two-phased constructor. |
|
393 // --------------------------------------------------------- |
|
394 // |
|
395 CZhuyinKeyHandler* CZhuyinKeyHandler::NewL() |
|
396 { |
|
397 CZhuyinKeyHandler* self = CZhuyinKeyHandler::NewLC(); |
|
398 CleanupStack::Pop( self ); // self; |
|
399 return self; |
|
400 } |
|
401 |
|
402 // --------------------------------------------------------- |
|
403 // Two-phased constructor. |
|
404 // --------------------------------------------------------- |
|
405 // |
|
406 void CZhuyinKeyHandler::ConstructL( ) |
|
407 { |
|
408 User::LeaveIfError( iTimer.CreateLocal( ) ); // Initialize timer |
|
409 CActiveScheduler::Add( this ); // Add to scheduler |
|
410 } |
|
411 |
|
412 // --------------------------------------------------------- |
|
413 // Cancel and destroy. |
|
414 // --------------------------------------------------------- |
|
415 // |
|
416 CZhuyinKeyHandler::~CZhuyinKeyHandler( ) |
|
417 { |
|
418 Cancel( ); // Cancel any request, if outstanding |
|
419 iTimer.Close( ); // Destroy the RTimer object |
|
420 // Delete instance variables if any |
|
421 } |
|
422 |
|
423 // --------------------------------------------------------- |
|
424 // How to cancel me. |
|
425 // --------------------------------------------------------- |
|
426 // |
|
427 void CZhuyinKeyHandler::DoCancel( ) |
|
428 { |
|
429 iTimer.Cancel( ); |
|
430 } |
|
431 |
|
432 // --------------------------------------------------------- |
|
433 // Function for making the initial request. |
|
434 // --------------------------------------------------------- |
|
435 // |
|
436 void CZhuyinKeyHandler::Start() |
|
437 { |
|
438 Cancel(); // Cancel any request, just to be sure |
|
439 iTimer.After( iStatus, KTimerOut ); // Set for later |
|
440 SetActive(); // Tell scheduler a request is active |
|
441 } |
|
442 |
|
443 // --------------------------------------------------------- |
|
444 // Get Zhuyin symbol according to the inputting key. |
|
445 // --------------------------------------------------------- |
|
446 // |
|
447 TInt CZhuyinKeyHandler::GetZhuyinSymbol ( TPtiKey aKey, TDes& aOutBuf ) |
|
448 { |
|
449 TInt ret = 0; |
|
450 Start(); |
|
451 // if the same button is pressed for many times. |
|
452 if ( iLastKey == aKey |
|
453 && iTimeOut == EFalse ) |
|
454 { |
|
455 if ( iBtLoopLength != 0 ) |
|
456 { |
|
457 iBtClickNum++; |
|
458 if ( iBtClickNum > iBtLoopLength ) |
|
459 { |
|
460 iBtClickNum = 1; |
|
461 } |
|
462 } |
|
463 // Search for the corresponding unicode and value aOutBuf. |
|
464 ZhuyinKeyTable::GetUnicode(aKey,iBtClickNum,aOutBuf); |
|
465 ret = 0; |
|
466 } |
|
467 // if the pressed button is changed or time out event is happened. |
|
468 else if ( iLastKey == aKey |
|
469 && iTimeOut != EFalse ) |
|
470 { |
|
471 // Update iBtClickNum |
|
472 iBtClickNum = 1; |
|
473 // Search for the corresponding unicode and value aOutBuf. |
|
474 ZhuyinKeyTable::GetUnicode(aKey,iBtClickNum,aOutBuf); |
|
475 ret = 1; |
|
476 } |
|
477 else |
|
478 { |
|
479 // Update iBtClickNum |
|
480 iBtClickNum = 1; |
|
481 // Update iBtUnicodeNum |
|
482 iBtLoopLength = ZhuyinKeyTable::GetBtLoopLength(aKey); |
|
483 // Search for the corresponding unicode and value aOutBuf. |
|
484 ZhuyinKeyTable::GetUnicode(aKey,iBtClickNum,aOutBuf); |
|
485 if ( iBtLoopLength != 0 ) |
|
486 { |
|
487 ret = 1; |
|
488 } |
|
489 else |
|
490 { |
|
491 ret = -1; |
|
492 } |
|
493 } |
|
494 iLastKey = aKey; |
|
495 iTimeOut = EFalse; |
|
496 return ret; |
|
497 } |
|
498 |
|
499 // --------------------------------------------------------- |
|
500 // Set status change flag. |
|
501 // --------------------------------------------------------- |
|
502 // |
|
503 void CZhuyinKeyHandler::SetStatusChgFlag ( MZhuyinKeyHandler::TStatusChgFlag aChgFlag ) |
|
504 { |
|
505 iStatusChgFlag = aChgFlag; |
|
506 } |
|
507 |
|
508 // --------------------------------------------------------- |
|
509 // Get the status change flag. |
|
510 // --------------------------------------------------------- |
|
511 // |
|
512 MZhuyinKeyHandler::TStatusChgFlag CZhuyinKeyHandler::GetStatusChgFlag () |
|
513 { |
|
514 return iStatusChgFlag; |
|
515 } |
|
516 |
|
517 // --------------------------------------------------------- |
|
518 // Reset all the member variables. |
|
519 // --------------------------------------------------------- |
|
520 // |
|
521 void CZhuyinKeyHandler::Reset() |
|
522 { |
|
523 iLastKey = EPtiKeyNone; |
|
524 iTimeOut = ETrue ; |
|
525 iBtClickNum = 0; |
|
526 iBtLoopLength = 1; |
|
527 } |
|
528 |
|
529 |
|
530 // --------------------------------------------------------- |
|
531 // Get tonemark according to symbol in front of cursor. |
|
532 // --------------------------------------------------------- |
|
533 // |
|
534 TInt CZhuyinKeyHandler::GetToneMark ( const TDes& aBaseSymbol, TDes& aOutBuf ) |
|
535 { |
|
536 TInt ret = 0; |
|
537 iBtLoopLength = KBTLoopLength; |
|
538 iTimeOut = ETrue ; |
|
539 if ( aBaseSymbol.Compare(KPtiKeyStar_1) == 0 ) |
|
540 { |
|
541 iBtClickNum = KCLKCount1; |
|
542 } |
|
543 else if ( aBaseSymbol.Compare(KPtiKeyStar_2) == 0 ) |
|
544 { |
|
545 iBtClickNum = KCLKCount2; |
|
546 } |
|
547 else if ( aBaseSymbol.Compare(KPtiKeyStar_3) == 0 ) |
|
548 { |
|
549 iBtClickNum = KCLKCount3; |
|
550 } |
|
551 else if ( aBaseSymbol.Compare(KPtiKeyStar_4) == 0 ) |
|
552 { |
|
553 iBtClickNum = KCLKCount4; |
|
554 } |
|
555 else if ( aBaseSymbol.Compare(KPtiKeyStar_5) == 0 ) |
|
556 { |
|
557 iBtClickNum = KCLKCount5; |
|
558 } |
|
559 else |
|
560 { |
|
561 iBtClickNum = 0; |
|
562 ret = 1; |
|
563 } |
|
564 iBtClickNum++; |
|
565 if ( iBtClickNum > iBtLoopLength ) |
|
566 { |
|
567 iBtClickNum = 1; |
|
568 } |
|
569 ZhuyinKeyTable::GetUnicode(EPtiKeyStar,iBtClickNum,aOutBuf); |
|
570 iLastKey = EPtiKeyStar; |
|
571 iTimeOut = EFalse; |
|
572 return ret; |
|
573 } |
|
574 |
|
575 // --------------------------------------------------------- |
|
576 // Get tonemark according to symbol in front of cursor. |
|
577 // --------------------------------------------------------- |
|
578 // |
|
579 void CZhuyinKeyHandler::RunL( ) |
|
580 { |
|
581 iTimeOut = ETrue; |
|
582 } |
|
583 |
|
584 // --------------------------------------------------------- |
|
585 // Override to handle leaves from RunL(). Default implementation causes. |
|
586 // --------------------------------------------------------- |
|
587 // |
|
588 TInt CZhuyinKeyHandler::RunError( TInt aError ) |
|
589 { |
|
590 return aError; |
|
591 } |
|
592 |
|
593 // --------------------------------------------------------- |
|
594 // Set whether state change from entry to spelling editing is automatical. |
|
595 // --------------------------------------------------------- |
|
596 // |
|
597 void CZhuyinKeyHandler::SetState( TInt aState ) |
|
598 { |
|
599 iState = aState; |
|
600 } |
|
601 |
|
602 // --------------------------------------------------------- |
|
603 // Get state change states. |
|
604 // --------------------------------------------------------- |
|
605 // |
|
606 TInt CZhuyinKeyHandler::GetState() |
|
607 { |
|
608 return iState; |
|
609 } |
|
610 |
|
611 // End of file |
|