|
1 /* |
|
2 * Copyright (c) 2002-2005 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: drop-down list control |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <peninputsplititutnew.rsg> |
|
20 #include <peninputsplititutconfig_chinese.rsg> |
|
21 #include <skinlayout.cdl.h> |
|
22 #include <AknsDrawUtils.h> |
|
23 #include <AknsUtils.h> |
|
24 #include <AknUtils.h> |
|
25 #include <peninputrawkeybutton.h> |
|
26 #include <peninputrepeatbutton.h> |
|
27 #include <peninputcommonbutton.h> |
|
28 #include <AknFepGlobalEnums.h> |
|
29 #include <aknfeppeninputenums.h> |
|
30 #include <peninputdropdownlist.h> |
|
31 #include <s32mem.h> |
|
32 #include <peninputlabel.h> |
|
33 //#include <peninputlayoutbubblectrl.h> |
|
34 |
|
35 #include "peninputsplititutwindow.h" |
|
36 #include "peninputsplititutdatamgr.h" |
|
37 #include "peninputsplititutuimgrbase.h" |
|
38 #include "peninputsplititutuistatebase.h" |
|
39 #include "peninputsplititutchnuimgr.h" |
|
40 #include "peninputsplititutwesternuimgr.h" |
|
41 #include "peninputsplititutconverter.h" |
|
42 #include "peninputcommonbgctrl.h" |
|
43 |
|
44 _LIT(KBmpFileName, "z:\\resource\\apps\\peninputsplititut.mbm"); |
|
45 |
|
46 const TInt KImageMajorSkinId = EAknsMajorGeneric; |
|
47 const TUint KDefaultSpellTextColor = 0; |
|
48 |
|
49 const TInt KSpaceUnicode = 32; |
|
50 const TInt KButtonOneUnicode = 49; |
|
51 const TInt KInvalidBmp = -1; |
|
52 |
|
53 |
|
54 // ============================ MEMBER FUNCTIONS ============================= |
|
55 |
|
56 // --------------------------------------------------------------------------- |
|
57 // CSplitItutWindow::NewL |
|
58 // --------------------------------------------------------------------------- |
|
59 // |
|
60 CSplitItutWindow* CSplitItutWindow::NewL(CSplitItutWindowManager* aWindowMgr, |
|
61 CSplitItutUiLayout* aLayoutOwner, |
|
62 CSplitItutDataMgr* aDataMgr) |
|
63 { |
|
64 CSplitItutWindow* window = new (ELeave) CSplitItutWindow(aWindowMgr,aLayoutOwner,aDataMgr); |
|
65 |
|
66 CleanupStack::PushL(window); |
|
67 window->ConstructL(); |
|
68 CleanupStack::Pop(window); |
|
69 |
|
70 return window; |
|
71 } |
|
72 |
|
73 // --------------------------------------------------------------------------- |
|
74 // CSplitItutWindow::CSplitItutWindow |
|
75 // --------------------------------------------------------------------------- |
|
76 // |
|
77 CSplitItutWindow::CSplitItutWindow(CSplitItutWindowManager* aWindowMgr, |
|
78 CSplitItutUiLayout* aLayoutOwner, |
|
79 CSplitItutDataMgr* aDataMgr) |
|
80 : iDataMgr(aDataMgr), |
|
81 iLayoutOwner(aLayoutOwner), |
|
82 iWindowMgr(aWindowMgr) |
|
83 { |
|
84 } |
|
85 |
|
86 // --------------------------------------------------------------------------- |
|
87 // CSplitItutWindow::~CSplitItutWindow |
|
88 // --------------------------------------------------------------------------- |
|
89 // |
|
90 CSplitItutWindow::~CSplitItutWindow() |
|
91 { |
|
92 delete iBmpRotator; |
|
93 } |
|
94 |
|
95 // --------------------------------------------------------------------------- |
|
96 // CSplitItutWindow::SetPropertyL |
|
97 // --------------------------------------------------------------------------- |
|
98 // |
|
99 void CSplitItutWindow::SetPropertyL(MItutPropertySubscriber::TItutProperty aPropertyName, |
|
100 const TDesC& aPropertyValue) |
|
101 { |
|
102 switch (aPropertyName) |
|
103 { |
|
104 case MItutPropertySubscriber::EItutPropertyKeypadResourceId: |
|
105 case MItutPropertySubscriber::EItutPropertyCandidateListResourceId: |
|
106 { |
|
107 TInt resId = TItutDataConverter::AnyToInt(const_cast<TUint16*>(aPropertyValue.Ptr())); |
|
108 |
|
109 if (resId == KInvalidResId) |
|
110 { |
|
111 return; |
|
112 } |
|
113 |
|
114 if (aPropertyName == MItutPropertySubscriber::EItutPropertyKeypadResourceId) |
|
115 { |
|
116 ConstructItutKeypadFromResourceL(resId); |
|
117 } |
|
118 else if (iCandsList) |
|
119 { |
|
120 iCandsList->ResetAndClear(CFepCtrlDropdownList::EListExpandable); |
|
121 iCandsList->SetResourceId(resId); |
|
122 iCandsList->ConstructFromResourceL(); |
|
123 } |
|
124 } |
|
125 break; |
|
126 case MItutPropertySubscriber::EItutPropertyLandscape: |
|
127 { |
|
128 TBool landscape = *((TInt*)(aPropertyValue.Ptr())); |
|
129 |
|
130 if (iDataMgr->IsChinese()) |
|
131 { |
|
132 if (landscape) |
|
133 { |
|
134 // expand upward |
|
135 iSpellCandsList->SetCandExpandType(CFepCtrlDropdownList::ECandExpandUpward); |
|
136 iCandsList->SetCandExpandType(CFepCtrlDropdownList::ECandExpandUpward); |
|
137 } |
|
138 else |
|
139 { |
|
140 // portrait, expand downward |
|
141 iSpellCandsList->SetCandExpandType(); |
|
142 iCandsList->SetCandExpandType(); |
|
143 } |
|
144 } |
|
145 } |
|
146 break; |
|
147 default: |
|
148 break; |
|
149 } |
|
150 } |
|
151 |
|
152 // --------------------------------------------------------------------------- |
|
153 // CSplitItutWindow::CreateItutKeypadL |
|
154 // --------------------------------------------------------------------------- |
|
155 // |
|
156 void CSplitItutWindow::CreateItutKeypadL() |
|
157 { |
|
158 TRect keypadRect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EKeypadRect)); |
|
159 |
|
160 TFontSpec spec; |
|
161 |
|
162 iStandardItutKp = CVirtualKeyboard::NewL(keypadRect, |
|
163 iLayoutOwner, |
|
164 ECtrlIdStdItut, |
|
165 spec); |
|
166 AddControlL(iStandardItutKp); |
|
167 |
|
168 iStandardItutKp->SetResourceId(KInvalidResId); |
|
169 |
|
170 // read keypad image info |
|
171 ConstructKeyImageFromResourceL( R_ITUT_KEYPAD_BITMAP ); |
|
172 |
|
173 iStandardItutKp->SetKeyTextColorGroup( EAknsCIQsnTextColorsCG68 ); |
|
174 iStandardItutKp->SetDrawOpaqueBackground(EFalse); |
|
175 |
|
176 // read key shift icon res |
|
177 CPenInputColorIcon* shiftIcon = CPenInputColorIcon::NewL( R_ITUT_KEYPAD_SHIFT_ICON ); |
|
178 shiftIcon->ResizeL( iDataMgr->iShiftIconRect.Size() ); |
|
179 iStandardItutKp->SetShiftIcon( shiftIcon ); |
|
180 |
|
181 //set key to be 9 piece graphics |
|
182 iStandardItutKp->SetKeySkinId( EKeyBmpNormal, KAknsIIDQsnFrKeypadButtonFrNormal ); |
|
183 iStandardItutKp->SetKeySkinId( EKeyBmpHighlight, KAknsIIDQsnFrKeypadButtonFrPressed ); |
|
184 iStandardItutKp->SetKeySkinId( EKeyBmpDim, KAknsIIDQsnFrKeypadButtonFrInactive ); |
|
185 } |
|
186 |
|
187 // --------------------------------------------------------------------------- |
|
188 // CSplitItutWindow::CreateLayoutIconL |
|
189 // --------------------------------------------------------------------------- |
|
190 // |
|
191 void CSplitItutWindow::CreateLayoutIconL(TInt aMajorSkinId, |
|
192 TInt aMinorSkinId, |
|
193 const TDesC& aBmpFileName, |
|
194 TInt aBmpId, |
|
195 TInt aMaskBmpId, |
|
196 CFbsBitmap*& aBmp, |
|
197 CFbsBitmap*& aMaskBmp, |
|
198 TSize aSize) |
|
199 { |
|
200 TAknsItemID id; |
|
201 MAknsSkinInstance* skininstance = AknsUtils::SkinInstance(); |
|
202 id.Set(TInt(aMajorSkinId), aMinorSkinId); |
|
203 |
|
204 if (aBmpId != KInvalidBmp) |
|
205 { |
|
206 if (aMaskBmpId != KInvalidBmp) |
|
207 { |
|
208 AknsUtils::CreateIconL(skininstance, |
|
209 id, |
|
210 aBmp, |
|
211 aMaskBmp, |
|
212 aBmpFileName, |
|
213 aBmpId, |
|
214 aMaskBmpId); |
|
215 AknIconUtils::SetSize(aMaskBmp, aSize, EAspectRatioNotPreserved); |
|
216 } |
|
217 else |
|
218 { |
|
219 AknsUtils::CreateIconL(skininstance, |
|
220 id, |
|
221 aBmp, |
|
222 aBmpFileName, |
|
223 aBmpId); |
|
224 } |
|
225 |
|
226 AknIconUtils::SetSize(aBmp, aSize, EAspectRatioNotPreserved); |
|
227 } |
|
228 } |
|
229 |
|
230 // --------------------------------------------------------------------------- |
|
231 // CSplitItutWindow::ConstructItutKeypadFromResourceL |
|
232 // --------------------------------------------------------------------------- |
|
233 // |
|
234 void CSplitItutWindow::ConstructItutKeypadFromResourceL(TInt aResId) |
|
235 { |
|
236 iStandardItutKp->SetResourceId(aResId); |
|
237 |
|
238 iStandardItutKp->SetTextLineLayout( |
|
239 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadLeftTextLine)), |
|
240 EPosLeft); |
|
241 iStandardItutKp->SetTextLineLayout( |
|
242 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine1)), |
|
243 EPosRight1); |
|
244 iStandardItutKp->SetTextLineLayout( |
|
245 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine2)), |
|
246 EPosRight2); |
|
247 iStandardItutKp->SetTextLineLayout( |
|
248 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine3)), |
|
249 EPosRight3); |
|
250 |
|
251 TResourceReader reader; |
|
252 CCoeEnv::Static()->CreateResourceReaderLC(reader, aResId); |
|
253 |
|
254 // construct keys |
|
255 TInt countkeys = reader.ReadInt16(); |
|
256 |
|
257 RPointerArray<CVirtualKey>& keys = |
|
258 const_cast<RPointerArray<CVirtualKey>&>(iStandardItutKp->KeyArray()); |
|
259 |
|
260 if (keys.Count() == 0) |
|
261 { |
|
262 for (TInt i = 0; i < countkeys; i++) |
|
263 { |
|
264 RArray<TRect>& cellrects = |
|
265 TItutDataConverter::AnyToRectArray(iDataMgr->RequestData(EKeypadCellRects)); |
|
266 |
|
267 CVirtualKey* vk = CreateKeyL(reader, |
|
268 cellrects[i]); |
|
269 CleanupStack::PushL(vk); |
|
270 iStandardItutKp->AddRawKeyL(vk); |
|
271 CleanupStack::Pop(vk); |
|
272 } |
|
273 } |
|
274 else |
|
275 { |
|
276 countkeys = keys.Count(); |
|
277 for (TInt i = 0; i < countkeys; i++) |
|
278 { |
|
279 ChangeVirtualKeyInfoL(reader, keys[i]); |
|
280 } |
|
281 } |
|
282 |
|
283 CleanupStack::PopAndDestroy(1); // reader |
|
284 |
|
285 iStandardItutKp->Draw(); |
|
286 iStandardItutKp->UpdateArea( iStandardItutKp->Rect() ); |
|
287 } |
|
288 |
|
289 // --------------------------------------------------------------------------- |
|
290 // CSplitItutWindow::ChangeVirtualKeyInfoL |
|
291 // --------------------------------------------------------------------------- |
|
292 // |
|
293 void CSplitItutWindow::ChangeVirtualKeyInfoL( TResourceReader& aReader, |
|
294 CVirtualKey* aKey) |
|
295 { |
|
296 |
|
297 TBuf<5> mapData; |
|
298 //Init Data |
|
299 for (TInt i = 0; i < 5; i++) |
|
300 { |
|
301 mapData.Append(0); |
|
302 } |
|
303 |
|
304 RPointerArray<HBufC> unicodesArr; |
|
305 for (TInt i = 0; i <= EPosLast; i++) |
|
306 { |
|
307 HBufC* unicode = aReader.ReadHBufCL(); |
|
308 if (i == 0 && unicode != NULL) |
|
309 { |
|
310 mapData = unicode->Des(); |
|
311 } |
|
312 unicodesArr.AppendL(unicode); |
|
313 } |
|
314 |
|
315 TInt keyscancode = aReader.ReadInt16(); |
|
316 if (keyscancode != aKey->ScanCode()) |
|
317 { |
|
318 return; |
|
319 } |
|
320 |
|
321 TInt curMode = TItutDataConverter::AnyToInt( |
|
322 iLayoutOwner->DataMgr()->RequestData(EInputMode)); |
|
323 TBool isChinese = iLayoutOwner->DataMgr()->IsChinese(); |
|
324 TBool isThai = iLayoutOwner->DataMgr()->IsThai(); |
|
325 |
|
326 TInt latinOnly = TItutDataConverter::AnyToInt( |
|
327 iLayoutOwner->DataMgr()->RequestData(ELatinOnly)); |
|
328 |
|
329 //No symbol in Number range. Symbols under chinese are read from res |
|
330 if ( curMode != ENumber && curMode != ENativeNumber |
|
331 && iSymbolData.iSymbol1 != 0 && keyscancode == KButtonOneUnicode |
|
332 && ( !isChinese || latinOnly ) |
|
333 && ( !isThai ) ) |
|
334 { |
|
335 //So we should delete it |
|
336 for (TInt i = 0; i <= EPosLast; i++) |
|
337 { |
|
338 delete unicodesArr[i]; |
|
339 } |
|
340 SetUnicodesForHardKey1(aKey, mapData); |
|
341 } |
|
342 else |
|
343 { |
|
344 aKey->SetUnicodesL(unicodesArr); |
|
345 } |
|
346 |
|
347 unicodesArr.Close(); |
|
348 } |
|
349 |
|
350 // --------------------------------------------------------------------------- |
|
351 // CSplitItutWindow::CreateKeyL |
|
352 // --------------------------------------------------------------------------- |
|
353 // |
|
354 CVirtualKey* CSplitItutWindow::CreateKeyL(TResourceReader& aReader, |
|
355 TRect aKeyRect) |
|
356 { |
|
357 RPointerArray<HBufC> unicodesArr; |
|
358 for (TInt i = 0; i <= EPosLast; i++) |
|
359 { |
|
360 HBufC* unicode = aReader.ReadHBufCL(); |
|
361 unicodesArr.AppendL(unicode); |
|
362 } |
|
363 |
|
364 TInt keyscancode = aReader.ReadInt16(); |
|
365 |
|
366 CVirtualKey* vk = CVirtualKey::NewL(unicodesArr, |
|
367 keyscancode, |
|
368 aKeyRect); |
|
369 unicodesArr.Close(); |
|
370 CleanupStack::PushL(vk); |
|
371 |
|
372 TRect innerrect = aKeyRect; |
|
373 innerrect.Shrink(TSize(7, 7)); |
|
374 vk->SetInnerRect(innerrect); |
|
375 |
|
376 CleanupStack::Pop(vk); |
|
377 |
|
378 return vk; |
|
379 } |
|
380 |
|
381 // --------------------------------------------------------------------------- |
|
382 // CSplitItutWindow::CreateBackGroundControlL |
|
383 // --------------------------------------------------------------------------- |
|
384 // |
|
385 void CSplitItutWindow::CreateBackGroundControlL() |
|
386 { |
|
387 iBackgroundCtrl = CAknFepCtrlCommonBgCtrl::NewL( |
|
388 iLayoutOwner, |
|
389 ECtrlIdBackground, |
|
390 KAknsIIDQsnFrPopup, |
|
391 KAknsIIDQsnFrPopupCenter); |
|
392 |
|
393 |
|
394 iBackgroundCtrl->SetRect(TItutDataConverter::AnyToRect( |
|
395 iLayoutOwner->DataMgr()->RequestData(EBackgroundRect))); |
|
396 |
|
397 AddControlL(iBackgroundCtrl); |
|
398 } |
|
399 |
|
400 |
|
401 // --------------------------------------------------------------------------- |
|
402 // CSplitItutWindow::CreateRawKeyButtonL |
|
403 // --------------------------------------------------------------------------- |
|
404 // |
|
405 CAknFepCtrlCommonButton* CSplitItutWindow::CreateRawKeyButtonL(const TInt aControlId, |
|
406 const TInt aCommand) |
|
407 { |
|
408 CAknFepCtrlCommonButton* temp = NULL; |
|
409 |
|
410 if (aCommand == KUnavailableID) |
|
411 { |
|
412 temp = CAknFepCtrlRawKeyButton::NewL(iLayoutOwner, |
|
413 aControlId, |
|
414 KAknsIIDQsnFrFunctionButtonNormal, |
|
415 KAknsIIDQsnFrFunctionButtonPressed, |
|
416 KAknsIIDQsnFrFunctionButtonInactive, |
|
417 EEventRawKeyDownEvent, |
|
418 EEventRawKeyUpEvent); |
|
419 } |
|
420 else |
|
421 { |
|
422 temp = CAknFepCtrlRawKeyButton::NewL(iLayoutOwner, |
|
423 aControlId, |
|
424 KAknsIIDQsnFrFunctionButtonNormal, |
|
425 KAknsIIDQsnFrFunctionButtonPressed, |
|
426 KAknsIIDQsnFrFunctionButtonInactive, |
|
427 EEventRawKeyDownEvent, |
|
428 EEventRawKeyUpEvent, |
|
429 aCommand); |
|
430 } |
|
431 |
|
432 return temp; |
|
433 } |
|
434 |
|
435 // --------------------------------------------------------------------------- |
|
436 // CSplitItutWindow::CreateCommonButtonL |
|
437 // --------------------------------------------------------------------------- |
|
438 // |
|
439 CAknFepCtrlCommonButton* CSplitItutWindow::CreateCommonButtonL(const TInt aControlId) |
|
440 { |
|
441 return CAknFepCtrlCommonButton::NewL(iLayoutOwner, |
|
442 aControlId, |
|
443 KAknsIIDQsnFrFunctionButtonNormal, |
|
444 KAknsIIDQsnFrFunctionButtonPressed, |
|
445 KAknsIIDQsnFrFunctionButtonInactive ); |
|
446 |
|
447 } |
|
448 |
|
449 // --------------------------------------------------------------------------- |
|
450 // CSplitItutWindow::CreateRepeatButtonL |
|
451 // --------------------------------------------------------------------------- |
|
452 // |
|
453 CAknFepCtrlCommonButton* CSplitItutWindow::CreateRepeatButtonL(const TInt /*aControlId*/, |
|
454 const TInt /*aCommand*/) |
|
455 { |
|
456 return NULL; |
|
457 |
|
458 } |
|
459 |
|
460 |
|
461 // --------------------------------------------------------------------------- |
|
462 // CSplitItutWindow::CreateButtonL |
|
463 // --------------------------------------------------------------------------- |
|
464 // |
|
465 CFepUiBaseCtrl* CSplitItutWindow::CreateButtonL(TButtonType aType, |
|
466 const TInt aControlId, |
|
467 const TInt aRectId, |
|
468 const TInt aInnerRectId, |
|
469 const TInt aResourceId, |
|
470 const TInt aCommand) |
|
471 { |
|
472 CAknFepCtrlCommonButton* temp = NULL; |
|
473 |
|
474 switch(aType) |
|
475 { |
|
476 case ERawKeyButton: |
|
477 { |
|
478 temp = CreateRawKeyButtonL(aControlId, aCommand); |
|
479 } |
|
480 break; |
|
481 case ECommonButton: |
|
482 { |
|
483 temp = CreateCommonButtonL(aControlId); |
|
484 } |
|
485 break; |
|
486 default: |
|
487 { |
|
488 User::Leave(KErrArgument); |
|
489 } |
|
490 } |
|
491 |
|
492 TRect btnrect; |
|
493 TRect btnInnerRect; |
|
494 |
|
495 if (aRectId != KUnavailableID && |
|
496 aInnerRectId != KUnavailableID) |
|
497 { |
|
498 btnrect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aRectId)); |
|
499 btnInnerRect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aInnerRectId)); |
|
500 |
|
501 temp->SetRect(btnrect); |
|
502 temp->SetForgroundBmpRect(btnInnerRect); |
|
503 } |
|
504 |
|
505 if (aResourceId != KUnavailableID) |
|
506 { |
|
507 temp->SetResourceId(aResourceId); |
|
508 temp->ConstructFromResourceL(); |
|
509 } |
|
510 |
|
511 if (aRectId != KUnavailableID && |
|
512 aInnerRectId != KUnavailableID) |
|
513 { |
|
514 temp->SizeChanged(temp->Rect(), btnInnerRect, ETrue); |
|
515 } |
|
516 |
|
517 AddControlL(temp); |
|
518 |
|
519 return temp; |
|
520 } |
|
521 |
|
522 // --------------------------------------------------------------------------- |
|
523 // CSplitItutWindow::CreateAllButtonL |
|
524 // --------------------------------------------------------------------------- |
|
525 // |
|
526 void CSplitItutWindow::CreateAllButtonL() |
|
527 { |
|
528 //create backgrand |
|
529 CreateBackGroundControlL(); |
|
530 |
|
531 //create backspace |
|
532 CreateButtonL(ERawKeyButton, ECtrlIdBackspace, EBackspaceRect, |
|
533 EBackspaceInnerRect,R_FINGER_RAWKEY_BACKSPACE); |
|
534 |
|
535 // create navi |
|
536 CreateButtonL(ERawKeyButton, ECtrlIdArrowLeft, EArrowLeftRect, |
|
537 ELeftInnerRect,R_FINGER_RAWKEY_LEFTARROW); |
|
538 |
|
539 CreateButtonL(ERawKeyButton, ECtrlIdArrowRight, EArrowRightRect, |
|
540 ERightInnerRect,R_FINGER_RAWKEY_RIGHTARROW); |
|
541 |
|
542 /* |
|
543 CreateButtonL(ERepeatButtonEx, ECtrlIdArrowUp, EArrowUpRect, |
|
544 EUpInnerRect,R_PENINPUT_FINGER_CURSOR_UP); |
|
545 |
|
546 CreateButtonL(ERepeatButtonEx, ECtrlIdArrowDown, EArrowDownRect, |
|
547 EDownInnerRect,R_PENINPUT_FINGER_CURSOR_DOWN); |
|
548 */ |
|
549 //create option |
|
550 CreateButtonL(ECommonButton, ECtrlIdOptions, EOptionsRect, |
|
551 EOptionInnerRect, R_PENINPUT_FINGER_OPTIONS); |
|
552 |
|
553 //Crease close |
|
554 CreateButtonL(ECommonButton, ECtrlIdClose, ECloseRect, |
|
555 ECloseInnerRect, R_PENINPUT_FINGER_CLOSE); |
|
556 |
|
557 } |
|
558 |
|
559 // --------------------------------------------------------------------------- |
|
560 // CSplitItutWindow::CreateDropdownListL |
|
561 // --------------------------------------------------------------------------- |
|
562 // |
|
563 void CSplitItutWindow::CreateDropdownListL() |
|
564 { |
|
565 TRect outrect,innerrect; |
|
566 outrect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EPreviewBubbleRect)); |
|
567 innerrect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(EPreviewBubbleInnerRect)); |
|
568 TAknTextLineLayout bubbleTextLayout = |
|
569 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EPreviewBubbleTextlayout)); |
|
570 CFont* bubbleFont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EPreviewBubbleFont)); |
|
571 |
|
572 TDropdownListDrawInfo candiDrawInfo(KAknsIIDQsnFrFunctionButtonInactive, |
|
573 KAknsIIDQsnFrFunctionButtonNormal, |
|
574 KAknsIIDQsnFrFunctionButtonPressed, |
|
575 KAknsIIDQsnFrItutButtonCandiSideL, |
|
576 KAknsIIDQsnFrItutButtonCandiMiddle, |
|
577 KAknsIIDQsnFrItutButtonCandiSideR, |
|
578 KAknsIIDQsnFrItutButtonCandiPressedSideL, |
|
579 KAknsIIDQsnFrItutButtonCandiPressedMiddle, |
|
580 KAknsIIDQsnFrItutButtonCandiPressedSideR, |
|
581 TRgb(194, 221, 242), |
|
582 ETrue); |
|
583 |
|
584 TDropdownListDrawInfo compositionDrawInfo(KAknsIIDQsnFrFunctionButtonInactive, |
|
585 KAknsIIDQsnFrFunctionButtonNormal, |
|
586 KAknsIIDQsnFrFunctionButtonPressed, |
|
587 KAknsIIDQsnFrItutButtonComposeSideL, |
|
588 KAknsIIDQsnFrItutButtonComposeMiddle, |
|
589 KAknsIIDQsnFrItutButtonComposeSideR, |
|
590 KAknsIIDQsnFrItutButtonComposePressedSideL, |
|
591 KAknsIIDQsnFrItutButtonComposePressedSideR, |
|
592 KAknsIIDQsnFrItutButtonComposePressedMiddle, |
|
593 TRgb(194, 221, 242), |
|
594 ETrue); |
|
595 TInt unitWidth = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistUnitWidth)); |
|
596 TInt unitHeight = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistUnitHeight)); |
|
597 TInt horizontalMargin = |
|
598 TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistHorizontalMargin)); |
|
599 TInt verticalMargin = |
|
600 TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistVerticalMargin)); |
|
601 |
|
602 CFont* listfont = TItutDataConverter::AnyToFont(iDataMgr->RequestData(EDropdownListFont)); |
|
603 TInt textmargin = TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownListTextMargin)); |
|
604 TRgb textcolor = TItutDataConverter::AnyToRgb(iDataMgr->RequestData(EDropdownListTextColor)); |
|
605 |
|
606 TPoint spellListLTPos = |
|
607 TItutDataConverter::AnyToPoint(iDataMgr->RequestData(EDropdownListSpellLTPos)); |
|
608 // create spelling drop list |
|
609 iSpellCandsList = CFepCtrlDropdownList::NewL(iLayoutOwner, |
|
610 ECtrlIdSpellCandsList, |
|
611 R_AKN_FEP_PINYIN_SPELLING_DROP_DOWN_LIST, |
|
612 spellListLTPos, |
|
613 TSize(unitWidth, unitHeight), |
|
614 5, |
|
615 3); |
|
616 |
|
617 |
|
618 iSpellCandsList->SetCellMargin(horizontalMargin, verticalMargin); |
|
619 iSpellCandsList->SetFont(listfont); |
|
620 AddControlL(iSpellCandsList); |
|
621 iSpellCandsList->SetEventIdForCandidateSelected(EItutCmdCandidateSelected); |
|
622 iSpellCandsList->SetCandTruncateType(CFepCtrlDropdownList::ECandTruncateFromBeginning); |
|
623 iSpellCandsList->SetFuzzyBoundry(10); |
|
624 iSpellCandsList->Hide(ETrue); |
|
625 iSpellCandsList->SetDropdownListImgID(compositionDrawInfo); |
|
626 |
|
627 TPoint candListLTPos = |
|
628 TItutDataConverter::AnyToPoint(iDataMgr->RequestData(EDropdownListCandsLTPos)); |
|
629 // create candidate drop list |
|
630 iCandsList = CFepCtrlDropdownList::NewL(iLayoutOwner, |
|
631 ECtrlIdStdCandsList, |
|
632 R_AKN_FEP_NORMAL_CAND_DROP_DOWN_LIST, |
|
633 candListLTPos, |
|
634 TSize(unitWidth, unitHeight), |
|
635 5, |
|
636 3); |
|
637 |
|
638 |
|
639 iCandsList->SetCellMargin(horizontalMargin, verticalMargin); |
|
640 iCandsList->SetFont(listfont); |
|
641 AddControlL(iCandsList); |
|
642 iCandsList->SetEventIdForCandidateSelected(EItutCmdCandidateSelected); |
|
643 iCandsList->SetEventIdForNextPageCandidate(EItutCmdGetNextCandidatePage); |
|
644 iCandsList->SetEventIdForCandidateExisted(EItutCmdCandidateExisted); |
|
645 iCandsList->SetCandTruncateType(CFepCtrlDropdownList::ECandTruncateAsEllipsis); |
|
646 iCandsList->SetFuzzyBoundry(10); |
|
647 iCandsList->Hide(ETrue); |
|
648 iCandsList->SetDropdownListImgID(candiDrawInfo); |
|
649 |
|
650 TPoint puncListLTPos = |
|
651 TItutDataConverter::AnyToPoint(iDataMgr->RequestData(EDropdownListPuncLTPos)); |
|
652 // create punctuation drop list |
|
653 iPuncCandsList = CFepCtrlDropdownList::NewL(iLayoutOwner, |
|
654 ECtrlIdPuncCandsList, |
|
655 R_AKN_FEP_PUNC_DROP_DOWN_LIST, |
|
656 puncListLTPos, |
|
657 TSize(unitWidth, unitHeight), |
|
658 5, |
|
659 1); |
|
660 iPuncCandsList->SetCellMargin(horizontalMargin, verticalMargin); |
|
661 iPuncCandsList->SetFont(listfont); |
|
662 AddControlL(iPuncCandsList); |
|
663 iPuncCandsList->SetEventIdForCandidateSelected(EItutCmdCandidateSelected); |
|
664 iPuncCandsList->SetDropdownListImgID(candiDrawInfo); |
|
665 iPuncCandsList->Hide(ETrue); |
|
666 } |
|
667 |
|
668 // --------------------------------------------------------------------------- |
|
669 // CSplitItutWindow::ConstructL |
|
670 // --------------------------------------------------------------------------- |
|
671 // |
|
672 void CSplitItutWindow::ConstructL() |
|
673 { |
|
674 iBmpRotator = CPeninputSyncBitmapRotator::NewL(); |
|
675 CreateAllButtonL(); |
|
676 CreateItutKeypadL(); |
|
677 } |
|
678 |
|
679 // --------------------------------------------------------------------------- |
|
680 // CSplitItutWindow::AddControlL |
|
681 // --------------------------------------------------------------------------- |
|
682 // |
|
683 void CSplitItutWindow::AddControlL(CFepUiBaseCtrl* aControl) |
|
684 { |
|
685 iLayoutOwner->AddControlL(aControl); |
|
686 } |
|
687 |
|
688 // --------------------------------------------------------------------------- |
|
689 // CSplitItutWindow::CreateChineseSpecificCtrlsIfNeededL |
|
690 // --------------------------------------------------------------------------- |
|
691 // |
|
692 void CSplitItutWindow::CreateChineseSpecificCtrlsIfNeededL() |
|
693 { |
|
694 if (iChnCtrlInited) |
|
695 { |
|
696 return; |
|
697 } |
|
698 |
|
699 CreateDropdownListL(); |
|
700 // create spell control for stroke/zhuyin |
|
701 TRect rect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(ESpellRect)); |
|
702 iSpell = CFepInputContextField::NewL(rect, iLayoutOwner, ECtrlIdSpellICF); |
|
703 |
|
704 iSpell->SetResourceId(R_FINGER_SPELL); |
|
705 ConstructSpellCtrlFromResourceL(); |
|
706 |
|
707 iSpell->SetFont(TItutDataConverter::AnyToFont(iDataMgr->RequestData(ESpellFont))); |
|
708 AddControlL(iSpell); |
|
709 |
|
710 iSpell->Hide(ETrue); |
|
711 |
|
712 |
|
713 iChnCtrlInited = ETrue; |
|
714 } |
|
715 |
|
716 // --------------------------------------------------------------------------- |
|
717 // CSplitItutWindow::ConstructSpellCtrlFromResourceL |
|
718 // --------------------------------------------------------------------------- |
|
719 // |
|
720 void CSplitItutWindow::ConstructSpellCtrlFromResourceL() |
|
721 { |
|
722 if (!iSpell || !iSpell->ResourceId()) |
|
723 { |
|
724 return; |
|
725 } |
|
726 |
|
727 TResourceReader spellreader; |
|
728 CCoeEnv::Static()->CreateResourceReaderLC(spellreader, iSpell->ResourceId()); |
|
729 |
|
730 TInt bgimgResId = spellreader.ReadInt32(); |
|
731 TResourceReader bgreader; |
|
732 CCoeEnv::Static()->CreateResourceReaderLC(bgreader, bgimgResId); |
|
733 |
|
734 TInt bmpid = bgreader.ReadInt16(); |
|
735 TInt maskbmpid = bgreader.ReadInt16(); |
|
736 TInt bmpskinid = bgreader.ReadInt16(); |
|
737 |
|
738 CFbsBitmap* bmp = NULL; |
|
739 CFbsBitmap* maskbmp = NULL; |
|
740 |
|
741 CreateLayoutIconL(KImageMajorSkinId, |
|
742 bmpskinid, |
|
743 KBmpFileName, |
|
744 bmpid, |
|
745 maskbmpid, |
|
746 bmp, |
|
747 maskbmp, |
|
748 iSpell->Rect().Size()); |
|
749 |
|
750 if (bmp) |
|
751 { |
|
752 iSpell->SetBackgroundBitmapL(bmp); |
|
753 } |
|
754 |
|
755 delete maskbmp; |
|
756 |
|
757 CleanupStack::PopAndDestroy( 1 ); // bgreader |
|
758 |
|
759 TInt colorMajorSkinId = spellreader.ReadInt32(); |
|
760 TInt skinitemid= spellreader.ReadInt16(); |
|
761 TInt coloridx = spellreader.ReadInt16(); |
|
762 |
|
763 TAknsItemID colorid; |
|
764 colorid.Set(TInt(colorMajorSkinId), skinitemid); |
|
765 |
|
766 TRgb spelltextcolor; |
|
767 MAknsSkinInstance* skininstance = AknsUtils::SkinInstance(); |
|
768 TInt error = AknsUtils::GetCachedColor(skininstance, |
|
769 spelltextcolor, |
|
770 colorid, |
|
771 coloridx); |
|
772 |
|
773 if (error != KErrNone) |
|
774 { |
|
775 spelltextcolor = TRgb(KDefaultSpellTextColor); |
|
776 } |
|
777 |
|
778 iSpell->SetTextColor(spelltextcolor); |
|
779 |
|
780 CleanupStack::PopAndDestroy( 1 ); // spellreader |
|
781 } |
|
782 |
|
783 |
|
784 // --------------------------------------------------------------------------- |
|
785 // CSplitItutWindow::PenInputType |
|
786 // --------------------------------------------------------------------------- |
|
787 // |
|
788 TInt CSplitItutWindow::PenInputType() |
|
789 { |
|
790 return EPluginInputModeItut; |
|
791 } |
|
792 |
|
793 // --------------------------------------------------------------------------- |
|
794 // CSplitItutWindow::SetCtrlRect |
|
795 // --------------------------------------------------------------------------- |
|
796 // |
|
797 void CSplitItutWindow::SetCtrlRect(CFepUiBaseCtrl* aCtrl, TInt aRectIdx) |
|
798 { |
|
799 aCtrl->SetRect(TItutDataConverter::AnyToRect(iDataMgr->RequestData(aRectIdx))); |
|
800 } |
|
801 |
|
802 // --------------------------------------------------------------------------- |
|
803 // CSplitItutWindow::SizeChanged |
|
804 // --------------------------------------------------------------------------- |
|
805 // |
|
806 TInt CSplitItutWindow::SizeChanged() |
|
807 { |
|
808 // resize all controls |
|
809 SetCtrlRect(iStandardItutKp, EKeypadRect); |
|
810 |
|
811 iStandardItutKp->SetTextLineLayout( |
|
812 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadLeftTextLine)), |
|
813 EPosLeft); |
|
814 iStandardItutKp->SetTextLineLayout( |
|
815 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine1)), |
|
816 EPosRight1); |
|
817 iStandardItutKp->SetTextLineLayout( |
|
818 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine2)), |
|
819 EPosRight2); |
|
820 iStandardItutKp->SetTextLineLayout( |
|
821 TItutDataConverter::AnyToTextLine(iDataMgr->RequestData(EKeypadRightTextLine3)), |
|
822 EPosRight3); |
|
823 |
|
824 RPointerArray<CVirtualKey>& keys = |
|
825 const_cast<RPointerArray<CVirtualKey>&>(iStandardItutKp->KeyArray()); |
|
826 RArray<TRect>& cellRects = |
|
827 TItutDataConverter::AnyToRectArray(iDataMgr->RequestData(EKeypadCellRects)); |
|
828 |
|
829 for (TInt i = 0 ; i < keys.Count(); i++) |
|
830 { |
|
831 keys[i]->SetRect(cellRects[i]); |
|
832 TRect innerrect = cellRects[i]; |
|
833 innerrect.Shrink(TSize(4, 4)); |
|
834 keys[i]->SetInnerRect(innerrect); |
|
835 } |
|
836 // set key background image size |
|
837 TSize curSize = cellRects[0].Size(); |
|
838 if( iStandardItutKp->NonIrregularKeyBitmap(EKeyBmpNormal) ) |
|
839 { |
|
840 TSize size = iStandardItutKp->NonIrregularKeyBitmap(EKeyBmpNormal)->SizeInPixels(); |
|
841 if( curSize != size ) |
|
842 { |
|
843 for ( TInt i = 0; i <= EKeyBmpLastType; i++ ) |
|
844 { |
|
845 if( iStandardItutKp->NonIrregularKeyBitmap((TVirtualKeyBmpType)i) ) |
|
846 { |
|
847 AknIconUtils::SetSize( |
|
848 iStandardItutKp->NonIrregularKeyBitmap((TVirtualKeyBmpType)i), |
|
849 curSize, EAspectRatioNotPreserved ); |
|
850 } |
|
851 } |
|
852 } |
|
853 } |
|
854 |
|
855 // should set textline when it is defined in laf |
|
856 iBackgroundCtrl->SizeChanged( |
|
857 TItutDataConverter::AnyToRect(iDataMgr->RequestData( EBackgroundRect ) ) ); |
|
858 |
|
859 TRAP_IGNORE(ApplyVariantLafDataL(ETrue); |
|
860 /*iLayoutOwner->HandleCommand(EItutExtCmdSizeChanged, NULL)*/); |
|
861 |
|
862 |
|
863 if (iChnCtrlInited) |
|
864 { |
|
865 SetCtrlRect(iSpell, ESpellRect); |
|
866 iSpell->SetFont(TItutDataConverter::AnyToFont(iDataMgr->RequestData(ESpellFont))); |
|
867 |
|
868 ResizeCandidateList(iSpellCandsList, EDropdownListSpellLTPos, ETrue); |
|
869 ResizeCandidateList(iCandsList, EDropdownListCandsLTPos, ETrue); |
|
870 ResizeCandidateList(iPuncCandsList, EDropdownListPuncLTPos, EFalse); |
|
871 } |
|
872 |
|
873 return KErrNone; |
|
874 } |
|
875 |
|
876 // --------------------------------------------------------------------------- |
|
877 // CSplitItutWindow::ControlSizeChanged |
|
878 // --------------------------------------------------------------------------- |
|
879 // |
|
880 TBool CSplitItutWindow::ControlSizeChanged(const TInt aControlId, |
|
881 const TInt aRect, |
|
882 const TInt aInnerRect, |
|
883 TBool aIsReloadImages) |
|
884 { |
|
885 CAknFepCtrlCommonButton* temp = CommonButtonControl(aControlId); |
|
886 if( !temp ) |
|
887 return EFalse; |
|
888 |
|
889 |
|
890 TRect rect; |
|
891 TRect innerRect; |
|
892 |
|
893 rect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aRect)); |
|
894 innerRect = TItutDataConverter::AnyToRect(iDataMgr->RequestData(aInnerRect)); |
|
895 |
|
896 TBool bSizedChanged = (rect.Size() != temp->Rect().Size()) && |
|
897 (innerRect.Size() != temp->ForgroundBmpRect().Size()); |
|
898 temp->SizeChanged(rect, innerRect, aIsReloadImages); |
|
899 |
|
900 return bSizedChanged; |
|
901 } |
|
902 |
|
903 // --------------------------------------------------------------------------- |
|
904 // CSplitItutWindow::ApplyVariantLafDataL |
|
905 // --------------------------------------------------------------------------- |
|
906 // |
|
907 void CSplitItutWindow::ApplyVariantLafDataL(TBool /*aResolutionChange*/) |
|
908 { |
|
909 if( iDataMgr->IsChinese() ) |
|
910 { |
|
911 // ControlSizeChanged(ECtrlIdArrowUp, EArrowUpRect, EUpInnerRect, ETrue); |
|
912 // ControlSizeChanged(ECtrlIdArrowDown, EArrowDownRect, EDownInnerRect, ETrue); |
|
913 } |
|
914 |
|
915 TBool bSizeChanged = EFalse; |
|
916 ControlSizeChanged(ECtrlIdArrowLeft, EArrowLeftRect, ELeftInnerRect, ETrue); |
|
917 ControlSizeChanged(ECtrlIdArrowRight, EArrowRightRect, ERightInnerRect, ETrue); |
|
918 bSizeChanged = ControlSizeChanged(ECtrlIdBackspace, EBackspaceRect, EBackspaceInnerRect, ETrue); |
|
919 ControlSizeChanged(ECtrlIdOptions, EOptionsRect, EOptionInnerRect, ETrue); |
|
920 ControlSizeChanged(ECtrlIdClose, ECloseRect, ECloseInnerRect, ETrue); |
|
921 |
|
922 // resize all controls |
|
923 SetCtrlRect(iStandardItutKp, EKeypadRect); |
|
924 |
|
925 // Handle control res when language direction changing here. |
|
926 if( iDataMgr->IsLangDirectionSwitch() || |
|
927 ( bSizeChanged && iDataMgr->IsRtoLLanguage() ) ) |
|
928 { |
|
929 HandleButtonResOnLangDirChange( ECtrlIdBackspace ); |
|
930 iDataMgr->SetLangDirectionSwitch( EFalse ); |
|
931 } |
|
932 } |
|
933 |
|
934 // --------------------------------------------------------------------------- |
|
935 // CSplitItutWindow::ResizeCandidateList |
|
936 // --------------------------------------------------------------------------- |
|
937 // |
|
938 void CSplitItutWindow::ResizeCandidateList(CFepCtrlDropdownList* aList, |
|
939 TInt aLTPosIdx, TBool aExpandable) |
|
940 { |
|
941 if (!aList) |
|
942 { |
|
943 return; |
|
944 } |
|
945 |
|
946 TInt unitWidth = TItutDataConverter::AnyToInt( |
|
947 iDataMgr->RequestData(EDropdownlistUnitWidth)); |
|
948 TInt unitHeight = TItutDataConverter::AnyToInt( |
|
949 iDataMgr->RequestData(EDropdownlistUnitHeight)); |
|
950 TInt horizontalMargin = |
|
951 TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistHorizontalMargin)); |
|
952 TInt verticalMargin = |
|
953 TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownlistVerticalMargin)); |
|
954 TInt naviWidth = TItutDataConverter::AnyToInt( |
|
955 iDataMgr->RequestData(EDropdownlistUnitWidth)); |
|
956 CFont* listfont = TItutDataConverter::AnyToFont( |
|
957 iDataMgr->RequestData(EDropdownListFont)); |
|
958 TPoint listLTPos = TItutDataConverter::AnyToPoint(iDataMgr->RequestData(aLTPosIdx)); |
|
959 |
|
960 aList->SizeChanged(unitWidth, |
|
961 unitHeight, |
|
962 naviWidth, |
|
963 listLTPos); |
|
964 |
|
965 aList->SetCellMargin(horizontalMargin, verticalMargin); |
|
966 |
|
967 if (aExpandable) |
|
968 { |
|
969 TInt naviSpinBtnHeight = |
|
970 TItutDataConverter::AnyToInt(iDataMgr->RequestData(EDropdownListSpinBtnHeight)); |
|
971 |
|
972 aList->SetSpinBtnHeight(naviSpinBtnHeight); |
|
973 } |
|
974 } |
|
975 |
|
976 // --------------------------------------------------------------------------- |
|
977 // CSplitItutWindow::OnSkinChange |
|
978 // --------------------------------------------------------------------------- |
|
979 // |
|
980 void CSplitItutWindow::OnSkinChange() |
|
981 { |
|
982 // when skin change all control with skin image should be reload. |
|
983 TRAP_IGNORE(ConstructKeyImageFromResourceL( R_ITUT_KEYPAD_BITMAP )); |
|
984 |
|
985 // reconstruct shift icon when skin changed |
|
986 TRAP_IGNORE(iStandardItutKp->ShiftIcon()->ReConstructL()); |
|
987 TRAP_IGNORE(iStandardItutKp->ShiftIcon()->ResizeL(iDataMgr->iShiftIconRect.Size())); |
|
988 |
|
989 //Skin change will case the reconstuction of the button graphic. |
|
990 //When language is RToL, it should be mirrored again. |
|
991 if( iDataMgr->IsRtoLLanguage() ) |
|
992 { |
|
993 HandleButtonResOnLangDirChange( ECtrlIdBackspace ); |
|
994 } |
|
995 } |
|
996 |
|
997 |
|
998 // --------------------------------------------------------------------------- |
|
999 // CSplitItutWindow::CalculateFrameRects |
|
1000 // --------------------------------------------------------------------------- |
|
1001 // |
|
1002 void CSplitItutWindow::CalculateFrameRects(const TRect aRect, |
|
1003 TRect& aOuterRect, |
|
1004 TRect& aInnerRect ) |
|
1005 { |
|
1006 TRect windowRect = aRect; |
|
1007 |
|
1008 TAknLayoutRect topLeft; |
|
1009 topLeft.LayoutRect(windowRect, SkinLayout::Submenu_skin_placing_Line_2()); |
|
1010 |
|
1011 TAknLayoutRect bottomRight; |
|
1012 bottomRight.LayoutRect(windowRect, SkinLayout::Submenu_skin_placing_Line_5()); |
|
1013 |
|
1014 aOuterRect = TRect(topLeft.Rect().iTl, bottomRight.Rect().iBr); |
|
1015 aInnerRect = TRect(topLeft.Rect().iBr, bottomRight.Rect().iTl); |
|
1016 } |
|
1017 |
|
1018 |
|
1019 // --------------------------------------------------------------------------- |
|
1020 // CSplitItutWindow::CommonButtonControl |
|
1021 // --------------------------------------------------------------------------- |
|
1022 // |
|
1023 CAknFepCtrlCommonButton* CSplitItutWindow::CommonButtonControl(const TInt aControlId) |
|
1024 { |
|
1025 CFepUiBaseCtrl* ctrl = NULL; |
|
1026 ctrl = Control(aControlId); |
|
1027 |
|
1028 if (!ctrl) |
|
1029 { |
|
1030 return NULL; |
|
1031 } |
|
1032 |
|
1033 if (!ctrl->IsKindOfControl(ECtrlButton)) |
|
1034 |
|
1035 { |
|
1036 return NULL; |
|
1037 } |
|
1038 |
|
1039 return static_cast<CAknFepCtrlCommonButton*>(ctrl); |
|
1040 } |
|
1041 |
|
1042 |
|
1043 // --------------------------------------------------------------------------- |
|
1044 // CSplitItutWindow::Control |
|
1045 // --------------------------------------------------------------------------- |
|
1046 // |
|
1047 CFepUiBaseCtrl* CSplitItutWindow::Control(const TInt aCtrlId) |
|
1048 { |
|
1049 CFepUiBaseCtrl* ctrl = NULL; |
|
1050 RPointerArray<CFepUiBaseCtrl> todo; |
|
1051 TInt current = 0; |
|
1052 TBool found = EFalse; |
|
1053 |
|
1054 todo.Append(iLayoutOwner->RootControl()); |
|
1055 CControlGroup* temp; |
|
1056 |
|
1057 while (current < todo.Count() && !found) |
|
1058 { |
|
1059 ctrl = todo[current]; |
|
1060 |
|
1061 if(ctrl->ControlId() == aCtrlId) //Find control |
|
1062 { |
|
1063 found = ETrue; |
|
1064 } |
|
1065 else |
|
1066 { |
|
1067 if(ctrl->IsKindOfControl(ECtrlControlGroup)) |
|
1068 { |
|
1069 temp = static_cast<CControlGroup*>(ctrl); |
|
1070 for (int i = 0; i < temp->NumOfControls(); i++) |
|
1071 { |
|
1072 todo.Append(temp->At(i)); |
|
1073 } |
|
1074 } |
|
1075 |
|
1076 current++; |
|
1077 } |
|
1078 } |
|
1079 |
|
1080 todo.Close(); |
|
1081 |
|
1082 return found ? ctrl : NULL; |
|
1083 } |
|
1084 |
|
1085 // --------------------------------------------------------------------------- |
|
1086 // CSplitItutWindow::IsChineseMode |
|
1087 // --------------------------------------------------------------------------- |
|
1088 // |
|
1089 TBool CSplitItutWindow::IsChineseMode() |
|
1090 { |
|
1091 TInt immode = iDataMgr->InputMode(); |
|
1092 TBool chineseMode = EFalse; |
|
1093 |
|
1094 if (immode == EPinyin || immode == EStroke || immode == EZhuyin) |
|
1095 { |
|
1096 chineseMode = ETrue; |
|
1097 } |
|
1098 |
|
1099 return chineseMode; |
|
1100 } |
|
1101 |
|
1102 // --------------------------------------------------------------------------- |
|
1103 // CSplitItutWindow::ConstructKeyImageFromResourceL |
|
1104 // --------------------------------------------------------------------------- |
|
1105 // |
|
1106 void CSplitItutWindow::ConstructKeyImageFromResourceL( TInt aKeyImageResID ) |
|
1107 { |
|
1108 TResourceReader reader; |
|
1109 CCoeEnv::Static()->CreateResourceReaderLC( reader, aKeyImageResID ); |
|
1110 |
|
1111 TPtrC bmpFileName = reader.ReadTPtrC(); |
|
1112 TInt32 imgMajorSkinId = reader.ReadInt32(); |
|
1113 TAknsItemID id; |
|
1114 |
|
1115 RArray<TRect>& cellRects = |
|
1116 TItutDataConverter::AnyToRectArray(iDataMgr->RequestData(EKeypadCellRects)); |
|
1117 TSize keySize = cellRects[0].Size(); |
|
1118 for (TInt index = 0; index <= EKeyBmpLastType ; index += 2) |
|
1119 { |
|
1120 // Get the image ids and mask ids from resource |
|
1121 TInt bmpId = reader.ReadInt16(); |
|
1122 TInt bmpMskId = reader.ReadInt16(); |
|
1123 |
|
1124 // read skin item id |
|
1125 const TInt skinitemid = reader.ReadInt16(); |
|
1126 id.Set(TInt(imgMajorSkinId), skinitemid); |
|
1127 |
|
1128 if (bmpId != KInvalidBmp) |
|
1129 { |
|
1130 CFbsBitmap* bmp = NULL; |
|
1131 CFbsBitmap* maskbmp = NULL; |
|
1132 |
|
1133 if (bmpMskId != KInvalidBmp) |
|
1134 { |
|
1135 AknsUtils::CreateIconL(AknsUtils::SkinInstance(), |
|
1136 id, |
|
1137 bmp, |
|
1138 maskbmp, |
|
1139 bmpFileName, |
|
1140 bmpId, |
|
1141 bmpMskId); |
|
1142 |
|
1143 // set maskbmp and size |
|
1144 AknIconUtils::SetSize( maskbmp, keySize, EAspectRatioNotPreserved ); |
|
1145 iStandardItutKp->SetNonIrregularKeyBitmapL( |
|
1146 TVirtualKeyBmpType(EKeyBmpNormal + index + 1), maskbmp ); |
|
1147 } |
|
1148 else |
|
1149 { |
|
1150 AknsUtils::CreateIconL(AknsUtils::SkinInstance(), |
|
1151 id, |
|
1152 bmp, |
|
1153 bmpFileName, |
|
1154 bmpId); |
|
1155 } |
|
1156 // set bmp and size |
|
1157 AknIconUtils::SetSize( bmp, keySize, EAspectRatioNotPreserved ); |
|
1158 iStandardItutKp->SetNonIrregularKeyBitmapL( |
|
1159 TVirtualKeyBmpType(EKeyBmpNormal + index), bmp ); |
|
1160 } |
|
1161 } |
|
1162 // Pop and destroy reader |
|
1163 CleanupStack::PopAndDestroy( 1 ); |
|
1164 } |
|
1165 |
|
1166 // --------------------------------------------------------------------------- |
|
1167 // CSplitItutWindow::HandleButtonResOnLangDirChange |
|
1168 // --------------------------------------------------------------------------- |
|
1169 // |
|
1170 void CSplitItutWindow::HandleButtonResOnLangDirChange( TInt aControlId ) |
|
1171 { |
|
1172 TRAP_IGNORE(HandleButtonResOnLangDirChangeL(aControlId)); |
|
1173 } |
|
1174 |
|
1175 // --------------------------------------------------------------------------- |
|
1176 // CSplitItutWindow::HandleButtonResOnLangDirChangeL |
|
1177 // --------------------------------------------------------------------------- |
|
1178 // |
|
1179 void CSplitItutWindow::HandleButtonResOnLangDirChangeL( TInt aControlId ) |
|
1180 { |
|
1181 CAknFepCtrlCommonButton* ctrl = CommonButtonControl(aControlId); |
|
1182 if( ctrl && iBmpRotator) |
|
1183 { |
|
1184 TSyncRotationAngle rotChoice = CBitmapRotator::EMirrorVerticalAxis; |
|
1185 User::LeaveIfError( iBmpRotator->Rotate( *ctrl->ForgroundBmp() , |
|
1186 rotChoice ) ); |
|
1187 User::LeaveIfError( iBmpRotator->Rotate( *ctrl->ForgroundBmpMask() , |
|
1188 rotChoice ) ); |
|
1189 } |
|
1190 } |
|
1191 |
|
1192 // --------------------------------------------------------------------------- |
|
1193 // CSplitItutWindow::SetHardKeyOneSymbol |
|
1194 // --------------------------------------------------------------------------- |
|
1195 // |
|
1196 void CSplitItutWindow::SetHardKeyOneSymbol(TUint8* aData) |
|
1197 { |
|
1198 TRAP_IGNORE(SetHardKeyOneSymbolL(aData)); |
|
1199 } |
|
1200 |
|
1201 // --------------------------------------------------------------------------- |
|
1202 // CSplitItutWindow::SetHardKeyOneSymbolL |
|
1203 // --------------------------------------------------------------------------- |
|
1204 // |
|
1205 void CSplitItutWindow::SetHardKeyOneSymbolL(TUint8* aData) |
|
1206 { |
|
1207 //Read stream |
|
1208 RDesReadStream readStream; |
|
1209 |
|
1210 TPtr8 countPtr( aData, 3*sizeof(TInt), 3*sizeof(TInt) ); |
|
1211 readStream.Open(countPtr); |
|
1212 CleanupClosePushL(readStream); |
|
1213 |
|
1214 iSymbolData.iSymbol1 = readStream.ReadInt32L(); |
|
1215 iSymbolData.iSymbol2 = readStream.ReadInt32L(); |
|
1216 iSymbolData.iSymbol3 = readStream.ReadInt32L(); |
|
1217 |
|
1218 CleanupStack::PopAndDestroy(&readStream); |
|
1219 } |
|
1220 |
|
1221 // --------------------------------------------------------------------------- |
|
1222 // CSplitItutWindow::SetUnicodesForHardKey1 |
|
1223 // --------------------------------------------------------------------------- |
|
1224 // |
|
1225 void CSplitItutWindow::SetUnicodesForHardKey1(CVirtualKey* aKey, const TDesC& aMapData) |
|
1226 { |
|
1227 TRAP_IGNORE(SetUnicodesForHardKey1L(aKey, aMapData)); |
|
1228 } |
|
1229 |
|
1230 // --------------------------------------------------------------------------- |
|
1231 // CSplitItutWindow::SetUnicodesForHardKey1L |
|
1232 // --------------------------------------------------------------------------- |
|
1233 // |
|
1234 void CSplitItutWindow::SetUnicodesForHardKey1L(CVirtualKey* aKey, const TDesC& aMapData) |
|
1235 { |
|
1236 RPointerArray<HBufC> unicodesArr1; |
|
1237 RArray<TInt> unicodesInt; |
|
1238 |
|
1239 unicodesInt.Append(iSymbolData.iSymbol1); |
|
1240 unicodesInt.Append(iSymbolData.iSymbol2); |
|
1241 unicodesInt.Append(iSymbolData.iSymbol3); |
|
1242 |
|
1243 TInt curMode = TItutDataConverter::AnyToInt( |
|
1244 iLayoutOwner->DataMgr()->RequestData(EInputMode)); |
|
1245 |
|
1246 TInt curLang = TItutDataConverter::AnyToInt( |
|
1247 iLayoutOwner->DataMgr()->RequestData(ELanguage)); |
|
1248 |
|
1249 TInt latinOnly = TItutDataConverter::AnyToInt( |
|
1250 iLayoutOwner->DataMgr()->RequestData(ELatinOnly)); |
|
1251 |
|
1252 HBufC* symbols = HBufC::NewL( 20 ); |
|
1253 for (TInt i = 0; i <= 2; i++) |
|
1254 { |
|
1255 symbols->Des().Append( unicodesInt[i] ); |
|
1256 if (EHindi == curMode || |
|
1257 (ELatin == curMode && curLang == ELangThai && !latinOnly)) |
|
1258 { |
|
1259 continue; |
|
1260 } |
|
1261 else |
|
1262 { |
|
1263 symbols->Des().Append( KSpaceUnicode ); |
|
1264 } |
|
1265 } |
|
1266 |
|
1267 HBufC* number = HBufC::NewL( 1 ); |
|
1268 number->Des().Append( aMapData ); |
|
1269 unicodesArr1.AppendL(number); |
|
1270 unicodesArr1.AppendL(symbols); |
|
1271 |
|
1272 aKey->SetUnicodesL(unicodesArr1); |
|
1273 |
|
1274 unicodesArr1.Close(); |
|
1275 unicodesInt.Close(); |
|
1276 |
|
1277 } |
|
1278 // End Of File |