?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
joy.cpl: Added force feedback direction control.
[wine/multimedia.git] / dlls / joy.cpl / main.c
blobc8b4a270cfeae9288e6660dacf8da95560d209dc
1 /*
2 * Joystick testing control panel applet
3 *
4 * Copyright 2012 Lucas Fialho Zawacki
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 */
21
22 #define NONAMELESSUNION
23 #define COBJMACROS
24 #define CONST_VTABLE
25
26 #include <stdarg.h>
27 #include <windef.h>
28 #include <winbase.h>
29 #include <winuser.h>
30 #include <commctrl.h>
31 #include <cpl.h>
32 #include "ole2.h"
33
34 #include "wine/debug.h"
35 #include "joy.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(joycpl);
38
39 DECLSPEC_HIDDEN HMODULE hcpl;
40
41 /*********************************************************************
42 * DllMain
43 */
44 BOOL WINAPI DllMain(HINSTANCE hdll, DWORD reason, LPVOID reserved)
45 {
46 TRACE("(%p, %d, %p)\n", hdll, reason, reserved);
47
48 switch (reason)
49 {
50 case DLL_WINE_PREATTACH:
51 return FALSE; /* prefer native version */
52
53 case DLL_PROCESS_ATTACH:
54 DisableThreadLibraryCalls(hdll);
55 hcpl = hdll;
56 }
57 return TRUE;
58 }
59
60 /***********************************************************************
61 * enum_callback [internal]
62 * Enumerates, creates and sets the common data format for all the joystick devices.
63 * First time it checks if space for the joysticks was already reserved
64 * and if not, just counts how many there are.
65 */
66 static BOOL CALLBACK enum_callback(const DIDEVICEINSTANCEW *instance, void *context)
67 {
68 struct JoystickData *data = context;
69 struct Joystick *joystick;
70 DIPROPRANGE proprange;
71 DIDEVCAPS caps;
72
73 if (data->joysticks == NULL)
74 {
75 data->num_joysticks += 1;
76 return DIENUM_CONTINUE;
77 }
78
79 joystick = &data->joysticks[data->cur_joystick];
80 data->cur_joystick += 1;
81
82 IDirectInput8_CreateDevice(data->di, &instance->guidInstance, &joystick->device, NULL);
83 IDirectInputDevice8_SetDataFormat(joystick->device, &c_dfDIJoystick);
84
85 joystick->instance = *instance;
86
87 caps.dwSize = sizeof(caps);
88 IDirectInputDevice8_GetCapabilities(joystick->device, &caps);
89
90 joystick->num_buttons = caps.dwButtons;
91 joystick->num_axes = caps.dwAxes;
92 joystick->forcefeedback = caps.dwFlags & DIDC_FORCEFEEDBACK;
93
94 if (joystick->forcefeedback) data->num_ff++;
95
96 /* Set axis range to ease the GUI visualization */
97 proprange.diph.dwSize = sizeof(DIPROPRANGE);
98 proprange.diph.dwHeaderSize = sizeof(DIPROPHEADER);
99 proprange.diph.dwHow = DIPH_DEVICE;
100 proprange.diph.dwObj = 0;
101 proprange.lMin = TEST_AXIS_MIN;
102 proprange.lMax = TEST_AXIS_MAX;
103
104 IDirectInputDevice_SetProperty(joystick->device, DIPROP_RANGE, &proprange.diph);
105
106 return DIENUM_CONTINUE;
107 }
108
109 /***********************************************************************
110 * initialize_joysticks [internal]
111 */
112 static void initialize_joysticks(struct JoystickData *data)
113 {
114 data->num_joysticks = 0;
115 data->cur_joystick = 0;
116 IDirectInput8_EnumDevices(data->di, DI8DEVCLASS_GAMECTRL, enum_callback, data, DIEDFL_ATTACHEDONLY);
117 data->joysticks = HeapAlloc(GetProcessHeap(), 0, sizeof(struct Joystick) * data->num_joysticks);
118
119 /* Get all the joysticks */
120 IDirectInput8_EnumDevices(data->di, DI8DEVCLASS_GAMECTRL, enum_callback, data, DIEDFL_ATTACHEDONLY);
121 }
122
123 /***********************************************************************
124 * destroy_joysticks [internal]
125 */
126 static void destroy_joysticks(struct JoystickData *data)
127 {
128 int i, j;
129
130 for (i = 0; i < data->num_joysticks; i++)
131 {
132
133 if (data->joysticks[i].forcefeedback)
134 {
135 for (j = 0; j < data->joysticks[i].num_effects; j++)
136 IDirectInputEffect_Release(data->joysticks[i].effects[j].effect);
137
138 HeapFree(GetProcessHeap(), 0, data->joysticks[i].effects);
139 }
140
141 IDirectInputDevice8_Unacquire(data->joysticks[i].device);
142 IDirectInputDevice8_Release(data->joysticks[i].device);
143 }
144
145 HeapFree(GetProcessHeap(), 0, data->joysticks);
146 }
147
148 /*********************************************************************
149 * list_dlgproc [internal]
150 *
151 */
152 static INT_PTR CALLBACK list_dlgproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
153 {
154 TRACE("(%p, 0x%08x/%d, 0x%lx)\n", hwnd, msg, msg, lparam);
155 switch (msg)
156 {
157 case WM_INITDIALOG:
158 {
159 int i;
160 struct JoystickData *data = (struct JoystickData*) ((PROPSHEETPAGEW*)lparam)->lParam;
161
162 /* Set dialog information */
163 for (i = 0; i < data->num_joysticks; i++)
164 {
165 struct Joystick *joy = &data->joysticks[i];
166 SendDlgItemMessageW(hwnd, IDC_JOYSTICKLIST, LB_ADDSTRING, 0, (LPARAM) joy->instance.tszInstanceName);
167 }
168
169 return TRUE;
170 }
171
172 case WM_COMMAND:
173
174 switch (LOWORD(wparam))
175 {
176 case IDC_BUTTONDISABLE:
177 FIXME("Disable selected joystick from being enumerated\n");
178 break;
179
180 case IDC_BUTTONENABLE:
181 FIXME("Re-Enable selected joystick\n");
182 break;
183 }
184
185 return TRUE;
186
187 case WM_NOTIFY:
188 return TRUE;
189
190 default:
191 break;
192 }
193 return FALSE;
194 }
195
196 /*********************************************************************
197 * Joystick testing functions
198 *
199 */
200 static void dump_joy_state(DIJOYSTATE* st, int num_buttons)
201 {
202 int i;
203 TRACE("Ax (% 5d,% 5d,% 5d)\n", st->lX,st->lY, st->lZ);
204 TRACE("RAx (% 5d,% 5d,% 5d)\n", st->lRx, st->lRy, st->lRz);
205 TRACE("Slider (% 5d,% 5d)\n", st->rglSlider[0], st->rglSlider[1]);
206 TRACE("Pov (% 5d,% 5d,% 5d,% 5d)\n", st->rgdwPOV[0], st->rgdwPOV[1], st->rgdwPOV[2], st->rgdwPOV[3]);
207
208 TRACE("Buttons ");
209 for(i=0; i < num_buttons; i++)
210 TRACE(" %c",st->rgbButtons[i] ? 'x' : 'o');
211 TRACE("\n");
212 }
213
214 static void poll_input(const struct Joystick *joy, DIJOYSTATE *state)
215 {
216 HRESULT hr;
217
218 hr = IDirectInputDevice8_Poll(joy->device);
219
220 /* If it failed, try to acquire the joystick */
221 if (FAILED(hr))
222 {
223 hr = IDirectInputDevice8_Acquire(joy->device);
224 while (hr == DIERR_INPUTLOST) hr = IDirectInputDevice8_Acquire(joy->device);
225 }
226
227 if (hr == DIERR_OTHERAPPHASPRIO) return;
228
229 IDirectInputDevice8_GetDeviceState(joy->device, sizeof(DIJOYSTATE), state);
230 }
231
232 static DWORD WINAPI input_thread(void *param)
233 {
234 int axes_pos[TEST_MAX_AXES][2];
235 DIJOYSTATE state;
236 struct JoystickData *data = param;
237
238 /* Setup POV as clock positions
239 * 0
240 * 31500 4500
241 * 27000 -1 9000
242 * 22500 13500
243 * 18000
244 */
245 int ma = TEST_AXIS_MAX;
246 int pov_val[9] = {0, 4500, 9000, 13500,
247 18000, 22500, 27000, 31500, -1};
248 int pov_pos[9][2] = { {0, -ma}, {ma/2, -ma/2}, {ma, 0}, {ma/2, ma/2},
249 {0, ma}, {-ma/2, ma/2}, {-ma, 0}, {-ma/2, -ma/2}, {0, 0} };
250
251 ZeroMemory(&state, sizeof(state));
252
253 while (!data->stop)
254 {
255 int i;
256 poll_input(&data->joysticks[data->chosen_joystick], &state);
257
258 dump_joy_state(&state, data->joysticks[data->chosen_joystick].num_buttons);
259
260 /* Indicate pressed buttons */
261 for (i = 0; i < data->joysticks[data->chosen_joystick].num_buttons; i++)
262 if (state.rgbButtons[i])
263 SendMessageW(data->buttons[i], BM_SETSTATE, TRUE, 0);
264
265 /* Indicate axis positions, axes showing are hardcoded for now */
266 axes_pos[0][0] = state.lX;
267 axes_pos[0][1] = state.lY;
268 axes_pos[1][0] = state.lRx;
269 axes_pos[1][1] = state.lRy;
270 axes_pos[2][0] = state.lZ;
271 axes_pos[2][1] = state.lRz;
272
273 /* Set pov values */
274 for (i = 0; i < sizeof(pov_val)/sizeof(pov_val[0]); i++)
275 {
276 if (state.rgdwPOV[0] == pov_val[i])
277 {
278 axes_pos[3][0] = pov_pos[i][0];
279 axes_pos[3][1] = pov_pos[i][1];
280 }
281 }
282
283 for (i = 0; i < TEST_MAX_AXES; i++)
284 SetWindowPos(data->axes[i], 0,
285 TEST_AXIS_X + TEST_NEXT_AXIS_X*i + axes_pos[i][0],
286 TEST_AXIS_Y + axes_pos[i][1],
287 0, 0, SWP_NOZORDER | SWP_NOSIZE);
288
289 Sleep(TEST_POLL_TIME);
290
291 /* Reset button state */
292 for (i = 0; i < data->joysticks[data->chosen_joystick].num_buttons; i++)
293 SendMessageW(data->buttons[i], BM_SETSTATE, FALSE, 0);
294 }
295
296 return 0;
297 }
298
299 static void test_handle_joychange(HWND hwnd, struct JoystickData *data)
300 {
301 int i;
302
303 if (data->num_joysticks == 0) return;
304
305 data->chosen_joystick = SendDlgItemMessageW(hwnd, IDC_TESTSELECTCOMBO, CB_GETCURSEL, 0, 0);
306
307 /* Enable only buttons present in the device */
308 for (i = 0; i < TEST_MAX_BUTTONS; i++)
309 ShowWindow(data->buttons[i], i <= data->joysticks[data->chosen_joystick].num_buttons);
310 }
311
312 /*********************************************************************
313 * button_number_to_wchar [internal]
314 * Transforms an integer in the interval [0,99] into a 2 character WCHAR string
315 */
316 static void button_number_to_wchar(int n, WCHAR str[3])
317 {
318 str[1] = n % 10 + '0';
319 n /= 10;
320 str[0] = n % 10 + '0';
321 str[2] = '\0';
322 }
323
324 static void draw_joystick_buttons(HWND hwnd, struct JoystickData* data)
325 {
326 int i;
327 int row = 0, col = 0;
328 WCHAR button_label[3];
329 HINSTANCE hinst = (HINSTANCE) GetWindowLongPtrW(hwnd, GWLP_HINSTANCE);
330 static WCHAR button_class[] = {'B','u','t','t','o','n','\0'};
331
332 for (i = 0; i < TEST_MAX_BUTTONS; i++)
333 {
334 if ((i % TEST_BUTTON_COL_MAX) == 0 && i != 0)
335 {
336 row += 1;
337 col = 0;
338 }
339
340 button_number_to_wchar(i + 1, button_label);
341
342 data->buttons[i] = CreateWindowW(button_class, button_label, WS_CHILD,
343 TEST_BUTTON_X + TEST_NEXT_BUTTON_X*col, TEST_BUTTON_Y + TEST_NEXT_BUTTON_Y*row,
344 TEST_BUTTON_SIZE_X, TEST_BUTTON_SIZE_Y,
345 hwnd, NULL, NULL, hinst);
346
347 col += 1;
348 }
349 }
350
351 static void draw_joystick_axes(HWND hwnd, struct JoystickData* data)
352 {
353 int i;
354 HINSTANCE hinst = (HINSTANCE) GetWindowLongPtrW(hwnd, GWLP_HINSTANCE);
355 static const WCHAR button_class[] = {'B','u','t','t','o','n','\0'};
356 static const WCHAR axes_names[TEST_MAX_AXES][7] = { {'X',',','Y','\0'}, {'R','x',',','R','y','\0'},
357 {'Z',',','R','z','\0'}, {'P','O','V','\0'} };
358 static const DWORD axes_idc[TEST_MAX_AXES] = { IDC_TESTGROUPXY, IDC_TESTGROUPRXRY,
359 IDC_TESTGROUPZRZ, IDC_TESTGROUPPOV };
360
361 for (i = 0; i < TEST_MAX_AXES; i++)
362 {
363 /* Set axis box name */
364 SetWindowTextW(GetDlgItem(hwnd, axes_idc[i]), axes_names[i]);
365
366 data->axes[i] = CreateWindowW( button_class, NULL, WS_CHILD | WS_VISIBLE,
367 TEST_AXIS_X + TEST_NEXT_AXIS_X*i, TEST_AXIS_Y,
368 TEST_AXIS_SIZE_X, TEST_AXIS_SIZE_Y,
369 hwnd, (HMENU) IDC_JOYSTICKAXES + i, NULL, hinst);
370 }
371 }
372
373 /*********************************************************************
374 * test_dlgproc [internal]
375 *
376 */
377 static INT_PTR CALLBACK test_dlgproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
378 {
379 static HANDLE thread;
380 static struct JoystickData *data;
381 TRACE("(%p, 0x%08x/%d, 0x%lx)\n", hwnd, msg, msg, lparam);
382
383 switch (msg)
384 {
385 case WM_INITDIALOG:
386 {
387 int i;
388
389 data = (struct JoystickData*) ((PROPSHEETPAGEW*)lparam)->lParam;
390
391 /* Add enumerated joysticks to the combobox */
392 for (i = 0; i < data->num_joysticks; i++)
393 {
394 struct Joystick *joy = &data->joysticks[i];
395 SendDlgItemMessageW(hwnd, IDC_TESTSELECTCOMBO, CB_ADDSTRING, 0, (LPARAM) joy->instance.tszInstanceName);
396 }
397
398 draw_joystick_buttons(hwnd, data);
399 draw_joystick_axes(hwnd, data);
400
401 return TRUE;
402 }
403
404 case WM_COMMAND:
405 switch(wparam)
406 {
407 case MAKEWPARAM(IDC_TESTSELECTCOMBO, CBN_SELCHANGE):
408 test_handle_joychange(hwnd, data);
409 break;
410 }
411 return TRUE;
412
413 case WM_NOTIFY:
414 switch(((LPNMHDR)lparam)->code)
415 {
416 case PSN_SETACTIVE:
417 {
418 DWORD tid;
419
420 /* Initialize input thread */
421 if (data->num_joysticks > 0)
422 {
423 data->stop = FALSE;
424
425 /* Set the first joystick as default */
426 SendDlgItemMessageW(hwnd, IDC_TESTSELECTCOMBO, CB_SETCURSEL, 0, 0);
427 test_handle_joychange(hwnd, data);
428
429 thread = CreateThread(NULL, 0, input_thread, (void*) data, 0, &tid);
430 }
431 }
432 break;
433
434 case PSN_RESET: /* intentional fall-through */
435 case PSN_KILLACTIVE:
436 /* Stop input thread */
437 data->stop = TRUE;
438 MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, 0);
439 CloseHandle(thread);
440 break;
441 }
442 return TRUE;
443 }
444 return FALSE;
445 }
446
447 /*********************************************************************
448 * Joystick force feedback testing functions
449 *
450 */
451 static void draw_ff_axis(HWND hwnd, struct JoystickData *data)
452 {
453 HINSTANCE hinst = (HINSTANCE) GetWindowLongPtrW(hwnd, GWLP_HINSTANCE);
454 static WCHAR button_class[] = {'B','u','t','t','o','n','\0'};
455
456 /* Draw direction axis */
457 data->ff_axis = CreateWindowW( button_class, NULL, WS_CHILD | WS_VISIBLE,
458 FF_AXIS_X, FF_AXIS_Y,
459 FF_AXIS_SIZE_X, FF_AXIS_SIZE_Y,
460 hwnd, (HMENU) IDC_FFAXIS, NULL, hinst);
461 }
462
463 static void initialize_effects_list(HWND hwnd, struct Joystick* joy)
464 {
465 int i;
466
467 SendDlgItemMessageW(hwnd, IDC_FFEFFECTLIST, LB_RESETCONTENT, 0, 0);
468
469 for (i=0; i < joy->num_effects; i++)
470 {
471 /* Effect names start with GUID_, so we'll skip this part */
472 WCHAR *name = joy->effects[i].info.tszName + 5;
473 SendDlgItemMessageW(hwnd, IDC_FFEFFECTLIST, LB_ADDSTRING, 0, (LPARAM) name);
474 }
475 }
476
477 static void ff_handle_joychange(HWND hwnd, struct JoystickData *data)
478 {
479 int sel;
480
481 if (data->num_ff == 0) return;
482
483 sel = SendDlgItemMessageW(hwnd, IDC_FFSELECTCOMBO, CB_GETCURSEL, 0, 0);
484 data->chosen_joystick = SendDlgItemMessageW(hwnd, IDC_FFSELECTCOMBO, CB_GETITEMDATA, sel, 0);
485 initialize_effects_list(hwnd, &data->joysticks[data->chosen_joystick]);
486 }
487
488 static void ff_handle_effectchange(HWND hwnd, struct Joystick *joy)
489 {
490 int sel = SendDlgItemMessageW(hwnd, IDC_FFEFFECTLIST, LB_GETCURSEL, 0, 0);
491
492 if (sel < 0) return;
493
494 joy->chosen_effect = sel;
495 }
496
497 static DWORD WINAPI ff_input_thread(void *param)
498 {
499 struct JoystickData *data = param;
500 DIJOYSTATE state;
501
502 ZeroMemory(&state, sizeof(state));
503
504 while (!data->stop)
505 {
506 int i;
507 struct Joystick *joy = &data->joysticks[data->chosen_joystick];
508 int chosen_effect = joy->chosen_effect;
509 DIEFFECT *dieffect;
510 DWORD flags = DIEP_AXES | DIEP_DIRECTION | DIEP_NORESTART;
511
512 /* Skip this if we have no effects */
513 if (joy->num_effects == 0 || chosen_effect < 0) continue;
514
515 poll_input(joy, &state);
516
517 /* Set ff parameters and draw the axis */
518 dieffect = &joy->effects[chosen_effect].params;
519 dieffect->rgdwAxes[0] = state.lX;
520 dieffect->rgdwAxes[1] = state.lY;
521
522 SetWindowPos(data->ff_axis, 0, FF_AXIS_X + state.lX, FF_AXIS_Y + state.lY,
523 0, 0, SWP_NOZORDER | SWP_NOSIZE);
524
525 for (i=0; i < joy->num_buttons; i++)
526 if (state.rgbButtons[i])
527 {
528 IDirectInputEffect_SetParameters(joy->effects[chosen_effect].effect, dieffect, flags);
529 IDirectInputEffect_Start(joy->effects[chosen_effect].effect, 1, 0);
530 break;
531 }
532
533 Sleep(TEST_POLL_TIME);
534 }
535
536 return 0;
537 }
538
539 /***********************************************************************
540 * ff_effects_callback [internal]
541 * Enumerates, creates, sets the some parameters and stores all ff effects
542 * supported by the joystick. Works like enum_callback, counting the effects
543 * first and then storing them.
544 */
545 static BOOL CALLBACK ff_effects_callback(const DIEFFECTINFOW *pdei, void *pvRef)
546 {
547 HRESULT hr;
548 DIEFFECT dieffect;
549 DWORD axes[2] = {DIJOFS_X, DIJOFS_Y};
550 int direction[2] = {0, 0};
551 struct Joystick *joystick = pvRef;
552
553 if (joystick->effects == NULL)
554 {
555 joystick->num_effects += 1;
556 return DIENUM_CONTINUE;
557 }
558
559 hr = IDirectInputDevice8_Acquire(joystick->device);
560
561 if (FAILED(hr)) return DIENUM_CONTINUE;
562
563 ZeroMemory(&dieffect, sizeof(dieffect));
564
565 dieffect.dwSize = sizeof(dieffect);
566 dieffect.dwFlags = DIEFF_CARTESIAN;
567 dieffect.dwDuration = FF_PLAY_TIME;
568
569 dieffect.cAxes = 2;
570 dieffect.rgdwAxes = axes;
571 dieffect.rglDirection = direction;
572
573 if (IsEqualGUID(&pdei->guid, &GUID_RampForce))
574 {
575 DIRAMPFORCE rforce;
576
577 rforce.lStart = 0;
578 rforce.lEnd = DI_FFNOMINALMAX;
579
580 dieffect.cbTypeSpecificParams = sizeof(rforce);
581 dieffect.lpvTypeSpecificParams = &rforce;
582 dieffect.dwFlags |= DIEP_TYPESPECIFICPARAMS;
583 }
584 else if (IsEqualGUID(&pdei->guid, &GUID_ConstantForce))
585 {
586 DICONSTANTFORCE cforce;
587
588 cforce.lMagnitude = DI_FFNOMINALMAX;
589
590 dieffect.cbTypeSpecificParams = sizeof(cforce);
591 dieffect.lpvTypeSpecificParams = &cforce;
592 dieffect.dwFlags |= DIEP_TYPESPECIFICPARAMS;
593 }
594 else if (IsEqualGUID(&pdei->guid, &GUID_Sine) ||
595 IsEqualGUID(&pdei->guid, &GUID_Square) ||
596 IsEqualGUID(&pdei->guid, &GUID_Triangle) ||
597 IsEqualGUID(&pdei->guid, &GUID_SawtoothUp) ||
598 IsEqualGUID(&pdei->guid, &GUID_SawtoothDown))
599 {
600 DIPERIODIC pforce;
601
602 pforce.dwMagnitude = DI_FFNOMINALMAX;
603 pforce.lOffset = 0;
604 pforce.dwPhase = 0;
605 pforce.dwPeriod = FF_PERIOD_TIME;
606
607 dieffect.cbTypeSpecificParams = sizeof(pforce);
608 dieffect.lpvTypeSpecificParams = &pforce;
609 dieffect.dwFlags |= DIEP_TYPESPECIFICPARAMS;
610 }
611
612 hr = IDirectInputDevice2_CreateEffect(
613 joystick->device, &pdei->guid, &dieffect, &joystick->effects[joystick->cur_effect].effect, NULL);
614
615 joystick->effects[joystick->cur_effect].params = dieffect;
616 joystick->effects[joystick->cur_effect].info = *pdei;
617 joystick->cur_effect += 1;
618
619 return DIENUM_CONTINUE;
620 }
621
622 /*********************************************************************
623 * ff_dlgproc [internal]
624 *
625 */
626 static INT_PTR CALLBACK ff_dlgproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
627 {
628 static HANDLE thread;
629 static struct JoystickData *data;
630 TRACE("(%p, 0x%08x/%d, 0x%lx)\n", hwnd, msg, msg, lparam);
631
632 switch (msg)
633 {
634 case WM_INITDIALOG:
635 {
636 int i, cur = 0;
637
638 data = (struct JoystickData*) ((PROPSHEETPAGEW*)lparam)->lParam;
639
640 /* Add joysticks with FF support to the combobox and get the effects */
641 for (i = 0; i < data->num_joysticks; i++)
642 {
643 struct Joystick *joy = &data->joysticks[i];
644
645 if (joy->forcefeedback)
646 {
647 SendDlgItemMessageW(hwnd, IDC_FFSELECTCOMBO, CB_ADDSTRING, 0, (LPARAM) joy->instance.tszInstanceName);
648 SendDlgItemMessageW(hwnd, IDC_FFSELECTCOMBO, CB_SETITEMDATA, cur, i);
649
650 cur++;
651
652 /* Count device effects and then store them */
653 joy->num_effects = 0;
654 joy->effects = NULL;
655 IDirectInputDevice8_EnumEffects(joy->device, ff_effects_callback, (void *) joy, 0);
656 joy->effects = HeapAlloc(GetProcessHeap(), 0, sizeof(struct Effect) * joy->num_effects);
657
658 joy->cur_effect = 0;
659 IDirectInputDevice8_EnumEffects(joy->device, ff_effects_callback, (void*) joy, 0);
660 FIXME("%d --- %d\n", joy->num_effects, joy->cur_effect);
661 joy->num_effects = joy->cur_effect;
662
663 }
664 }
665
666 draw_ff_axis(hwnd, data);
667
668 return TRUE;
669 }
670
671 case WM_COMMAND:
672 switch(wparam)
673 {
674 case MAKEWPARAM(IDC_FFSELECTCOMBO, CBN_SELCHANGE):
675 ff_handle_joychange(hwnd, data);
676
677 SendDlgItemMessageW(hwnd, IDC_FFEFFECTLIST, LB_SETCURSEL, 0, 0);
678 ff_handle_effectchange(hwnd, &data->joysticks[data->chosen_joystick]);
679 break;
680
681 case MAKEWPARAM(IDC_FFEFFECTLIST, LBN_SELCHANGE):
682 ff_handle_effectchange(hwnd, &data->joysticks[data->chosen_joystick]);
683 break;
684 }
685 return TRUE;
686
687 case WM_NOTIFY:
688 switch(((LPNMHDR)lparam)->code)
689 {
690 case PSN_SETACTIVE:
691 if (data->num_ff > 0)
692 {
693 DWORD tid;
694
695 data->stop = FALSE;
696 /* Set the first joystick as default */
697 SendDlgItemMessageW(hwnd, IDC_FFSELECTCOMBO, CB_SETCURSEL, 0, 0);
698 ff_handle_joychange(hwnd, data);
699
700 SendDlgItemMessageW(hwnd, IDC_FFEFFECTLIST, LB_SETCURSEL, 0, 0);
701 ff_handle_effectchange(hwnd, &data->joysticks[data->chosen_joystick]);
702
703 thread = CreateThread(NULL, 0, ff_input_thread, (void*) data, 0, &tid);
704 }
705 break;
706
707 case PSN_RESET: /* intentional fall-through */
708 case PSN_KILLACTIVE:
709 /* Stop ff thread */
710 data->stop = TRUE;
711 MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, 0);
712 CloseHandle(thread);
713 break;
714 }
715 return TRUE;
716 }
717 return FALSE;
718 }
719
720 /******************************************************************************
721 * propsheet_callback [internal]
722 */
723 static int CALLBACK propsheet_callback(HWND hwnd, UINT msg, LPARAM lparam)
724 {
725 TRACE("(%p, 0x%08x/%d, 0x%lx)\n", hwnd, msg, msg, lparam);
726 switch (msg)
727 {
728 case PSCB_INITIALIZED:
729 break;
730 }
731 return 0;
732 }
733
734 /******************************************************************************
735 * display_cpl_sheets [internal]
736 *
737 * Build and display the dialog with all control panel propertysheets
738 *
739 */
740 static void display_cpl_sheets(HWND parent, struct JoystickData *data)
741 {
742 INITCOMMONCONTROLSEX icex;
743 PROPSHEETPAGEW psp[NUM_PROPERTY_PAGES];
744 PROPSHEETHEADERW psh;
745 DWORD id = 0;
746
747 OleInitialize(NULL);
748 /* Initialize common controls */
749 icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
750 icex.dwICC = ICC_LISTVIEW_CLASSES | ICC_BAR_CLASSES;
751 InitCommonControlsEx(&icex);
752
753 ZeroMemory(&psh, sizeof(psh));
754 ZeroMemory(psp, sizeof(psp));
755
756 /* Fill out all PROPSHEETPAGE */
757 psp[id].dwSize = sizeof (PROPSHEETPAGEW);
758 psp[id].hInstance = hcpl;
759 psp[id].u.pszTemplate = MAKEINTRESOURCEW(IDD_LIST);
760 psp[id].pfnDlgProc = list_dlgproc;
761 psp[id].lParam = (INT_PTR) data;
762 id++;
763
764 psp[id].dwSize = sizeof (PROPSHEETPAGEW);
765 psp[id].hInstance = hcpl;
766 psp[id].u.pszTemplate = MAKEINTRESOURCEW(IDD_TEST);
767 psp[id].pfnDlgProc = test_dlgproc;
768 psp[id].lParam = (INT_PTR) data;
769 id++;
770
771 psp[id].dwSize = sizeof (PROPSHEETPAGEW);
772 psp[id].hInstance = hcpl;
773 psp[id].u.pszTemplate = MAKEINTRESOURCEW(IDD_FORCEFEEDBACK);
774 psp[id].pfnDlgProc = ff_dlgproc;
775 psp[id].lParam = (INT_PTR) data;
776 id++;
777
778 /* Fill out the PROPSHEETHEADER */
779 psh.dwSize = sizeof (PROPSHEETHEADERW);
780 psh.dwFlags = PSH_PROPSHEETPAGE | PSH_USEICONID | PSH_USECALLBACK;
781 psh.hwndParent = parent;
782 psh.hInstance = hcpl;
783 psh.pszCaption = MAKEINTRESOURCEW(IDS_CPL_NAME);
784 psh.nPages = id;
785 psh.u3.ppsp = psp;
786 psh.pfnCallback = propsheet_callback;
787
788 /* display the dialog */
789 PropertySheetW(&psh);
790
791 OleUninitialize();
792 }
793
794 /*********************************************************************
795 * CPlApplet (joy.cpl.@)
796 *
797 * Control Panel entry point
798 *
799 * PARAMS
800 * hWnd [I] Handle for the Control Panel Window
801 * command [I] CPL_* Command
802 * lParam1 [I] first extra Parameter
803 * lParam2 [I] second extra Parameter
804 *
805 * RETURNS
806 * Depends on the command
807 *
808 */
809 LONG CALLBACK CPlApplet(HWND hwnd, UINT command, LPARAM lParam1, LPARAM lParam2)
810 {
811 static struct JoystickData data;
812 TRACE("(%p, %u, 0x%lx, 0x%lx)\n", hwnd, command, lParam1, lParam2);
813
814 switch (command)
815 {
816 case CPL_INIT:
817 {
818 HRESULT hr;
819
820 /* Initialize dinput */
821 hr = DirectInput8Create(GetModuleHandleW(NULL), DIRECTINPUT_VERSION, &IID_IDirectInput8W, (void**)&data.di, NULL);
822
823 if (FAILED(hr))
824 {
825 ERR("Failed to initialize DirectInput: 0x%08x\n", hr);
826 return FALSE;
827 }
828
829 /* Then get all the connected joysticks */
830 initialize_joysticks(&data);
831
832 return TRUE;
833 }
834 case CPL_GETCOUNT:
835 return 1;
836
837 case CPL_INQUIRE:
838 {
839 CPLINFO *appletInfo = (CPLINFO *) lParam2;
840
841 appletInfo->idName = IDS_CPL_NAME;
842 appletInfo->idInfo = IDS_CPL_INFO;
843 appletInfo->lData = 0;
844 return TRUE;
845 }
846
847 case CPL_DBLCLK:
848 display_cpl_sheets(hwnd, &data);
849 break;
850
851 case CPL_STOP:
852 destroy_joysticks(&data);
853
854 /* And destroy dinput too */
855 IDirectInput8_Release(data.di);
856 break;
857 }
858
859 return FALSE;
860 }
Maarten's multimedia branch