|
1 /* |
|
2 * Copyright (c) 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: test case |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <w32std.h> |
|
20 #include <coecntrl.h> |
|
21 #include <barsread.h> |
|
22 #include <eiklbbut.h> |
|
23 #include <eikcmbut.h> |
|
24 #include <aknbitmapanimation.h> |
|
25 #include <eikcba.h> |
|
26 #include <S32FILE.H> |
|
27 #include <eikenv.h> |
|
28 #include <eikbtgps.h> |
|
29 #include <avkon.hrh> |
|
30 #include <eikcmobs.h> |
|
31 #include <eikbgfty.h> |
|
32 #include <aknchoicelist.h> |
|
33 #include <caknmemoryselectionsettingpage.h> |
|
34 #include <CommonDialogs.rsg> // Common dialogs resource IDs |
|
35 #include <caknmemoryselectionsettingitemmultidrive.h> |
|
36 #include <caknmemoryselectiondialogmultidrive.h> |
|
37 #include <caknfilenamepromptdialog.h> |
|
38 #include <akncommondialogsdynmem.h> |
|
39 #include <documenthandler.h> |
|
40 #include <maknfileselectionobserver.h> |
|
41 #include <aknfontaccess.h> |
|
42 #include <AknColourSelectionGrid.h> |
|
43 #include <aknsinglecolumnstyletreelist.h> |
|
44 #include <aknsinglestyletreelist.h> |
|
45 #include <avkon.mbg> |
|
46 #include <aknsconstants.h> |
|
47 #include <eikhkeyt.h> |
|
48 #include <aknindicatorcontainer.h> |
|
49 #include <akninfrm.h> |
|
50 #include <eikedwin.h> |
|
51 #include <eikfnlab.h> |
|
52 #include <eikctlib.h> |
|
53 #include <akninputlanguageinfo.h> |
|
54 #include <aknnotedialog.h> |
|
55 #include <aknnavide.h> |
|
56 #include <aknpopupnotify.h> |
|
57 #include <aknpopupsettingpage.h> |
|
58 #include <aknpopuplayout.h> |
|
59 #include <aknpopup.h> |
|
60 #include <eikhfdlg.h> |
|
61 #include <eikbtpan.h> |
|
62 #include <aknquerydialog.h> |
|
63 #include <aknclearer.h> |
|
64 #include <aknsfld.h> |
|
65 #include <S32MEM.H> |
|
66 #include <aknsoundsystem.h> |
|
67 #include <akntitle.h> |
|
68 #include <akncommondialogs.h> |
|
69 #include <akntoolbar.h> |
|
70 #include <akntouchpane.h> |
|
71 #include <aknlayoutfont.h> |
|
72 #include <hwrmhaptics.h> |
|
73 #include <AknsLayeredBackgroundControlContext.h> |
|
74 #include <AknsImageAttributeData.h> |
|
75 #include <aknappui.h> |
|
76 #include <AknsItemDef.h> |
|
77 #include <gdi.h> |
|
78 #include <AknsListBoxBackgroundControlContext.h> |
|
79 #include <AknsFrameBackgroundControlContext.h> |
|
80 #include <AknStaticNoteDialog.h> |
|
81 #include <aknmessagequerydialog.h> |
|
82 #include <Aknedsts.h> |
|
83 #include <AknIconArray.h> |
|
84 |
|
85 #include <bctestmix50.rsg> |
|
86 #include "bctestmix50patchcontrolcase.h" |
|
87 #include "bctestmix50patchmisc.h" |
|
88 #include "bctestmix50container.h" |
|
89 #include "bctestmix50.hrh" |
|
90 |
|
91 // ======== MEMBER FUNCTIONS ======== |
|
92 |
|
93 // --------------------------------------------------------------------------- |
|
94 // Symbian 2nd static Constructor |
|
95 // --------------------------------------------------------------------------- |
|
96 // |
|
97 CBCTestMix50PatchControlCase* CBCTestMix50PatchControlCase::NewL( CBCTestMix50Container* |
|
98 aContainer ) |
|
99 { |
|
100 CBCTestMix50PatchControlCase* self = new( ELeave ) CBCTestMix50PatchControlCase( |
|
101 aContainer ); |
|
102 CleanupStack::PushL( self ); |
|
103 self->ConstructL(); |
|
104 CleanupStack::Pop( self ); |
|
105 return self; |
|
106 } |
|
107 |
|
108 // --------------------------------------------------------------------------- |
|
109 // C++ default constructor |
|
110 // --------------------------------------------------------------------------- |
|
111 // |
|
112 CBCTestMix50PatchControlCase::CBCTestMix50PatchControlCase( CBCTestMix50Container* |
|
113 aContainer ) |
|
114 : iContainer( aContainer ) |
|
115 { |
|
116 iCoeEnv = CCoeEnv::Static(); |
|
117 } |
|
118 |
|
119 // --------------------------------------------------------------------------- |
|
120 // Destructor |
|
121 // --------------------------------------------------------------------------- |
|
122 // |
|
123 CBCTestMix50PatchControlCase::~CBCTestMix50PatchControlCase() |
|
124 { |
|
125 } |
|
126 |
|
127 // --------------------------------------------------------------------------- |
|
128 // Symbian 2nd Constructor |
|
129 // --------------------------------------------------------------------------- |
|
130 // |
|
131 void CBCTestMix50PatchControlCase::ConstructL() |
|
132 { |
|
133 BuildScriptL(); |
|
134 } |
|
135 |
|
136 // --------------------------------------------------------------------------- |
|
137 // CBCTestMix50PatchControlCase::BuildScriptL |
|
138 // --------------------------------------------------------------------------- |
|
139 // |
|
140 void CBCTestMix50PatchControlCase::BuildScriptL() |
|
141 { |
|
142 // Add script as your need. |
|
143 AddTestL( DELAY(5), LeftCBA, Down, Down, LeftCBA, RightCBA, |
|
144 RightCBA, RightCBA, RightCBA, RightCBA, RightCBA, |
|
145 RightCBA, RightCBA, RightCBA, RightCBA, RightCBA, |
|
146 RightCBA, RightCBA, RightCBA, RightCBA, RightCBA, |
|
147 RightCBA, RightCBA, RightCBA, RightCBA, RightCBA, |
|
148 RightCBA, RightCBA, RightCBA, RightCBA, RightCBA, |
|
149 RightCBA, RightCBA, RightCBA, RightCBA, RightCBA, |
|
150 RightCBA, RightCBA, |
|
151 TEND ); |
|
152 |
|
153 } |
|
154 |
|
155 // --------------------------------------------------------------------------- |
|
156 // CBCTestMix50PatchControlCase::RunL |
|
157 // --------------------------------------------------------------------------- |
|
158 // |
|
159 void CBCTestMix50PatchControlCase::RunL( TInt aCmd ) |
|
160 { |
|
161 // Call release before prepare to let container has time to draw the |
|
162 // control created in PrepareCaseL. |
|
163 ReleaseCaseL(); |
|
164 PrepareCaseL( aCmd ); |
|
165 switch ( aCmd ) |
|
166 { |
|
167 case EBCTestCmdOutline3: |
|
168 TestAnimationL(); |
|
169 TestButtonsL(); |
|
170 TestChoiceListL(); |
|
171 TestCommonFileL(); |
|
172 TestSelectCommonFileL(); |
|
173 TestSaveCommonFileL(); |
|
174 TestDocumentHandlerL(); |
|
175 TestFontsL(); |
|
176 TestGridsL(); |
|
177 TestHListsAndHotkeysL(); |
|
178 TestMiscellOneL(); |
|
179 TestInitializationL(); |
|
180 TestInputLanL(); |
|
181 TestMenusL(); |
|
182 TestNotesL(); |
|
183 TestMiscellTwoL(); |
|
184 TestPopupsL(); |
|
185 TestUIFrmL(); |
|
186 TestQueriesL(); |
|
187 TestScrollerL(); |
|
188 TestSearchfieldL(); |
|
189 TestSettingPagesL(); |
|
190 TestTitlePaneL(); |
|
191 TestAknToolbarL(); |
|
192 TestAknTouchPaneL(); |
|
193 TestHapticsL(); |
|
194 TestImageTableItemDataL(); |
|
195 TestMBmpItemDataL(); |
|
196 TestColTableItemDataL(); |
|
197 TestBackgroundCCL(); |
|
198 TestAknLayoutUtilsL(); |
|
199 TestAknsUtilsL(); |
|
200 TestAknsDrawUtilsL(); |
|
201 TestDialogsL(); |
|
202 TestPopupL(); |
|
203 TestStatesL(); |
|
204 TestIpFieldEditorL(); |
|
205 TestIconArrayL(); |
|
206 TestAknVolumeControlL(); |
|
207 TestAknEnvL(); |
|
208 break; |
|
209 default: |
|
210 break; |
|
211 } |
|
212 } |
|
213 |
|
214 // --------------------------------------------------------------------------- |
|
215 // CBCTestMix50PatchControlCase::PrepareCaseL |
|
216 // --------------------------------------------------------------------------- |
|
217 // |
|
218 void CBCTestMix50PatchControlCase::PrepareCaseL( TInt aCmd ) |
|
219 { |
|
220 switch ( aCmd ) |
|
221 { |
|
222 case EBCTestCmdOutline1: |
|
223 // Here is a simple demo. You should create your control |
|
224 // instead of this. |
|
225 iControl = new( ELeave ) CCoeControl(); |
|
226 iControl->SetContainerWindowL( *iContainer ); |
|
227 iControl->MakeVisible( ETrue ); |
|
228 break; |
|
229 default: |
|
230 break; |
|
231 } |
|
232 // Pass the owner of iControl to iContainer.s |
|
233 iContainer->SetControlL( iControl ); |
|
234 } |
|
235 |
|
236 // --------------------------------------------------------------------------- |
|
237 // CBCTestMix50PatchControlCase::ReleaseCaseL |
|
238 // --------------------------------------------------------------------------- |
|
239 // |
|
240 void CBCTestMix50PatchControlCase::ReleaseCaseL() |
|
241 { |
|
242 // let container delete the component control. |
|
243 iContainer->ResetControl(); |
|
244 iControl = NULL; |
|
245 } |
|
246 |
|
247 // --------------------------------------------------------------------------- |
|
248 // CBCTestMix50PatchControlCase::TestAnimationL |
|
249 // --------------------------------------------------------------------------- |
|
250 // |
|
251 void CBCTestMix50PatchControlCase::TestAnimationL() |
|
252 { |
|
253 // Test bitmap animation api |
|
254 _LIT( KStrExcludeAnimationFrames, |
|
255 "CAknBitmapAnimation::ExcludeAnimationFramesFromCache() invoked " ); |
|
256 _LIT( KStrSetScaleModeForAnimationBackgroundFrame, |
|
257 "SetScaleModeForAnimationBackgroundFrame() invoked" ); |
|
258 |
|
259 CAknBitmapAnimation* ani= CAknBitmapAnimation::NewL(); |
|
260 CleanupStack::PushL(ani); |
|
261 |
|
262 TResourceReader reader; |
|
263 CCoeEnv::Static()->CreateResourceReaderLC(reader, |
|
264 R_BCTEST_BMPANIM_DATA_ORG ); |
|
265 ani->ConstructFromResourceL(reader); |
|
266 CleanupStack::PopAndDestroy(); |
|
267 |
|
268 ani->SetScaleModeForAnimationBackgroundFrame( EAspectRatioNotPreserved ); |
|
269 AssertTrueL( ETrue, KStrSetScaleModeForAnimationBackgroundFrame ); |
|
270 |
|
271 ani->ExcludeAnimationFramesFromCache(); |
|
272 AssertTrueL( ETrue, KStrExcludeAnimationFrames ); |
|
273 CleanupStack::PopAndDestroy( ani ); |
|
274 } |
|
275 |
|
276 // --------------------------------------------------------------------------- |
|
277 // CBCTestMix50PatchControlCase::TestButtonsL |
|
278 // --------------------------------------------------------------------------- |
|
279 // |
|
280 void CBCTestMix50PatchControlCase::TestButtonsL() |
|
281 { |
|
282 // Test the button apis |
|
283 _LIT( KDrawNow, |
|
284 "CEikCommandButtonBase::Draw() invoked" ); |
|
285 _LIT( KButBaseWriteInternalStateL, |
|
286 "CEikButtonBase::WriteInternalStateL() invoked" ); |
|
287 _LIT( KDimCommandByPosition, |
|
288 "CEikButtonGroupContainer::DimCommandByPosition() invoked"); |
|
289 _LIT( KIsCommandDimmedByPosition, |
|
290 "CEikButtonGroupContainer::IsCommandDimmedByPosition() invoked" ); |
|
291 _LIT( KAnimateCommandByPosition, |
|
292 "CEikButtonGroupContainer::AnimateCommandByPosition() invoked" ); |
|
293 _LIT( KAnimateCommand, |
|
294 "MEikButtonGroup::AnimateCommand() invoked"); |
|
295 _LIT( KLbbutWriteInternalStateL, |
|
296 "CEikLabeledButton::WriteInternalStateL() invoked"); |
|
297 _LIT( KOfferCommandListL, |
|
298 "CEikButtonGroupContainer::OfferCommandListL( array ) invoked" ); |
|
299 _LIT( KOfferCommandListResL, |
|
300 "CEikButtonGroupContainer::OfferCommandListL( resource ) invoked" ); |
|
301 _LIT( KMEikOfferCommandListL, |
|
302 "MEikEnhancedButtonGroup::OfferCommandListL( array ) invoked "); |
|
303 _LIT( KIsCommandInGroup, |
|
304 "MEikEnhancedButtonGroup::IsCommandInGroup" ); |
|
305 _LIT( KReplaceCommand, |
|
306 "MEikEnhancedButtonGroup::ReplaceCommand" ); |
|
307 |
|
308 CBCTestCommandButtonBase* cmdButtonBase = |
|
309 CBCTestCommandButtonBase::NewL(); |
|
310 CleanupStack::PushL( cmdButtonBase ); |
|
311 cmdButtonBase->SetContainerWindowL( *iContainer ); |
|
312 TResourceReader reader; |
|
313 CCoeEnv::Static()->CreateResourceReaderLC( reader, R_BCTEST_CMDBT_LABEL ); |
|
314 cmdButtonBase->ConstructLabelFromResourceL( |
|
315 reader, CEikCommandButtonBase::EFirst ); |
|
316 |
|
317 cmdButtonBase->ActivateGc(); |
|
318 cmdButtonBase->Draw( iContainer->Rect() ); |
|
319 cmdButtonBase->DeactivateGc(); |
|
320 AssertTrueL( ETrue, KDrawNow ); |
|
321 |
|
322 _LIT( KStreamName, "c:\\BCTestLog\\buttontest.txt" ); |
|
323 RFs& tempServer = CEikonEnv::Static()->FsSession(); |
|
324 tempServer.Delete( KStreamName ); |
|
325 RFileWriteStream fWrite; |
|
326 User::LeaveIfError( fWrite.Create( tempServer, |
|
327 KStreamName, EFileWrite ) ); |
|
328 CleanupClosePushL( fWrite ); |
|
329 cmdButtonBase->WriteInternalStateL( fWrite ); |
|
330 AssertTrueL( ETrue, KButBaseWriteInternalStateL ); |
|
331 |
|
332 AssertTrueL( ETrue, KLbbutWriteInternalStateL); |
|
333 CleanupStack::PopAndDestroy( &fWrite ); |
|
334 CleanupStack::PopAndDestroy(); // reader |
|
335 CleanupStack::PopAndDestroy( cmdButtonBase ); |
|
336 |
|
337 CEikButtonGroupContainer* currentBtGrp = |
|
338 CEikButtonGroupContainer::Current(); |
|
339 currentBtGrp->DimCommandByPosition( |
|
340 CEikButtonGroupContainer::ELeftSoftkeyPosition, EFalse ); |
|
341 AssertTrueL( ETrue, KDimCommandByPosition ); |
|
342 |
|
343 currentBtGrp->MakeCommandVisibleByPosition( |
|
344 CEikButtonGroupContainer::ELeftSoftkeyPosition, ETrue ); |
|
345 |
|
346 currentBtGrp->IsCommandDimmedByPosition( |
|
347 CEikButtonGroupContainer::ELeftSoftkeyPosition ); |
|
348 AssertTrueL( ETrue,KIsCommandDimmedByPosition ); |
|
349 |
|
350 currentBtGrp->AnimateCommandByPosition( |
|
351 CEikButtonGroupContainer::ELeftSoftkeyPosition ); |
|
352 AssertTrueL( ETrue, KAnimateCommandByPosition ); |
|
353 |
|
354 |
|
355 TInt toolbarresourceid = R_BCTESTMIX50PATCH_CBA_OPTIONS_NEXT; |
|
356 TInt commandid = EAknSoftkeyOptions; |
|
357 currentBtGrp->AnimateCommand( commandid ); |
|
358 AssertTrueL( ETrue, KAnimateCommand ); |
|
359 |
|
360 RArray<TInt> arr; |
|
361 arr.Append( commandid ); |
|
362 //TRAP( res, eikcba->OfferCommandListL( arr ) ); |
|
363 currentBtGrp->OfferCommandListL( arr ); |
|
364 AssertTrueL( ETrue, KOfferCommandListL ); |
|
365 AssertTrueL( ETrue, KMEikOfferCommandListL ); |
|
366 arr.Close(); |
|
367 |
|
368 currentBtGrp->IsCommandInGroup( commandid ); |
|
369 AssertTrueL( ETrue, KIsCommandInGroup ); |
|
370 currentBtGrp->ReplaceCommand( commandid, toolbarresourceid ); |
|
371 AssertTrueL( ETrue, KReplaceCommand ); |
|
372 |
|
373 currentBtGrp->OfferCommandListL( commandid ); |
|
374 AssertTrueL( ETrue, KOfferCommandListResL ); |
|
375 |
|
376 currentBtGrp->MakeCommandVisibleByPosition( |
|
377 CEikButtonGroupContainer::ELeftSoftkeyPosition, ETrue ); |
|
378 |
|
379 TInt resourceId = R_BCTESTMIX50PATCH_CASE_MENU; |
|
380 |
|
381 RWindowGroup& parentWg = CCoeEnv::Static()->RootWin(); |
|
382 TUint btgroupflags = 0; |
|
383 |
|
384 EikButtonGroupFactory::TCreationData creationData( |
|
385 CEikButtonGroupContainer::EView, this, |
|
386 resourceId, &parentWg, btgroupflags, |
|
387 CEikButtonGroupContainer::EVertical ); |
|
388 _LIT( KTCreationData, "TCreationData test" ); |
|
389 AssertTrueL( ETrue, KTCreationData ); |
|
390 } |
|
391 |
|
392 // --------------------------------------------------------------------------- |
|
393 // CBCTestMix50PatchControlCase::TestChoiceListL() |
|
394 // ChoiceListL test |
|
395 // --------------------------------------------------------------------------- |
|
396 // |
|
397 void CBCTestMix50PatchControlCase::TestChoiceListL() |
|
398 { |
|
399 _LIT(KHandlePointerEvent, "CAknChoiceList::HandlePointerEvent() invoked"); |
|
400 |
|
401 CDesCArrayFlat* itemArray = new ( ELeave ) CDesCArrayFlat( 8 ); |
|
402 CleanupStack::PushL( itemArray ); |
|
403 itemArray->AppendL( _L("orking") ); |
|
404 itemArray->AppendL( _L("ll") ); |
|
405 itemArray->AppendL( _L("sti") ); |
|
406 itemArray->AppendL( _L("w") ); |
|
407 CBCTestChoiceList *choiceList =static_cast<CBCTestChoiceList*> |
|
408 ( CAknChoiceList::NewL( iContainer, itemArray, |
|
409 CAknChoiceList::EAknChoiceListWithCurrentSelection ) ); |
|
410 CleanupStack::PushL( choiceList ); |
|
411 TPointerEvent pointerEvent; |
|
412 pointerEvent.iType = TPointerEvent::EButton1Up ; |
|
413 choiceList->HandlePointerEventL( pointerEvent ); |
|
414 AssertTrueL( ETrue, KHandlePointerEvent ); |
|
415 |
|
416 CleanupStack::PopAndDestroy( choiceList ); |
|
417 CleanupStack::Pop( itemArray ); |
|
418 } |
|
419 |
|
420 // --------------------------------------------------------------------------- |
|
421 // CBCTestMix50PatchControlCase::TestCommonFileL() |
|
422 // common file test |
|
423 // --------------------------------------------------------------------------- |
|
424 // |
|
425 void CBCTestMix50PatchControlCase::TestCommonFileL() |
|
426 { |
|
427 _LIT( KSetTitleL, |
|
428 "CAknMemorySelectionDialogMultiDrive::SetTitleL() invoked" ); |
|
429 _LIT( KSetLeftSoftkeyL, |
|
430 "CAknMemorySelectionDialogMultiDrivef::SetLeftSoftkeyL() invoked" ); |
|
431 _LIT( KSetRightSoftkeyL, |
|
432 "CAknMemorySelectionDialogMultiDrive::SetRightSoftkeyL() invoked" ); |
|
433 _LIT( KGetItem, |
|
434 "CAknMemorySelectionDialogMultiDrive::GetItem() invoked" ); |
|
435 _LIT( KExecute1, |
|
436 "CAknMemorySelectionDialogMultiDrive::ExecuteL1()invoked" ); |
|
437 _LIT( KExecute2, |
|
438 "CAknMemorySelectionDialogMultiDrive::ExecuteL2() invoked" ); |
|
439 _LIT( KRunDlgLD13, |
|
440 "CAknMemorySelectionDialogMultiDrive::RunDlgLD1()inovked" ); |
|
441 _LIT( KRunDlgLD14, |
|
442 "CAknMemorySelectionDialogMultiDrive::RunDlgLD2()invoked" ); |
|
443 _LIT( KRunDlgLD15, |
|
444 "CAknMemorySelectionDialogMultiDrive::RunDlgLD3()invoked" ); |
|
445 _LIT( KRunDlgLD16, |
|
446 "CAknMemorySelectionDialogMultiDrive::AddDrivePathsL()invoked" ); |
|
447 _LIT( KCAknMemorySelectionSettingItemMultiDriveDes, |
|
448 "~CAknMemorySelectionSettingItemMultiDrive()invoked"); |
|
449 _LIT( KMultiDriveNewL1, |
|
450 "CAknMemorySelectionDialogMultiDrive::NewL()1 invoked" ); |
|
451 _LIT( KMultiDriveNewL2, |
|
452 "CAknMemorySelectionDialogMultiDrive::NewL()2 invoked" ); |
|
453 _LIT( KCAknMemorySelectionSettingItemMultiDrive, |
|
454 "CAknMemorySelectionSettingItemMultiDrive() invoked"); |
|
455 _LIT( KCompleteConstructionL, |
|
456 "CAknMemorySelectionSettingItemMultiDrive::CompleteConstructionL("); |
|
457 _LIT( KSettingTextL, |
|
458 "CAknMemorySelectionSettingItemMultiDrive::SettingTextL() invoked"); |
|
459 _LIT( KLoadL, |
|
460 "CAknMemorySelectionSettingItemMultiDrive::LoadL()invoked"); |
|
461 _LIT( KStoreL, |
|
462 "CAknMemorySelectionSettingItemMultiDrive::StoreL()invoked"); |
|
463 |
|
464 TDriveNumber aSelDr = EDriveC; |
|
465 |
|
466 CAknMemorySelectionSettingItemMultiDrive* memSelection = |
|
467 new ( ELeave ) CAknMemorySelectionSettingItemMultiDrive( |
|
468 R_BCTEST_MIX50PATCH_SETTING_PAGE, aSelDr ); |
|
469 AssertTrueL( ETrue, KCAknMemorySelectionSettingItemMultiDrive ); |
|
470 CleanupStack::PushL( memSelection ); |
|
471 |
|
472 memSelection->CompleteConstructionL(); |
|
473 AssertTrueL( ETrue, KCompleteConstructionL ); |
|
474 |
|
475 memSelection->SettingTextL(); |
|
476 AssertTrueL( ETrue, KSettingTextL ); |
|
477 |
|
478 memSelection->LoadL(); |
|
479 AssertTrueL( ETrue, KLoadL ); |
|
480 |
|
481 memSelection->StoreL(); |
|
482 AssertTrueL( ETrue, KStoreL ); |
|
483 |
|
484 CleanupStack::PopAndDestroy( memSelection ); |
|
485 AssertTrueL( ETrue, KCAknMemorySelectionSettingItemMultiDriveDes ); |
|
486 |
|
487 TInt includedMedias = 5; |
|
488 TCommonDialogType aDialogDr = ECFDDialogTypeNormal; |
|
489 |
|
490 CAknMemorySelectionDialogMultiDrive* memSelDialogMulDriver = |
|
491 CAknMemorySelectionDialogMultiDrive::NewL( aDialogDr, ETrue ); |
|
492 AssertNotNullL( memSelDialogMulDriver, KMultiDriveNewL1 ); |
|
493 |
|
494 CleanupStack::PushL( memSelDialogMulDriver ); |
|
495 CleanupStack::PopAndDestroy( memSelDialogMulDriver ); |
|
496 |
|
497 memSelDialogMulDriver = CAknMemorySelectionDialogMultiDrive::NewL( |
|
498 aDialogDr, 0, EFalse, includedMedias ); |
|
499 AssertNotNullL( memSelDialogMulDriver, KMultiDriveNewL2 ); |
|
500 CleanupStack::PushL( memSelDialogMulDriver ); |
|
501 |
|
502 _LIT( tTxt, "Selection dialog title" ); |
|
503 TBuf<16> aDefaultFolder( _L("c:\\") ); |
|
504 TBuf<16> aRootPath( _L("d:\\") ); |
|
505 TBuf<KMaxFileName> rText; |
|
506 |
|
507 memSelDialogMulDriver->SetTitleL( tTxt ); |
|
508 AssertTrueL( ETrue, KSetTitleL ); |
|
509 |
|
510 memSelDialogMulDriver->SetLeftSoftkeyL( _L("OK") ); |
|
511 AssertTrueL( ETrue, KSetLeftSoftkeyL ); |
|
512 |
|
513 memSelDialogMulDriver->SetRightSoftkeyL( _L("Cancel") ); |
|
514 AssertTrueL( ETrue, KSetRightSoftkeyL ); |
|
515 |
|
516 memSelDialogMulDriver->GetItem( 0, rText ); |
|
517 AssertTrueL( ETrue, KGetItem ); |
|
518 |
|
519 memSelDialogMulDriver->ExecuteL( aSelDr ); |
|
520 AssertTrueL( ETrue, KExecute1); |
|
521 |
|
522 memSelDialogMulDriver->ExecuteL( aSelDr, &rText, &aDefaultFolder ); |
|
523 AssertTrueL( ETrue, KExecute2 ); |
|
524 |
|
525 memSelDialogMulDriver->RunDlgLD( aSelDr ); |
|
526 AssertTrueL( ETrue, KRunDlgLD13 ); |
|
527 |
|
528 memSelDialogMulDriver->RunDlgLD( aSelDr, aDefaultFolder ); |
|
529 AssertTrueL( ETrue, KRunDlgLD14 ); |
|
530 |
|
531 memSelDialogMulDriver->RunDlgLD( aSelDr, 0 ); |
|
532 AssertTrueL( ETrue, KRunDlgLD15 ); |
|
533 |
|
534 memSelDialogMulDriver->AddDrivePathsL( aRootPath, aDefaultFolder ); |
|
535 AssertTrueL( ETrue, KRunDlgLD16 ); |
|
536 |
|
537 CleanupStack::PopAndDestroy( memSelDialogMulDriver ); |
|
538 |
|
539 TBuf<KMaxFileName> fileName( _L("c:\\data\\testcommonfile.txt") ); |
|
540 RFile file; |
|
541 file.Replace( CCoeEnv::Static()->FsSession(), fileName, EFileWrite ); |
|
542 file.Close(); |
|
543 |
|
544 CAknFileNamePromptDialog* promptDialog = CAknFileNamePromptDialog::NewL(); |
|
545 CleanupStack::PushL( promptDialog ); |
|
546 promptDialog->RenameL( fileName ); |
|
547 CleanupStack::PopAndDestroy( promptDialog ); |
|
548 } |
|
549 |
|
550 // --------------------------------------------------------------------------- |
|
551 // CBCTestMix50PatchControlCase::TestSelectCommonFileL() |
|
552 // common file select api test |
|
553 // --------------------------------------------------------------------------- |
|
554 // |
|
555 void CBCTestMix50PatchControlCase::TestSelectCommonFileL() |
|
556 { |
|
557 _LIT( KTitle, "Common File Test " ); |
|
558 _LIT( KRunSelectDlgLD, "AknCommonDialogsDynMem::RunSelectDlgLD()invoked"); |
|
559 |
|
560 TBuf<KMaxFileName> folder(_L("c:\\data")); |
|
561 TBuf<KMaxFileName> fileName( _L("c:\\data\\testcommonfile.txt") ); |
|
562 TInt res = R_BCTEST_MIX50PATCH_MEMORY_SELECTION_LOCATIONS; |
|
563 |
|
564 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
565 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
566 fileName, |
|
567 res); |
|
568 |
|
569 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
570 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
571 fileName, |
|
572 res, |
|
573 KTitle()); |
|
574 |
|
575 MonkFilter filter; |
|
576 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
577 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
578 fileName, |
|
579 res, |
|
580 &filter ); |
|
581 |
|
582 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
583 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
584 fileName, |
|
585 res, |
|
586 0 ); |
|
587 |
|
588 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
589 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
590 fileName, |
|
591 res, |
|
592 &filter ); |
|
593 |
|
594 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
595 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
596 fileName, |
|
597 folder, |
|
598 res ); |
|
599 |
|
600 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
601 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
602 fileName, |
|
603 folder, |
|
604 res, |
|
605 &filter ); |
|
606 |
|
607 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
608 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
609 fileName, |
|
610 folder, |
|
611 res, |
|
612 0 ); |
|
613 |
|
614 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
615 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
616 fileName, |
|
617 folder, |
|
618 res, |
|
619 0, |
|
620 KTitle() ); |
|
621 AssertTrueL( ETrue, KRunSelectDlgLD ); |
|
622 } |
|
623 |
|
624 // --------------------------------------------------------------------------- |
|
625 // CBCTestMix50PatchControlCase::TestSaveCommonFileL() |
|
626 // Common file save api test |
|
627 // --------------------------------------------------------------------------- |
|
628 // |
|
629 void CBCTestMix50PatchControlCase::TestSaveCommonFileL() |
|
630 { |
|
631 _LIT( KTitle, "Common File Test " ); |
|
632 _LIT( KRunSaveDlgLD, "AknCommonDialogsDynMem::RunSaveDlgLD()invoked"); |
|
633 |
|
634 TBuf<KMaxFileName> folder(_L("c:\\data")); |
|
635 TBuf<KMaxFileName> fileName( _L("c:\\data\\testcommonfile.txt") ); |
|
636 TInt res = R_BCTEST_MIX50PATCH_MEMORY_SELECTION_LOCATIONS; |
|
637 |
|
638 AknCommonDialogsDynMem::RunSaveDlgLD( |
|
639 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
640 fileName, |
|
641 res); |
|
642 |
|
643 |
|
644 AknCommonDialogsDynMem::RunSelectDlgLD( |
|
645 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
646 fileName, |
|
647 res, |
|
648 KTitle()); |
|
649 |
|
650 MonkFilter filter; |
|
651 AknCommonDialogsDynMem::RunSaveDlgLD( |
|
652 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
653 fileName, |
|
654 res, |
|
655 &filter ); |
|
656 |
|
657 AknCommonDialogsDynMem::RunSaveDlgLD( |
|
658 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
659 fileName, |
|
660 res, |
|
661 KTitle(), |
|
662 KTitle() ); |
|
663 |
|
664 |
|
665 AknCommonDialogsDynMem::RunSaveDlgLD( |
|
666 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
667 fileName, |
|
668 res, |
|
669 0 ); |
|
670 |
|
671 AknCommonDialogsDynMem::RunSaveDlgLD( |
|
672 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
673 fileName, |
|
674 res, |
|
675 0, |
|
676 KTitle() ); |
|
677 |
|
678 AknCommonDialogsDynMem::RunSaveDlgLD( |
|
679 AknCommonDialogsDynMem::EMemoryTypePhone, |
|
680 fileName, |
|
681 folder, |
|
682 res, |
|
683 0, |
|
684 KTitle() ); |
|
685 AssertTrueL( ETrue, KRunSaveDlgLD ); |
|
686 } |
|
687 |
|
688 // --------------------------------------------------------------------------- |
|
689 // CBCTestMix50PatchControlCase::TestDocumentHandlerL() |
|
690 // document handler api test |
|
691 // --------------------------------------------------------------------------- |
|
692 // |
|
693 void CBCTestMix50PatchControlCase::TestDocumentHandlerL() |
|
694 { |
|
695 _LIT( KOpenFile1, |
|
696 "CDocumentHandler::OpenFileL(RFile&,TDataType&) invoked" ); |
|
697 _LIT( KOpenFile2, |
|
698 "CDocumentHandler::OpenFileL(TDesC&,TDataType&) invoked" ); |
|
699 _LIT( KNewLC1, |
|
700 "CDocumentHandler::NewLC() invoked" ); |
|
701 _LIT( KNewLC2, |
|
702 "CDocumentHandler::NewLC( CEikProcess* ) invoked" ); |
|
703 _LIT( KGetProgressiveDownloadAppUidsL, |
|
704 "CDocumentHandler::GetProgressiveDownloadAppUidsL() invoked"); |
|
705 _LIT( KCanHandleProgressivelyL, |
|
706 "CDocumentHandler::CanHandleProgressivelyL() invoked"); |
|
707 |
|
708 CDocumentHandler *docHandler = CDocumentHandler::NewLC(); |
|
709 AssertNotNullL( docHandler, KNewLC1 ); |
|
710 CleanupStack::PopAndDestroy( docHandler ); |
|
711 |
|
712 CEikProcess* proc = CEikonEnv::Static()->Process(); |
|
713 docHandler = CDocumentHandler::NewLC( proc ); |
|
714 AssertNotNullL( docHandler, KNewLC2 ); |
|
715 |
|
716 TDataType dataType; |
|
717 _LIT( KEmbeddedFileName, "C:\\BCTestLog\\DocHandleEmbedded.txt" ); |
|
718 RFs& fs = CEikonEnv::Static()->FsSession(); |
|
719 RFile embeddedFile; |
|
720 if( embeddedFile.Open( fs, KEmbeddedFileName, |
|
721 EFileWrite | EFileShareAny ) != KErrNone ) |
|
722 { |
|
723 embeddedFile.Create( fs, KEmbeddedFileName, |
|
724 EFileWrite | EFileShareAny ); |
|
725 } |
|
726 CleanupClosePushL( embeddedFile ); |
|
727 _LIT8( KContent, "Content Text" ); |
|
728 embeddedFile.Write( KContent ); |
|
729 TInt error; |
|
730 error = docHandler->OpenFileL( embeddedFile, dataType ); |
|
731 AssertIntL( KErrNone, error, KOpenFile1 ); |
|
732 |
|
733 error = KErrNone; |
|
734 error = docHandler->OpenFileL( KEmbeddedFileName(), dataType ); |
|
735 AssertIntL( KErrNone, error, KOpenFile2 ); |
|
736 |
|
737 TUid uid = { 0 }; |
|
738 docHandler->CanHandleProgressivelyL( dataType, uid ); |
|
739 AssertTrueL( ETrue, KCanHandleProgressivelyL ); |
|
740 |
|
741 RArray<TInt32> uidList; |
|
742 docHandler->GetProgressiveDownloadAppUidsL( uidList ); |
|
743 CleanupClosePushL( uidList ); |
|
744 AssertTrueL( ETrue, KGetProgressiveDownloadAppUidsL ); |
|
745 |
|
746 CleanupStack::PopAndDestroy(); // uidList |
|
747 CleanupStack::PopAndDestroy(); // embeddedFile |
|
748 CleanupStack::PopAndDestroy( docHandler ); |
|
749 } |
|
750 |
|
751 // --------------------------------------------------------------------------- |
|
752 // CBCTestMix50PatchControlCase::TestChoiceListL() |
|
753 // ChoiceListL test |
|
754 // --------------------------------------------------------------------------- |
|
755 // |
|
756 void CBCTestMix50PatchControlCase::TestFontsL() |
|
757 { |
|
758 _LIT( KGetFont1, |
|
759 "AknFontAccess::GetFont( CBitmapDevice& , \ |
|
760 TFontStyle ,TInt, TAknFontFamily ) invoked" ); |
|
761 _LIT( KGetClosestFont1, |
|
762 "AknFontAccess::GetClosestFont( CBitmapDevice& ,TFontStyle \ |
|
763 ,TInt, TAknFontFamily ) invoked" ); |
|
764 _LIT( KGetFont2, |
|
765 "AknFontAccess::GetFont( CBitmapDevice& ,TFontStyle , \ |
|
766 TInt, TDesC& ) invoked" ); |
|
767 _LIT( KGetClosestFont2, |
|
768 "AknFontAccess::GetClosestFont( CBitmapDevice& ,TFontStyle , \ |
|
769 TInt, TDesC& ) invoked" ); |
|
770 _LIT( KAknLayoutTest1, |
|
771 "AknLayoutUtils::CreateLayoutFontFromSpecificationL( const \ |
|
772 TAknFontSpecification&) invoked" ); |
|
773 _LIT( KAknLayoutTest2, |
|
774 "AknLayoutUtils::CreateLayoutFontFromSpecificationL( const \ |
|
775 TTypeface&, const TAknFontSpecification& ) invoked" ); |
|
776 |
|
777 TFontStyle fontStyle( EPostureItalic, EStrokeWeightBold, |
|
778 EPrintPosSuperscript ); |
|
779 const TInt KFontSizeInPixels=12; |
|
780 CBitmapDevice* dev = CCoeEnv::Static()->ScreenDevice(); |
|
781 TInt fontSizeInTwips = dev->VerticalPixelsToTwips( KFontSizeInPixels ); |
|
782 |
|
783 CFont* font = AknFontAccess::GetFont( *dev, fontStyle, |
|
784 fontSizeInTwips, AknFontAccess::EAknFontFamilySansSerif ); |
|
785 AssertTrueL( ETrue, KGetFont1 ); |
|
786 dev->ReleaseFont( font ); |
|
787 |
|
788 font = NULL; |
|
789 font = AknFontAccess::GetClosestFont( *dev, fontStyle, |
|
790 fontSizeInTwips, AknFontAccess::EAknFontFamilySansSerif ); |
|
791 AssertTrueL( ETrue, KGetClosestFont1 ); |
|
792 dev->ReleaseFont( font ); |
|
793 |
|
794 TBuf<14> fontName( _L( "courier") ); |
|
795 font = NULL; |
|
796 font = AknFontAccess::GetFont( *dev, fontStyle, |
|
797 fontSizeInTwips, fontName ); |
|
798 AssertTrueL( ETrue, KGetFont2 ); |
|
799 dev->ReleaseFont( font ); |
|
800 |
|
801 font = NULL; |
|
802 font = AknFontAccess::GetClosestFont( *dev, fontStyle, |
|
803 fontSizeInTwips, fontName ); |
|
804 AssertTrueL( ETrue, KGetClosestFont2 ); |
|
805 dev->ReleaseFont( font ); |
|
806 |
|
807 TAknFontSpecification fontSpec( ELatinPlain12 ); |
|
808 CAknLayoutFont* layoutFont = AknFontAccess:: |
|
809 CreateLayoutFontFromSpecificationL( *dev, fontSpec ); |
|
810 delete layoutFont; |
|
811 AssertTrueL( ETrue, KAknLayoutTest1 ); |
|
812 |
|
813 TTypeface typeFace; |
|
814 layoutFont = AknFontAccess::CreateLayoutFontFromSpecificationL( *dev, typeFace, fontSpec ); |
|
815 delete layoutFont; |
|
816 AssertTrueL( ETrue, KAknLayoutTest2 ); |
|
817 } |
|
818 |
|
819 // --------------------------------------------------------------------------- |
|
820 // CBCTestMix50PatchControlCase::TestGridsL() |
|
821 // Grids api test |
|
822 // --------------------------------------------------------------------------- |
|
823 // |
|
824 void CBCTestMix50PatchControlCase::TestGridsL() |
|
825 { |
|
826 _LIT( KHandleControlEventL, |
|
827 " CAknColourSelectionGrid::HandleControlEventL() invoked"); |
|
828 _LIT( KHandleDialogPageEventL, |
|
829 " CAknColourSelectionGrid::HandleDialogPageEventL() invoked"); |
|
830 |
|
831 CArrayFixFlat<TRgb>* array = new( ELeave ) CArrayFixFlat<TRgb>(1); |
|
832 CleanupStack::PushL( array ); |
|
833 TRgb rgb = ( KRgbRed, KRgbGreen, KRgbBlue ); |
|
834 array->AppendL( rgb ); |
|
835 TBool noneChosen = ETrue; |
|
836 CAknColourSelectionGrid* colourSelectionGrid = |
|
837 CAknColourSelectionGrid::NewL( |
|
838 array, ETrue, noneChosen, rgb ); |
|
839 CleanupStack::PushL( colourSelectionGrid ); |
|
840 |
|
841 colourSelectionGrid->HandleControlEventL( iContainer, |
|
842 MCoeControlObserver::EEventRequestExit ); |
|
843 AssertTrueL( ETrue, KHandleControlEventL ); |
|
844 |
|
845 colourSelectionGrid->HandleDialogPageEventL( |
|
846 MEikDialogPageObserver::EUnknownType ); |
|
847 AssertTrueL( ETrue, KHandleDialogPageEventL ); |
|
848 |
|
849 CleanupStack::PopAndDestroy( colourSelectionGrid ); |
|
850 CleanupStack::PopAndDestroy( array ); |
|
851 } |
|
852 |
|
853 // --------------------------------------------------------------------------- |
|
854 // CBCTestMix50PatchControlCase::TestHListsAndHotkeysL() |
|
855 // hierarchical list and hot key api test |
|
856 // --------------------------------------------------------------------------- |
|
857 // |
|
858 void CBCTestMix50PatchControlCase::TestHListsAndHotkeysL() |
|
859 { |
|
860 |
|
861 _LIT( KChild, |
|
862 "CAknTreeList::KChild() invoked " ); |
|
863 _LIT( KVisibleItemIndex, |
|
864 "CAknTreeList::VisibleItemIndex() invoked" ); |
|
865 _LIT( KSort1, |
|
866 "CAknTreeList::Sort( AknCustomTreeOrdering*, TBool ) invoked " ); |
|
867 _LIT( KSort2, |
|
868 "CAknTreeList::Sort( AknCustomTreeOrdering*, TBool, TBool ) invoked " ); |
|
869 _LIT( KChildCount, |
|
870 " CAknTreeList::ChildCount() invoked " ); |
|
871 _LIT( KConstructFromResourceL, |
|
872 "CEikHotKeyTable::ConstructFromResourceL() invoked" ); |
|
873 _LIT( KAddItemL, |
|
874 "CEikHotKeyTable::AddItemL() invoked" ); |
|
875 _LIT( KHotKeyFromCommandId, |
|
876 "CEikHotKeyTable::HotKeyFromCommandId() invoked" ); |
|
877 _LIT( KRemoveItem, |
|
878 "CEikHotKeyTable::RemoveItem()invoked" ); |
|
879 _LIT( KReset, |
|
880 "CEikHotKeyTable::Reset() invoked" ); |
|
881 |
|
882 TInt index; |
|
883 TBool mark = ETrue; |
|
884 TBool draw=ETrue; |
|
885 CAknTreeList* list = CAknSingleStyleTreeList::NewLC(); |
|
886 |
|
887 MAknCustomTreeOrdering* custom = NULL; |
|
888 list->Sort( custom, draw ); |
|
889 AssertTrueL( ETrue, KSort1 ); |
|
890 |
|
891 _LIT( KNodeText, "Node" ); |
|
892 TUint32 flags = CAknSingleStyleTreeList::EPersistent; |
|
893 static_cast<CAknSingleStyleTreeList*>( list )->AddNodeL( |
|
894 KAknTreeIIDRoot,KNodeText, flags, EFalse ); |
|
895 |
|
896 index = list->ChildCount(KAknTreeIIDRoot); |
|
897 AssertTrueL( ETrue, KChildCount ); |
|
898 |
|
899 TAknTreeItemID item; |
|
900 item = list->Child( KAknTreeIIDRoot, index - 1 ); |
|
901 AssertTrueL( ETrue, KChild ); |
|
902 |
|
903 list->VisibleItemIndex( item ); |
|
904 AssertTrueL( ETrue, KVisibleItemIndex ); |
|
905 |
|
906 list->Sort(KAknTreeIIDRoot, mark, draw ); |
|
907 AssertTrueL( ETrue, KSort2 ); |
|
908 |
|
909 CleanupStack::PopAndDestroy( list ); |
|
910 |
|
911 const TInt KModifierCode = 0; |
|
912 CEikHotKeyTable* hotKey = new( ELeave) CEikHotKeyTable(); |
|
913 CleanupStack::PushL( hotKey ); |
|
914 |
|
915 hotKey->ConstructFromResourceL( R_BCTEST_MIX50PATCH_HOTKEY_COMMAND ); |
|
916 AssertTrueL( ETrue, KConstructFromResourceL ); |
|
917 |
|
918 hotKey->AddItemL( EBCTestCmdOutline1, Key1, KModifierCode ); |
|
919 AssertTrueL( ETrue, KAddItemL ); |
|
920 |
|
921 hotKey->AddItemL( EBCTestCmdOutline1, Key1, EModifierCtrl ); |
|
922 hotKey->AddItemL( EProgCmdAutoTest, Key2, |
|
923 EModifierShift|EModifierCtrl ); |
|
924 |
|
925 TInt cmdId = hotKey->CommandIdFromHotKey( Key1, EModifierCtrl ); |
|
926 _LIT( KCommandIdFromHotKey, "CEikHotKeyTable::CommandIdFromHotKey" ); |
|
927 AssertTrueL( ETrue, KCommandIdFromHotKey ); |
|
928 |
|
929 TInt keyCode; |
|
930 TInt kModifier; |
|
931 TBool flag = hotKey->HotKeyFromCommandId( EBCTestCmdOutline1, keyCode, |
|
932 kModifier ); |
|
933 AssertTrueL( flag, KHotKeyFromCommandId ); |
|
934 |
|
935 flag = hotKey->HotKeyFromCommandId( EProgCmdAutoTest, keyCode, |
|
936 kModifier ); |
|
937 _LIT( KHotKeyFromCommandId1, "CEikHotKeyTable::HotKeyFromCommandId 1" ); |
|
938 AssertTrueL( flag, KHotKeyFromCommandId1 ); |
|
939 |
|
940 hotKey->RemoveItem( EBCTestCmdOutline1 ); |
|
941 AssertTrueL( ETrue, KRemoveItem ); |
|
942 |
|
943 hotKey->Reset(); |
|
944 AssertTrueL( ETrue, KReset ); |
|
945 |
|
946 CleanupStack::Pop( hotKey ); |
|
947 delete hotKey; |
|
948 } |
|
949 |
|
950 // --------------------------------------------------------------------------- |
|
951 // CBCTestMix50PatchControlCase::TestMiscellOneL() |
|
952 // miscellaneous apis test |
|
953 // --------------------------------------------------------------------------- |
|
954 // |
|
955 void CBCTestMix50PatchControlCase::TestMiscellOneL() |
|
956 { |
|
957 _LIT( KWriteInternalStateL, |
|
958 "EikImage::WriteInternalStateL() invoked" ); |
|
959 _LIT( KHandleResourceChange, |
|
960 "CAknInputFrame::HandleResourceChange() invoked"); |
|
961 _LIT( KReplaceIndicatorIconL, |
|
962 "CAknIndicatorContainer::ReplaceIndicatorIconL()invoked"); |
|
963 _LIT( KDraw, |
|
964 "CEikFileNameLabel::Draw()invoked"); |
|
965 |
|
966 CBCTestImage* image = new ( ELeave ) CBCTestImage; |
|
967 CleanupStack::PushL( image ); |
|
968 |
|
969 _LIT( KFileName, "c:\\bctestlog\\image.txt" ); |
|
970 RFs& fileSession = CCoeEnv::Static()->FsSession(); |
|
971 RFileWriteStream fileStream; |
|
972 if ( fileStream.Open( fileSession, KFileName(), EFileWrite ) != KErrNone ) |
|
973 { |
|
974 fileStream.Create( fileSession, KFileName(), EFileWrite ); |
|
975 } |
|
976 CleanupClosePushL( fileStream ); |
|
977 image->WriteInternalStateL( fileStream ); |
|
978 AssertTrueL( ETrue, KWriteInternalStateL ); |
|
979 |
|
980 CleanupStack::PopAndDestroy( &fileStream ); |
|
981 CleanupStack::PopAndDestroy( image ); |
|
982 |
|
983 // Test indicator container api |
|
984 CAknIndicatorContainer* indicator = |
|
985 new( ELeave ) CAknIndicatorContainer(); |
|
986 CleanupStack::PushL( indicator ); |
|
987 indicator->ConstructL(); |
|
988 TUid uId; |
|
989 uId = indicator->CreateIndicatorFromResourceL( |
|
990 R_BCTEST_MIX50PATCH_INDICATOR, |
|
991 CAknIndicatorContainer::EMultiColorIndicator ); |
|
992 |
|
993 CFbsBitmap* bitmap( NULL ); |
|
994 // Get bitmap for "abc" icon |
|
995 TAknsItemID skinId = KAknsIIDQgnStatCaseSmall; |
|
996 TInt bitmapId = EMbmAvkonQgn_stat_case_small; |
|
997 MAknsSkinInstance *skin = AknsUtils::SkinInstance(); |
|
998 AknsUtils::CreateIconLC( skin, |
|
999 skinId, |
|
1000 bitmap, |
|
1001 AknIconUtils::AvkonIconFileName(), |
|
1002 bitmapId ); |
|
1003 |
|
1004 TSize size; |
|
1005 User::LeaveIfError( AknIconUtils::GetContentDimensions( bitmap, |
|
1006 size ) ); |
|
1007 CFbsBitmap* emptyMask = new (ELeave) CFbsBitmap(); |
|
1008 CleanupStack::PushL( emptyMask ); |
|
1009 User::LeaveIfError( emptyMask->Create( size, EGray2 ) ); |
|
1010 |
|
1011 // Ownership of bitmap and newMask is transferred to indicator. |
|
1012 indicator->ReplaceIndicatorIconL( uId, EAknIndicatorStateOn, |
|
1013 CAknIndicatorContainer::ELayoutModeUsual, bitmap, emptyMask ); |
|
1014 AssertTrueL( ETrue, KReplaceIndicatorIconL ); |
|
1015 |
|
1016 CleanupStack::Pop( 2, bitmap ); // CSI: 47,12 # emptyMask, bitmap |
|
1017 CleanupStack::PopAndDestroy( indicator ); |
|
1018 |
|
1019 // input frame api |
|
1020 CEikEdwin* edwin = new( ELeave ) CEikEdwin(); |
|
1021 CleanupStack::PushL( edwin ); |
|
1022 edwin->ConstructL( 0, 30, 100, 1 ); |
|
1023 |
|
1024 CFbsBitmap* bmp = new( ELeave ) CFbsBitmap(); |
|
1025 CleanupStack::PushL( bmp ); |
|
1026 bmp->Load( AknIconUtils::AvkonIconFileName(), |
|
1027 EMbmAvkonQgn_stat_chi_pinyin ); |
|
1028 |
|
1029 CGulIcon* icon = CGulIcon::NewL( bmp ); |
|
1030 CleanupStack::PushL( icon ); |
|
1031 |
|
1032 CAknInputFrame* inputFrame = CAknInputFrame::NewL( edwin, |
|
1033 EFalse, icon ); |
|
1034 CleanupStack::PushL( inputFrame ); |
|
1035 // POPUP_FIELD_SELECTION_BMP |
|
1036 inputFrame->HandleResourceChange( KEikColorResourceChange ); |
|
1037 AssertTrueL( ETrue, KHandleResourceChange ); |
|
1038 |
|
1039 CleanupStack::PopAndDestroy( inputFrame ); |
|
1040 CleanupStack::Pop( icon ); |
|
1041 CleanupStack::Pop( bmp ); |
|
1042 CleanupStack::PopAndDestroy( edwin ); |
|
1043 |
|
1044 // labels api |
|
1045 CBCTestEikFileNameLabel* fileNameLabel = new( |
|
1046 ELeave ) CBCTestEikFileNameLabel; |
|
1047 CleanupStack::PushL( fileNameLabel ); |
|
1048 fileNameLabel->ConstructL(); |
|
1049 fileNameLabel->SetContainerWindowL( *iContainer ); |
|
1050 fileNameLabel->ActivateGc(); |
|
1051 fileNameLabel->Draw( iContainer->Rect() ); |
|
1052 AssertTrueL( ETrue, KDraw ); |
|
1053 fileNameLabel->DeactivateGc(); |
|
1054 |
|
1055 CleanupStack::PopAndDestroy( fileNameLabel ); |
|
1056 } |
|
1057 |
|
1058 // --------------------------------------------------------------------------- |
|
1059 // CBCTestMix50PatchControlCase::TestInitializationL() |
|
1060 // initialization api test |
|
1061 // --------------------------------------------------------------------------- |
|
1062 // |
|
1063 void CBCTestMix50PatchControlCase::TestInitializationL() |
|
1064 { |
|
1065 _LIT( KResourceFile , |
|
1066 "CEikCtlLibrary::ResourceFile() invoked" ); |
|
1067 _LIT( KControlFactory , |
|
1068 "CEikCtlLibrary::ControlFactory() invoked" ); |
|
1069 _LIT( KInitializeL , |
|
1070 "CEikCtlLibrary::InitializeL() invoked" ); |
|
1071 _LIT( KButtonGroupFactory , |
|
1072 "CEikCtlLibrary::ButtonGroupFactory() invoked" ); |
|
1073 |
|
1074 CEikCtlLibrary::ResourceFile(); |
|
1075 AssertTrueL( ETrue, KResourceFile ); |
|
1076 |
|
1077 CEikCtlLibrary::ControlFactory(); |
|
1078 AssertTrueL( ETrue, KControlFactory ); |
|
1079 |
|
1080 CEikCtlLibrary::InitializeL(); |
|
1081 AssertTrueL( ETrue, KInitializeL ); |
|
1082 |
|
1083 CEikCtlLibrary::ButtonGroupFactory(); |
|
1084 AssertTrueL( ETrue, KButtonGroupFactory ); |
|
1085 } |
|
1086 |
|
1087 // --------------------------------------------------------------------------- |
|
1088 // CBCTestMix50PatchControlCase::TestInputLanL() |
|
1089 // input language api test |
|
1090 // --------------------------------------------------------------------------- |
|
1091 // |
|
1092 void CBCTestMix50PatchControlCase::TestInputLanL() |
|
1093 { |
|
1094 _LIT( KTAknInputLanguageCapabilities, |
|
1095 "TAknInputLanguageCapabilities::TAknInputLanguageCapabilities() \ |
|
1096 invoked" ); |
|
1097 _LIT( KAssignCapability, |
|
1098 "TAknInputLanguageCapabilities::AssignCapability()invoked " ); |
|
1099 _LIT( KFilteredCapabilities, "TAknInputLanguageCapabilities:: \ |
|
1100 FilteredCapabilities()invoked" ); |
|
1101 _LIT( KHasCapability, "TAknInputLanguageCapabilities:: \ |
|
1102 HasCapability()invoked" ); |
|
1103 _LIT( KSetAllCapabilities, "TAknInputLanguageCapabilities:: \ |
|
1104 SetAllCapabilities()invoked" ); |
|
1105 _LIT( KMdcaCount, |
|
1106 "CAknInputLanguageList::MdcaCount()invoked" ); |
|
1107 _LIT( KMdcaPoint, |
|
1108 "CAknInputLanguageList::MdcaPoint" ); |
|
1109 _LIT( KLanItem1, |
|
1110 "CAknInputLanguageItem::LanguageCode" ); |
|
1111 _LIT( KLanItem2, |
|
1112 "CAknInputLanguageItem::LanguageName" ); |
|
1113 _LIT( KLanItem3, "CAknInputLanguageItem::Capabilities" ); |
|
1114 _LIT( KCAknInputLanguageItemDes, |
|
1115 "CAknInputLanguageItem::~CAknInputLanguageItem() invoked" ); |
|
1116 _LIT( KCAknInputLanguageListDes, |
|
1117 "CAknInputLanguageList::~CAknInputLanguageList() invoked"); |
|
1118 |
|
1119 CAknInputLanguageInfo* lanInfo = |
|
1120 AknInputLanguageInfoFactory::CreateInputLanguageInfoL(); |
|
1121 CleanupStack::PushL( lanInfo ); |
|
1122 |
|
1123 TAknInputLanguageCapabilities capFilter; |
|
1124 AssertTrueL( ETrue, KAssignCapability ); |
|
1125 |
|
1126 capFilter.AssignCapability( |
|
1127 TAknInputLanguageCapabilities::EMultitap, ETrue ); |
|
1128 AssertTrueL( ETrue, KAssignCapability); |
|
1129 |
|
1130 TAknInputLanguageCapabilities inputCap; |
|
1131 TAknInputLanguageCapabilities desCap; |
|
1132 AssertTrueL( ETrue, KTAknInputLanguageCapabilities ); |
|
1133 |
|
1134 inputCap.AssignCapability( TInt ( 1 ),EFalse ); |
|
1135 AssertTrueL( ETrue, KAssignCapability ); |
|
1136 |
|
1137 inputCap.FilteredCapabilities( desCap ); |
|
1138 AssertTrueL( ETrue, KFilteredCapabilities ); |
|
1139 |
|
1140 inputCap.HasAnySupport(); |
|
1141 AssertTrueL( ETrue, KHasCapability ); |
|
1142 |
|
1143 inputCap.HasCapability( TInt ( 1 ) ); |
|
1144 AssertTrueL( ETrue, KHasCapability ); |
|
1145 |
|
1146 inputCap.SetAllCapabilities(); |
|
1147 AssertTrueL( ETrue, KSetAllCapabilities ); |
|
1148 |
|
1149 CAknInputLanguageList* inputList = new ( |
|
1150 ELeave ) CAknInputLanguageList( TInt( 1 ) ); |
|
1151 CleanupStack::PushL( inputList ); |
|
1152 |
|
1153 CArrayFixFlat<TInt>* codeList = new( ELeave ) CArrayFixFlat<TInt>( 1 ); |
|
1154 CleanupStack::PushL( codeList ); |
|
1155 codeList->AppendL( ELangEnglish ); |
|
1156 |
|
1157 lanInfo->AppendLanguagesL( inputList, codeList, capFilter ); |
|
1158 |
|
1159 TInt cunt = inputList->MdcaCount(); |
|
1160 AssertTrueL( ETrue, KMdcaCount ); |
|
1161 |
|
1162 TPtrC ptr = inputList->MdcaPoint( 0 ); |
|
1163 AssertTrueL( ETrue, KMdcaPoint ); |
|
1164 |
|
1165 CAknInputLanguageItem* lanItem = (*inputList)[0]; |
|
1166 |
|
1167 TLanguage code = lanItem->LanguageCode(); |
|
1168 AssertIntL( ELangEnglish, code, KLanItem1 ); |
|
1169 |
|
1170 TPtrC name = lanItem->LanguageName(); |
|
1171 AssertTrueL( ETrue, KLanItem2 ); |
|
1172 |
|
1173 TAknInputLanguageCapabilities cap = lanItem->Capabilities(); |
|
1174 AssertTrueL( ETrue, KLanItem3 ); |
|
1175 |
|
1176 CleanupStack::PopAndDestroy( codeList ); |
|
1177 CleanupStack::PopAndDestroy( inputList ); |
|
1178 AssertTrueL( ETrue, KCAknInputLanguageListDes ); |
|
1179 AssertTrueL( ETrue, KCAknInputLanguageItemDes ); |
|
1180 CleanupStack::PopAndDestroy( lanInfo ); |
|
1181 } |
|
1182 |
|
1183 // --------------------------------------------------------------------------- |
|
1184 // CBCTestMix50PatchControlCase::TestMenusL() |
|
1185 // menu api test |
|
1186 // --------------------------------------------------------------------------- |
|
1187 // |
|
1188 void CBCTestMix50PatchControlCase::TestMenusL() |
|
1189 { |
|
1190 _LIT( KCTitleArray,"CTitleArray::CTitleArray() invoked" ); |
|
1191 _LIT( KAddTitleL, "CTitleArray::AddTitleL() invoked"); |
|
1192 _LIT( KCTitleArrayDes, "CTitleArray::~CTitleArray() invoked" ); |
|
1193 |
|
1194 CEikMenuBar::CTitleArray* titleArray = new ( |
|
1195 ELeave ) CEikMenuBar::CTitleArray(); |
|
1196 AssertNotNullL( titleArray, KCTitleArray ); |
|
1197 CleanupStack::PushL( titleArray ); |
|
1198 |
|
1199 CEikMenuBarTitle* titleBar = new (ELeave) CEikMenuBarTitle; |
|
1200 CleanupStack::PushL( titleBar ); |
|
1201 titleArray->AddTitleL( titleBar ); // ownership transferred |
|
1202 AssertTrueL( ETrue, KAddTitleL ); |
|
1203 |
|
1204 CleanupStack::Pop( titleBar ); |
|
1205 CleanupStack::PopAndDestroy( titleArray ); |
|
1206 AssertTrueL( ETrue, KCTitleArrayDes ); |
|
1207 } |
|
1208 |
|
1209 // --------------------------------------------------------------------------- |
|
1210 // CBCTestMix50PatchControlCase::TestNotesL() |
|
1211 // notes api test |
|
1212 // --------------------------------------------------------------------------- |
|
1213 // |
|
1214 void CBCTestMix50PatchControlCase::TestNotesL() |
|
1215 { |
|
1216 _LIT( KExecuteDlgLD1, |
|
1217 "CAknNoteDialog::KExecuteDlgLD( const TTimeout, \ |
|
1218 const TTone ,TInt ) invoked" ); |
|
1219 _LIT( KExecuteDlgLD2, |
|
1220 "CAknNoteDialog::KExecuteDlgLD( const TTone, TInt ) invoked" ); |
|
1221 _LIT( KExecuteDlgLD3, |
|
1222 "CAknNoteDialog::KExecuteDlgLD( TInt, TInt ) invoked" ); |
|
1223 CAknNoteDialog* noteDialog = new( ELeave ) CAknNoteDialog(); |
|
1224 |
|
1225 noteDialog->ExecuteDlgLD( R_BCTEST_MIX50PATCH_NOTE_ICON ); |
|
1226 AssertTrueL( ETrue, KExecuteDlgLD3 ); |
|
1227 noteDialog = NULL; |
|
1228 |
|
1229 noteDialog = new( ELeave ) CAknNoteDialog(); |
|
1230 noteDialog->ExecuteDlgLD( CAknNoteDialog::EConfirmationTone, |
|
1231 R_BCTEST_MIX50PATCH_NOTE_ICON ); |
|
1232 AssertTrueL( ETrue, KExecuteDlgLD2 ); |
|
1233 noteDialog = NULL; |
|
1234 |
|
1235 noteDialog = new( ELeave ) CAknNoteDialog(); |
|
1236 noteDialog->ExecuteDlgLD( CAknNoteDialog::EShortTimeout, |
|
1237 CAknNoteDialog::EConfirmationTone, R_BCTEST_MIX50PATCH_NOTE_ICON ); |
|
1238 AssertTrueL( ETrue, KExecuteDlgLD1 ); |
|
1239 noteDialog = NULL; |
|
1240 } |
|
1241 |
|
1242 // --------------------------------------------------------------------------- |
|
1243 // CBCTestMix50PatchControlCase::TestMiscellTwoL() |
|
1244 // another miscellaneous apis test |
|
1245 // --------------------------------------------------------------------------- |
|
1246 // |
|
1247 void CBCTestMix50PatchControlCase::TestMiscellTwoL() |
|
1248 { |
|
1249 _LIT( KSetPreferredNaviDecoratorLayoutStyle , |
|
1250 "CAknNavigationControlContainer:: \ |
|
1251 SetPreferredNaviDecoratorLayoutStyle()invoked"); |
|
1252 _LIT( KHandleResourceChange, "CAknLocalScreenClearer:: \ |
|
1253 HandleResourceChange()invoked"); |
|
1254 _LIT( KTopContext, "CAknKeySoundSystem::TopContext()invoked"); |
|
1255 |
|
1256 // Navigation pane api |
|
1257 CAknNavigationControlContainer* navictlContainer = new ( ELeave ) |
|
1258 CAknNavigationControlContainer(); |
|
1259 CleanupStack::PushL( navictlContainer ); |
|
1260 navictlContainer->ConstructL(); |
|
1261 navictlContainer->SetPreferredNaviDecoratorLayoutStyle( |
|
1262 CAknNavigationDecorator::ENaviControlLayoutNarrow ); |
|
1263 AssertTrueL( ETrue, KSetPreferredNaviDecoratorLayoutStyle ); |
|
1264 CleanupStack::PopAndDestroy( navictlContainer ); |
|
1265 |
|
1266 // CAknLocalScreenClearer |
|
1267 CAknLocalScreenClearer* clearer = CAknLocalScreenClearer::NewLC(); |
|
1268 clearer->HandleResourceChange( KEikColorResourceChange ); |
|
1269 AssertTrueL( ETrue, KHandleResourceChange ); |
|
1270 CleanupStack::PopAndDestroy( clearer ); |
|
1271 |
|
1272 // CAknKeySoundSystem |
|
1273 const TInt KUid = 100; |
|
1274 CAknKeySoundSystem *aknsoundsystem = CAknKeySoundSystem::NewL( KUid ); |
|
1275 CleanupStack::PushL( aknsoundsystem ); |
|
1276 aknsoundsystem->TopContext(); |
|
1277 AssertTrueL( ETrue, KTopContext ); |
|
1278 CleanupStack::PopAndDestroy( aknsoundsystem ); |
|
1279 } |
|
1280 |
|
1281 // --------------------------------------------------------------------------- |
|
1282 // CBCTestMix50PatchControlCase::TestNotifierL() |
|
1283 // notifier api test |
|
1284 // --------------------------------------------------------------------------- |
|
1285 // |
|
1286 void CBCTestMix50PatchControlCase::TestNotifierL() |
|
1287 { |
|
1288 _LIT( KMsg, "CAknPopupNotify test test test!!!!" ); |
|
1289 _LIT( KPopupMessageL, "CAknPopupNotify::PopupMessageL()invoked"); |
|
1290 CAknPopupNotify* notifier = CAknPopupNotify::NewL(); |
|
1291 CleanupStack::PushL( notifier ); |
|
1292 notifier->PopupMessageL( KMsg() ); |
|
1293 AssertTrueL( ETrue, KPopupMessageL ); |
|
1294 CleanupStack::PopAndDestroy( notifier ); |
|
1295 } |
|
1296 |
|
1297 // --------------------------------------------------------------------------- |
|
1298 // CBCTestMix50PatchControlCase::TestPopupsL() |
|
1299 // pop up dialog api test |
|
1300 // --------------------------------------------------------------------------- |
|
1301 // |
|
1302 void CBCTestMix50PatchControlCase::TestPopupsL() |
|
1303 { |
|
1304 _LIT( KTAknPopupWindowLayoutDef, |
|
1305 "TAknPopupWindowLayoutDef::TAknPopupWindowLayoutDef() invoked" ); |
|
1306 _LIT( KFadedComponent, |
|
1307 "MAknFadedComponent::FadedComponent()invoked"); |
|
1308 _LIT( KCountFadedComponents, |
|
1309 "MAknFadedComponent::CountFadedComponents()invoked"); |
|
1310 |
|
1311 TAknPopupWindowLayoutDef layout; |
|
1312 AssertTrueL( ETrue, KTAknPopupWindowLayoutDef ); |
|
1313 |
|
1314 CBCTestFadedComponent* fadedComponent = new ( |
|
1315 ELeave ) CBCTestFadedComponent; |
|
1316 CleanupStack::PushL( fadedComponent ); |
|
1317 |
|
1318 TInt count = fadedComponent->CountFadedComponents(); |
|
1319 AssertTrueL( ETrue, KCountFadedComponents ); |
|
1320 |
|
1321 fadedComponent->FadedComponent( count-1 ); |
|
1322 AssertTrueL( ETrue, KFadedComponent ); |
|
1323 |
|
1324 CleanupStack::PopAndDestroy( fadedComponent ); |
|
1325 } |
|
1326 |
|
1327 // --------------------------------------------------------------------------- |
|
1328 // CBCTestMix50PatchControlCase::TestUIFrmL() |
|
1329 // ui framework api test |
|
1330 // --------------------------------------------------------------------------- |
|
1331 // |
|
1332 void CBCTestMix50PatchControlCase::TestUIFrmL() |
|
1333 { |
|
1334 _LIT( KAddButtonL, "CEikButtonPanel::AddButtonL() invoked " ); |
|
1335 |
|
1336 // CEikButtonPanel |
|
1337 CEikButtonPanel * panel = new ( ELeave )CEikButtonPanel(); |
|
1338 CleanupStack::PushL( panel ); |
|
1339 panel->ConstructL(); |
|
1340 |
|
1341 CEikLabeledButton* button = new (ELeave) CEikLabeledButton; |
|
1342 CleanupStack::PushL( button ); |
|
1343 TResourceReader reader; |
|
1344 CCoeEnv::Static()->CreateResourceReaderLC( reader, R_BCTEST_MIX50PATCH_LBBUT ); |
|
1345 button->ConstructFromResourceL( reader ); |
|
1346 |
|
1347 // ownership transferred |
|
1348 panel->AddButtonL( button,EBCTestMix50PatchLabelledButton, 1 ); |
|
1349 AssertTrueL( ETrue, KAddButtonL ); |
|
1350 |
|
1351 CleanupStack::PopAndDestroy(); // reader internal state |
|
1352 CleanupStack::Pop( button ); |
|
1353 CleanupStack::PopAndDestroy( panel ); |
|
1354 } |
|
1355 |
|
1356 // --------------------------------------------------------------------------- |
|
1357 // CBCTestMix50PatchControlCase::TestQueriesL() |
|
1358 // queries api test |
|
1359 // --------------------------------------------------------------------------- |
|
1360 // |
|
1361 void CBCTestMix50PatchControlCase::TestQueriesL() |
|
1362 { |
|
1363 _LIT( KHeader, |
|
1364 " Query dialog header "); |
|
1365 _LIT( KHandleQueryEditorSizeEventL, |
|
1366 "CAknQueryDialog::HandleQueryEditorSizeEventL()invoked"); |
|
1367 _LIT( KSetHeaderTextL, |
|
1368 "CAknQueryDialog::SetHeaderTextL()invoked"); |
|
1369 _LIT( KSetHeaderImageL, |
|
1370 "CAknQueryDialog::SetHeaderImageL()invoked"); |
|
1371 _LIT( KSetMediatorObserver, |
|
1372 "CAknListQueryDialog::SetMediatorObserver()invoked"); |
|
1373 _LIT( KSetMinimumAndMaximum1, |
|
1374 "CAknQueryControl::SetMinimumAndMaximum#1() invoked "); |
|
1375 _LIT( KSetMinimumAndMaximum2, |
|
1376 "CAknQueryControl::SetMinimumAndMaximum#2() invoked "); |
|
1377 _LIT( KSetMinimumAndMaximum3, |
|
1378 "CAknQueryControl::SetMinimumAndMaximum#3() invoked "); |
|
1379 |
|
1380 CAknQueryDialog* dialog = CAknQueryDialog::NewL(); |
|
1381 CleanupStack::PushL( dialog ); |
|
1382 |
|
1383 dialog->HandleQueryEditorSizeEventL( NULL, |
|
1384 MAknQueryControlObserver::EQueryControltSizeChanging ); |
|
1385 AssertTrueL( ETrue, KHandleQueryEditorSizeEventL ); |
|
1386 |
|
1387 dialog->SetHeaderTextL( KHeader() ); |
|
1388 AssertTrueL( ETrue, KSetHeaderTextL ); |
|
1389 |
|
1390 CEikImage* image = new( ELeave ) CEikImage; |
|
1391 CleanupStack::PushL( image ); // image |
|
1392 |
|
1393 CFbsBitmap* bmp = AknIconUtils::CreateIconL( |
|
1394 AknIconUtils::AvkonIconFileName(), |
|
1395 EMbmAvkonQgn_indi_speaker_active ); |
|
1396 CleanupStack::PushL( bmp ); |
|
1397 |
|
1398 image->SetPicture( bmp ); |
|
1399 dialog->SetHeaderImageL( image ); |
|
1400 AssertTrueL( ETrue, KSetHeaderImageL ); |
|
1401 |
|
1402 CleanupStack::Pop( bmp ); |
|
1403 CleanupStack::Pop( image ); |
|
1404 CleanupStack::PopAndDestroy( dialog ); |
|
1405 |
|
1406 CAknQueryDialog* dialog2 = CAknQueryDialog::NewL(); |
|
1407 dialog2->ExecuteLD( R_BCTESTAKNQUEDLG_ONELINE_DATA_QUERY, _L( "Hello" ) ); |
|
1408 TInt* index = new (ELeave) TInt( 1 ); |
|
1409 CleanupStack::PushL( index ); |
|
1410 |
|
1411 CAknListQueryDialog* listDialog = new ( |
|
1412 ELeave ) CAknListQueryDialog( index ); |
|
1413 CleanupStack::PushL( listDialog ); |
|
1414 |
|
1415 listDialog->SetMediatorObserver( NULL ); |
|
1416 AssertTrueL( ETrue, KSetMediatorObserver ); |
|
1417 |
|
1418 CleanupStack::PopAndDestroy( listDialog ); |
|
1419 CleanupStack::PopAndDestroy( index ); |
|
1420 |
|
1421 CAknQueryControl* duration = new(ELeave) CAknQueryControl(); |
|
1422 CleanupStack::PushL( duration ); |
|
1423 duration->SetContainerWindowL( *iContainer ); |
|
1424 TResourceReader reader; |
|
1425 iCoeEnv->CreateResourceReaderLC( reader, R_BCTEST_DURATION_EDWIN_CONTROL ); |
|
1426 duration->ConstructFromResourceL( reader ); |
|
1427 const TTimeIntervalSeconds time( 1 ); |
|
1428 |
|
1429 duration->SetMinimumAndMaximum( time, time ); |
|
1430 AssertTrueL( ETrue, KSetMinimumAndMaximum1 ); |
|
1431 |
|
1432 CleanupStack::PopAndDestroy(); |
|
1433 CleanupStack::PopAndDestroy( duration ); |
|
1434 |
|
1435 CAknQueryControl* number = new(ELeave) CAknQueryControl(); |
|
1436 CleanupStack::PushL( number ); |
|
1437 number->SetContainerWindowL( *iContainer ); |
|
1438 iCoeEnv->CreateResourceReaderLC( reader, R_BCTEST_NUMBER_EDWIN_CONTROL ); |
|
1439 number->ConstructFromResourceL( reader ); |
|
1440 |
|
1441 number->SetMinimumAndMaximum( 1, 2 ); |
|
1442 AssertTrueL( ETrue, KSetMinimumAndMaximum2 ); |
|
1443 |
|
1444 CleanupStack::PopAndDestroy(); |
|
1445 CleanupStack::PopAndDestroy( number ); |
|
1446 |
|
1447 CAknQueryControl* date = new(ELeave) CAknQueryControl(); |
|
1448 CleanupStack::PushL( date ); |
|
1449 date->SetContainerWindowL( *iContainer ); |
|
1450 |
|
1451 iCoeEnv->CreateResourceReaderLC( reader, R_BCTEST_DATE_EDWIN_CONTROL ); |
|
1452 date->ConstructFromResourceL( reader ); |
|
1453 |
|
1454 const TReal r( 1 ); |
|
1455 date->SetMinimumAndMaximum( r, r ); |
|
1456 AssertTrueL( ETrue, KSetMinimumAndMaximum3 ); |
|
1457 |
|
1458 CleanupStack::PopAndDestroy(); |
|
1459 CleanupStack::PopAndDestroy( date ); |
|
1460 } |
|
1461 |
|
1462 // --------------------------------------------------------------------------- |
|
1463 // CBCTestMix50PatchControlCase::TestScrollerL() |
|
1464 // scroller api test |
|
1465 // --------------------------------------------------------------------------- |
|
1466 // |
|
1467 void CBCTestMix50PatchControlCase::TestScrollerL() |
|
1468 { |
|
1469 _LIT( KDrawBackgroundState, |
|
1470 "CEikScrollBarFrame::DrawBackgroundState()invoked"); |
|
1471 _LIT( KSetScrollBarFrameObserver, |
|
1472 "CEikScrollBarFrame::SetScrollBarFrameObserver()invoked"); |
|
1473 _LIT( KSetScrollPopupInfoTextL, |
|
1474 "CAknDoubleSpanScrollBar::SetScrollPopupInfoTextL()invoked"); |
|
1475 |
|
1476 CDesCArray* itemArray = new (ELeave) CDesCArrayFlat(2); |
|
1477 CleanupStack::PushL( itemArray ); |
|
1478 itemArray->AppendL( _L("scroller api test") ); |
|
1479 |
|
1480 CEikTextListBox* listBox = new (ELeave) CEikTextListBox; |
|
1481 CleanupStack::PushL( listBox ); |
|
1482 |
|
1483 listBox->ConstructL( iContainer ); |
|
1484 listBox->Model()->SetItemTextArray( itemArray ); |
|
1485 // ownership transferred |
|
1486 listBox->Model()->SetOwnershipType( ELbmOwnsItemArray ); |
|
1487 |
|
1488 CEikScrollBarFrame* scrollBarFrame = new( ELeave) CEikScrollBarFrame( |
|
1489 iContainer, listBox, ETrue ); |
|
1490 CleanupStack::PushL( scrollBarFrame ); |
|
1491 |
|
1492 TBool vState; |
|
1493 TBool hState; |
|
1494 scrollBarFrame->DrawBackgroundState( hState, vState ); |
|
1495 AssertTrueL( ETrue, KDrawBackgroundState ); |
|
1496 |
|
1497 scrollBarFrame->SetScrollBarFrameObserver( listBox ); |
|
1498 AssertTrueL( ETrue, KSetScrollBarFrameObserver ); |
|
1499 |
|
1500 CleanupStack::PopAndDestroy( scrollBarFrame ); |
|
1501 CleanupStack::PopAndDestroy( listBox ); |
|
1502 CleanupStack::Pop( itemArray ); |
|
1503 |
|
1504 _LIT( KInfoText, "scroll bar api test" ); |
|
1505 CAknDoubleSpanScrollBar* scrollBar = new |
|
1506 ( ELeave ) CAknDoubleSpanScrollBar( iContainer ); |
|
1507 CleanupStack::PushL( scrollBar ); |
|
1508 |
|
1509 scrollBar->SetScrollPopupInfoTextL( KInfoText ); |
|
1510 AssertTrueL( ETrue, KSetScrollPopupInfoTextL ); |
|
1511 |
|
1512 CleanupStack::PopAndDestroy( scrollBar ); |
|
1513 } |
|
1514 |
|
1515 // --------------------------------------------------------------------------- |
|
1516 // CBCTestMix50PatchControlCase::TestSearchfieldL() |
|
1517 // search field apis test |
|
1518 // --------------------------------------------------------------------------- |
|
1519 // |
|
1520 void CBCTestMix50PatchControlCase::TestSearchfieldL() |
|
1521 { |
|
1522 _LIT( KSetAdaptiveGridChars, |
|
1523 "CAknSearchField::SetAdaptiveGridChars()invoked"); |
|
1524 _LIT( KShowAdaptiveSearchGrid, |
|
1525 "CAknSearchField::ShowAdaptiveSearchGrid()invoked"); |
|
1526 _LIT( KSetListColumnFilterFlags, |
|
1527 "CAknSearchField::SetListColumnFilterFlags()invoked"); |
|
1528 _LIT( KListColumnFilterFlags, |
|
1529 "CAknSearchField::ListColumnFilterFlags()invoked"); |
|
1530 _LIT( KAddAdaptiveSearchTextObserverL, |
|
1531 "CAknSearchField::AddAdaptiveSearchTextObserverL()invoked"); |
|
1532 _LIT( KRemoveAdaptiveSearchTextObserver, |
|
1533 "CAknSearchField::RemoveAdaptiveSearchTextObserver()invoked"); |
|
1534 _LIT( KAdaptiveSearchEnabled, |
|
1535 "CAknSearchField::AdaptiveSearchEnabled()invoked"); |
|
1536 _LIT( KLanguageChanged, |
|
1537 "CAknSearchField::LanguageChanged()invoked"); |
|
1538 _LIT( KHandlePointerEventL, |
|
1539 "CAknSearchField::HandlePointerEventL()invoked"); |
|
1540 _LIT( KAdaptiveChars, |
|
1541 "Eternity"); |
|
1542 |
|
1543 const TInt KSearchFieldMaxLength = 128; |
|
1544 CAknSearchField* searchField = CAknSearchField::NewL( |
|
1545 *iContainer, CAknSearchField::ESearch, |
|
1546 NULL, KSearchFieldMaxLength ); |
|
1547 CleanupStack::PushL( searchField ); |
|
1548 |
|
1549 searchField->SetAdaptiveGridChars( KAdaptiveChars() ); |
|
1550 AssertTrueL( ETrue, KSetAdaptiveGridChars ); |
|
1551 |
|
1552 searchField->ShowAdaptiveSearchGrid(); |
|
1553 AssertTrueL( ETrue, KShowAdaptiveSearchGrid ); |
|
1554 |
|
1555 searchField->AdaptiveSearchEnabled(); |
|
1556 AssertTrueL( ETrue, KAdaptiveSearchEnabled ); |
|
1557 |
|
1558 searchField->LanguageChanged(); |
|
1559 AssertTrueL( ETrue, KLanguageChanged ); |
|
1560 |
|
1561 TBitFlags32 flag( 256 ); |
|
1562 searchField->SetListColumnFilterFlags( flag ); |
|
1563 AssertTrueL( ETrue, KSetListColumnFilterFlags ); |
|
1564 |
|
1565 searchField->ListColumnFilterFlags(); |
|
1566 AssertTrueL( ETrue, KListColumnFilterFlags ); |
|
1567 |
|
1568 TPointerEvent pointerEvent; |
|
1569 pointerEvent.iType = TPointerEvent::EButton1Up ; |
|
1570 searchField->HandlePointerEventL( pointerEvent ); |
|
1571 AssertTrueL( ETrue, KHandlePointerEventL ); |
|
1572 |
|
1573 CBCTestSearchfieldObserver* observer = new ( |
|
1574 ELeave ) CBCTestSearchfieldObserver; |
|
1575 CleanupStack::PushL( observer ); |
|
1576 |
|
1577 searchField->AddAdaptiveSearchTextObserverL( observer ); |
|
1578 AssertTrueL( ETrue, KAddAdaptiveSearchTextObserverL ); |
|
1579 |
|
1580 searchField->RemoveAdaptiveSearchTextObserver( observer ); |
|
1581 AssertTrueL( ETrue, KRemoveAdaptiveSearchTextObserver ); |
|
1582 |
|
1583 CleanupStack::PopAndDestroy( observer ); |
|
1584 CleanupStack::PopAndDestroy( searchField ); |
|
1585 } |
|
1586 |
|
1587 // --------------------------------------------------------------------------- |
|
1588 // CBCTestMix50PatchControlCase::TestSettingPagesL() |
|
1589 // setting page apis test |
|
1590 // --------------------------------------------------------------------------- |
|
1591 // |
|
1592 void CBCTestMix50PatchControlCase::TestSettingPagesL() |
|
1593 { |
|
1594 _LIT( KSettingPage, |
|
1595 "SP Test" ); |
|
1596 _LIT( KVolumeWriteInternalStateL, |
|
1597 "CAknVolumeSettingPage::WriteInternalStateL()invoked" ); |
|
1598 _LIT( KIntegerWriteInternalStateL, |
|
1599 "CAknIntegerSettingPage::WriteInternalStateL()invoked" ); |
|
1600 _LIT( KTextWriteInternalStateL, |
|
1601 "CAknTextettingPage::WriteInternalStateL()invoked" ); |
|
1602 _LIT( KSliderWriteInternalStateL, |
|
1603 "CAknSliderSettingPage::WriteInternalStateL()invoked" ); |
|
1604 _LIT( KWriteInternalStateL, |
|
1605 "CAknVolumeSettingPage::WriteInternalStateL()invoked" ); |
|
1606 _LIT( KRadioButtonWriteInternalStateL, |
|
1607 "CAknVolumeSettingPage::WriteInternalStateL()invoked" ); |
|
1608 _LIT( KNumericPasswordWriteInternalStateL, |
|
1609 "CAknVolumeSettingPage::WriteInternalStateL()invoked" ); |
|
1610 _LIT( KPasswordWriteInternalStateL, |
|
1611 "CAknVolumeSettingPage::WriteInternalStateL()invoked" ); |
|
1612 _LIT( KFieldWriteInternalStateL, |
|
1613 "CAknVolumeSettingPage::WriteInternalStateL()invoked" ); |
|
1614 _LIT( KAlphaPasswordWriteInternalStateL, |
|
1615 "CAknAlphaPasswordSettingPage::WriteInternalStateL()invoked" ); |
|
1616 _LIT( KCheckboxWriteInternalStateL, |
|
1617 "CAknVolumeSettingPage::WriteInternalStateL()invoked" ); |
|
1618 _LIT( KMenuShowing, |
|
1619 "CAknSettingPage::MenuShowing()invoked"); |
|
1620 _LIT( KWaiting, |
|
1621 "CAknSettingPage::Waiting()invoked"); |
|
1622 _LIT( KCheckAndSetDataValidity, |
|
1623 "CAknSettingPage::CheckAndSetDataValidity()invoked"); |
|
1624 _LIT( KTextLabel, |
|
1625 "CAknSettingPage::TextLabel()invoked"); |
|
1626 _LIT( KHandlePointerEventL, |
|
1627 "CAknIpFieldSettingPage::HandlePointerEventL()invoked"); |
|
1628 _LIT( KCheckboxHandleListBoxEventL, |
|
1629 "CAknCheckBoxSettingPage::HandleListBoxEventL()invoked"); |
|
1630 _LIT( KSettingPageConstructFromResource, |
|
1631 "CAknSettingPage::ConstructFromResource()#2 invoked"); |
|
1632 _LIT( KAknSettingPage, |
|
1633 "CAknSettingPage::CAknSettingPage()#2 invoked"); |
|
1634 |
|
1635 |
|
1636 TInt volumevalue = 3; |
|
1637 TBuf<20> temp; |
|
1638 temp.Append( KSettingPage() ); |
|
1639 CBCTestVolumeSettingPage* volumeSettingPage = new ( |
|
1640 ELeave ) CBCTestVolumeSettingPage( |
|
1641 R_BCTEST_MIX50PATCH_VOLUME_SETTING_PAGE, volumevalue ); |
|
1642 |
|
1643 CleanupStack::PushL( volumeSettingPage ); |
|
1644 volumeSettingPage->ConstructL(); |
|
1645 |
|
1646 CBufFlat* buf = CBufFlat::NewL( 200 ); |
|
1647 CleanupStack::PushL( buf ); |
|
1648 |
|
1649 RBufWriteStream stream; |
|
1650 stream.Open( *buf ); |
|
1651 volumeSettingPage->WriteInternalStateL( stream ); |
|
1652 AssertTrueL( ETrue, KVolumeWriteInternalStateL ); |
|
1653 |
|
1654 TInt test = 10; |
|
1655 CBCTestIntegerSettingPage* integerSettingPage = new (ELeave) |
|
1656 CBCTestIntegerSettingPage( |
|
1657 R_BCTEST_MIX50PATCH_SETPAGE_TEXT_SETTING_PAGE, test ); |
|
1658 CleanupStack::PushL( integerSettingPage ); |
|
1659 integerSettingPage->ConstructL(); |
|
1660 |
|
1661 integerSettingPage->WriteInternalStateL( stream ); |
|
1662 AssertTrueL( ETrue, KIntegerWriteInternalStateL ); |
|
1663 |
|
1664 CBCTestTextSettingPage* textSettingPage = new ( |
|
1665 ELeave ) CBCTestTextSettingPage( |
|
1666 R_BCTEST_MIX50PATCH_SETPAGE_TEXT_SETTING_PAGE, temp ); |
|
1667 CleanupStack::PushL( textSettingPage ); |
|
1668 textSettingPage->ConstructL(); |
|
1669 |
|
1670 textSettingPage->WriteInternalStateL( stream ); |
|
1671 AssertTrueL( ETrue, KTextWriteInternalStateL ); |
|
1672 |
|
1673 CBCTestSliderSettingPage* sliderSettingPage = new (ELeave) |
|
1674 CBCTestSliderSettingPage( |
|
1675 R_BCTEST_MIX50PATCH_SETPAGE_SLIDER_SETTING_PAGE, test ); |
|
1676 CleanupStack::PushL( sliderSettingPage ); |
|
1677 sliderSettingPage->ConstructL(); |
|
1678 |
|
1679 sliderSettingPage->WriteInternalStateL( stream ); |
|
1680 AssertTrueL( ETrue, KSliderWriteInternalStateL ); |
|
1681 |
|
1682 CBCTestPatchAknSettingPage* settingPage = new( ELeave ) |
|
1683 CBCTestPatchAknSettingPage( R_BCTEST_MIX50PATCH_SETTING_PAGE ); |
|
1684 CleanupStack::PushL( settingPage ); |
|
1685 settingPage->ConstructL(); |
|
1686 // settingPage->SetFocusToEditor(); |
|
1687 |
|
1688 settingPage->MenuShowing(); |
|
1689 AssertTrueL( ETrue, KMenuShowing ); |
|
1690 |
|
1691 settingPage->Waiting(); |
|
1692 AssertTrueL( ETrue, KWaiting ); |
|
1693 |
|
1694 settingPage->WriteInternalStateL( stream ); |
|
1695 AssertTrueL( ETrue, KWriteInternalStateL ); |
|
1696 |
|
1697 settingPage->CheckAndSetDataValidity(); |
|
1698 AssertTrueL( ETrue, KCheckAndSetDataValidity ); |
|
1699 |
|
1700 settingPage->TextLabel(); |
|
1701 AssertTrueL( ETrue, KTextLabel ); |
|
1702 |
|
1703 TInt currentItem(0); |
|
1704 CDesCArrayFlat* array = CCoeEnv::Static()->ReadDesCArrayResourceL( |
|
1705 R_BCTEST_MIX50PATCH_SETPAGE_LIST_ITEM_ARRAY ); |
|
1706 CleanupStack::PushL( array ); |
|
1707 |
|
1708 CBCTestRadioButtonSettingPage* radioButtonSettingPage = new (ELeave) |
|
1709 CBCTestRadioButtonSettingPage( |
|
1710 R_BCTEST_MIX50PATCH_SETPAGE_RADIOBTN_SETPAGE, currentItem, array ); |
|
1711 CleanupStack::PushL( radioButtonSettingPage ); |
|
1712 radioButtonSettingPage->ConstructL(); |
|
1713 |
|
1714 radioButtonSettingPage->WriteInternalStateL( stream ); |
|
1715 AssertTrueL( ETrue, KRadioButtonWriteInternalStateL ); |
|
1716 |
|
1717 _LIT(KOldPassword, "TESTOLD"); |
|
1718 CBCTestNumericPasswordSettingPage* numericPwdSettingPage = new (ELeave) |
|
1719 CBCTestNumericPasswordSettingPage( |
|
1720 R_BCTEST_MIX50PATCH_PASSWORD_SETTING_PAGE, temp, KOldPassword); |
|
1721 CleanupStack::PushL( numericPwdSettingPage ); |
|
1722 numericPwdSettingPage->ConstructL(); |
|
1723 |
|
1724 numericPwdSettingPage->WriteInternalStateL( stream ); |
|
1725 AssertTrueL( ETrue, KNumericPasswordWriteInternalStateL ); |
|
1726 |
|
1727 CBCTestAlphaPasswordSettingPage* alphaPwdSettingPage = new (ELeave) |
|
1728 CBCTestAlphaPasswordSettingPage( |
|
1729 R_BCTEST_MIX50PATCH_PASSWORD_SETTING_PAGE, temp, KOldPassword); |
|
1730 CleanupStack::PushL( alphaPwdSettingPage ); |
|
1731 alphaPwdSettingPage->ConstructL(); |
|
1732 |
|
1733 alphaPwdSettingPage->WriteInternalStateL( stream ); |
|
1734 AssertTrueL( ETrue, KAlphaPasswordWriteInternalStateL ); |
|
1735 |
|
1736 CBCTestPasswordSettingPage* pwdSettingPage = new (ELeave) |
|
1737 CBCTestPasswordSettingPage( |
|
1738 R_BCTEST_MIX50PATCH_PASSWORD_SETTING_PAGE, temp, KOldPassword ); |
|
1739 CleanupStack::PushL( pwdSettingPage ); |
|
1740 pwdSettingPage->ConstructL(); |
|
1741 |
|
1742 pwdSettingPage->WriteInternalStateL( stream ); |
|
1743 AssertTrueL( ETrue, KPasswordWriteInternalStateL ); |
|
1744 |
|
1745 TInetAddr ipAddr(10); |
|
1746 CBCTestIpFieldSettingPage* ipFieldSettingPage = new (ELeave) |
|
1747 CBCTestIpFieldSettingPage( |
|
1748 R_BCTEST_MIX50PATCH_SETPAGE_IPADDRESS_SETTING_PAGE, ipAddr ); |
|
1749 CleanupStack::PushL( ipFieldSettingPage ); |
|
1750 ipFieldSettingPage->ConstructL(); |
|
1751 |
|
1752 TPointerEvent pointerEvent; |
|
1753 pointerEvent.iType = TPointerEvent::EButton1Up ; |
|
1754 ipFieldSettingPage->HandlePointerEventL( pointerEvent ); |
|
1755 AssertTrueL( ETrue, KHandlePointerEventL ); |
|
1756 |
|
1757 ipFieldSettingPage->WriteInternalStateL( stream ); |
|
1758 AssertTrueL( ETrue, KFieldWriteInternalStateL ); |
|
1759 |
|
1760 CSelectableItem* item = new( ELeave ) CSelectableItem( temp, EFalse ); |
|
1761 CleanupStack::PushL( item ); |
|
1762 item->ConstructL(); |
|
1763 CSelectionItemList* itemList = new( ELeave ) CSelectionItemList( 1 ); |
|
1764 CleanupStack::PushL( itemList ); |
|
1765 itemList->AppendL( item ); |
|
1766 CBCTestCheckBoxSettingPage* checkboxSettingPage = new( ELeave ) |
|
1767 CBCTestCheckBoxSettingPage( |
|
1768 R_BCTESTLIST_CHECKBOX_SETTING_PAGE, itemList ); |
|
1769 CleanupStack::PushL( checkboxSettingPage ); |
|
1770 checkboxSettingPage->ConstructL(); |
|
1771 |
|
1772 checkboxSettingPage->HandlePointerEventL( pointerEvent ); |
|
1773 AssertTrueL( ETrue, KCheckboxHandleListBoxEventL ); |
|
1774 |
|
1775 checkboxSettingPage->WriteInternalStateL( stream ); |
|
1776 AssertTrueL( ETrue, KCheckboxWriteInternalStateL ); |
|
1777 |
|
1778 CBCTestPatchAknSettingPage *sp = new (ELeave) |
|
1779 CBCTestPatchAknSettingPage( R_AVKON_DEFAULT_SETTING_PAGE ); |
|
1780 CleanupStack::PushL( sp ); |
|
1781 TResourceReader reader; |
|
1782 iCoeEnv->CreateResourceReaderLC( reader , R_BCTEST_MIX50PATCH_SETTING_PAGE ); |
|
1783 sp->ConstructFromResourceL( reader ); |
|
1784 AssertTrueL( ETrue, KSettingPageConstructFromResource ); |
|
1785 CleanupStack::PopAndDestroy(); // reader |
|
1786 CleanupStack::PopAndDestroy( sp ); |
|
1787 |
|
1788 CAknSettingPage* sp2 = new (ELeave) CAknSettingPage( &KSettingPage, 0, 0, 0, 0 ); |
|
1789 AssertNotNullL( sp2, KAknSettingPage ); |
|
1790 delete sp2; |
|
1791 CleanupStack::PopAndDestroy( checkboxSettingPage ); |
|
1792 CleanupStack::PopAndDestroy( itemList ); |
|
1793 CleanupStack::PopAndDestroy( item ); |
|
1794 CleanupStack::PopAndDestroy( ipFieldSettingPage ); |
|
1795 CleanupStack::PopAndDestroy( pwdSettingPage ); |
|
1796 CleanupStack::PopAndDestroy( alphaPwdSettingPage ); |
|
1797 CleanupStack::PopAndDestroy( numericPwdSettingPage ); |
|
1798 CleanupStack::PopAndDestroy( radioButtonSettingPage ); |
|
1799 CleanupStack::PopAndDestroy( array ); |
|
1800 CleanupStack::PopAndDestroy( settingPage ); |
|
1801 CleanupStack::PopAndDestroy( sliderSettingPage ); |
|
1802 CleanupStack::PopAndDestroy( textSettingPage ); |
|
1803 CleanupStack::PopAndDestroy( integerSettingPage ); |
|
1804 CleanupStack::PopAndDestroy( buf ); |
|
1805 CleanupStack::PopAndDestroy( volumeSettingPage ); |
|
1806 } |
|
1807 |
|
1808 // --------------------------------------------------------------------------- |
|
1809 // CBCTestMix50PatchControlCase::TestTitlePaneL() |
|
1810 // title pane apis test |
|
1811 // --------------------------------------------------------------------------- |
|
1812 // |
|
1813 void CBCTestMix50PatchControlCase::TestTitlePaneL() |
|
1814 { |
|
1815 _LIT ( KSetNumberOfVisibleTextRows, |
|
1816 "CAknTitlePane::SetNumberOfVisibleTextRows()invoked"); |
|
1817 CAknTitlePane* titlePane = new (ELeave) CAknTitlePane; |
|
1818 CleanupStack::PushL( titlePane ); |
|
1819 titlePane->ConstructL(); |
|
1820 |
|
1821 TInt numOfRows = titlePane->MaxNumberOfVisibleTextRows(); |
|
1822 titlePane->SetNumberOfVisibleTextRows( numOfRows ); |
|
1823 AssertTrueL( ETrue, KSetNumberOfVisibleTextRows ); |
|
1824 |
|
1825 CleanupStack::PopAndDestroy( titlePane ); |
|
1826 } |
|
1827 |
|
1828 // --------------------------------------------------------------------------- |
|
1829 // CBCTestMix50PatchControlCase::TestChoiceListL() |
|
1830 // ChoiceListL test |
|
1831 // --------------------------------------------------------------------------- |
|
1832 // |
|
1833 void CBCTestMix50PatchControlCase::TestAknToolbarL() |
|
1834 { |
|
1835 _LIT( KHideItemsAndDrawOnlyBackgroundWithTCoeWinPriority, |
|
1836 "CAknToolbar::HideItemsAndDrawOnlyBackground with TCoeWinPriority" ); |
|
1837 _LIT( KHideItemsAndDrawOnlyBackground, |
|
1838 "CAknToolbar::HideItemsAndDrawOnlyBackground" ); |
|
1839 _LIT( KCountFadedComponents, |
|
1840 "CAknToolbar::CountFadedComponents" ); |
|
1841 _LIT( KFadedComponent, |
|
1842 "CAknToolbar::FadedComponent" ); |
|
1843 _LIT( KPrepareForFocusLoss, |
|
1844 "CAknToolbar::PrepareForFocusLossL" ); |
|
1845 |
|
1846 // Test some API here |
|
1847 CAknToolbar *toolBar = CAknToolbar::NewL( R_BCTEST_MIX50PATCH_TOOLBAR ); |
|
1848 CleanupStack::PushL( toolBar ); |
|
1849 |
|
1850 toolBar->SetMopParent( iContainer ); |
|
1851 toolBar->HideItemsAndDrawOnlyBackground(ETrue); |
|
1852 AssertTrueL( ETrue, KHideItemsAndDrawOnlyBackground ); |
|
1853 |
|
1854 toolBar->HideItemsAndDrawOnlyBackground(EFalse,ECoeWinPriorityLow); |
|
1855 AssertTrueL( ETrue, KHideItemsAndDrawOnlyBackgroundWithTCoeWinPriority ); |
|
1856 |
|
1857 toolBar->CountFadedComponents(); |
|
1858 AssertTrueL( ETrue, KCountFadedComponents ); |
|
1859 |
|
1860 toolBar->FadedComponent(0); |
|
1861 AssertTrueL( ETrue, KFadedComponent ); |
|
1862 |
|
1863 toolBar->PrepareForFocusLossL(); |
|
1864 AssertTrueL( ETrue, KPrepareForFocusLoss ); |
|
1865 |
|
1866 toolBar->SetToolbarObserver( this ); |
|
1867 this->MAknToolbarObserver_Reserved_1(); |
|
1868 _LIT( KAknToolbarObserver_r_Reserved_1, \ |
|
1869 "MAknToolbarObserver::MAknToolbarObserver_Reserved_1" ); |
|
1870 AssertTrueL( ETrue, KAknToolbarObserver_r_Reserved_1 ); |
|
1871 |
|
1872 this->MAknToolbarObserver_Reserved_2(); |
|
1873 _LIT( KAknToolbarObserver_r_Reserved_2, \ |
|
1874 "MAknToolbarObserver::MAknToolbarObserver_Reserved_2" ); |
|
1875 AssertTrueL( ETrue, KAknToolbarObserver_r_Reserved_2 ); |
|
1876 |
|
1877 CleanupStack::PopAndDestroy( toolBar ); |
|
1878 } |
|
1879 |
|
1880 // --------------------------------------------------------------------------- |
|
1881 // CBCTestMix50PatchControlCase::TestAknTouchPaneL() |
|
1882 // touch pane api test |
|
1883 // --------------------------------------------------------------------------- |
|
1884 // |
|
1885 void CBCTestMix50PatchControlCase::TestAknTouchPaneL() |
|
1886 { |
|
1887 _LIT( KNewL, "NewL with resourceId test" ); |
|
1888 _LIT( KSetFepPenSupportInterface, |
|
1889 "CAknTouchPane::SetFepPenSupportInterface" ); |
|
1890 _LIT( KDraw, "CAknTouchPane::Draw" ); |
|
1891 |
|
1892 if ( !AknLayoutUtils::PenEnabled() ) |
|
1893 { |
|
1894 return; |
|
1895 } |
|
1896 |
|
1897 CAknTouchPane* touchPane = CAknTouchPane::NewL( R_BCTEST_MIX50PATCH_TOUCHPANE ); |
|
1898 CleanupStack::PushL( touchPane ); |
|
1899 AssertTrueL( ETrue, KNewL ); |
|
1900 |
|
1901 TRect rect = iContainer->Rect(); |
|
1902 |
|
1903 CBCTestFepPen* interface = new( ELeave ) CBCTestFepPen(); |
|
1904 CleanupStack::PushL( interface ); |
|
1905 touchPane->SetFepPenSupportInterface( interface ); |
|
1906 |
|
1907 AssertTrueL( ETrue, KSetFepPenSupportInterface ); |
|
1908 CleanupStack::PopAndDestroy( interface ); |
|
1909 |
|
1910 iContainer->ActivateGc();//necessary |
|
1911 touchPane->Draw( iContainer->SystemGc(), *iContainer, rect ); |
|
1912 iContainer->DeactivateGc(); |
|
1913 AssertTrueL( ETrue, KDraw ); |
|
1914 |
|
1915 CleanupStack::PopAndDestroy( touchPane ); |
|
1916 } |
|
1917 |
|
1918 // --------------------------------------------------------------------------- |
|
1919 // CBCTestMix50PatchControlCase::TestChoiceListL() |
|
1920 // ChoiceListL test |
|
1921 // --------------------------------------------------------------------------- |
|
1922 // |
|
1923 void CBCTestMix50PatchControlCase::TestAknEnvL() |
|
1924 { |
|
1925 _LIT( KTxtAknEnvSplitViewActive, "CAknEnv::SplitViewActive" ); |
|
1926 _LIT( KAknEnvRequestCommandMediationL, |
|
1927 "CAknEnv::RequestCommandMediationL" ); |
|
1928 _LIT( KAknEnvEndCommandMediation, "CAknEnv::EndCommandMediation" ); |
|
1929 |
|
1930 CAknEnv* aknEnv = CAknEnv::Static(); |
|
1931 aknEnv->SplitViewActive(); |
|
1932 AssertTrueL( ETrue, KTxtAknEnvSplitViewActive ); |
|
1933 |
|
1934 CEikButtonGroupContainer* cba = iAvkonAppUi->Cba(); |
|
1935 aknEnv->RequestCommandMediationL( *cba, *this ); |
|
1936 AssertTrueL( ETrue, KAknEnvRequestCommandMediationL ); |
|
1937 |
|
1938 aknEnv->EndCommandMediation( *this ); |
|
1939 AssertTrueL( ETrue, KAknEnvEndCommandMediation ); |
|
1940 } |
|
1941 |
|
1942 // --------------------------------------------------------------------------- |
|
1943 // CBCTestMix50PatchControlCase::TestChoiceListL() |
|
1944 // ChoiceListL test |
|
1945 // --------------------------------------------------------------------------- |
|
1946 // |
|
1947 void CBCTestMix50PatchControlCase::TestAknVolumeControlL() |
|
1948 { |
|
1949 _LIT( KTxtCAknVolumeControl, "CAknVolumeControl::CAknVolumeControl" ); |
|
1950 _LIT( KTxtConstructFromResourceL, "CAknVolumeControl::ConstructFromResourceL" ); |
|
1951 _LIT( KTxtMinimumSize, "CAknVolumeControl::MinimumSize" ); |
|
1952 |
|
1953 CAknVolumeControl* volumeCtrl = new( ELeave ) CAknVolumeControl; |
|
1954 CleanupStack::PushL( volumeCtrl ); |
|
1955 AssertNotNullL( volumeCtrl, KTxtCAknVolumeControl ); |
|
1956 volumeCtrl->SetContainerWindowL( *iContainer ); |
|
1957 |
|
1958 TResourceReader reader; |
|
1959 CEikonEnv::Static()->CreateResourceReaderLC( reader, R_BCTEST_MIX50PATCH_SETPAGE_VOLUME ); |
|
1960 volumeCtrl->ConstructFromResourceL( reader ); |
|
1961 AssertTrueL( ETrue, KTxtConstructFromResourceL ); |
|
1962 CleanupStack::PopAndDestroy(); // reader |
|
1963 |
|
1964 TSize nSize = volumeCtrl->MinimumSize(); |
|
1965 AssertTrueL( ETrue, KTxtMinimumSize ); |
|
1966 |
|
1967 CleanupStack::PopAndDestroy( volumeCtrl ); |
|
1968 volumeCtrl = NULL; |
|
1969 } |
|
1970 |
|
1971 // --------------------------------------------------------------------------- |
|
1972 // CBCTestMix50PatchControlCase::TestHapticsL() |
|
1973 // Haptics test |
|
1974 // --------------------------------------------------------------------------- |
|
1975 // |
|
1976 void CBCTestMix50PatchControlCase::TestHapticsL() |
|
1977 { |
|
1978 _LIT( KNewL1, "CHWRMHaptics::NewL(MHWRMHapticsObserver*,\ |
|
1979 MHWRMHapticsActuatorObserver* )" ); |
|
1980 _LIT( KNewL2, "CHWRMHaptics::NewL(MHWRMHapticsObserver*,\ |
|
1981 MHWRMHapticsActuatorObserver*, TRequestStatus& )" ); |
|
1982 CHWRMHaptics* haptics = CHWRMHaptics::NewL( NULL, NULL ); |
|
1983 CleanupStack::PushL(haptics); |
|
1984 AssertNotNullL( haptics, KNewL1 ); |
|
1985 CleanupStack::PopAndDestroy(haptics); |
|
1986 haptics = NULL; |
|
1987 |
|
1988 TRequestStatus rs = KRequestPending; |
|
1989 haptics = CHWRMHaptics::NewL(NULL, NULL, rs); |
|
1990 CleanupStack::PushL(haptics); |
|
1991 AssertNotNullL( haptics, KNewL2 ); |
|
1992 User::WaitForRequest(rs); |
|
1993 CleanupStack::PopAndDestroy(haptics); |
|
1994 } |
|
1995 |
|
1996 // --------------------------------------------------------------------------- |
|
1997 // CBCTestMix50PatchControlCase::TestImageTableItemDataL() |
|
1998 // Image table item data test |
|
1999 // --------------------------------------------------------------------------- |
|
2000 // |
|
2001 void CBCTestMix50PatchControlCase::TestImageTableItemDataL() |
|
2002 { |
|
2003 _LIT(KSetImagesL, "CAknsImageTableItemData::SetImagesL() tested"); |
|
2004 _LIT(KImages, "CAknsImageTableItemData::Images() tested"); |
|
2005 _LIT(KImageIID, "CAknsImageTableItemData::ImageIID() tested"); |
|
2006 _LIT(KNumberOfImages, "CAknsImageTableItemData::NumberOfImages() tested"); |
|
2007 |
|
2008 // CBCTestAknsImageItemData* itemData = new (ELeave) |
|
2009 // CBCTestAknsImageItemData( EAknsITImage ); |
|
2010 // CleanupStack::PushL( itemData ); |
|
2011 // |
|
2012 // itemData->Type(); |
|
2013 // AssertTrueL( ETrue, KType ); |
|
2014 // |
|
2015 // TAknsImageAttributeData attributeData; |
|
2016 // itemData->SetAttributesL( attributeData ); |
|
2017 // AssertTrueL( ETrue, KSetAttributes ); |
|
2018 // |
|
2019 // itemData->Attributes(); |
|
2020 // AssertTrueL( ETrue, KAttributes ); |
|
2021 // |
|
2022 // CleanupStack::PopAndDestroy( itemData ); |
|
2023 CAknsImageTableItemData* itemData = CAknsImageTableItemData::NewL(); |
|
2024 CleanupStack::PushL(itemData); |
|
2025 |
|
2026 TAknsItemID skinIdArray[] = |
|
2027 { |
|
2028 KAknsIIDQgnIndiSctClose, |
|
2029 KAknsIIDQgnIndiAdaptSearchBackspace |
|
2030 }; |
|
2031 |
|
2032 //IMPORT_C void SetImagesL (const TInt aNumberOfImages, const TAknsItemID *aImages) |
|
2033 itemData->SetImagesL( sizeof( skinIdArray )/sizeof(skinIdArray[0]), skinIdArray ); |
|
2034 AssertTrueL( ETrue, KSetImagesL ); |
|
2035 |
|
2036 itemData->Images(); |
|
2037 AssertTrueL( ETrue, KImages ); |
|
2038 |
|
2039 itemData->ImageIID( itemData->NumberOfImages() - 1 ); |
|
2040 AssertTrueL( ETrue, KNumberOfImages ); |
|
2041 AssertTrueL( ETrue, KImageIID ); |
|
2042 |
|
2043 CleanupStack::PopAndDestroy(); //itemData |
|
2044 } |
|
2045 |
|
2046 // --------------------------------------------------------------------------- |
|
2047 // CBCTestMix50PatchControlCase::TestMBmpItemDataL() |
|
2048 // masked bitmap item data test |
|
2049 // --------------------------------------------------------------------------- |
|
2050 // |
|
2051 void CBCTestMix50PatchControlCase::TestMBmpItemDataL() |
|
2052 { |
|
2053 _LIT(KNewL, "CAknsMaskedBitmapItemData::NewL() tested"); |
|
2054 _LIT(KMask, "CAknsMaskedBitmapItemData::Mask() tested"); |
|
2055 _LIT(KSetMask, "CAknsMaskedBitmapItemData::SetMask() tested"); |
|
2056 _LIT(KDestroyAndSetMask, "CAknsMaskedBitmapItemData::DestroyAndSetMask() tested"); |
|
2057 |
|
2058 CAknsMaskedBitmapItemData* bmpItemData = CAknsMaskedBitmapItemData::NewL(); |
|
2059 CleanupStack::PushL( bmpItemData ); |
|
2060 AssertTrueL( ETrue, KNewL ); |
|
2061 |
|
2062 CFbsBitmap* bitmap = new(ELeave)CFbsBitmap; |
|
2063 TSize screenSize = iAvkonAppUi->ApplicationRect().Size(); |
|
2064 bitmap->Create( screenSize, iCoeEnv->ScreenDevice()->DisplayMode() ); |
|
2065 bmpItemData->SetMask( bitmap ); |
|
2066 AssertTrueL( ETrue, KSetMask ); |
|
2067 |
|
2068 bmpItemData->Mask(); |
|
2069 AssertTrueL( ETrue, KMask ); |
|
2070 |
|
2071 CFbsBitmap* bitmap2 = new (ELeave)CFbsBitmap; |
|
2072 bitmap2->Duplicate( EMbmAvkonQgn_note_ok ); |
|
2073 bmpItemData->DestroyAndSetMask( bitmap2 ); |
|
2074 AssertTrueL( ETrue, KDestroyAndSetMask ); |
|
2075 |
|
2076 CleanupStack::PopAndDestroy( bmpItemData ); |
|
2077 } |
|
2078 |
|
2079 // --------------------------------------------------------------------------- |
|
2080 // CBCTestMix50PatchControlCase::TestColTableItemDataL() |
|
2081 // color table item data test |
|
2082 // --------------------------------------------------------------------------- |
|
2083 // |
|
2084 void CBCTestMix50PatchControlCase::TestColTableItemDataL() |
|
2085 { |
|
2086 _LIT(KNewL, "CAknsColorTableItemData::NewL() tested"); |
|
2087 _LIT(KSetColorsL, "CAknsColorTableItemData::SetColorsL() tested"); |
|
2088 _LIT(KColorIndexed, "CAknsColorTableItemData::ColorIndexed() tested"); |
|
2089 _LIT(KColorRgb, "CAknsColorTableItemData::ColorRgb() tested"); |
|
2090 _LIT(KGetColorL, "CAknsColorTableItemData::GetColorL() tested"); |
|
2091 |
|
2092 const TInt numOfEntries = 2; |
|
2093 CAknsColorTableItemData* itemData = CAknsColorTableItemData::NewL(); |
|
2094 CleanupStack::PushL( itemData ); |
|
2095 AssertTrueL( ETrue, KNewL ); |
|
2096 |
|
2097 TAknsColorTableEntry colorTable[numOfEntries] = { |
|
2098 ( 0, 0x000000 ), |
|
2099 ( 1, 0x555555 ) |
|
2100 }; |
|
2101 itemData->SetColorsL( numOfEntries, colorTable ); |
|
2102 AssertTrueL( ETrue, KSetColorsL ); |
|
2103 |
|
2104 TInt index = itemData->ColorIndexed( numOfEntries-1 ); |
|
2105 AssertTrueL( ETrue, KColorIndexed ); |
|
2106 |
|
2107 TRgb color = itemData->ColorRgb( numOfEntries - 1 ); |
|
2108 AssertTrueL( ETrue, KColorRgb ); |
|
2109 |
|
2110 itemData->GetColorL( index, color ); |
|
2111 AssertTrueL( ETrue, KGetColorL ); |
|
2112 |
|
2113 CleanupStack::PopAndDestroy( itemData ); |
|
2114 } |
|
2115 |
|
2116 // --------------------------------------------------------------------------- |
|
2117 // CBCTestMix50PatchControlCase::TestBackgroundCCL() |
|
2118 // Background control context test |
|
2119 // --------------------------------------------------------------------------- |
|
2120 // |
|
2121 void CBCTestMix50PatchControlCase::TestBackgroundCCL() |
|
2122 { |
|
2123 _LIT( KNewL, "CAknsLayeredBackgroundControlContext::NewL() tested"); |
|
2124 _LIT( KSetLayerImage, |
|
2125 "CAknsLayeredBackgroundControlContext::SetLayerImage() tested"); |
|
2126 _LIT( KSetLayerRect, |
|
2127 "CAknsLayeredBackgroundControlContext::SetLayerRect() tested"); |
|
2128 _LIT( KLisboxNewL, "CAknsListBoxBackgroundControlContext::NewL()"); |
|
2129 _LIT( KSetTiledBitmap, |
|
2130 "CAknsListBoxBackgroundControlContext::SetTiledBitmap() tested"); |
|
2131 _LIT( KSetTiledRect, |
|
2132 "CAknsListBoxBackgroundControlContext::SetTiledRect() tested"); |
|
2133 _LIT( KSetBottomBitmap, |
|
2134 "CAknsListBoxBackgroundControlContext::SetBottomBitmap() tested"); |
|
2135 _LIT( KSetBottomRect, |
|
2136 "CAknsListBoxBackgroundControlContext::SetBottomRect() tested"); |
|
2137 _LIT( KSetParentContext, |
|
2138 "CAknsBasicBackgroundControlContext::SetParentContext() tested"); |
|
2139 _LIT( KControlContextOfParent, |
|
2140 "AknsDrawUtils::ControlContextOfParent() tested"); |
|
2141 _LIT( KLinearOrder, "TAknsItemID::LinearOrder"); |
|
2142 |
|
2143 TInt const layers = 2; |
|
2144 TRect rect( 0, 0 ,10, 10 ); |
|
2145 TAknsItemID skinIdArray[] = |
|
2146 { |
|
2147 KAknsIIDQgnIndiSctClose, |
|
2148 KAknsIIDQgnIndiAdaptSearchBackspace |
|
2149 }; |
|
2150 TInt result = TAknsItemID::LinearOrder( |
|
2151 KAknsIIDQgnIndiSctClose, |
|
2152 KAknsIIDQgnIndiAdaptSearchBackspace ); |
|
2153 AssertTrueL( ETrue, KLinearOrder ); |
|
2154 |
|
2155 CAknsLayeredBackgroundControlContext* cc = |
|
2156 CAknsLayeredBackgroundControlContext::NewL( |
|
2157 KAknsIIDQsnBgAreaStatus, |
|
2158 rect, |
|
2159 EFalse, |
|
2160 1); |
|
2161 CleanupStack::PushL( cc ); |
|
2162 AssertNotNullL( cc, KNewL ); |
|
2163 CleanupStack::PopAndDestroy( cc ); |
|
2164 cc = NULL; |
|
2165 |
|
2166 cc = CAknsLayeredBackgroundControlContext::NewL( |
|
2167 KAknsIIDQsnBgAreaStatus, |
|
2168 rect, |
|
2169 EFalse, |
|
2170 layers + 1); |
|
2171 CleanupStack::PushL( cc ); |
|
2172 AssertNotNullL( cc, KNewL ); |
|
2173 |
|
2174 for ( TInt n = 0; n < layers; n++ ) |
|
2175 { |
|
2176 cc->SetLayerImage( n, KAknsIIDNone ); |
|
2177 } |
|
2178 AssertTrueL( ETrue, KSetLayerImage ); |
|
2179 |
|
2180 for( TInt n = 0; n < layers; n++ ) |
|
2181 { |
|
2182 cc->SetLayerRect( n, rect ); |
|
2183 } |
|
2184 AssertTrueL( ETrue, KSetLayerRect ); |
|
2185 CleanupStack::PopAndDestroy( cc ); |
|
2186 |
|
2187 CAknsListBoxBackgroundControlContext* listboxcc = |
|
2188 CAknsListBoxBackgroundControlContext::NewL( |
|
2189 KAknsIIDQsnBgAreaStatus, |
|
2190 rect, |
|
2191 EFalse, |
|
2192 KAknsIIDQgnIndiSctClose, |
|
2193 rect |
|
2194 ); |
|
2195 CleanupStack::PushL( listboxcc ); |
|
2196 AssertNotNullL( listboxcc, KLisboxNewL ); |
|
2197 |
|
2198 listboxcc->SetTiledBitmap( KAknsIIDNone ); |
|
2199 AssertTrueL( ETrue, KSetTiledBitmap ); |
|
2200 |
|
2201 listboxcc->SetTiledRect( rect ); |
|
2202 AssertTrueL( ETrue, KSetTiledRect ); |
|
2203 |
|
2204 listboxcc->SetBottomBitmap( KAknsIIDNone ); |
|
2205 AssertTrueL( ETrue, KSetBottomBitmap ); |
|
2206 |
|
2207 listboxcc->SetBottomRect( rect ); |
|
2208 AssertTrueL( ETrue, KSetBottomRect ); |
|
2209 |
|
2210 listboxcc->SetParentContext( NULL ); |
|
2211 AssertTrueL( ETrue, KSetParentContext ); |
|
2212 CleanupStack::PopAndDestroy( listboxcc ); |
|
2213 |
|
2214 AknsDrawUtils::ControlContextOfParent( iContainer ); |
|
2215 AssertTrueL( ETrue, KControlContextOfParent ); |
|
2216 |
|
2217 CAknsFrameBackgroundControlContext* context = |
|
2218 CAknsFrameBackgroundControlContext::NewL( |
|
2219 KAknsIIDNone, rect, rect, EFalse ); |
|
2220 CleanupStack::PushL(context); |
|
2221 |
|
2222 context->SetFrame( KAknsIIDQsnBgAreaStatus ); |
|
2223 _LIT( KSetFrame, "CAknsFrameBackgroundControlContext::SetFrame" ); |
|
2224 AssertTrueL( ETrue, KSetFrame ); |
|
2225 |
|
2226 TRect innerRect = TRect( 2, 2, 8, 8 ); |
|
2227 TRect outterRect = TRect ( 1, 1, 9, 9 ); |
|
2228 context->SetFrameRects( outterRect, innerRect ); |
|
2229 _LIT( KSetFrameRects, "CAknsFrameBackgroundControlContext::SetFrameRects" ); |
|
2230 AssertTrueL( ETrue, KSetFrameRects ); |
|
2231 |
|
2232 context->SetCenter( KAknsIIDNone ); |
|
2233 _LIT( KSetCenter, "CAknsFrameBackgroundControlContext::SetCenter" ); |
|
2234 AssertTrueL( ETrue, KSetCenter ); |
|
2235 |
|
2236 CleanupStack::PopAndDestroy(); //context |
|
2237 } |
|
2238 |
|
2239 // --------------------------------------------------------------------------- |
|
2240 // CBCTestMix50PatchControlCase::TestAknLayoutUtilsL() |
|
2241 // Akn layout utility apis test |
|
2242 // --------------------------------------------------------------------------- |
|
2243 // |
|
2244 void CBCTestMix50PatchControlCase::TestAknLayoutUtilsL() |
|
2245 { |
|
2246 |
|
2247 CEikLabel* label = new(ELeave) CEikLabel; |
|
2248 CleanupStack::PushL(label); |
|
2249 TRect rect; |
|
2250 label->SetContainerWindowL( *iContainer ); |
|
2251 AknLayoutUtils::SAknLayoutLabel layoutLabel; |
|
2252 layoutLabel.iFont=0; |
|
2253 layoutLabel.iC=1; |
|
2254 layoutLabel.iL=1; |
|
2255 layoutLabel.iR=1; |
|
2256 layoutLabel.iB=1; |
|
2257 layoutLabel.iW=1; |
|
2258 layoutLabel.iJ=1; |
|
2259 layoutLabel.iNumberOfLinesShown=1; |
|
2260 |
|
2261 // IMPORT_C void LayoutLabel (CEikLabel *aLabel, |
|
2262 // const TRect &aLabelParent, |
|
2263 // const SAknLayoutLabel &aLayout, |
|
2264 // const CFont *aCustomFont=0) |
|
2265 AknLayoutUtils::LayoutLabel( label, rect, layoutLabel, 0 ); |
|
2266 _LIT( KLayoutLabel2, "AknsUtils::LayoutLabel#2" ); |
|
2267 AssertTrueL( ETrue, KLayoutLabel2 ); |
|
2268 |
|
2269 // IMPORT_C TRect RectFromCoords ( |
|
2270 // const TRect &aParent, |
|
2271 // TInt h, |
|
2272 // TInt l, |
|
2273 // TInt r, |
|
2274 // TInt B, |
|
2275 // TInt W, |
|
2276 // TInt LB=0) |
|
2277 rect = AknLayoutUtils::RectFromCoords( rect, 1, 1, 1, 1, 1, 1 ); |
|
2278 _LIT( KRectFromCoords1, "AknsUtils::RectFromCoords#1" ); |
|
2279 AssertTrueL( ETrue, KRectFromCoords1 ); |
|
2280 |
|
2281 CEikImage* image = new(ELeave)CEikImage; |
|
2282 CleanupStack::PushL( image ); |
|
2283 TInt i = 1; |
|
2284 TAknWindowLineLayout lineLayout( i ); |
|
2285 |
|
2286 // IMPORT_C void LayoutImage ( |
|
2287 // CEikImage *aImage, |
|
2288 // const TRect &aParent, |
|
2289 // const TAknWindowLineLayout &aLayout) |
|
2290 AknLayoutUtils::LayoutImage( image, rect, lineLayout ); |
|
2291 _LIT( KLayoutImage2, "AknsUtils::LayoutImage#2" ); |
|
2292 AssertTrueL( ETrue, KLayoutImage2 ); |
|
2293 |
|
2294 CCoeControl* control = new(ELeave) CCoeControl; |
|
2295 CleanupStack::PushL( control ); |
|
2296 |
|
2297 AknLayoutUtils::SAknLayoutControl layoutControl; |
|
2298 layoutControl.iC=1; |
|
2299 layoutControl.iL=1; |
|
2300 layoutControl.iR=1; |
|
2301 layoutControl.iB=1; |
|
2302 layoutControl.iW=1; |
|
2303 layoutControl.iH=1; |
|
2304 |
|
2305 // IMPORT_C void LayoutControl( |
|
2306 // CCoeControl *aControl, |
|
2307 // const TRect &aControlParent, |
|
2308 // const SAknLayoutControl &aLayout) |
|
2309 AknLayoutUtils::LayoutControl( control, rect, layoutControl ); |
|
2310 _LIT( KLayoutControl2, "AknsUtils::LayoutControl#2" ); |
|
2311 AssertTrueL( ETrue, KLayoutControl2 ); |
|
2312 |
|
2313 // IMPORT_C void LayoutControl ( |
|
2314 // CCoeControl *aControl, |
|
2315 // const TRect &aControlParent, |
|
2316 // TInt, |
|
2317 // TInt l, |
|
2318 // TInt t, |
|
2319 // TInt r, |
|
2320 // TInt b, |
|
2321 // TInt W, |
|
2322 // TInt H) |
|
2323 AknLayoutUtils::LayoutControl( control, rect, 1, 1, 1, 1, 1, 1, 1 ); |
|
2324 _LIT( KLayoutControl4, "AknsUtils::LayoutControl#4" ); |
|
2325 AssertTrueL( ETrue, KLayoutControl4 ); |
|
2326 |
|
2327 CEikMfne *mfne = new(ELeave)CEikMfne(); |
|
2328 CleanupStack::PushL( mfne ); |
|
2329 AknLayoutUtils::SAknLayoutMfne layoutMfne; |
|
2330 layoutMfne.iFont=0; |
|
2331 layoutMfne.iC=1; |
|
2332 layoutMfne.iL=1; |
|
2333 layoutMfne.iR=1; |
|
2334 layoutMfne.iB=1; |
|
2335 layoutMfne.iW=1; |
|
2336 layoutMfne.iJ=1; |
|
2337 |
|
2338 // IMPORT_C void LayoutMfne ( |
|
2339 // CEikMfne *aMfne, |
|
2340 // const TRect &aMfneParent, |
|
2341 // const SAknLayoutMfne &aLayout) |
|
2342 AknLayoutUtils::LayoutMfne( mfne, rect, layoutMfne ); |
|
2343 _LIT( KLayoutMfne2, "AknsUtils::LayoutMfne#2" ); |
|
2344 AssertTrueL( ETrue, KLayoutMfne2 ); |
|
2345 |
|
2346 // IMPORT_C void LayoutMfne ( |
|
2347 // CEikMfne *aMfne, |
|
2348 // const TRect &aMfneParent, |
|
2349 // TInt font, |
|
2350 // TInt C, |
|
2351 // TInt l, |
|
2352 // TInt r, |
|
2353 // TInt B, |
|
2354 // TInt W, |
|
2355 // TInt J) |
|
2356 AknLayoutUtils::LayoutMfne( mfne, rect, 0, 0, 0, 0, 0, 0, 0 ); |
|
2357 _LIT( KLayoutMfne4, "AknsUtils::LayoutMfne#4" ); |
|
2358 AssertTrueL( ETrue, KLayoutMfne4 ); |
|
2359 |
|
2360 CAknIntegerEdwin* edwin = CAknIntegerEdwin::NewL( 1, 2, 2 ); |
|
2361 CleanupStack::PushL( edwin ); |
|
2362 edwin->SetContainerWindowL( *iContainer ); |
|
2363 |
|
2364 // IMPORT_C void LayoutEdwin ( |
|
2365 // CEikEdwin *aEdwin, |
|
2366 // const TRect &aEdwinParent, |
|
2367 // TInt font, |
|
2368 // TInt C, |
|
2369 // TInt l, |
|
2370 // TInt r, |
|
2371 // TInt B, |
|
2372 // TInt W, |
|
2373 // TInt J, |
|
2374 // TInt aNumberOfLinesShown, |
|
2375 // TInt aNextLineBaseline, |
|
2376 // const CFont *aCustomFont=0, |
|
2377 // TBool aMinimizeEdwinView=EFalse ) |
|
2378 AknLayoutUtils::LayoutEdwin( |
|
2379 edwin, rect, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, EFalse ); |
|
2380 _LIT( KLayoutEdwin5, "AknsUtils::LayoutEdwin#5" ); |
|
2381 AssertTrueL( ETrue, KLayoutEdwin5 ); |
|
2382 |
|
2383 // IMPORT_C void LayoutImage ( |
|
2384 // CEikImage *aImage, |
|
2385 // const TRect &aParent, |
|
2386 // const SAknLayoutControl &aLayout) |
|
2387 AknLayoutUtils::LayoutImage( image, rect, layoutControl ); |
|
2388 _LIT( KLayoutImage4, "AknsUtils::LayoutImage#4" ); |
|
2389 AssertTrueL( ETrue, KLayoutImage4 ); |
|
2390 |
|
2391 // IMPORT_C void LayoutLabel ( |
|
2392 // CEikLabel *aLabel, |
|
2393 // const TRect &aLabelParent, |
|
2394 // const SAknLayoutLabel &aLayout, |
|
2395 // const CFont *aCustomFont=0) |
|
2396 AknLayoutUtils::LayoutLabel( label, rect, layoutLabel, 0 ); |
|
2397 _LIT( KLayoutLabel5, "AknsUtils::LayoutLabel#5" ); |
|
2398 AssertTrueL( ETrue, KLayoutLabel5 ); |
|
2399 |
|
2400 // IMPORT_C void LayoutEdwin ( |
|
2401 // CEikEdwin *aEdwin, |
|
2402 // const TRect &aEdwinParent, |
|
2403 // const SAknLayoutEdwin &aLayout, |
|
2404 // const CFont *aCustomFont=0, |
|
2405 // TBool aMinimizeEdwinView=EFalse) |
|
2406 AknLayoutUtils::SAknLayoutEdwin edwinLayout; |
|
2407 edwinLayout.iFont=0; |
|
2408 edwinLayout.iC=1; |
|
2409 edwinLayout.iL=1; |
|
2410 edwinLayout.iR=1; |
|
2411 edwinLayout.iB=1; |
|
2412 edwinLayout.iW=1; |
|
2413 edwinLayout.iJ=1; |
|
2414 edwinLayout.iNumberOfLinesShown=1; |
|
2415 AknLayoutUtils::LayoutEdwin( edwin, rect, edwinLayout, 0, EFalse ); |
|
2416 _LIT( KLayoutEdwin2, "AknsUtils::LayoutEdwin#2" ); |
|
2417 AssertTrueL( ETrue, KLayoutEdwin2 ); |
|
2418 |
|
2419 CleanupStack::PopAndDestroy( edwin ); |
|
2420 CleanupStack::PopAndDestroy( mfne ); |
|
2421 CleanupStack::PopAndDestroy( control ); |
|
2422 CleanupStack::PopAndDestroy( image ); |
|
2423 CleanupStack::PopAndDestroy( label ); |
|
2424 } |
|
2425 |
|
2426 // --------------------------------------------------------------------------- |
|
2427 // CBCTestMix50PatchControlCase::TestAknsUtilsL() |
|
2428 // Akn skin utility apis test |
|
2429 // --------------------------------------------------------------------------- |
|
2430 // |
|
2431 void CBCTestMix50PatchControlCase::TestAknsUtilsL() |
|
2432 { |
|
2433 MAknsSkinInstance* instance = AknsUtils::SkinInstance(); |
|
2434 |
|
2435 CFbsBitmap* bitmap = NULL; |
|
2436 CFbsBitmap* mask = NULL; |
|
2437 TRgb rgb = TRgb(); |
|
2438 |
|
2439 //IMPORT_C static void CreateColorIconLC( |
|
2440 // MAknsSkinInstance* aInstance, const TAknsItemID& aID, |
|
2441 // const TAknsItemID& aColorID, const TInt aColorIndex, |
|
2442 // CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, |
|
2443 // const TDesC& aFilename, |
|
2444 // const TInt aFileBitmapId, const TInt aFileMaskId, |
|
2445 // const TRgb aDefaultColor ); |
|
2446 _LIT(KAvkonBitmapFile, "z:\\resource\\apps\\avkon2.mbm"); |
|
2447 AknsUtils::CreateColorIconLC( |
|
2448 instance, |
|
2449 KAknsIIDQsnCpClockDigitalZero, |
|
2450 KAknsIIDQsnCpClockDigitalZero, |
|
2451 0, |
|
2452 bitmap, |
|
2453 mask, |
|
2454 KAvkonBitmapFile, |
|
2455 0, |
|
2456 0, |
|
2457 rgb); |
|
2458 _LIT( KCreateColorIconLC, "AknsUtils::CreateColorIconLC" ); |
|
2459 AssertTrueL( ETrue, KCreateColorIconLC ); |
|
2460 |
|
2461 if( mask ) |
|
2462 CleanupStack::PopAndDestroy( ); |
|
2463 if( bitmap ) |
|
2464 CleanupStack::PopAndDestroy( ); |
|
2465 mask = bitmap = NULL; |
|
2466 |
|
2467 //IMPORT_C static void CreateColorIconL( |
|
2468 // MAknsSkinInstance* aInstance, const TAknsItemID& aID, |
|
2469 // const TAknsItemID& aColorID, const TInt aColorIndex, |
|
2470 // CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, |
|
2471 // const TDesC& aFilename, |
|
2472 // const TInt aFileBitmapId, const TInt aFileMaskId, |
|
2473 // const TRgb aDefaultColor ); |
|
2474 AknsUtils::CreateColorIconL( |
|
2475 instance, |
|
2476 KAknsIIDQsnCpClockDigitalZero, |
|
2477 KAknsIIDQsnCpClockDigitalZero, |
|
2478 0, bitmap, |
|
2479 mask, |
|
2480 KAvkonBitmapFile, |
|
2481 0, |
|
2482 0, |
|
2483 rgb); |
|
2484 _LIT( KCreateColorIconL, "AknsUtils::CreateColorIconL" ); |
|
2485 AssertTrueL( ETrue, KCreateColorIconL ); |
|
2486 |
|
2487 if( mask ) |
|
2488 delete mask; |
|
2489 if( bitmap ) |
|
2490 delete bitmap; |
|
2491 mask = bitmap = NULL; |
|
2492 |
|
2493 //IMPORT_C static void CreateIconL( |
|
2494 // MAknsSkinInstance* aInstance, const TAknsItemID& aID, |
|
2495 // CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, |
|
2496 // const TDesC& aFilename, |
|
2497 // const TInt aFileBitmapId, const TInt aFileMaskId ); |
|
2498 AknsUtils::CreateIconL( |
|
2499 instance, |
|
2500 KAknsIIDQsnCpClockDigitalZero, |
|
2501 bitmap, |
|
2502 mask, |
|
2503 KAvkonBitmapFile, |
|
2504 0, |
|
2505 0); |
|
2506 _LIT( KCreateIconL, "AknsUtils::CreateIconL" ); |
|
2507 AssertTrueL( ETrue, KCreateIconL ); |
|
2508 |
|
2509 if( mask ) |
|
2510 delete mask; |
|
2511 if( bitmap ) |
|
2512 delete bitmap; |
|
2513 mask = bitmap = NULL; |
|
2514 |
|
2515 //IMPORT_C static void CreateIconL( |
|
2516 // MAknsSkinInstance* aInstance, const TAknsItemID& aID, |
|
2517 // CFbsBitmap*& aBitmap, |
|
2518 // const TDesC& aFilename, |
|
2519 // const TInt aFileBitmapId ); |
|
2520 AknsUtils::CreateIconL( |
|
2521 instance, |
|
2522 KAknsIIDQsnCpClockDigitalZero, |
|
2523 bitmap, |
|
2524 KAvkonBitmapFile, |
|
2525 0); |
|
2526 _LIT( KCreateIconL1, "AknsUtils::CreateIconL#1" ); |
|
2527 AssertTrueL( ETrue, KCreateIconL1 ); |
|
2528 |
|
2529 if( bitmap ) |
|
2530 delete bitmap; |
|
2531 bitmap = NULL; |
|
2532 |
|
2533 //IMPORT_C static void CreateIconLC( |
|
2534 // MAknsSkinInstance* aInstance, const TAknsItemID& aID, |
|
2535 // CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, |
|
2536 // const TDesC& aFilename, |
|
2537 // const TInt aFileBitmapId, const TInt aFileMaskId ); |
|
2538 AknsUtils::CreateIconLC( |
|
2539 instance, |
|
2540 KAknsIIDQsnCpClockDigitalZero, |
|
2541 bitmap, |
|
2542 mask, |
|
2543 KAvkonBitmapFile, |
|
2544 0, |
|
2545 0); |
|
2546 _LIT( KCreateIconLC, "AknsUtils::CreateIconLC" ); |
|
2547 AssertTrueL( ETrue, KCreateIconLC ); |
|
2548 |
|
2549 if( mask ) |
|
2550 CleanupStack::PopAndDestroy( ); |
|
2551 if( bitmap ) |
|
2552 CleanupStack::PopAndDestroy( ); |
|
2553 mask = bitmap = NULL; |
|
2554 |
|
2555 //IMPORT_C static void CreateIconLC( |
|
2556 // MAknsSkinInstance* aInstance, const TAknsItemID& aID, |
|
2557 // CFbsBitmap*& aBitmap, |
|
2558 // const TDesC& aFilename, |
|
2559 // const TInt aFileBitmapId ); |
|
2560 AknsUtils::CreateIconLC( |
|
2561 instance, |
|
2562 KAknsIIDQsnCpClockDigitalZero, |
|
2563 bitmap, |
|
2564 KAvkonBitmapFile, |
|
2565 0); |
|
2566 _LIT( KCreateIconLC1, "AknsUtils::CreateIconLC#1" ); |
|
2567 AssertTrueL( ETrue, KCreateIconLC1 ); |
|
2568 |
|
2569 if( bitmap ) |
|
2570 CleanupStack::PopAndDestroy( ); |
|
2571 bitmap = NULL; |
|
2572 |
|
2573 TAknsItemID itemID = KAknsIIDNone; |
|
2574 |
|
2575 //IMPORT_C void GetCachedMaskedBitmap ( |
|
2576 // MAknsSkinInstance *aInstance, |
|
2577 // const TAknsItemID &aID, |
|
2578 // CFbsBitmap *&aBitmap, |
|
2579 // CFbsBitmap *&aMask) |
|
2580 AknsUtils::GetCachedMaskedBitmap( instance, itemID, bitmap, mask ); |
|
2581 _LIT( KGetCachedMaskedBitmap, "AknsUtils::GetCachedMaskedBitmap" ); |
|
2582 AssertTrueL( ETrue, KGetCachedMaskedBitmap ); |
|
2583 |
|
2584 if( mask ) |
|
2585 delete mask; |
|
2586 if( bitmap ) |
|
2587 delete bitmap; |
|
2588 mask = bitmap = NULL; |
|
2589 |
|
2590 TInt err = KErrNone; |
|
2591 TPoint point = TPoint(); |
|
2592 CAknQueryDialog* dialog = CAknQueryDialog::NewL(); |
|
2593 CleanupStack::PushL( dialog ); |
|
2594 |
|
2595 //IMPORT_C void RegisterControlPosition ( |
|
2596 // const CCoeControl *aControl) |
|
2597 AknsUtils::RegisterControlPosition( dialog ); |
|
2598 _LIT( KRegisterControlPosition, "AknsUtils::RegisterControlPosition" ); |
|
2599 AssertTrueL( ETrue, KRegisterControlPosition ); |
|
2600 |
|
2601 //IMPORT_C void DeregisterControlPosition ( |
|
2602 // const CCoeControl *aControl) |
|
2603 AknsUtils::DeregisterControlPosition( dialog ); |
|
2604 |
|
2605 //IMPORT_C void RegisterControlPosition ( |
|
2606 // const CCoeControl *aControl, |
|
2607 // const TPoint &aPoint) |
|
2608 AknsUtils::RegisterControlPosition( dialog, point ); |
|
2609 _LIT( KRegisterControlPosition1, "AknsUtils::RegisterControlPosition#1" ); |
|
2610 AssertTrueL( ETrue, KRegisterControlPosition1 ); |
|
2611 |
|
2612 //IMPORT_C TInt GetControlPosition ( |
|
2613 // const CCoeControl *aControl, |
|
2614 // TPoint &aScreenPos) |
|
2615 err = AknsUtils::GetControlPosition( dialog, point ); |
|
2616 _LIT( KGetControlPosition, "AknsUtils::GetControlPosition" ); |
|
2617 AssertTrueL( ETrue, KGetControlPosition ); |
|
2618 |
|
2619 //IMPORT_C void DeregisterControlPosition ( |
|
2620 // const CCoeControl *aControl) |
|
2621 AknsUtils::DeregisterControlPosition( dialog ); |
|
2622 _LIT( KDeregisterControlPosition, "AknsUtils::DeregisterControlPosition" ); |
|
2623 AssertTrueL( ETrue, KDeregisterControlPosition ); |
|
2624 |
|
2625 CleanupStack::PopAndDestroy( dialog ); |
|
2626 |
|
2627 //IMPORT_C void SetAvkonSkinEnabledL ( |
|
2628 // const TBool aEnabled) |
|
2629 AknsUtils::SetAvkonSkinEnabledL(EFalse); |
|
2630 AknsUtils::AvkonSkinEnabled(); |
|
2631 _LIT( KAvkonSkinEnabled, "AknsUtils::AvkonSkinEnabled" ); |
|
2632 AssertTrueL( ETrue, KAvkonSkinEnabled ); |
|
2633 |
|
2634 |
|
2635 //IMPORT_C TInt GetCachedColor ( |
|
2636 // MAknsSkinInstance *aInstance, |
|
2637 // TRgb &aRgb, |
|
2638 // const TAknsItemID &aID, |
|
2639 // const TInt aIndex) |
|
2640 TInt color = AknsUtils::GetCachedColor( instance, rgb, itemID, 0 ); |
|
2641 _LIT( KGetCachedColor, "AknsUtils::GetCachedColor" ); |
|
2642 AssertTrueL( ETrue, KGetCachedColor ); |
|
2643 |
|
2644 //IMPORT_C CFbsBitmap * GetCachedBitmap ( |
|
2645 // MAknsSkinInstance *aInstance, |
|
2646 // const TAknsItemID &aID) |
|
2647 bitmap = AknsUtils::GetCachedBitmap( NULL, itemID ); |
|
2648 _LIT( KGetCachedBitmap, "AknsUtils::GetCachedBitmap" ); |
|
2649 AssertTrueL( ETrue, KGetCachedBitmap ); |
|
2650 |
|
2651 if( bitmap ) |
|
2652 delete bitmap; |
|
2653 bitmap = NULL; |
|
2654 } |
|
2655 |
|
2656 // --------------------------------------------------------------------------- |
|
2657 // CBCTestMix50PatchControlCase::TestAknsDrawUtilsL() |
|
2658 // Akn skin utility apis test |
|
2659 // --------------------------------------------------------------------------- |
|
2660 // |
|
2661 void CBCTestMix50PatchControlCase::TestAknsDrawUtilsL() |
|
2662 { |
|
2663 |
|
2664 TRect rect = TRect(); |
|
2665 MAknsSkinInstance* instance = AknsUtils::SkinInstance(); |
|
2666 |
|
2667 CWindowGc& gc = iCoeEnv->SystemGc(); |
|
2668 MAknsControlContext* cc = AknsDrawUtils::ControlContext( iContainer ); |
|
2669 |
|
2670 gc.Activate( *iContainer->DrawableWindow() ); |
|
2671 |
|
2672 //IMPORT_C TBool Background ( |
|
2673 // MAknsSkinInstance *aInstance, |
|
2674 // MAknsControlContext *aContext, |
|
2675 // const CCoeControl *aControl, |
|
2676 // CWindowGc &aGc, |
|
2677 // const TRect &aRect) |
|
2678 TBool output = AknsDrawUtils::Background( instance, cc, iContainer, gc, rect ); |
|
2679 _LIT( KBackground1, "AknsDrawUtils::Background#1" ); |
|
2680 AssertTrueL( ETrue, KBackground1 ); |
|
2681 |
|
2682 //IMPORT_C TBool Background ( |
|
2683 // MAknsSkinInstance *aInstance, |
|
2684 // MAknsControlContext *aContext, |
|
2685 // const CCoeControl *aControl, |
|
2686 // CWindowGc &aGc, |
|
2687 // const TRect &aRect, |
|
2688 // const TInt aDrawParam) |
|
2689 output = AknsDrawUtils::Background( |
|
2690 instance, cc, iContainer, gc, rect, KAknsDrawParamDefault ); |
|
2691 _LIT( KBackground2, "AknsDrawUtils::Background#2" ); |
|
2692 AssertTrueL( ETrue, KBackground2 ); |
|
2693 |
|
2694 //IMPORT_C TBool BackgroundBetweenRects ( |
|
2695 // MAknsSkinInstance *aInstance, |
|
2696 // MAknsControlContext *aContext, |
|
2697 // CWindowGc &aGc, |
|
2698 // const TRect &aOuterRect, |
|
2699 // const TRect &aInnerRect) |
|
2700 |
|
2701 TRect innerRect = rect; |
|
2702 innerRect.Shrink( 2, 2 ); |
|
2703 output = AknsDrawUtils::BackgroundBetweenRects( |
|
2704 instance, cc, gc, rect, innerRect ); |
|
2705 _LIT( KBackgroundBetweenRects, "AknsDrawUtils::BackgroundBetweenRects" ); |
|
2706 AssertTrueL( ETrue, KBackgroundBetweenRects ); |
|
2707 |
|
2708 //IMPORT_C TBool BackgroundBetweenRects ( |
|
2709 // MAknsSkinInstance *aInstance, |
|
2710 // MAknsControlContext *aContext, |
|
2711 // const CCoeControl *aControl, |
|
2712 // CWindowGc &aGc, |
|
2713 // const TRect &aOuterRect, |
|
2714 // const TRect &aInnerRect) |
|
2715 output = AknsDrawUtils::BackgroundBetweenRects( |
|
2716 instance, cc, iContainer, gc, rect, innerRect); |
|
2717 _LIT( KBackgroundBetweenRects1, "AknsDrawUtils::BackgroundBetweenRects#1" ); |
|
2718 AssertTrueL( ETrue, KBackgroundBetweenRects1 ); |
|
2719 |
|
2720 //IMPORT_C TBool BackgroundBetweenRects ( |
|
2721 // MAknsSkinInstance *aInstance, |
|
2722 // MAknsControlContext *aContext, |
|
2723 // const CCoeControl *aControl, |
|
2724 // CWindowGc &aGc, |
|
2725 // const TRect &aOuterRect, |
|
2726 // const TRect &aInnerRect, |
|
2727 // const TInt aDrawParam ) |
|
2728 output = AknsDrawUtils::BackgroundBetweenRects( |
|
2729 instance, cc, iContainer, gc, rect, innerRect, KAknsDrawParamDefault ); |
|
2730 _LIT( KBackgroundBetweenRects2, "AknsDrawUtils::BackgroundBetweenRects#2" ); |
|
2731 AssertTrueL( ETrue, KBackgroundBetweenRects2 ); |
|
2732 |
|
2733 //IMPORT_C TBool DrawBackground ( |
|
2734 // MAknsSkinInstance *aInstance, |
|
2735 // MAknsControlContext *aContext, |
|
2736 // const CCoeControl *aControl, |
|
2737 // CBitmapContext &aGc, |
|
2738 // const TPoint &aDstPos, |
|
2739 // const TRect &aControlRect, |
|
2740 // const TInt aDrawParam) |
|
2741 TPoint point = TPoint(); |
|
2742 output = AknsDrawUtils::DrawBackground( |
|
2743 instance, cc, iContainer, gc, point, rect, KAknsDrawParamDefault); |
|
2744 _LIT( KDrawBackground, "AknsDrawUtils::DrawBackground" ); |
|
2745 AssertTrueL( ETrue, KDrawBackground ); |
|
2746 |
|
2747 //IMPORT_C void DrawCachedImage ( |
|
2748 // MAknsSkinInstance *aInstance, |
|
2749 // CWindowGc &aGc, |
|
2750 // const TRect &aRect, |
|
2751 // const TAknsItemID &aID) |
|
2752 AknsDrawUtils::DrawCachedImage( instance, gc, rect, KAknsIIDNone ); |
|
2753 _LIT( KDrawCachedImagee, "AknsDrawUtils::DrawCachedImage" ); |
|
2754 AssertTrueL( ETrue, KDrawCachedImagee ); |
|
2755 |
|
2756 //IMPORT_C TBool DrawFrame ( |
|
2757 // MAknsSkinInstance *aInstance, |
|
2758 // CWindowGc &aGc, |
|
2759 // const TRect &aOuterRect, |
|
2760 // const TRect &aInnerRect, |
|
2761 // const TAknsItemID &aFrameID, |
|
2762 // const TAknsItemID &aCenterID) |
|
2763 output = AknsDrawUtils::DrawFrame( |
|
2764 instance, gc, rect, innerRect, KAknsIIDNone, KAknsIIDNone ); |
|
2765 _LIT( KDrawFrame, "AknsDrawUtils::DrawFrame" ); |
|
2766 AssertTrueL( ETrue, KDrawFrame ); |
|
2767 |
|
2768 gc.Deactivate(); |
|
2769 } |
|
2770 |
|
2771 // --------------------------------------------------------------------------- |
|
2772 // CBCTestMix50PatchControlCase::TestDialogsL() |
|
2773 // Various dialogs api test |
|
2774 // --------------------------------------------------------------------------- |
|
2775 // |
|
2776 void CBCTestMix50PatchControlCase::TestDialogsL() |
|
2777 { |
|
2778 //IMPORT_C CAknMessageQueryDialog(); |
|
2779 CAknMessageQueryDialog* messageDialog = new(ELeave) CAknMessageQueryDialog(); |
|
2780 CleanupStack::PushL( messageDialog ); |
|
2781 _LIT( KAknMessageQueryDialog, |
|
2782 "CAknMessageQueryDialog::CAknMessageQueryDialog#5" ); |
|
2783 AssertTrueL( ETrue, KAknMessageQueryDialog ); |
|
2784 CleanupStack::PopAndDestroy( messageDialog ); |
|
2785 |
|
2786 CAknQueryDialog* queryDialog = CAknQueryDialog::NewL(); |
|
2787 CleanupStack::PushL( queryDialog ); |
|
2788 |
|
2789 _LIT( KPrompt, "Query dialog apis test" ); |
|
2790 queryDialog->ExecuteLD( |
|
2791 R_BCTESTAKNQUEDLG_ONELINE_DATA_QUERY , KPrompt() ); |
|
2792 _LIT( KExecuteLD, "CAknQueryDialog::ExecuteLD#1" ); |
|
2793 AssertTrueL( ETrue, KExecuteLD ); |
|
2794 |
|
2795 CleanupStack::Pop( queryDialog ); |
|
2796 |
|
2797 //IMPORT_C CAknStaticNoteDialog(CEikDialog** aSelfPtr); |
|
2798 iStaticNoteDialog = NULL; |
|
2799 iStaticNoteDialog = new (ELeave) CAknStaticNoteDialog( |
|
2800 REINTERPRET_CAST( CEikDialog**, &iStaticNoteDialog) ); |
|
2801 CleanupStack::PushL( iStaticNoteDialog ); |
|
2802 _LIT( KAknStaticNoteDialog1, |
|
2803 "CAknStaticNoteDialog::CAknStaticNoteDialog#1" ); |
|
2804 AssertNotNullL( iStaticNoteDialog, KAknStaticNoteDialog1 ); |
|
2805 |
|
2806 iStaticNoteDialog->SetNumberOfBorders( 1 ); |
|
2807 _LIT( KSetNumberOfBorders, "CAknStaticNoteDialog::SetNumberOfBorders"); |
|
2808 AssertTrueL( ETrue, KSetNumberOfBorders ); |
|
2809 |
|
2810 CleanupStack::PopAndDestroy( iStaticNoteDialog ); |
|
2811 |
|
2812 // IMPORT_C CAknNoteDialog( |
|
2813 // CEikDialog** aSelfPtr, |
|
2814 // const TTone& aTone = ENoTone, |
|
2815 // const TTimeout& aTimeout = ENoTimeout ); |
|
2816 iNoteDialog = NULL; |
|
2817 iNoteDialog = new (ELeave)CBCTestAknNoteDialog( |
|
2818 REINTERPRET_CAST( CEikDialog**,&iNoteDialog ) ); |
|
2819 CleanupStack::PushL( iNoteDialog ); |
|
2820 CBCTestAknNoteDialog::OwnStaticDeleteL( iNoteDialog ); |
|
2821 CleanupStack::Pop(); |
|
2822 _LIT( KStaticDeleteL, "CAknNoteDialog::StaticDeleteL" ); |
|
2823 AssertTrueL( ETrue, KStaticDeleteL ); |
|
2824 } |
|
2825 |
|
2826 // --------------------------------------------------------------------------- |
|
2827 // CBCTestMix50PatchControlCase::TestPopupsL() |
|
2828 // Popup control api test |
|
2829 // --------------------------------------------------------------------------- |
|
2830 // |
|
2831 void CBCTestMix50PatchControlCase::TestPopupL() |
|
2832 { |
|
2833 CAknSinglePopupMenuStyleListBox* listbox = new(ELeave)CAknSinglePopupMenuStyleListBox; |
|
2834 CleanupStack::PushL( listbox ); |
|
2835 |
|
2836 CAknPopupList* popupList = CAknPopupList::NewL( listbox, |
|
2837 R_AVKON_SOFTKEYS_OK_BACK, AknPopupLayouts::EMenuWindow ); |
|
2838 CleanupStack::PushL( popupList ); |
|
2839 |
|
2840 //IMPORT_C CAknPopupHeadingPane * Heading () const |
|
2841 const CAknPopupHeadingPane* heading = popupList->Heading(); |
|
2842 _LIT( KHeading, "CAknPopupList::Heading#1" ); |
|
2843 AssertTrueL( ETrue, KHeading ); |
|
2844 |
|
2845 CleanupStack::PopAndDestroy( 2 ); // popupList + listbox |
|
2846 } |
|
2847 |
|
2848 // --------------------------------------------------------------------------- |
|
2849 // CBCTestMix50PatchControlCase::TestStatesL() |
|
2850 // Kinds of states classes api test |
|
2851 // --------------------------------------------------------------------------- |
|
2852 // |
|
2853 void CBCTestMix50PatchControlCase::TestStatesL() |
|
2854 { |
|
2855 TAknEditorCaseState caseState; |
|
2856 _LIT( KTAknEditorCaseState, |
|
2857 "TAknEditorCaseState::TAknEditorCaseState() invoked" ); |
|
2858 AssertTrueL( ETrue, KTAknEditorCaseState ); |
|
2859 |
|
2860 caseState.SetCurrentCase( 0 ); |
|
2861 _LIT( KSetCurrentCase, |
|
2862 "TAknEditorCaseState::SetCurrentCase() invoked" ); |
|
2863 AssertTrueL( ETrue, KSetCurrentCase ); |
|
2864 |
|
2865 CAknEdwinState *edwinState = new (ELeave) CAknEdwinState; |
|
2866 CleanupStack::PushL( edwinState ); |
|
2867 |
|
2868 edwinState->SetFormAccessor( NULL ); |
|
2869 _LIT( KSetFormAccessor, |
|
2870 "CAknEdwinState::SetFormAccessor() invoked" ); |
|
2871 AssertTrueL( ETrue, KSetFormAccessor ); |
|
2872 |
|
2873 TCursorSelection cursorSelection( 0, 0 ); |
|
2874 edwinState->SetInlineEditSpan( cursorSelection ); |
|
2875 _LIT( KSetInlineEditSpan, |
|
2876 "CAknEdwinState::SetInlineEditSpan() invoked" ); |
|
2877 AssertTrueL( ETrue, KSetInlineEditSpan ); |
|
2878 |
|
2879 edwinState->SetNumericKeymap( EAknEditorStandardNumberModeKeymap ); |
|
2880 _LIT( KSetNumericKeymap, "CAknEdwinState::SetNumericKeymap() invoked" ); |
|
2881 AssertTrueL( ETrue, KSetNumericKeymap ); |
|
2882 |
|
2883 edwinState->SetPermittedCases( 0 ); |
|
2884 _LIT( KSetPermittedCases, |
|
2885 "CAknEdwinState::SetPermittedCases() invoked" ); |
|
2886 AssertTrueL( ETrue, KSetPermittedCases ); |
|
2887 |
|
2888 edwinState->SetDefaultCase( 0 ); |
|
2889 _LIT( KSetDefaultCase, "CAknEdwinState::SetDefaultCase() invoked" ); |
|
2890 AssertTrueL( ETrue, KSetDefaultCase ); |
|
2891 |
|
2892 edwinState->SetPermittedInputModes( 0 ); |
|
2893 _LIT( KSetPermittedInputModes, |
|
2894 "CAknEdwinState::SetPermittedInputModes() invoked" ); |
|
2895 AssertTrueL( ETrue, KSetPermittedInputModes ); |
|
2896 |
|
2897 edwinState->SpecialCharacterTableResourceId(); |
|
2898 _LIT( KSpecialCharacterTableResourceId, |
|
2899 "CAknEdwinState::SpecialCharacterTableResourceId() invoked" ); |
|
2900 AssertTrueL( ETrue, KSpecialCharacterTableResourceId ); |
|
2901 |
|
2902 edwinState->PermittedInputModes(); |
|
2903 _LIT( KPermittedInputModes, "CAknEdwinState::PermittedInputModes() invoked" ); |
|
2904 AssertTrueL( ETrue, KPermittedInputModes ); |
|
2905 |
|
2906 edwinState->Flags(); |
|
2907 _LIT( KFlags, "CAknEdwinState::Flags() invoked" ); |
|
2908 AssertTrueL( ETrue, KFlags ); |
|
2909 |
|
2910 edwinState->ReportAknEdStateEventL( |
|
2911 MAknEdStateObserver::EAknEdwinStateEventStateUpdate ); |
|
2912 _LIT( KReportAknEdStateEventL, |
|
2913 "CAknEdwinState::ReportAknEdStateEventL() invoked" ); |
|
2914 AssertTrueL( ETrue, KReportAknEdStateEventL ); |
|
2915 |
|
2916 CleanupStack::PopAndDestroy( edwinState ); |
|
2917 } |
|
2918 |
|
2919 // --------------------------------------------------------------------------- |
|
2920 // CBCTestMix50PatchControlCase::TestStatesL() |
|
2921 // Kinds of states classes api test |
|
2922 // --------------------------------------------------------------------------- |
|
2923 // |
|
2924 void CBCTestMix50PatchControlCase::TestIpFieldEditorL() |
|
2925 { |
|
2926 TInetAddr minimumAddress; |
|
2927 TInetAddr maximumAddress; |
|
2928 TInetAddr initialAddress; |
|
2929 minimumAddress.Input( _L("1.1.1.1") ); |
|
2930 maximumAddress.Input( _L("255.255.255.255") ); |
|
2931 initialAddress.Input( _L("192.168.1.1") ); |
|
2932 CAknIpFieldEditor *ipFieldEditor = CAknIpFieldEditor::NewL( |
|
2933 minimumAddress, maximumAddress, initialAddress ); |
|
2934 CleanupStack::PushL( ipFieldEditor ); |
|
2935 |
|
2936 _LIT( KCAknIpFieldEditor, "CAknIpFieldEditor::CAknIpFieldEditor() invoked" ); |
|
2937 AssertNotNullL( ipFieldEditor, KCAknIpFieldEditor ); |
|
2938 |
|
2939 ipFieldEditor->SetContainerWindowL( *iContainer ); |
|
2940 TResourceReader reader; |
|
2941 iCoeEnv->CreateResourceReaderLC( reader, R_BCTEST_IP_FIELD ); |
|
2942 |
|
2943 // IMPORT_C TInetAddr ReadIPAddress( TResourceReader& aResourceReader ); |
|
2944 ipFieldEditor->ReadIPAddress( reader ); |
|
2945 _LIT( KReadIPAddress, "CAknIpFieldEditor::ReadIPAddress() invoked" ); |
|
2946 AssertNotNullL( ipFieldEditor, KReadIPAddress ); |
|
2947 |
|
2948 CleanupStack::PopAndDestroy(); // reader |
|
2949 CleanupStack::PopAndDestroy( ipFieldEditor ); |
|
2950 } |
|
2951 |
|
2952 // --------------------------------------------------------------------------- |
|
2953 // CBCTestMix50PatchControlCase::TestIconArrayL() |
|
2954 // Icon array apis test |
|
2955 // --------------------------------------------------------------------------- |
|
2956 // |
|
2957 void CBCTestMix50PatchControlCase::TestIconArrayL() |
|
2958 { |
|
2959 CAknIconArray* iconArray = new(ELeave)CAknIconArray( 5 ); |
|
2960 CleanupStack::PushL( iconArray ); |
|
2961 |
|
2962 TResourceReader reader; |
|
2963 iCoeEnv->CreateResourceReaderLC( reader, R_AVKON_FIND_PANE_INDICATOR_ICONS ); |
|
2964 |
|
2965 //IMPORT_C void AppendFromResourceL ( TResourceReader &aReader ) |
|
2966 _LIT( KAppendFromResourceL, |
|
2967 "CAknMarkableListDialog::CAknMarkableListDialog#1() invoked"); |
|
2968 iconArray->AppendFromResourceL( reader ); |
|
2969 AssertTrueL( ETrue, KAppendFromResourceL ); |
|
2970 |
|
2971 CleanupStack::PopAndDestroy(); // reader |
|
2972 CleanupStack::PopAndDestroy( iconArray ); |
|
2973 } |