]> git.saurik.com Git - wxWidgets.git/blob - tests/events/keyboard.cpp
projects / wxWidgets.git / blob
? search:


8e28c60cda758838bc9097db8bee61830c9d99d4
[wxWidgets.git] / tests / events / keyboard.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: tests/events/keyboard.cpp
3 // Purpose: Test keyboard events
4 // Author: Vadim Zeitlin
5 // Created: 2010-09-05
6 // Copyright: (c) 2010 Vadim Zeitlin <vadim@wxwidgets.org>
7 ///////////////////////////////////////////////////////////////////////////////
8
9 // ----------------------------------------------------------------------------
10 // headers
11 // ----------------------------------------------------------------------------
12
13 #include "testprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 // FIXME: As all the other tests involving wxUIActionSimulator, this one is
20 // broken under OS X, the test window siply never gets any events.
21 #if wxUSE_UIACTIONSIMULATOR && !defined(__WXOSX__)
22
23 #ifndef WX_PRECOMP
24 #include "wx/app.h"
25 #include "wx/event.h"
26 #include "wx/window.h"
27 #endif // WX_PRECOMP
28
29 #include "wx/uiaction.h"
30 #include "wx/vector.h"
31
32 namespace
33 {
34
35 // ----------------------------------------------------------------------------
36 // test window verifying the event generation
37 // ----------------------------------------------------------------------------
38
39 class KeyboardTestWindow : public wxWindow
40 {
41 public:
42 KeyboardTestWindow(wxWindow *parent)
43 : wxWindow(parent, wxID_ANY, wxPoint(0, 0), parent->GetClientSize())
44 {
45 Connect(wxEVT_KEY_DOWN, wxKeyEventHandler(KeyboardTestWindow::OnKeyDown));
46 Connect(wxEVT_CHAR, wxKeyEventHandler(KeyboardTestWindow::OnChar));
47 Connect(wxEVT_KEY_UP, wxKeyEventHandler(KeyboardTestWindow::OnKeyUp));
48 }
49
50 unsigned GetKeyDownCount() const { return m_keyDownEvents.size(); }
51 unsigned GetCharCount() const { return m_charEvents.size(); }
52 unsigned GetKeyUpCount() const { return m_keyUpEvents.size(); }
53
54 const wxKeyEvent& GetKeyDownEvent(unsigned n = 0) const
55 {
56 return m_keyDownEvents[n];
57 }
58 const wxKeyEvent& GetCharEvent(unsigned n = 0) const
59 {
60 return m_charEvents[n];
61 }
62 const wxKeyEvent& GetKeyUpEvent(unsigned n = 0) const
63 {
64 return m_keyUpEvents[n];
65 }
66
67 void ClearEvents()
68 {
69 m_keyDownEvents =
70 m_charEvents =
71 m_keyUpEvents = wxVector<wxKeyEvent>();
72 }
73
74 private:
75 void OnKeyDown(wxKeyEvent& event)
76 {
77 m_keyDownEvents.push_back(event);
78 event.Skip();
79 }
80
81 void OnChar(wxKeyEvent& event)
82 {
83 m_charEvents.push_back(event);
84 event.Skip();
85 }
86
87 void OnKeyUp(wxKeyEvent& event)
88 {
89 m_keyUpEvents.push_back(event);
90 event.Skip();
91 }
92
93 wxVector<wxKeyEvent> m_keyDownEvents,
94 m_charEvents,
95 m_keyUpEvents;
96
97
98 wxDECLARE_NO_COPY_CLASS(KeyboardTestWindow);
99 };
100
101 // Object describing the (main fields of) keyboard event.
102 struct KeyDesc
103 {
104 KeyDesc(int keycode, int mods = 0)
105 : m_keycode(keycode),
106 m_mods(mods)
107 {
108 }
109
110 int m_keycode;
111 int m_mods;
112 };
113
114 // Helper for ModKeyDown().
115 int GetModForKey(int keycode)
116 {
117 switch ( keycode )
118 {
119 case WXK_CONTROL: return wxMOD_CONTROL;
120 case WXK_SHIFT: return wxMOD_SHIFT;
121 case WXK_ALT: return wxMOD_ALT;
122 default:
123 wxFAIL_MSG( "Unknown modifier key" );
124 }
125
126 return wxMOD_NONE;
127 }
128
129 // Helper function to allow writing just ModKeyDown(WXK_CONTROL) instead of
130 // more verbose KeyDesc(WXK_CONTROL, wxMOD_CONTROL).
131 KeyDesc ModKeyDown(int keycode)
132 {
133 return KeyDesc(keycode, GetModForKey(keycode));
134 }
135
136 // Another helper provided for symmetry with ModKeyDown() only.
137 KeyDesc ModKeyUp(int keycode)
138 {
139 return KeyDesc(keycode);
140 }
141
142 // Verify that the event object corresponds to our idea of what it should be.
143 void TestEvent(int line, const wxKeyEvent& ev, const KeyDesc& desc)
144 {
145 // Construct the message we'll display if an assert fails.
146 std::string msg;
147 const wxEventType t = ev.GetEventType();
148 if ( t == wxEVT_KEY_DOWN )
149 msg = "key down";
150 else if ( t == wxEVT_CHAR )
151 msg = "char";
152 else if ( t == wxEVT_KEY_UP )
153 msg = "key up";
154 else
155 CPPUNIT_FAIL( "unknown event type" );
156
157 msg += " event at line ";
158 msg += wxString::Format("%d", line).mb_str();
159
160
161 CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong key code in " + msg,
162 desc.m_keycode,
163 ev.GetKeyCode() );
164
165 #if wxUSE_UNICODE
166 if ( desc.m_keycode < WXK_START )
167 {
168 // For Latin-1 our key code is the same as Unicode character value.
169 CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong Unicode key in " + msg,
170 (char)desc.m_keycode,
171 (char)ev.GetUnicodeKey() );
172 }
173 else // Special key
174 {
175 // Key codes above WXK_START don't correspond to printable characters.
176 CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong non-zero Unicode key in " + msg,
177 0,
178 (int)ev.GetUnicodeKey() );
179 }
180 #endif // wxUSE_UNICODE
181
182 CPPUNIT_ASSERT_EQUAL_MESSAGE( "wrong modifiers in " + msg,
183 desc.m_mods,
184 ev.GetModifiers() );
185 }
186
187 // Call TestEvent() passing it the line number from where it was called: this
188 // is useful for interpreting the assert failure messages.
189 #define ASSERT_KEY_EVENT_IS( ev, desc ) TestEvent(__LINE__, ev, desc)
190
191 } // anonymous namespace
192
193 // --------------------------------------------------------------------------
194 // test class
195 // --------------------------------------------------------------------------
196
197 class KeyboardEventTestCase : public CppUnit::TestCase
198 {
199 public:
200 KeyboardEventTestCase() {}
201
202 virtual void setUp();
203 virtual void tearDown();
204
205 private:
206 CPPUNIT_TEST_SUITE( KeyboardEventTestCase );
207 CPPUNIT_TEST( NormalLetter );
208 CPPUNIT_TEST( NormalSpecial );
209 CPPUNIT_TEST( CtrlLetter );
210 CPPUNIT_TEST( CtrlSpecial );
211 CPPUNIT_TEST( ShiftLetter );
212 CPPUNIT_TEST( ShiftSpecial );
213 CPPUNIT_TEST_SUITE_END();
214
215 void NormalLetter();
216 void NormalSpecial();
217 void CtrlLetter();
218 void CtrlSpecial();
219 void ShiftLetter();
220 void ShiftSpecial();
221
222 KeyboardTestWindow *m_win;
223
224 wxDECLARE_NO_COPY_CLASS(KeyboardEventTestCase);
225 };
226
227 wxREGISTER_UNIT_TEST(KeyboardEvent);
228
229 void KeyboardEventTestCase::setUp()
230 {
231 m_win = new KeyboardTestWindow(wxTheApp->GetTopWindow());
232 m_win->SetFocus();
233 wxYield(); // needed to show the new window
234
235 // The window might get some key up events when it's being shown if the key
236 // was pressed when the program was started and released after the window
237 // was shown, e.g. this does happen in practice when launching the test
238 // from command line. Simply discard all the spurious events so far.
239 m_win->ClearEvents();
240 }
241
242 void KeyboardEventTestCase::tearDown()
243 {
244 m_win->Destroy();
245 }
246
247 void KeyboardEventTestCase::NormalLetter()
248 {
249 wxUIActionSimulator sim;
250 sim.Char('a');
251 wxYield();
252
253 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyDownCount() );
254 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(), 'A' );
255
256 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
257 ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(), 'a' );
258
259 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyUpCount() );
260 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(), 'A' );
261 }
262
263 void KeyboardEventTestCase::NormalSpecial()
264 {
265 wxUIActionSimulator sim;
266 sim.Char(WXK_END);
267 wxYield();
268
269 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyDownCount() );
270 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(), WXK_END );
271
272 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
273 ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(), WXK_END );
274
275 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetKeyUpCount() );
276 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(), WXK_END );
277 }
278
279 void KeyboardEventTestCase::CtrlLetter()
280 {
281 wxUIActionSimulator sim;
282 sim.Char('z', wxMOD_CONTROL);
283 wxYield();
284
285 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
286 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
287 ModKeyDown(WXK_CONTROL) );
288 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
289 KeyDesc('Z', wxMOD_CONTROL) );
290
291 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
292 ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
293 KeyDesc('\x1a', wxMOD_CONTROL) );
294
295 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
296 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
297 KeyDesc('Z', wxMOD_CONTROL) );
298 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
299 ModKeyUp(WXK_CONTROL) );
300 }
301
302 void KeyboardEventTestCase::CtrlSpecial()
303 {
304 wxUIActionSimulator sim;
305 sim.Char(WXK_PAGEUP, wxMOD_CONTROL);
306 wxYield();
307
308 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
309 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
310 ModKeyDown(WXK_CONTROL) );
311 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
312 KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );
313
314 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
315 ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
316 KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );
317
318 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
319 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
320 KeyDesc(WXK_PAGEUP, wxMOD_CONTROL) );
321 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
322 ModKeyUp(WXK_CONTROL) );
323 }
324
325 void KeyboardEventTestCase::ShiftLetter()
326 {
327 wxUIActionSimulator sim;
328 sim.Char('Q', wxMOD_SHIFT);
329 wxYield();
330
331 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
332 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
333 ModKeyDown(WXK_SHIFT) );
334 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
335 KeyDesc('Q', wxMOD_SHIFT) );
336
337 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
338 ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
339 KeyDesc('Q', wxMOD_SHIFT) );
340
341 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
342 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
343 KeyDesc('Q', wxMOD_SHIFT) );
344 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
345 ModKeyUp(WXK_SHIFT) );
346 }
347
348 void KeyboardEventTestCase::ShiftSpecial()
349 {
350 wxUIActionSimulator sim;
351 sim.Char(WXK_F3, wxMOD_SHIFT);
352 wxYield();
353
354 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyDownCount() );
355 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(0),
356 ModKeyDown(WXK_SHIFT) );
357 ASSERT_KEY_EVENT_IS( m_win->GetKeyDownEvent(1),
358 KeyDesc(WXK_F3, wxMOD_SHIFT) );
359
360 CPPUNIT_ASSERT_EQUAL( 1, m_win->GetCharCount() );
361 ASSERT_KEY_EVENT_IS( m_win->GetCharEvent(),
362 KeyDesc(WXK_F3, wxMOD_SHIFT) );
363
364 CPPUNIT_ASSERT_EQUAL( 2, m_win->GetKeyUpCount() );
365 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(0),
366 KeyDesc(WXK_F3, wxMOD_SHIFT) );
367 ASSERT_KEY_EVENT_IS( m_win->GetKeyUpEvent(1),
368 ModKeyUp(WXK_SHIFT) );
369 }
370
371 #endif // wxUSE_UIACTIONSIMULATOR
wxWidgets (Impactor)