1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Test capture key |
|
15 // |
|
16 // |
|
17 |
|
18 #include <e32std.h> |
|
19 #include <e32svr.h> |
|
20 #include "W32STD.H" |
|
21 #include "../tlib/testbase.h" |
|
22 #include "TMAN.H" |
|
23 |
|
24 enum THotKeyRetValues |
|
25 { |
|
26 EHotKeyOkay, |
|
27 EHotKeyRetry, |
|
28 EHotKeyFail, |
|
29 }; |
|
30 |
|
31 struct SHotKeyParams |
|
32 { |
|
33 THotKey hotKey; |
|
34 TUint keyCode; |
|
35 TUint mod_mask; |
|
36 TUint modifiers; |
|
37 }; |
|
38 |
|
39 struct SHotKeyTestParams |
|
40 { |
|
41 TText *txt; // Text message telling user what to do |
|
42 }; |
|
43 |
|
44 LOCAL_D SHotKeyParams HotKeys[]={ |
|
45 {EHotKeyEnableLogging,'e',EModifierFunc|EModifierCtrl|EModifierShift,0}, |
|
46 {EHotKeyDisableLogging,'d',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc}, |
|
47 {EHotKeyOfDeath,'q',0}, |
|
48 {EHotKeyOfDeath,'w',0}, |
|
49 }; |
|
50 |
|
51 LOCAL_D SHotKeyTestParams HotKeyTests[]={ |
|
52 {(TText *)_S("Use \"e\" to enable logging")}, |
|
53 {(TText *)_S("Use \"<Alt>d\" to disable logging")}, |
|
54 {(TText *)_S("Use \"q\" to kill the foreground app")}, |
|
55 {(TText *)_S("Use \"w\" to kill the foreground app")}, |
|
56 {(TText *)_S("Use \"<Cntrl><Alt><Shift>K\" to kill the foreground app")}, |
|
57 }; |
|
58 |
|
59 LOCAL_D TBool HotKeyTestIsDeathTest[]={EFalse, EFalse, ETrue, ETrue, ETrue}; |
|
60 |
|
61 struct SErrorHotKey |
|
62 { |
|
63 THotKey hotKey; |
|
64 TUint keyCode; |
|
65 TUint mod_mask; |
|
66 TUint modifiers; |
|
67 }; |
|
68 |
|
69 LOCAL_D SErrorHotKey errorKeys[]={ |
|
70 {EHotKeyEnableLogging,'a',EModifierFunc|EModifierShift,EModifierFunc|EModifierCtrl}, |
|
71 {EHotKeyDisableLogging,'1',0,EModifierFunc}, |
|
72 {EHotKeyEnableLogging,3,EModifierCtrl,EModifierCtrl|EModifierShift}, |
|
73 {EHotKeyDisableLogging,'a',EModifierFunc|EModifierShift,EModifierFunc|EModifierCtrl}, |
|
74 {(THotKey)100,'1',0,EModifierFunc}, |
|
75 {(THotKey)200, 3,EModifierCtrl,EModifierCtrl|EModifierShift}, |
|
76 }; |
|
77 |
|
78 const TInt numHotKeys=sizeof(HotKeys)/sizeof(HotKeys[0]); |
|
79 const TInt numHotKeyTests=sizeof(HotKeyTests)/sizeof(HotKeyTests[0]); |
|
80 const TInt numErrorKeys=sizeof(errorKeys)/sizeof(errorKeys[0]); |
|
81 |
|
82 class SHKWindow; |
|
83 class THotKeyTest; |
|
84 class SHKConnection; |
|
85 |
|
86 class SHKDeath : public CActive |
|
87 { |
|
88 public: |
|
89 SHKDeath(TInt aPriority); |
|
90 void SetConnection(SHKConnection *aConn); |
|
91 virtual void DoCancel(); |
|
92 virtual void RunL(); |
|
93 void Request(); |
|
94 private: |
|
95 SHKConnection *iConn; |
|
96 }; |
|
97 |
|
98 class SHKWindowGroup : public CTWindowGroup |
|
99 { |
|
100 public: |
|
101 SHKWindowGroup(CTClient *aClient); |
|
102 void KeyL(const TKeyEvent &aKey,const TTime &aTime); |
|
103 }; |
|
104 |
|
105 class SHKConnection : public CTClient |
|
106 { |
|
107 public: |
|
108 SHKConnection(THotKeyTest *aTest, TInt aMode); |
|
109 ~SHKConnection(); |
|
110 void ConstructL(); |
|
111 void KeyL(const TKeyEvent &aKey); |
|
112 void SubStateChangedL(); |
|
113 void CompleteL(); |
|
114 protected: |
|
115 TInt iMode; |
|
116 SHKDeath iDeath; |
|
117 THotKeyTest *iTest; |
|
118 CTWin *iWin; |
|
119 static TInt iMainWinId; |
|
120 }; |
|
121 |
|
122 class SHKWindow : public CTWin |
|
123 { |
|
124 public: |
|
125 SHKWindow(THotKeyTest *aTest); |
|
126 void SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc); |
|
127 void Draw(); |
|
128 protected: |
|
129 THotKeyTest *iTest; |
|
130 TRgb iBack; |
|
131 }; |
|
132 |
|
133 class SHKWindow2 : public CTWin |
|
134 { |
|
135 public: |
|
136 SHKWindow2(); |
|
137 void SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc); |
|
138 void Draw(); |
|
139 }; |
|
140 |
|
141 class THotKeyTest : public CTestBase |
|
142 { |
|
143 public: |
|
144 THotKeyTest(); |
|
145 ~THotKeyTest(); |
|
146 TestState DoTestL(); |
|
147 void ConstructL(); |
|
148 void EndCaptureKeyTest(); |
|
149 TInt SubState() const; |
|
150 void IncSubStateL(); |
|
151 void BadParamsL(); |
|
152 private: |
|
153 SHKConnection *iConn1; |
|
154 TSize iWinSize; |
|
155 TInt iState; |
|
156 TInt iSubState; |
|
157 TBool iIsInActiveScheduler; |
|
158 }; |
|
159 |
|
160 TInt SHKConnection::iMainWinId; |
|
161 |
|
162 TInt SubThread(TAny *); |
|
163 |
|
164 GLDEF_C CTestBase *CreateHotKeyTest() |
|
165 { |
|
166 return(new(ELeave) THotKeyTest()); |
|
167 } |
|
168 |
|
169 THotKeyTest::THotKeyTest() : CTestBase(_L("Hot Key")) |
|
170 {} |
|
171 |
|
172 THotKeyTest::~THotKeyTest() |
|
173 { |
|
174 User::SetJustInTime(ETrue); |
|
175 for(TInt index=0;index<numHotKeys;index++) |
|
176 { |
|
177 Client()->iWs.ClearHotKeys(HotKeys[index].hotKey); |
|
178 Client()->iWs.RestoreDefaultHotKey(HotKeys[index].hotKey); |
|
179 } |
|
180 delete iConn1; |
|
181 if (iIsInActiveScheduler) |
|
182 CActiveScheduler::Stop(); |
|
183 } |
|
184 |
|
185 void THotKeyTest::EndCaptureKeyTest() |
|
186 { |
|
187 Request(); |
|
188 } |
|
189 |
|
190 void THotKeyTest::ConstructL() |
|
191 { |
|
192 iConn1=new(ELeave) SHKConnection(this, EFalse); |
|
193 iConn1->ConstructL(); |
|
194 for(TInt index=0;index<numHotKeys;index++) |
|
195 User::LeaveIfError(Client()->iWs.SetHotKey(HotKeys[index].hotKey, HotKeys[index].keyCode,HotKeys[index].mod_mask,HotKeys[index].modifiers)); |
|
196 User::SetJustInTime(EFalse); |
|
197 } |
|
198 |
|
199 // |
|
200 // SHKDeath // |
|
201 // |
|
202 |
|
203 SHKDeath::SHKDeath(TInt aPriority) : CActive(aPriority) |
|
204 { |
|
205 CActiveScheduler::Add(this); |
|
206 } |
|
207 |
|
208 void SHKDeath::SetConnection(SHKConnection *aConn) |
|
209 { |
|
210 iConn=aConn; |
|
211 } |
|
212 |
|
213 void SHKDeath::DoCancel() |
|
214 { |
|
215 } |
|
216 |
|
217 void SHKDeath::RunL() |
|
218 { |
|
219 iConn->CompleteL(); |
|
220 } |
|
221 |
|
222 void SHKDeath::Request() |
|
223 { |
|
224 SetActive(); |
|
225 } |
|
226 |
|
227 // |
|
228 |
|
229 SHKWindowGroup::SHKWindowGroup(CTClient *aClient) : CTWindowGroup(aClient) |
|
230 {} |
|
231 |
|
232 void SHKWindowGroup::KeyL(const TKeyEvent &aKey,const TTime &) |
|
233 { |
|
234 ((SHKConnection *)iClient)->KeyL(aKey); |
|
235 } |
|
236 |
|
237 // |
|
238 // SHKConnection |
|
239 |
|
240 SHKConnection::SHKConnection(THotKeyTest *aTest, TInt aMode) : iMode(aMode), iDeath(100), iTest(aTest) |
|
241 { |
|
242 iDeath.SetConnection(this); |
|
243 } |
|
244 |
|
245 SHKConnection::~SHKConnection() |
|
246 { |
|
247 iGroup->GroupWin()->EnableReceiptOfFocus(EFalse); |
|
248 CTWin::Delete(iWin); |
|
249 } |
|
250 |
|
251 void SHKConnection::KeyL(const TKeyEvent &aKey) |
|
252 { |
|
253 if (iTest) |
|
254 { |
|
255 if (aKey.iCode==EKeyEnter && !HotKeyTestIsDeathTest[iTest->SubState()]) |
|
256 iTest->IncSubStateL(); |
|
257 else if (aKey.iCode==EKeyEscape) |
|
258 iTest->AbortL(); |
|
259 } |
|
260 } |
|
261 |
|
262 void SHKConnection::CompleteL() |
|
263 { |
|
264 iTest->IncSubStateL(); |
|
265 } |
|
266 |
|
267 void SHKConnection::SubStateChangedL() |
|
268 { |
|
269 if (HotKeyTestIsDeathTest[iTest->SubState()]) |
|
270 { |
|
271 RThread thread; |
|
272 iMainWinId=iGroup->GroupWin()->Identifier(); |
|
273 TInt subState=iTest->SubState(); |
|
274 User::After(100000); |
|
275 User::LeaveIfError(thread.Create(_L("SubThread"),SubThread,KDefaultStackSize,0x2000,0x2000,&subState,EOwnerThread)); |
|
276 thread.Logon(iDeath.iStatus); |
|
277 iDeath.Request(); |
|
278 thread.Resume(); |
|
279 thread.Close(); |
|
280 } |
|
281 iWin->Invalidate(); |
|
282 iWs.Flush(); |
|
283 } |
|
284 |
|
285 void SHKConnection::ConstructL() |
|
286 { |
|
287 CTClient::ConstructL(); |
|
288 iGroup=new(ELeave) SHKWindowGroup(this); |
|
289 iGroup->ConstructL(); |
|
290 TSize screenSize=iGroup->Size(); |
|
291 iGroup->GroupWin()->AutoForeground(EFalse); // Don't allow clicking to cause foreground, might mess up test |
|
292 TInt winWidth; |
|
293 TInt winHeight; |
|
294 if (iMode==0) |
|
295 { |
|
296 winWidth=screenSize.iWidth/2; |
|
297 winHeight=screenSize.iHeight-10; |
|
298 SHKWindow *win=new(ELeave) SHKWindow(iTest); |
|
299 win->SetUpL(TPoint(5,5),TSize(winWidth,winHeight),iGroup,*iGc); |
|
300 iWin=win; |
|
301 } |
|
302 else |
|
303 { |
|
304 winWidth=150; |
|
305 winHeight=50; |
|
306 iGroup->GroupWin()->SetOwningWindowGroup(iMainWinId); |
|
307 SHKWindow2 *win=new(ELeave) SHKWindow2(); |
|
308 win->SetUpL(TPoint((screenSize.iWidth-winWidth)/2,(screenSize.iHeight-winHeight)/2),TSize(winWidth,winHeight),iGroup,*iGc); |
|
309 iWin=win; |
|
310 } |
|
311 iWs.Flush(); |
|
312 } |
|
313 |
|
314 // |
|
315 // SHKWindow, class // |
|
316 // |
|
317 |
|
318 SHKWindow::SHKWindow(THotKeyTest *aTest) : CTWin(), iTest(aTest) |
|
319 { |
|
320 iBack=TRgb::Gray256(230); |
|
321 } |
|
322 |
|
323 void SHKWindow::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc) |
|
324 { |
|
325 ConstructExtLD(*parent,pos,size); |
|
326 iWin.SetBackgroundColor(iBack); |
|
327 Activate(); |
|
328 AssignGC(aGc); |
|
329 } |
|
330 |
|
331 void SHKWindow::Draw() |
|
332 { |
|
333 iGc->Clear(); |
|
334 iGc->DrawText(TPtrC(HotKeyTests[iTest->SubState()].txt), TPoint(10,20)); |
|
335 iGc->DrawText(TPtrC(_L("Press <Enter> when tested okay")), TPoint(10,35)); |
|
336 iGc->DrawText(TPtrC(_L("or escape to abort tests")), TPoint(10,50)); |
|
337 } |
|
338 |
|
339 // |
|
340 // SHKWindow2, class // |
|
341 // |
|
342 |
|
343 SHKWindow2::SHKWindow2() : CTWin() |
|
344 { |
|
345 } |
|
346 |
|
347 void SHKWindow2::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc) |
|
348 { |
|
349 ConstructExtLD(*parent,pos,size); |
|
350 iWin.SetBackgroundColor(TRgb(0,0,0)); |
|
351 Activate(); |
|
352 AssignGC(aGc); |
|
353 } |
|
354 |
|
355 void SHKWindow2::Draw() |
|
356 { |
|
357 iGc->SetBrushColor(TRgb::Gray4(1)); |
|
358 iGc->Clear(); |
|
359 iGc->SetPenColor(TRgb::Gray4(3)); |
|
360 iGc->DrawText(TPtrC(_L("Kill me!!!")), TPoint(10,15)); |
|
361 } |
|
362 |
|
363 // |
|
364 |
|
365 TInt THotKeyTest::SubState() const |
|
366 { |
|
367 return(iSubState); |
|
368 } |
|
369 |
|
370 void THotKeyTest::IncSubStateL() |
|
371 { |
|
372 if (iSubState==(numHotKeyTests-1)) |
|
373 EndCaptureKeyTest(); |
|
374 else |
|
375 { |
|
376 iSubState++; |
|
377 iConn1->SubStateChangedL(); |
|
378 } |
|
379 } |
|
380 |
|
381 void THotKeyTest::BadParamsL() |
|
382 { |
|
383 TInt resCount=Client()->iWs.ResourceCount(); |
|
384 for(TInt index=0;index<numErrorKeys;index++) |
|
385 TestL(Client()->iWs.SetHotKey(errorKeys[index].hotKey, errorKeys[index].keyCode,errorKeys[index].mod_mask,errorKeys[index].modifiers)==KErrArgument); |
|
386 TestL(Client()->iWs.ResourceCount()==resCount); |
|
387 } |
|
388 |
|
389 TestState THotKeyTest::DoTestL() |
|
390 { |
|
391 switch(iState) |
|
392 { |
|
393 case 0: |
|
394 LogSubTest(_L("Errors"),1); |
|
395 BadParamsL(); |
|
396 LogSubTest(_L("CaptureKey"),2); |
|
397 iState++; |
|
398 return(EContinue); |
|
399 default: |
|
400 return(EFinished); |
|
401 } |
|
402 } |
|
403 |
|
404 //======================================================// |
|
405 // Sub thread to do tests and get shot by window server // |
|
406 //======================================================// |
|
407 |
|
408 void SubThreadMain() |
|
409 { |
|
410 CActiveScheduler *TheActiveScheduler=new(ELeave) CActiveScheduler; |
|
411 CActiveScheduler::Install(TheActiveScheduler); |
|
412 SHKConnection *conn=new(ELeave) SHKConnection(NULL, ETrue); |
|
413 conn->ConstructL(); |
|
414 CActiveScheduler::Start(); |
|
415 delete TheActiveScheduler; |
|
416 } |
|
417 |
|
418 TInt SubThread(TAny *) |
|
419 { |
|
420 CTrapCleanup* CleanUpStack=CTrapCleanup::New(); |
|
421 TRAPD(err,SubThreadMain()); |
|
422 delete CleanUpStack; |
|
423 return(err); |
|
424 } |
|