|
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 eiksbfrm.h |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // [INCLUDE FILES] |
|
20 #include <eiksbfrm.h> |
|
21 #include <coemain.h> |
|
22 #include <coeaui.h> |
|
23 |
|
24 #include "testsdkscroller.h" |
|
25 #include "testsdkscrollercontrol.h" |
|
26 |
|
27 // CONSTANTS |
|
28 const TInt KWidth = 100; |
|
29 const TInt KHeight = 100; |
|
30 |
|
31 // ============================ MEMBER FUNCTIONS =============================== |
|
32 |
|
33 // ----------------------------------------------------------------------------- |
|
34 // CTestSDKScroller::TestSDKSbFrmLaDefConsL |
|
35 // ----------------------------------------------------------------------------- |
|
36 // |
|
37 TInt CTestSDKScroller::TestSDKSbFrmLaDefConsL( CStifItemParser& /*aItem*/ ) |
|
38 { |
|
39 |
|
40 // Print to UI |
|
41 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
42 _LIT( KTestSDKSbFrmLaDefCons, "in SbFrmLaNewL" ); |
|
43 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmLaDefCons ); |
|
44 // Print to log file |
|
45 iLog->Log( KTestSDKSbFrmLaDefCons ); |
|
46 |
|
47 TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout; |
|
48 CleanupStack::PushL( sbFrameLa ); |
|
49 STIF_ASSERT_NOT_NULL( sbFrameLa ); |
|
50 |
|
51 CleanupStack::PopAndDestroy( sbFrameLa ); |
|
52 return KErrNone; |
|
53 |
|
54 } |
|
55 |
|
56 // ----------------------------------------------------------------------------- |
|
57 // CTestSDKScroller::TestSDKSbFrmLaSetInclusiveMarginL |
|
58 // ----------------------------------------------------------------------------- |
|
59 // |
|
60 TInt CTestSDKScroller::TestSDKSbFrmLaSetInclusiveMarginL( CStifItemParser& /*aItem*/ ) |
|
61 { |
|
62 |
|
63 // Print to UI |
|
64 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
65 _LIT( KTestSDKSbFrmLaSetInclusiveMargin, "in SbFrmLaSetInclusiveMargin" ); |
|
66 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmLaSetInclusiveMargin ); |
|
67 // Print to log file |
|
68 iLog->Log( KTestSDKSbFrmLaSetInclusiveMargin ); |
|
69 |
|
70 TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout; |
|
71 CleanupStack::PushL( sbFrameLa ); |
|
72 |
|
73 TInt margin = 0; |
|
74 sbFrameLa->SetInclusiveMargin( margin ); |
|
75 |
|
76 CleanupStack::PopAndDestroy( sbFrameLa ); |
|
77 return KErrNone; |
|
78 |
|
79 } |
|
80 |
|
81 // ----------------------------------------------------------------------------- |
|
82 // CTestSDKScroller::TestSDKSbFrmLaSetClientMarginL |
|
83 // ----------------------------------------------------------------------------- |
|
84 // |
|
85 TInt CTestSDKScroller::TestSDKSbFrmLaSetClientMarginL( CStifItemParser& /*aItem*/ ) |
|
86 { |
|
87 |
|
88 // Print to UI |
|
89 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
90 _LIT( KTestSDKSbFrmLaSetInclusiveMargin, "in SbFrmLaSetInclusiveMargin" ); |
|
91 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmLaSetInclusiveMargin ); |
|
92 // Print to log file |
|
93 iLog->Log( KTestSDKSbFrmLaSetInclusiveMargin ); |
|
94 |
|
95 TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout; |
|
96 CleanupStack::PushL( sbFrameLa ); |
|
97 |
|
98 TInt margin = 0; |
|
99 sbFrameLa->SetClientMargin( margin ); |
|
100 |
|
101 CleanupStack::PopAndDestroy( sbFrameLa ); |
|
102 return KErrNone; |
|
103 |
|
104 } |
|
105 |
|
106 // ----------------------------------------------------------------------------- |
|
107 // CTestSDKScroller::TestSDKSbFrmDefConsWithPaL |
|
108 // ----------------------------------------------------------------------------- |
|
109 // |
|
110 TInt CTestSDKScroller::TestSDKSbFrmDefConsWithPaL( CStifItemParser& /*aItem*/ ) |
|
111 { |
|
112 |
|
113 // Print to UI |
|
114 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
115 _LIT( KTestSDKSbFrmDefConsWithPa, "in SbFrmDefConsWithPa" ); |
|
116 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDefConsWithPa ); |
|
117 // Print to log file |
|
118 iLog->Log( KTestSDKSbFrmDefConsWithPa ); |
|
119 |
|
120 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
121 CleanupStack::PushL( control ); |
|
122 |
|
123 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
124 CleanupStack::PushL( sbFrame ); |
|
125 STIF_ASSERT_NOT_NULL( sbFrame ); |
|
126 |
|
127 CleanupStack::PopAndDestroy( sbFrame ); |
|
128 CleanupStack::PopAndDestroy( control ); |
|
129 return KErrNone; |
|
130 |
|
131 } |
|
132 |
|
133 // ----------------------------------------------------------------------------- |
|
134 // CTestSDKScroller::TestSDKSbFrmDrawSbsNowL |
|
135 // ----------------------------------------------------------------------------- |
|
136 // |
|
137 TInt CTestSDKScroller::TestSDKSbFrmDrawSbsNowL( CStifItemParser& /*aItem*/ ) |
|
138 { |
|
139 |
|
140 // Print to UI |
|
141 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
142 _LIT( KTestSDKSbFrmDrawSbsNow, "in SbFrmDrawSbsNow" ); |
|
143 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDrawSbsNow ); |
|
144 // Print to log file |
|
145 iLog->Log( KTestSDKSbFrmDrawSbsNow ); |
|
146 |
|
147 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
148 CleanupStack::PushL( control ); |
|
149 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
150 CleanupStack::PushL( sbFrame ); |
|
151 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
152 |
|
153 sbFrame->DrawScrollBarsNow(); |
|
154 |
|
155 CleanupStack::PopAndDestroy( sbFrame ); |
|
156 CleanupStack::PopAndDestroy( control ); |
|
157 return KErrNone; |
|
158 |
|
159 } |
|
160 |
|
161 // ----------------------------------------------------------------------------- |
|
162 // CTestSDKScroller::TestSDKSbFrmSetSbVisibilityL |
|
163 // ----------------------------------------------------------------------------- |
|
164 // |
|
165 TInt CTestSDKScroller::TestSDKSbFrmSetSbVisibilityL( CStifItemParser& /*aItem*/ ) |
|
166 { |
|
167 |
|
168 // Print to UI |
|
169 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
170 _LIT( KTestSDKSbFrmSetSbVisibilityL, "in SbFrmSbVisibilityL" ); |
|
171 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetSbVisibilityL ); |
|
172 // Print to log file |
|
173 iLog->Log( KTestSDKSbFrmSetSbVisibilityL ); |
|
174 |
|
175 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
176 CleanupStack::PushL( control ); |
|
177 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
178 CleanupStack::PushL( sbFrame ); |
|
179 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
180 |
|
181 CEikScrollBarFrame::TScrollBarVisibility hVisibility = |
|
182 CEikScrollBarFrame::EOff; |
|
183 CEikScrollBarFrame::TScrollBarVisibility vVisibility = |
|
184 CEikScrollBarFrame::EOff; |
|
185 sbFrame->SetScrollBarVisibilityL( hVisibility, vVisibility ); |
|
186 |
|
187 CleanupStack::PopAndDestroy( sbFrame ); |
|
188 CleanupStack::PopAndDestroy( control ); |
|
189 return KErrNone; |
|
190 |
|
191 } |
|
192 |
|
193 // ----------------------------------------------------------------------------- |
|
194 // CTestSDKScroller::TestSDKSbFrmVSbVisibilityL |
|
195 // ----------------------------------------------------------------------------- |
|
196 // |
|
197 TInt CTestSDKScroller::TestSDKSbFrmVSbVisibilityL( CStifItemParser& /*aItem*/ ) |
|
198 { |
|
199 |
|
200 // Print to UI |
|
201 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
202 _LIT( KTestSDKSbFrmVSbVisibilityL, "in SbFrmVSbVisibilityL" ); |
|
203 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmVSbVisibilityL ); |
|
204 // Print to log file |
|
205 iLog->Log( KTestSDKSbFrmVSbVisibilityL ); |
|
206 |
|
207 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame; |
|
208 CleanupStack::PushL( sbFrame ); |
|
209 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
210 |
|
211 CEikScrollBarFrame::TScrollBarVisibility hVisibility = |
|
212 CEikScrollBarFrame::EOn; |
|
213 CEikScrollBarFrame::TScrollBarVisibility vVisibility = |
|
214 CEikScrollBarFrame::EOn; |
|
215 sbFrame->SetScrollBarVisibilityL( hVisibility, vVisibility ); |
|
216 |
|
217 CEikScrollBarFrame::TScrollBarVisibility vSbVisibility = |
|
218 sbFrame->VScrollBarVisibility(); |
|
219 STIF_ASSERT_EQUALS( vVisibility, vSbVisibility ); |
|
220 |
|
221 CleanupStack::PopAndDestroy( sbFrame ); |
|
222 return KErrNone; |
|
223 |
|
224 } |
|
225 |
|
226 // ----------------------------------------------------------------------------- |
|
227 // CTestSDKScroller::TestSDKSbFrmSetSbfrmObserverL |
|
228 // ----------------------------------------------------------------------------- |
|
229 // |
|
230 TInt CTestSDKScroller::TestSDKSbFrmSetSbfrmObserverL( CStifItemParser& /*aItem*/ ) |
|
231 { |
|
232 |
|
233 // Print to UI |
|
234 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
235 _LIT( KTestSDKSbFrmSetSbfrmObserverL, "in SbFrmDefConsWithPa" ); |
|
236 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetSbfrmObserverL ); |
|
237 // Print to log file |
|
238 iLog->Log( KTestSDKSbFrmSetSbfrmObserverL ); |
|
239 |
|
240 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
241 CleanupStack::PushL( control ); |
|
242 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
243 CleanupStack::PushL( sbFrame ); |
|
244 |
|
245 sbFrame->SetScrollBarFrameObserver( control ); |
|
246 |
|
247 CleanupStack::PopAndDestroy( sbFrame ); |
|
248 CleanupStack::PopAndDestroy( control ); |
|
249 return KErrNone; |
|
250 |
|
251 } |
|
252 |
|
253 // ----------------------------------------------------------------------------- |
|
254 // CTestSDKScroller::TestSDKSbFrmTileL |
|
255 // ----------------------------------------------------------------------------- |
|
256 // |
|
257 TInt CTestSDKScroller::TestSDKSbFrmTileL( CStifItemParser& /*aItem*/ ) |
|
258 { |
|
259 |
|
260 // Print to UI |
|
261 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
262 _LIT( KTestSDKSbFrmTile, "in SbFrmTile" ); |
|
263 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTile ); |
|
264 // Print to log file |
|
265 iLog->Log( KTestSDKSbFrmTile ); |
|
266 |
|
267 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
268 CleanupStack::PushL( control ); |
|
269 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
270 CleanupStack::PushL( sbFrame ); |
|
271 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
272 |
|
273 TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel; |
|
274 CleanupStack::PushL( vModel ); |
|
275 TBool model = sbFrame->Tile( vModel ); |
|
276 STIF_ASSERT_FALSE( model ); |
|
277 |
|
278 CleanupStack::PopAndDestroy( vModel ); |
|
279 CleanupStack::PopAndDestroy( sbFrame ); |
|
280 CleanupStack::PopAndDestroy( control ); |
|
281 return KErrNone; |
|
282 |
|
283 } |
|
284 |
|
285 // ----------------------------------------------------------------------------- |
|
286 // CTestSDKScroller::TestSDKSbFrmTileWithSbfrmLaL |
|
287 // ----------------------------------------------------------------------------- |
|
288 // |
|
289 TInt CTestSDKScroller::TestSDKSbFrmTileWithSbfrmLaL( CStifItemParser& /*aItem*/ ) |
|
290 { |
|
291 |
|
292 // Print to UI |
|
293 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
294 _LIT( KTestSDKSbFrmTileWithSbfrmLa, "in SbFrmTileWithSbfrmLa" ); |
|
295 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTileWithSbfrmLa ); |
|
296 // Print to log file |
|
297 iLog->Log( KTestSDKSbFrmTileWithSbfrmLa ); |
|
298 |
|
299 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
300 CleanupStack::PushL( control ); |
|
301 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
302 CleanupStack::PushL( sbFrame ); |
|
303 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
304 |
|
305 TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel; |
|
306 CleanupStack::PushL( vModel ); |
|
307 TEikScrollBarModel* hModel = new ( ELeave ) TEikScrollBarModel; |
|
308 CleanupStack::PushL( hModel ); |
|
309 TEikScrollBarFrameLayout* sbFrameLa = new ( ELeave ) TEikScrollBarFrameLayout; |
|
310 CleanupStack::PushL( sbFrameLa ); |
|
311 TSize size( KWidth, KHeight ); |
|
312 TRect clientRect( size ); |
|
313 TRect inclusiveRect( size ); |
|
314 |
|
315 TBool model = sbFrame->TileL( hModel, vModel, clientRect, |
|
316 inclusiveRect, *sbFrameLa ); |
|
317 STIF_ASSERT_FALSE( model ); |
|
318 |
|
319 CleanupStack::PopAndDestroy( sbFrameLa ); |
|
320 CleanupStack::PopAndDestroy( hModel ); |
|
321 CleanupStack::PopAndDestroy( vModel ); |
|
322 CleanupStack::PopAndDestroy( sbFrame ); |
|
323 CleanupStack::PopAndDestroy( control ); |
|
324 return KErrNone; |
|
325 |
|
326 } |
|
327 |
|
328 // ----------------------------------------------------------------------------- |
|
329 // CTestSDKScroller::TestSDKSbFrmMoveThumbsByL |
|
330 // ----------------------------------------------------------------------------- |
|
331 // |
|
332 TInt CTestSDKScroller::TestSDKSbFrmMoveThumbsByL( CStifItemParser& /*aItem*/ ) |
|
333 { |
|
334 |
|
335 // Print to UI |
|
336 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
337 _LIT( KTestSDKSbFrmMoveThumbsBy, "in SbFrmMoveThumbsBy" ); |
|
338 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmMoveThumbsBy ); |
|
339 // Print to log file |
|
340 iLog->Log( KTestSDKSbFrmMoveThumbsBy ); |
|
341 |
|
342 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
343 CleanupStack::PushL( control ); |
|
344 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
345 CleanupStack::PushL( sbFrame ); |
|
346 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
347 |
|
348 TInt deltaX = 1; |
|
349 TInt deltaY = 1; |
|
350 sbFrame->MoveThumbsBy( deltaX, deltaY ); |
|
351 |
|
352 CleanupStack::PopAndDestroy( sbFrame ); |
|
353 CleanupStack::PopAndDestroy( control ); |
|
354 return KErrNone; |
|
355 |
|
356 } |
|
357 |
|
358 // ----------------------------------------------------------------------------- |
|
359 // CTestSDKScroller::TestSDKSbFrmMoveHThumbToL |
|
360 // ----------------------------------------------------------------------------- |
|
361 // |
|
362 TInt CTestSDKScroller::TestSDKSbFrmMoveHThumbToL( CStifItemParser& /*aItem*/ ) |
|
363 { |
|
364 |
|
365 // Print to UI |
|
366 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
367 _LIT( KTestSDKSbFrmMoveHThumbTo, "in SbFrmMoveHThumbTo" ); |
|
368 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmMoveHThumbTo ); |
|
369 // Print to log file |
|
370 iLog->Log( KTestSDKSbFrmMoveHThumbTo ); |
|
371 |
|
372 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
373 CleanupStack::PushL( control ); |
|
374 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
375 CleanupStack::PushL( sbFrame ); |
|
376 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
377 |
|
378 TInt hThumbPos = 0; |
|
379 sbFrame->MoveHorizThumbTo( hThumbPos ); |
|
380 |
|
381 CleanupStack::PopAndDestroy( sbFrame ); |
|
382 CleanupStack::PopAndDestroy( control ); |
|
383 return KErrNone; |
|
384 |
|
385 } |
|
386 |
|
387 // ----------------------------------------------------------------------------- |
|
388 // CTestSDKScroller::TestSDKSbFrmMoveVThumbToL |
|
389 // ----------------------------------------------------------------------------- |
|
390 // |
|
391 TInt CTestSDKScroller::TestSDKSbFrmMoveVThumbToL( CStifItemParser& /*aItem*/ ) |
|
392 { |
|
393 |
|
394 // Print to UI |
|
395 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
396 _LIT( KTestSDKSbFrmMoveVThumbTo, "in SbFrmMoveVThumbTo" ); |
|
397 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmMoveVThumbTo ); |
|
398 // Print to log file |
|
399 iLog->Log( KTestSDKSbFrmMoveVThumbTo ); |
|
400 |
|
401 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
402 CleanupStack::PushL( control ); |
|
403 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
404 CleanupStack::PushL( sbFrame ); |
|
405 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
406 |
|
407 TInt vThumbPos = 0; |
|
408 sbFrame->MoveVertThumbTo( vThumbPos ); |
|
409 |
|
410 CleanupStack::PopAndDestroy( sbFrame ); |
|
411 CleanupStack::PopAndDestroy( control ); |
|
412 return KErrNone; |
|
413 |
|
414 } |
|
415 |
|
416 // ----------------------------------------------------------------------------- |
|
417 // CTestSDKScroller::TestSDKSbFrmSetVFocusPosToThumbPosL |
|
418 // ----------------------------------------------------------------------------- |
|
419 // |
|
420 TInt CTestSDKScroller::TestSDKSbFrmSetVFocusPosToThumbPosL( CStifItemParser& /*aItem*/ ) |
|
421 { |
|
422 |
|
423 // Print to UI |
|
424 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
425 _LIT( KTestSDKSbFrmSetVFocusPosToThumbPos, "in SbFrmSetVFocusPosToThumbPos" ); |
|
426 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetVFocusPosToThumbPos ); |
|
427 // Print to log file |
|
428 iLog->Log( KTestSDKSbFrmSetVFocusPosToThumbPos ); |
|
429 |
|
430 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
431 CleanupStack::PushL( control ); |
|
432 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
433 CleanupStack::PushL( sbFrame ); |
|
434 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
435 |
|
436 TInt focusPos = 0; |
|
437 sbFrame->SetVFocusPosToThumbPos( focusPos ); |
|
438 |
|
439 CleanupStack::PopAndDestroy( sbFrame ); |
|
440 CleanupStack::PopAndDestroy( control ); |
|
441 return KErrNone; |
|
442 |
|
443 } |
|
444 |
|
445 // ----------------------------------------------------------------------------- |
|
446 // CTestSDKScroller::TestSDKSbFrmSbBreadthL |
|
447 // ----------------------------------------------------------------------------- |
|
448 // |
|
449 TInt CTestSDKScroller::TestSDKSbFrmSbBreadthL( CStifItemParser& /*aItem*/ ) |
|
450 { |
|
451 |
|
452 // Print to UI |
|
453 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
454 _LIT( KTestSDKSbFrmSbBreadth, "in SbFrmSbBreadth" ); |
|
455 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSbBreadth ); |
|
456 // Print to log file |
|
457 iLog->Log( KTestSDKSbFrmSbBreadth ); |
|
458 |
|
459 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
460 CleanupStack::PushL( control ); |
|
461 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
462 CleanupStack::PushL( sbFrame ); |
|
463 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
464 |
|
465 CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal; |
|
466 TInt hOrientation = sbFrame->ScrollBarBreadth( orientation ); |
|
467 STIF_ASSERT_EQUALS( 0, hOrientation ); |
|
468 |
|
469 CleanupStack::PopAndDestroy( sbFrame ); |
|
470 CleanupStack::PopAndDestroy( control ); |
|
471 return KErrNone; |
|
472 |
|
473 } |
|
474 |
|
475 // ----------------------------------------------------------------------------- |
|
476 // CTestSDKScroller::TestSDKSbFrmSetAdjustsHModelL |
|
477 // ----------------------------------------------------------------------------- |
|
478 // |
|
479 TInt CTestSDKScroller::TestSDKSbFrmSetAdjustsHModelL( CStifItemParser& /*aItem*/ ) |
|
480 { |
|
481 |
|
482 // Print to UI |
|
483 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
484 _LIT( KTestSDKSbFrmSetAdjustsHModel, "in SbFrmSetAdjustsHModel" ); |
|
485 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetAdjustsHModel ); |
|
486 // Print to log file |
|
487 iLog->Log( KTestSDKSbFrmSetAdjustsHModel ); |
|
488 |
|
489 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
490 CleanupStack::PushL( control ); |
|
491 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
492 CleanupStack::PushL( sbFrame ); |
|
493 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
494 |
|
495 sbFrame->SetAdjustsHorizontalModel( ETrue ); |
|
496 |
|
497 CleanupStack::PopAndDestroy( sbFrame ); |
|
498 CleanupStack::PopAndDestroy( control ); |
|
499 return KErrNone; |
|
500 |
|
501 } |
|
502 |
|
503 // ----------------------------------------------------------------------------- |
|
504 // CTestSDKScroller::TestSDKSbFrmSetAdjustsVModelL |
|
505 // ----------------------------------------------------------------------------- |
|
506 // |
|
507 TInt CTestSDKScroller::TestSDKSbFrmSetAdjustsVModelL( CStifItemParser& /*aItem*/ ) |
|
508 { |
|
509 |
|
510 // Print to UI |
|
511 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
512 _LIT( KTestSDKSbFrmSetAdjustsVModel, "in SbFrmSetAdjustsVModel" ); |
|
513 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetAdjustsVModel ); |
|
514 // Print to log file |
|
515 iLog->Log( KTestSDKSbFrmSetAdjustsVModel ); |
|
516 |
|
517 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
518 CleanupStack::PushL( control ); |
|
519 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
520 CleanupStack::PushL( sbFrame ); |
|
521 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
522 |
|
523 sbFrame->SetAdjustsVerticalModel( ETrue ); |
|
524 |
|
525 CleanupStack::PopAndDestroy( sbFrame ); |
|
526 CleanupStack::PopAndDestroy( control ); |
|
527 return KErrNone; |
|
528 |
|
529 } |
|
530 |
|
531 // ----------------------------------------------------------------------------- |
|
532 // CTestSDKScroller::TestSDKSbFrmSetSbfrmFlagsL |
|
533 // ----------------------------------------------------------------------------- |
|
534 // |
|
535 TInt CTestSDKScroller::TestSDKSbFrmSetSbfrmFlagsL( CStifItemParser& /*aItem*/ ) |
|
536 { |
|
537 |
|
538 // Print to UI |
|
539 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
540 _LIT( KTestSDKSbFrmSetSbfrmFlags, "in SbFrmSetSbfrmFlags" ); |
|
541 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetSbfrmFlags ); |
|
542 // Print to log file |
|
543 iLog->Log( KTestSDKSbFrmSetSbfrmFlags ); |
|
544 |
|
545 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
546 CleanupStack::PushL( control ); |
|
547 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
548 CleanupStack::PushL( sbFrame ); |
|
549 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
550 |
|
551 TInt mask = 0; |
|
552 sbFrame->SetScrollBarFrameFlags( mask ); |
|
553 |
|
554 CleanupStack::PopAndDestroy( sbFrame ); |
|
555 CleanupStack::PopAndDestroy( control ); |
|
556 return KErrNone; |
|
557 |
|
558 } |
|
559 |
|
560 // ----------------------------------------------------------------------------- |
|
561 // CTestSDKScroller::TestSDKSbFrmSbExistsL |
|
562 // ----------------------------------------------------------------------------- |
|
563 // |
|
564 TInt CTestSDKScroller::TestSDKSbFrmSbExistsL( CStifItemParser& /*aItem*/ ) |
|
565 { |
|
566 |
|
567 // Print to UI |
|
568 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
569 _LIT( KTestSDKSbFrmSbExists, "in SbFrmSbExists" ); |
|
570 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSbExists ); |
|
571 // Print to log file |
|
572 iLog->Log( KTestSDKSbFrmSbExists ); |
|
573 |
|
574 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
575 CleanupStack::PushL( control ); |
|
576 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
577 CleanupStack::PushL( sbFrame ); |
|
578 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
579 |
|
580 CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal; |
|
581 TBool exist = sbFrame->ScrollBarExists( orientation ); |
|
582 STIF_ASSERT_FALSE( exist ); |
|
583 |
|
584 CleanupStack::PopAndDestroy( sbFrame ); |
|
585 CleanupStack::PopAndDestroy( control ); |
|
586 return KErrNone; |
|
587 |
|
588 } |
|
589 |
|
590 // ----------------------------------------------------------------------------- |
|
591 // CTestSDKScroller::TestSDKSbFrmCountComCtrlsL |
|
592 // ----------------------------------------------------------------------------- |
|
593 // |
|
594 TInt CTestSDKScroller::TestSDKSbFrmCountComCtrlsL( CStifItemParser& /*aItem*/ ) |
|
595 { |
|
596 |
|
597 // Print to UI |
|
598 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
599 _LIT( KTestSDKSbFrmCountComCtrls, "in SbFrmCountComCtrls" ); |
|
600 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmCountComCtrls ); |
|
601 // Print to log file |
|
602 iLog->Log( KTestSDKSbFrmCountComCtrls ); |
|
603 |
|
604 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
605 CleanupStack::PushL( control ); |
|
606 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
607 CleanupStack::PushL( sbFrame ); |
|
608 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
609 |
|
610 TInt count = sbFrame->CountComponentControls(); |
|
611 STIF_ASSERT_EQUALS( 2, count ); |
|
612 |
|
613 CleanupStack::PopAndDestroy( sbFrame ); |
|
614 CleanupStack::PopAndDestroy( control ); |
|
615 return KErrNone; |
|
616 |
|
617 } |
|
618 |
|
619 // ----------------------------------------------------------------------------- |
|
620 // CTestSDKScroller::TestSDKSbFrmComponentControlL |
|
621 // ----------------------------------------------------------------------------- |
|
622 // |
|
623 TInt CTestSDKScroller::TestSDKSbFrmComponentControlL( CStifItemParser& /*aItem*/ ) |
|
624 { |
|
625 |
|
626 // Print to UI |
|
627 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
628 _LIT( KTestSDKSbFrmComponentControl, "in SbFrmComponentControl" ); |
|
629 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmComponentControl ); |
|
630 // Print to log file |
|
631 iLog->Log( KTestSDKSbFrmComponentControl ); |
|
632 |
|
633 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
634 CleanupStack::PushL( control ); |
|
635 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
636 CleanupStack::PushL( sbFrame ); |
|
637 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
638 |
|
639 TInt index = 0; |
|
640 CCoeControl* sbFrameControl = sbFrame->ComponentControl( index ); |
|
641 STIF_ASSERT_NOT_NULL( sbFrameControl ); |
|
642 |
|
643 CleanupStack::PopAndDestroy( sbFrame ); |
|
644 CleanupStack::PopAndDestroy( control ); |
|
645 return KErrNone; |
|
646 |
|
647 } |
|
648 |
|
649 // ----------------------------------------------------------------------------- |
|
650 // CTestSDKScroller::TestSDKSbFrmGetSbHandleL |
|
651 // ----------------------------------------------------------------------------- |
|
652 // |
|
653 TInt CTestSDKScroller::TestSDKSbFrmGetSbHandleL( CStifItemParser& /*aItem*/ ) |
|
654 { |
|
655 |
|
656 // Print to UI |
|
657 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
658 _LIT( KTestSDKSbFrmGetSbHandle, "in SbFrmGetSbHandle" ); |
|
659 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmGetSbHandle ); |
|
660 // Print to log file |
|
661 iLog->Log( KTestSDKSbFrmGetSbHandle ); |
|
662 |
|
663 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
664 CleanupStack::PushL( control ); |
|
665 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
666 CleanupStack::PushL( sbFrame ); |
|
667 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
668 |
|
669 CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal; |
|
670 CEikScrollBar* sbHandle = sbFrame->GetScrollBarHandle( orientation ); |
|
671 STIF_ASSERT_NULL( sbHandle ); |
|
672 |
|
673 CleanupStack::PopAndDestroy( sbFrame ); |
|
674 CleanupStack::PopAndDestroy( control ); |
|
675 return KErrNone; |
|
676 |
|
677 } |
|
678 |
|
679 // ----------------------------------------------------------------------------- |
|
680 // CTestSDKScroller::TestSDKSbFrmVScrollBarL |
|
681 // ----------------------------------------------------------------------------- |
|
682 // |
|
683 TInt CTestSDKScroller::TestSDKSbFrmVScrollBarL( CStifItemParser& /*aItem*/ ) |
|
684 { |
|
685 |
|
686 // Print to UI |
|
687 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
688 _LIT( KTestSDKSbFrmVScrollBar, "in SbFrmVScrollBar" ); |
|
689 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmVScrollBar ); |
|
690 // Print to log file |
|
691 iLog->Log( KTestSDKSbFrmVScrollBar ); |
|
692 |
|
693 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
694 CleanupStack::PushL( control ); |
|
695 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
696 CleanupStack::PushL( sbFrame ); |
|
697 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
698 |
|
699 CEikScrollBar* vScrollBar = sbFrame->VerticalScrollBar(); |
|
700 STIF_ASSERT_NOT_NULL( vScrollBar ); |
|
701 |
|
702 CleanupStack::PopAndDestroy( sbFrame ); |
|
703 CleanupStack::PopAndDestroy( control ); |
|
704 return KErrNone; |
|
705 |
|
706 } |
|
707 |
|
708 // ----------------------------------------------------------------------------- |
|
709 // CTestSDKScroller::TestSDKSbFrmSetTypeOfHSbL |
|
710 // ----------------------------------------------------------------------------- |
|
711 // |
|
712 TInt CTestSDKScroller::TestSDKSbFrmSetTypeOfHSbL( CStifItemParser& /*aItem*/ ) |
|
713 { |
|
714 |
|
715 // Print to UI |
|
716 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
717 _LIT( KTestSDKSbFrmSetTypeOfHSb, "in SbFrmSetTypeOfHSb" ); |
|
718 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetTypeOfHSb ); |
|
719 // Print to log file |
|
720 iLog->Log( KTestSDKSbFrmSetTypeOfHSb ); |
|
721 |
|
722 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
723 CleanupStack::PushL( control ); |
|
724 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
725 CleanupStack::PushL( sbFrame ); |
|
726 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
727 |
|
728 CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EArrowHead; |
|
729 sbFrame->SetTypeOfHScrollBar( sbType ); |
|
730 |
|
731 CleanupStack::PopAndDestroy( sbFrame ); |
|
732 CleanupStack::PopAndDestroy( control ); |
|
733 return KErrNone; |
|
734 |
|
735 } |
|
736 |
|
737 // ----------------------------------------------------------------------------- |
|
738 // CTestSDKScroller::TestSDKSbFrmSetTypeOfVSbL |
|
739 // ----------------------------------------------------------------------------- |
|
740 // |
|
741 TInt CTestSDKScroller::TestSDKSbFrmSetTypeOfVSbL( CStifItemParser& /*aItem*/ ) |
|
742 { |
|
743 |
|
744 // Print to UI |
|
745 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
746 _LIT( KTestSDKSbFrmSetTypeOfVSb, "in SbFrmSetTypeOfVSb" ); |
|
747 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSetTypeOfVSb ); |
|
748 // Print to log file |
|
749 iLog->Log( KTestSDKSbFrmSetTypeOfVSb ); |
|
750 |
|
751 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
752 CleanupStack::PushL( control ); |
|
753 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
754 CleanupStack::PushL( sbFrame ); |
|
755 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
756 |
|
757 CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EArrowHead; |
|
758 sbFrame->SetTypeOfVScrollBar( sbType ); |
|
759 |
|
760 CleanupStack::PopAndDestroy( sbFrame ); |
|
761 CleanupStack::PopAndDestroy( control ); |
|
762 return KErrNone; |
|
763 |
|
764 } |
|
765 |
|
766 // ----------------------------------------------------------------------------- |
|
767 // CTestSDKScroller::TestSDKSbFrmTypeOfHSbL |
|
768 // ----------------------------------------------------------------------------- |
|
769 // |
|
770 TInt CTestSDKScroller::TestSDKSbFrmTypeOfHSbL( CStifItemParser& /*aItem*/ ) |
|
771 { |
|
772 |
|
773 // Print to UI |
|
774 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
775 _LIT( KTestSDKSbFrmTypeOfHSb, "in SbFrmTypeOfHSb" ); |
|
776 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTypeOfHSb ); |
|
777 // Print to log file |
|
778 iLog->Log( KTestSDKSbFrmTypeOfHSb ); |
|
779 |
|
780 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
781 CleanupStack::PushL( control ); |
|
782 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
783 CleanupStack::PushL( sbFrame ); |
|
784 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
785 |
|
786 CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EDoubleSpan; |
|
787 CEikScrollBarFrame::TScrollBarType type = sbFrame->TypeOfHScrollBar(); |
|
788 STIF_ASSERT_EQUALS( sbType, type ); |
|
789 |
|
790 CleanupStack::PopAndDestroy( sbFrame ); |
|
791 CleanupStack::PopAndDestroy( control ); |
|
792 return KErrNone; |
|
793 |
|
794 } |
|
795 |
|
796 // ----------------------------------------------------------------------------- |
|
797 // CTestSDKScroller::TestSDKSbFrmTypeOfVSbL |
|
798 // ----------------------------------------------------------------------------- |
|
799 // |
|
800 TInt CTestSDKScroller::TestSDKSbFrmTypeOfVSbL( CStifItemParser& /*aItem*/ ) |
|
801 { |
|
802 |
|
803 // Print to UI |
|
804 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
805 _LIT( KTestSDKSbFrmTypeOfVSb, "in SbFrmTypeOfVSb" ); |
|
806 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTypeOfVSb ); |
|
807 // Print to log file |
|
808 iLog->Log( KTestSDKSbFrmTypeOfVSb ); |
|
809 |
|
810 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
811 CleanupStack::PushL( control ); |
|
812 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
813 CleanupStack::PushL( sbFrame ); |
|
814 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
815 |
|
816 CEikScrollBarFrame::TScrollBarType sbType = CEikScrollBarFrame::EDoubleSpan; |
|
817 CEikScrollBarFrame::TScrollBarType type = sbFrame->TypeOfVScrollBar(); |
|
818 STIF_ASSERT_EQUALS( sbType, type ); |
|
819 |
|
820 CleanupStack::PopAndDestroy( sbFrame ); |
|
821 CleanupStack::PopAndDestroy( control ); |
|
822 return KErrNone; |
|
823 |
|
824 } |
|
825 |
|
826 // ----------------------------------------------------------------------------- |
|
827 // CTestSDKScroller::TestSDKSbFrmIsArrowHeadSbL |
|
828 // ----------------------------------------------------------------------------- |
|
829 // |
|
830 TInt CTestSDKScroller::TestSDKSbFrmIsArrowHeadSbL( CStifItemParser& /*aItem*/ ) |
|
831 { |
|
832 |
|
833 // Print to UI |
|
834 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
835 _LIT( KTestSDKSbFrmIsArrowHeadSb, "in SbFrmIsArrowHeadSb" ); |
|
836 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmIsArrowHeadSb ); |
|
837 // Print to log file |
|
838 iLog->Log( KTestSDKSbFrmIsArrowHeadSb ); |
|
839 |
|
840 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
841 CleanupStack::PushL( control ); |
|
842 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
843 CleanupStack::PushL( sbFrame ); |
|
844 |
|
845 TInt flags = 0; |
|
846 TBool isArrowHead = sbFrame->IsArrowHeadScrollBar( flags ); |
|
847 STIF_ASSERT_TRUE( isArrowHead ); |
|
848 |
|
849 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
850 isArrowHead = sbFrame->IsArrowHeadScrollBar( flags ); |
|
851 STIF_ASSERT_FALSE( isArrowHead ); |
|
852 |
|
853 CleanupStack::PopAndDestroy( sbFrame ); |
|
854 CleanupStack::PopAndDestroy( control ); |
|
855 return KErrNone; |
|
856 |
|
857 } |
|
858 |
|
859 // ----------------------------------------------------------------------------- |
|
860 // CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsL |
|
861 // ----------------------------------------------------------------------------- |
|
862 // |
|
863 TInt CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsL( CStifItemParser& /*aItem*/ ) |
|
864 { |
|
865 |
|
866 // Print to UI |
|
867 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
868 _LIT( KTestSDKSbFrmCreDoubleSpanSbsL, "in SbFrmIsArrowHeadSb" ); |
|
869 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmCreDoubleSpanSbsL ); |
|
870 // Print to log file |
|
871 iLog->Log( KTestSDKSbFrmCreDoubleSpanSbsL ); |
|
872 |
|
873 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
874 CleanupStack::PushL( control ); |
|
875 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
876 CleanupStack::PushL( sbFrame ); |
|
877 |
|
878 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
879 |
|
880 CleanupStack::PopAndDestroy( sbFrame ); |
|
881 CleanupStack::PopAndDestroy( control ); |
|
882 return KErrNone; |
|
883 |
|
884 } |
|
885 |
|
886 // ----------------------------------------------------------------------------- |
|
887 // CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsWithSbPaL |
|
888 // ----------------------------------------------------------------------------- |
|
889 // |
|
890 TInt CTestSDKScroller::TestSDKSbFrmCreDoubleSpanSbsWithSbPaL( CStifItemParser& /*aItem*/ ) |
|
891 { |
|
892 |
|
893 // Print to UI |
|
894 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
895 _LIT( KTestSDKSbFrmCreDoubleSpanSbsWithSbPaL, "in SbFrmIsArrowHeadSb" ); |
|
896 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmCreDoubleSpanSbsWithSbPaL ); |
|
897 // Print to log file |
|
898 iLog->Log( KTestSDKSbFrmCreDoubleSpanSbsWithSbPaL ); |
|
899 |
|
900 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
901 CleanupStack::PushL( control ); |
|
902 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
903 CleanupStack::PushL( sbFrame ); |
|
904 |
|
905 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse, ETrue, ETrue ); |
|
906 |
|
907 CleanupStack::PopAndDestroy( sbFrame ); |
|
908 CleanupStack::PopAndDestroy( control ); |
|
909 return KErrNone; |
|
910 |
|
911 } |
|
912 |
|
913 // ----------------------------------------------------------------------------- |
|
914 // CTestSDKScroller::TestSDKSbFrmTileWithRectL |
|
915 // ----------------------------------------------------------------------------- |
|
916 // |
|
917 TInt CTestSDKScroller::TestSDKSbFrmTileWithRectL( CStifItemParser& /*aItem*/ ) |
|
918 { |
|
919 |
|
920 // Print to UI |
|
921 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
922 _LIT( KTestSDKSbFrmTileWithRect, "in SbFrmTileWithRect" ); |
|
923 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTileWithRect ); |
|
924 // Print to log file |
|
925 iLog->Log( KTestSDKSbFrmTileWithRect ); |
|
926 |
|
927 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
928 CleanupStack::PushL( control ); |
|
929 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
930 CleanupStack::PushL( sbFrame ); |
|
931 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
932 |
|
933 TEikScrollBarModel* hModel = new ( ELeave ) TEikScrollBarModel; |
|
934 CleanupStack::PushL( hModel ); |
|
935 TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel; |
|
936 CleanupStack::PushL( vModel ); |
|
937 sbFrame->Tile( hModel, vModel ); |
|
938 |
|
939 CleanupStack::PopAndDestroy( vModel ); |
|
940 CleanupStack::PopAndDestroy( hModel ); |
|
941 CleanupStack::PopAndDestroy( sbFrame ); |
|
942 CleanupStack::PopAndDestroy( control ); |
|
943 return KErrNone; |
|
944 |
|
945 } |
|
946 |
|
947 // ----------------------------------------------------------------------------- |
|
948 // CTestSDKScroller::TestSDKSbFrmTileWithSbModelL |
|
949 // ----------------------------------------------------------------------------- |
|
950 // |
|
951 TInt CTestSDKScroller::TestSDKSbFrmTileWithSbModelL( CStifItemParser& /*aItem*/ ) |
|
952 { |
|
953 |
|
954 // Print to UI |
|
955 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
956 _LIT( KTestSDKSbFrmTileWithSbModel, "in SbFrmTileWithSbModel" ); |
|
957 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmTileWithSbModel ); |
|
958 // Print to log file |
|
959 iLog->Log( KTestSDKSbFrmTileWithSbModel ); |
|
960 |
|
961 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
962 CleanupStack::PushL( control ); |
|
963 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
964 CleanupStack::PushL( sbFrame ); |
|
965 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
966 |
|
967 TEikScrollBarModel* vModel = new ( ELeave ) TEikScrollBarModel; |
|
968 CleanupStack::PushL( vModel ); |
|
969 TSize size( KWidth, KHeight ); |
|
970 TRect vScrollBar( size ); |
|
971 sbFrame->Tile( vModel, vScrollBar ); |
|
972 |
|
973 CleanupStack::PopAndDestroy( vModel ); |
|
974 CleanupStack::PopAndDestroy( sbFrame ); |
|
975 CleanupStack::PopAndDestroy( control ); |
|
976 return KErrNone; |
|
977 |
|
978 } |
|
979 |
|
980 // ----------------------------------------------------------------------------- |
|
981 // CTestSDKScroller::TestSDKSbFrmSbVisibilityL |
|
982 // ----------------------------------------------------------------------------- |
|
983 // |
|
984 TInt CTestSDKScroller::TestSDKSbFrmSbVisibilityL( CStifItemParser& /*aItem*/ ) |
|
985 { |
|
986 |
|
987 // Print to UI |
|
988 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
989 _LIT( KTestSDKSbFrmSbVisibility, "in SbFrmSbVisibility" ); |
|
990 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmSbVisibility ); |
|
991 // Print to log file |
|
992 iLog->Log( KTestSDKSbFrmSbVisibility ); |
|
993 |
|
994 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
995 CleanupStack::PushL( control ); |
|
996 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
997 CleanupStack::PushL( sbFrame ); |
|
998 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
999 |
|
1000 CEikScrollBar::TOrientation orientation = CEikScrollBar::EHorizontal; |
|
1001 CEikScrollBarFrame::TScrollBarVisibility sbVisibility = sbFrame->ScrollBarVisibility( orientation ); |
|
1002 STIF_ASSERT_EQUALS( CEikScrollBarFrame::EOff, sbVisibility ); |
|
1003 |
|
1004 CleanupStack::PopAndDestroy( sbFrame ); |
|
1005 CleanupStack::PopAndDestroy( control ); |
|
1006 return KErrNone; |
|
1007 |
|
1008 } |
|
1009 |
|
1010 // ----------------------------------------------------------------------------- |
|
1011 // CTestSDKScroller::TestSDKSbFrmDrawBgL |
|
1012 // ----------------------------------------------------------------------------- |
|
1013 // |
|
1014 TInt CTestSDKScroller::TestSDKSbFrmDrawBgL( CStifItemParser& /*aItem*/ ) |
|
1015 { |
|
1016 |
|
1017 // Print to UI |
|
1018 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
1019 _LIT( KTestSDKSbFrmDrawBg, "in SbFrmDrawBg" ); |
|
1020 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDrawBg ); |
|
1021 // Print to log file |
|
1022 iLog->Log( KTestSDKSbFrmDrawBg ); |
|
1023 |
|
1024 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
1025 CleanupStack::PushL( control ); |
|
1026 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
1027 CleanupStack::PushL( sbFrame ); |
|
1028 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
1029 |
|
1030 TInt err = sbFrame->DrawBackground( ETrue, ETrue ); |
|
1031 |
|
1032 CleanupStack::PopAndDestroy( sbFrame ); |
|
1033 CleanupStack::PopAndDestroy( control ); |
|
1034 return err; |
|
1035 |
|
1036 } |
|
1037 |
|
1038 // ----------------------------------------------------------------------------- |
|
1039 // CTestSDKScroller::TestSDKSbFrmDrawBgStateL |
|
1040 // ----------------------------------------------------------------------------- |
|
1041 // |
|
1042 TInt CTestSDKScroller::TestSDKSbFrmDrawBgStateL( CStifItemParser& /*aItem*/ ) |
|
1043 { |
|
1044 |
|
1045 // Print to UI |
|
1046 _LIT( KTestSDKScroller, "testsdkscroller" ); |
|
1047 _LIT( KTestSDKSbFrmDrawBgState, "in SbFrmDrawBgState" ); |
|
1048 TestModuleIf().Printf( 0, KTestSDKScroller, KTestSDKSbFrmDrawBgState ); |
|
1049 // Print to log file |
|
1050 iLog->Log( KTestSDKSbFrmDrawBgState ); |
|
1051 |
|
1052 CTestScrollerControl* control = CTestScrollerControl::NewL(); |
|
1053 CleanupStack::PushL( control ); |
|
1054 CEikScrollBarFrame* sbFrame = new ( ELeave ) CEikScrollBarFrame( control, control ); |
|
1055 CleanupStack::PushL( sbFrame ); |
|
1056 sbFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); |
|
1057 |
|
1058 TBool drawHorizontal = ETrue; |
|
1059 TBool drawVertical = ETrue; |
|
1060 TInt err = sbFrame->DrawBackgroundState( drawHorizontal, drawVertical ); |
|
1061 |
|
1062 CleanupStack::PopAndDestroy( sbFrame ); |
|
1063 CleanupStack::PopAndDestroy( control ); |
|
1064 return err; |
|
1065 |
|
1066 } |
|
1067 |
|
1068 |