Cygwin support, using SDL.
[btb/d2x.git] / unused / win95 / joyc.c
1 /*
2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
12 */
13
14
15 #pragma off (unreferenced)
16 static char rcsid[] = "$Id: joyc.c,v 1.1.1.1 2001-01-19 03:30:15 bradleyb Exp $";
17 #pragma on (unreferenced)
18
19 #define WIN95
20 #define _WIN32
21 #define WIN32_LEAN_AND_MEAN
22
23 #include <windows.h>
24 #include <mmsystem.h>
25 #include <stdlib.h>
26 #include <stdio.h>
27 #include <conio.h>
28
29 #include "winapp.h"
30 #include "types.h"
31 #include "mono.h"
32 #include "joy.h"
33 #include "tactile.h"
34 #include "winregs.h"
35
36 #include "args.h"
37
38 //      Controls
39 //#include "win\cyberimp.h"
40 //#include "spw_inp.h"
41
42 #define WIN_TACTILE_ON
43
44 #define JOY_READ_BUTTONS 
45 #define MAX_BUTTONS 20
46 #define JOY_POLL_RATE   75      // 100 ms.
47
48
49 //      Data Structures ============================================================
50
51 typedef struct Button_info {
52         ubyte           ignore;
53         ubyte           state;
54         ubyte           last_state;
55         unsigned        timedown;
56         ubyte           downcount;
57         ubyte           upcount;
58 } Button_info;
59
60 typedef struct Joy_info {
61         int                     joyid;
62         ubyte                   present_mask;
63         int                     max_timer;
64         int                     read_count;
65         ubyte                   last_value;
66         Button_info     buttons[MAX_BUTTONS];
67         int                     axis_min[7];
68         int                     axis_center[7];
69         int                     axis_max[7];
70         int                     has_pov;
71         int                     threshold;
72         int                     raw_x1, raw_y1, raw_z1, raw_r1, raw_u1, raw_v1, pov;
73 } Joy_info;
74
75 LRESULT joy_handler_win(HWND hWnd, UINT joymsg, UINT wParam, LPARAM lParam);
76
77
78 //      Globals ====================================================================
79
80 Joy_info joystick;
81 int SpecialDevice = 0;
82
83 char SBall_installed = 0;
84 char joy_installed = 0;
85 char joy_present = 0;
86
87
88 //      Extra Controls structures
89 //SPW_Control SBall_Control;                                            // Space Ball Interface
90
91 static JOYCAPS  WinJoyCaps;
92 static BOOL             CHStickHack=0;
93
94
95 //      Functions ==================================================================
96
97 /*      joy_init
98                 Reset joystick information and request joystick notification from
99                 Windows...  Calibration shouldn't be a problem since Windows 95 takes
100                 care of that.  Also attaches a window to the joystick.
101 */
102 int joy_init(int joy, int spjoy)
103 {
104         int i;
105         //int num_devs;
106
107         atexit(joy_close);
108
109 //      Reset Joystick information.
110         joy_flush();
111         memset(&joystick, 0, sizeof(joystick));
112
113         for (i=0; i<MAX_BUTTONS; i++)
114                 joystick.buttons[i].last_state = 0;
115
116         if ( !joy_installed )   {
117       joy_present = 0;
118       joy_installed = 1;
119       joystick.max_timer = 65536;
120       joystick.read_count = 0;
121       joystick.last_value = 0;
122         }
123
124         if (spjoy) {
125         // Special joystick interface initialize.
126                 int port;
127
128                 SpecialDevice = 0;
129                 joy_present = 0;
130
131         //      if (FindArg("-CyberImpact")) 
132         //              SpecialDevice = TACTILE_CYBERNET;                       
133
134                 if (i = FindArg("-Iforce")) {
135                         SpecialDevice = TACTILE_IMMERSION;
136                         if (atoi(Args[i+1]) != 0) port = atoi(Args[i+1]);
137                 }
138                         
139                 if (SpecialDevice) 
140                         mprintf((0, "Using Special Joystick!\n"));
141                 
142                 switch(SpecialDevice)
143                 {
144                 #ifdef WIN_TACTILE_ON
145                         case TACTILE_CYBERNET:
146                                 TactileStick = TACTILE_CYBERNET;
147                                 if (!Tactile_open(0)) joy_present = 0;
148                                 else joy_present = 1;
149                                 break;
150
151                         case TACTILE_IMMERSION:
152                                 TactileStick = TACTILE_IMMERSION;
153                                 if (!Tactile_open(port)) joy_present = 0;
154                                 else joy_present = 1;
155                                 break;
156                 #endif
157                 }
158                 if (!joy_present) SpecialDevice = 0;
159         }       
160         else 
161                 joy_present = (char)joyGetNumDevs();
162                 
163
164         return joy_present;
165 }
166
167
168 //      joy_close
169 //              closes to joystick by releasing it from the application window
170
171 void joy_close()
172 {
173         if (joy_installed) {
174         
175                 switch (SpecialDevice)
176                 {
177                         case TACTILE_CYBERNET:
178                                 SpecialDevice = 0;
179                                 break;
180                 
181                         case TACTILE_IMMERSION:
182                                 SpecialDevice = 0;      
183                                 break;
184                 }
185                 joyReleaseCapture(joystick.joyid);
186                 joy_installed = 0;
187         }
188 }
189                 
190
191 //      joy_get/set_cal_vals
192 //              functions that access all of the joystick axis'.  
193 //              An array of at least four elements must be passed to each function
194
195 void joy_get_cal_vals(int *axis_min, int *axis_center, int *axis_max)
196 {
197    int i;
198
199    for (i=0; i < 7; i++)
200         {
201       axis_min[i] = joystick.axis_min[i];
202       axis_center[i] = joystick.axis_center[i];
203       axis_max[i] = joystick.axis_max[i];
204    }
205 }
206
207
208 void joy_set_cal_vals(int *axis_min, int *axis_center, int *axis_max)
209 {
210         int i;
211         
212    for (i=0; i < 7; i++)     
213         {
214       joystick.axis_min[i] = axis_min[i];
215       joystick.axis_center[i] = axis_center[i];
216       joystick.axis_max[i] = axis_max[i];
217    }
218 }
219
220
221 //      joy_get_present_mask
222 //              returns the joystick axis' available to be used and accessed
223
224 ubyte joy_get_present_mask()    
225 {
226         return joystick.present_mask;
227 }
228
229
230
231 //      joy_flush
232 //              resets joystick button parameters
233
234 void joy_flush()        
235 {
236    int i;
237
238    for (i=0; i<MAX_BUTTONS; i++ )   {
239       joystick.buttons[i].ignore = 0;
240       joystick.buttons[i].state = 0;
241       joystick.buttons[i].timedown = 0;
242       joystick.buttons[i].downcount = 0;
243       joystick.buttons[i].upcount = 0;
244    }
245 }
246
247
248 //      joy_read_raw_buttons
249 //              returns the status of the buttons at that moment.
250
251 ubyte joy_read_raw_buttons()    
252 {
253         JOYINFOEX       joy;
254         ubyte                   value=0;
255
256         if (!joy_present) { return 0; }
257         
258         memset(&joy, 0, sizeof(joy));
259         joy.dwSize = sizeof(joy);
260         joy.dwFlags = JOY_RETURNBUTTONS | JOY_USEDEADZONE;
261         joyGetPosEx(joystick.joyid, &joy);
262
263 //      For now we support just four buttons
264         value = value | ((ubyte)joy.dwButtons & JOY_BUTTON1);
265         value = value | ((ubyte)joy.dwButtons & JOY_BUTTON2);
266         value = value | ((ubyte)joy.dwButtons & JOY_BUTTON3);
267         value = value | ((ubyte)joy.dwButtons & JOY_BUTTON4);
268         
269         return value;
270 }
271
272
273 ubyte joystick_read_raw_axis( ubyte mask, int * axis )
274 {
275         JOYINFOEX       joy;
276         ubyte read_masks = 0;
277         int i;
278
279         if (!joy_installed) return 0;
280         if (!joy_present) return 0;
281
282         for (i = 0; i < 7; i++)
283                 axis[i] = 0;
284
285         axis[3] = JOY_POVCENTERED;
286
287         switch (SpecialDevice)
288         {
289                 case TACTILE_CYBERNET:
290 //@@                    CyberImpact_ReadRawValues(mask, axis);
291 //@@                    joystick.raw_x1 = axis[0];
292 //@@                    joystick.raw_y1 = axis[1];
293 //@@                    joystick.raw_z1 = axis[2];
294 //@@                    joystick.raw_r1 = axis[4];
295 //@@                    joystick.raw_u1 = axis[5];
296 //@@                    joystick.raw_v1 = axis[6];
297 //@@                    joystick.pov = axis[3];
298 //@@                    break;
299
300                 case TACTILE_IMMERSION:
301                 #ifdef WIN_TACTILE_ON
302                         IForce_ReadRawValues(axis);
303                 #endif
304                         joystick.raw_x1 = axis[0];
305                         joystick.raw_y1 = axis[1];
306                         joystick.raw_z1 = axis[2];
307                         joystick.raw_r1 = axis[4];
308                         joystick.raw_u1 = axis[5];
309                         joystick.raw_v1 = axis[6];
310                         joystick.pov = axis[3];
311                         break;
312
313                 default:
314                         memset(&joy, 0, sizeof(joy));
315                         joy.dwSize = sizeof(joy);
316                         joy.dwFlags = JOY_RETURNALL | JOY_USEDEADZONE;
317                         joyGetPosEx(joystick.joyid, &joy);
318                         joystick.raw_x1 = joy.dwXpos;
319                         joystick.raw_y1 = joy.dwYpos;
320                         joystick.raw_z1 = joy.dwZpos;
321                         joystick.raw_r1 = joy.dwRpos;
322                         joystick.raw_u1 = joy.dwUpos;
323                         joystick.raw_v1 = joy.dwVpos;
324                         joystick.pov = joy.dwPOV;
325         }
326
327         mask &= joystick.present_mask;
328         if (mask == 0) return 0;                                // Don't read if no stick present
329
330         if (mask & JOY_1_X_AXIS) {
331                 axis[0] = joystick.raw_x1;
332                 read_masks |= JOY_1_X_AXIS;
333         }
334         if (mask & JOY_1_Y_AXIS) {
335                 axis[1] = joystick.raw_y1;
336                 read_masks |= JOY_1_Y_AXIS;
337         }
338         if (mask & JOY_1_Z_AXIS) {
339                 axis[2] = joystick.raw_z1;
340                 read_masks |= JOY_1_Z_AXIS;
341         }
342         if (mask & JOY_1_R_AXIS) {
343                 axis[4] = joystick.raw_r1;
344                 read_masks |= JOY_1_R_AXIS;
345         }
346         if (mask & JOY_1_U_AXIS) {
347                 axis[5] = joystick.raw_u1;
348                 read_masks |= JOY_1_U_AXIS;
349         }
350         if (mask & JOY_1_V_AXIS) {
351                 axis[6] = joystick.raw_v1;
352                 read_masks |= JOY_1_V_AXIS;
353         }
354         if (mask & JOY_1_POV) {
355                 axis[3] = joystick.pov;
356                 read_masks |= JOY_1_POV;
357         }
358
359         return read_masks;
360 }
361
362
363 void joy_set_ul()       
364 {
365         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS+JOY_EXT_AXIS, joystick.axis_min );
366         if ( joystick.present_mask & 3 )
367                 joy_present = 1;
368         else
369                 joy_present = 0;
370 }
371
372
373 void joy_set_lr()       
374 {
375         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS+JOY_EXT_AXIS, joystick.axis_max );
376         if ( joystick.present_mask & 3 )
377                 joy_present = 1;
378         else
379                 joy_present = 0;
380 }
381
382
383 void joy_set_cen() 
384 {
385         switch (SpecialDevice)
386         {
387                 case TACTILE_CYBERNET:
388                 //@@    CyberImpact_CalibCenter();
389                         break;
390         }
391
392         joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS+JOY_EXT_AXIS, joystick.axis_center );
393         if ( joystick.present_mask & 3 )
394                 joy_present = 1;
395         else
396                 joy_present = 0;
397 }
398
399
400 void joy_set_cen_fake(int channel)      
401 {
402 //      Do we need this???
403 }
404
405
406 int joy_get_scaled_reading( int raw, int axn )  
407 {
408         int x, d;
409
410         // Make sure it's calibrated properly.
411         if ( joystick.axis_center[axn] - joystick.axis_min[axn] < 128 ) return 0;
412         if ( joystick.axis_max[axn] - joystick.axis_center[axn] < 128 ) return 0;
413
414         raw -= joystick.axis_center[axn];
415
416         if ( raw < 0 )  {
417                 d = joystick.axis_center[axn]-joystick.axis_min[axn];
418         } else {
419                 d = joystick.axis_max[axn]-joystick.axis_center[axn];
420         }
421
422         if ( d )
423                 x = (raw << 7) / d;
424         else 
425                 x = 0;
426
427         if ( x < -128 ) x = -128;
428         if ( x > 127 ) x = 127;
429
430         return x;
431
432 //@@    int x;
433 //@@
434 //@@    if ((joystick.axis_max[axn] - joystick.axis_min[axn]) == 0) return 0;
435 //@@    if (axn == 3) return raw;
436 //@@    
437 //@@    x = (256 * raw)/(joystick.axis_max[axn]-joystick.axis_min[axn]);
438 //@@    x=x- 128;
439 //@@
440 //@@    return x;
441 }       
442
443
444 void joy_get_pos( int *x, int *y )      
445 {
446         ubyte flags;
447         int axis[4];
448
449
450         if (!joy_installed || !joy_present) { *x = *y = 0; return; }
451
452         flags=joystick_read_raw_axis( JOY_1_X_AXIS+JOY_1_Y_AXIS, axis );
453
454         if ( flags & JOY_1_X_AXIS )
455                 *x = joy_get_scaled_reading( axis[0], 0 );
456         else
457                 *x = 0;
458
459         if ( flags & JOY_1_Y_AXIS )
460                 *y = joy_get_scaled_reading( axis[1], 1 );
461         else
462                 *y = 0;
463 }
464
465
466 ubyte joy_read_stick( ubyte masks, int *axis )  
467 {
468         ubyte flags;
469         int raw_axis[7];        
470
471
472         if ((!joy_installed)||(!joy_present)) { 
473                 axis[0] = 0; axis[1] = 0;
474                 axis[2] = 0; axis[3] = 0;
475                 axis[4] = 0; axis[5] = 0;
476                 axis[6] = 0; 
477                 return 0;  
478         }
479
480         flags=joystick_read_raw_axis( masks, raw_axis );
481
482         if ( flags & JOY_1_X_AXIS )
483                 axis[0] = joy_get_scaled_reading( raw_axis[0], 0 );
484         else
485                 axis[0] = 0;
486
487         if ( flags & JOY_1_Y_AXIS )
488                 axis[1] = joy_get_scaled_reading( raw_axis[1], 1 );
489         else
490                 axis[1] = 0;
491
492         if ( flags & JOY_1_Z_AXIS )
493                 axis[2] = joy_get_scaled_reading( raw_axis[2], 2 );
494         else
495                 axis[2] = 0;
496
497         if ( flags & JOY_1_R_AXIS )
498                 axis[4] = joy_get_scaled_reading( raw_axis[4], 4 );
499         else
500                 axis[4] = 0;
501
502         if ( flags & JOY_1_U_AXIS )
503                 axis[5] = joy_get_scaled_reading( raw_axis[5], 5 );
504         else
505                 axis[5] = 0;
506
507         if ( flags & JOY_1_V_AXIS )
508                 axis[6] = joy_get_scaled_reading( raw_axis[6], 6 );
509         else
510                 axis[6] = 0;
511
512         if ( flags & JOY_1_POV )
513                 axis[3] = joy_get_scaled_reading( raw_axis[3], 3 );
514         else
515                 axis[3] = 0;
516
517         return flags;
518 }
519
520
521 int joy_get_btns()      
522 {
523         if ((!joy_installed)||(!joy_present)) return 0;
524         return joy_read_raw_buttons();
525 }
526
527
528 void joy_get_btn_down_cnt( int *btn0, int *btn1 ) 
529 {
530         if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }
531                 
532         *btn0 = joystick.buttons[0].downcount;
533         joystick.buttons[0].downcount = 0;
534         *btn1 = joystick.buttons[1].downcount;
535         joystick.buttons[1].downcount = 0;
536 }
537
538
539 int joy_get_button_state( int btn )     
540 {
541         int count;
542
543         if ((!joy_installed)||(!joy_present)) return 0;
544
545         if ( btn >= MAX_BUTTONS ) return 0;
546
547         count = joystick.buttons[btn].state;
548         
549         return  count;
550 }
551
552
553 int joy_get_button_up_cnt( int btn ) 
554 {
555         int count;
556
557         if ((!joy_installed)||(!joy_present)) return 0;
558
559         if ( btn >= MAX_BUTTONS ) return 0;
560
561         count = joystick.buttons[btn].upcount;
562         joystick.buttons[btn].upcount = 0;
563
564         return count;
565 }
566
567
568 int joy_get_button_down_cnt( int btn ) 
569 {
570         int count;
571
572         if ((!joy_installed)||(!joy_present)) return 0;
573         if ( btn >= MAX_BUTTONS ) return 0;
574
575         count = joystick.buttons[btn].downcount;
576         joystick.buttons[btn].downcount = 0;
577
578         return count;
579 }
580
581         
582 fix joy_get_button_down_time( int btn ) 
583 {
584         fix count;
585
586         if ((!joy_installed)||(!joy_present)) return 0;
587         if ( btn >= MAX_BUTTONS ) return 0;
588
589         count = joystick.buttons[btn].timedown;
590         joystick.buttons[btn].timedown = 0;
591
592         return count;           //fixdiv(count, 1000);
593 }
594
595
596 void joy_get_btn_up_cnt( int *btn0, int *btn1 ) 
597 {
598         if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }
599         
600         *btn0 = joystick.buttons[0].upcount;
601         joystick.buttons[0].upcount = 0;
602         *btn1 = joystick.buttons[1].upcount;
603         joystick.buttons[1].upcount = 0;
604 }
605
606
607 void joy_set_btn_values( int btn, int state, fix timedown, int downcount, int upcount )
608 {
609         joystick.buttons[btn].ignore = 1;
610         joystick.buttons[btn].state = state;
611         joystick.buttons[btn].timedown = timedown;      //fixmul(timedown,1000);        //convert to miliseconds
612         joystick.buttons[btn].downcount = downcount;
613         joystick.buttons[btn].upcount = upcount;
614 }
615
616
617 //      Windows 95 Custom joystick configuration.
618 //              These are 'low level' routines to get information about a joystick
619 //              in Windows 95.
620 //              Note: spjoy is for 'unique' joysticks.
621
622 int joy95_init_stick(int joy, int spjoy)
623 {
624         UINT                    joyid;
625         MMRESULT        mmresult;
626         char                    joyname[256];
627
628         if (!joy_installed)               
629                 return 0;
630
631         switch (SpecialDevice)
632         {
633                 case TACTILE_CYBERNET:
634                 //@@    joystick.present_mask = JOY_1_X_AXIS | JOY_1_Y_AXIS | JOY_1_Z_AXIS | JOY_1_POV;
635                 //@@    joystick.has_pov = 1;
636                         break;
637
638                 case TACTILE_IMMERSION:
639                         mprintf((0, "Joystick name= I-Force compatible device.\n"));
640                         break;
641         }
642
643 //      if (spjoy) return 1;
644
645         joystick.joyid = 0;
646
647         if (joy == 1) joystick.joyid = joyid = JOYSTICKID1;
648         else 
649                 return 0;
650
651         mmresult = joyGetDevCaps(joyid, &WinJoyCaps, sizeof(WinJoyCaps));
652         if (mmresult != JOYERR_NOERROR) {
653                 mprintf((1, "Attempt to get Joystick %d caps failed.\n", joy));
654                 return 0;
655         }
656    mprintf ((0,"Joystick name=%s\n",WinJoyCaps.szPname));
657
658 //      Tell our Window App. about this joystick.
659         joySetThreshold(joyid, WinJoyCaps.wXmax/256);
660         mmresult = joySetCapture(GetLibraryWindow(), 
661                                                 joyid, 
662                                                 JOY_POLL_RATE, 
663                                                 FALSE);
664
665         if (mmresult != JOYERR_NOERROR) {
666                 mprintf((1, "Unable to capture joystick %d. Error=%d\n", joy,mmresult));
667                 return 0;
668         }
669
670 //      Get raw axis' min and max.
671         joystick.threshold                      = WinJoyCaps.wXmax/256;
672         joystick.max_timer                      = WinJoyCaps.wPeriodMax;
673
674         joystick.threshold                      = WinJoyCaps.wXmax/256;
675         joystick.max_timer                      = WinJoyCaps.wPeriodMax;
676         joystick.axis_min[0]                    = WinJoyCaps.wXmin;
677         joystick.axis_min[1]                    = WinJoyCaps.wYmin;
678         joystick.axis_min[2]                    = WinJoyCaps.wZmin;
679         joystick.axis_min[4]                    = WinJoyCaps.wRmin;
680         joystick.axis_min[5]                    = WinJoyCaps.wUmin;
681         joystick.axis_min[6]                    = WinJoyCaps.wVmin;
682         joystick.axis_max[0]                    = WinJoyCaps.wXmax;
683         joystick.axis_max[1]                    = WinJoyCaps.wYmax;
684         joystick.axis_max[2]                    = WinJoyCaps.wZmax;
685         joystick.axis_max[4]                    = WinJoyCaps.wRmax;
686         joystick.axis_max[5]                    = WinJoyCaps.wUmax;
687         joystick.axis_max[6]                    = WinJoyCaps.wVmax;
688         joystick.axis_center[0]                 = (WinJoyCaps.wXmax-WinJoyCaps.wXmin)/2;
689         joystick.axis_center[1]                 = (WinJoyCaps.wYmax-WinJoyCaps.wYmin)/2;
690         joystick.axis_center[2]                 = (WinJoyCaps.wZmax-WinJoyCaps.wZmin)/2;
691         joystick.axis_center[4]                 = (WinJoyCaps.wRmax-WinJoyCaps.wRmin)/2;
692         joystick.axis_center[5]                 = (WinJoyCaps.wUmax-WinJoyCaps.wUmin)/2;
693         joystick.axis_center[6]                 = (WinJoyCaps.wVmax-WinJoyCaps.wVmin)/2;
694
695         joystick.present_mask = JOY_1_X_AXIS | JOY_1_Y_AXIS;
696         
697         if (WinJoyCaps.wCaps & JOYCAPS_HASPOV) {
698                 joystick.has_pov = 1;
699                 joystick.present_mask |= JOY_1_POV;
700         }
701         else joystick.has_pov = 0;
702
703         if (WinJoyCaps.wCaps & JOYCAPS_HASZ) 
704                 joystick.present_mask |= JOY_1_Z_AXIS;
705         if (WinJoyCaps.wCaps & JOYCAPS_HASR) 
706                 joystick.present_mask |= JOY_1_R_AXIS;
707         if (WinJoyCaps.wCaps & JOYCAPS_HASU)
708                 joystick.present_mask |= JOY_1_U_AXIS;
709         if (WinJoyCaps.wCaps & JOYCAPS_HASV) 
710                 joystick.present_mask |= JOY_1_V_AXIS;
711
712         joy95_get_name(JOYSTICKID1, joyname, 255);
713         if (!strcmpi(joyname, "CH Flightstick Pro") || FindArg("-ordinaljoy")) {
714                 CHStickHack = 1;
715         }
716         else CHStickHack = 0;
717
718                         
719         return 1;
720 }
721
722 void joy95_get_name(int joyid, char *name, int namesize) 
723 {
724         JOYCAPS jc;
725         MMRESULT res;
726         //HKEY hkey;
727         //long lres;
728         char regpath[256];
729         registry_handle *rhandle;
730         char reglabel[32];
731
732         name[0] = 0;
733
734         switch(SpecialDevice) 
735         {
736                 case TACTILE_IMMERSION:
737                         strcpy(name, "I-Force Force-Feedback");
738                         return;
739         }
740
741         res = joyGetDevCaps(joyid, &jc, sizeof(jc));
742         if (res != JOYERR_NOERROR) {
743                 strcpy(name, "NO JOYSTICK DETECTED");
744                 return;
745         }
746         
747 // we have the reg key!
748         registry_setpath(HKEY_LOCAL_MACHINE);
749         strcpy(regpath, "System\\CurrentControlSet\\control\\MediaResources\\joystick\\");
750         strcat(regpath, jc.szRegKey);
751         strcat(regpath, "\\CurrentJoystickSettings");
752         sprintf(reglabel, "Joystick%dOEMName", joyid+1);
753
754         if ((rhandle = registry_open(regpath))) {
755                 if (!registry_getstring(rhandle, reglabel, name, namesize)) {
756                         registry_close(rhandle);
757                         strcpy(name, "JOYSTICK");
758                         return;
759                 }
760                 registry_close(rhandle);
761         
762         // have reg entry for full name
763                 strcpy(regpath, "System\\CurrentControlSet\\control\\MediaProperties\\PrivateProperties\\Joystick\\OEM\\");
764                 strcat(regpath, name);
765         
766                 if ((rhandle = registry_open(regpath))) {
767                         if (!registry_getstring(rhandle, "OEMName", name, namesize)) {
768                                 registry_close(rhandle);
769                                 strcpy(name, "JOYSTICK");
770                                 return;
771                         }
772                         registry_close(rhandle);
773                 }
774                 else strcpy(name, "JOYSTICK"); 
775         }
776         else strcpy(name, "JOYSTICK");
777 }
778                   
779
780         
781 /*      joy_handler_win
782                 This function takes the place of the joy_handler function for dos.  
783                 The main window procedure will call this function whenever a joystick message
784                 is transmitted.
785 */
786 LRESULT joy_handler_win(HWND hWnd, UINT joymsg, UINT wParam, LPARAM lParam)
787 {
788         DWORD interval_time;
789         DWORD new_time;
790         static DWORD old_time = 0xffffffff;
791         
792         Button_info *button;
793         int state=0;
794         DWORD value=0;
795         int i;
796
797 //      take care of first time initialization
798         if (!joy_installed) return 1;
799         if (old_time == 0xffffffff) {
800                 old_time = timer_get_fixed_seconds();
801                 return 0;
802         }
803
804 //      read and translate buttons 0-3
805         switch (joymsg)
806         {
807                 JOYINFOEX       joy;
808
809                 case MM_JOY1MOVE:
810                 //      For now we support just four buttons
811                         memset(&joy, 0, sizeof(joy));
812                         joy.dwSize = sizeof(joy);
813                         joy.dwFlags = JOY_RETURNBUTTONS | JOY_RETURNPOV;
814                         joyGetPosEx(joystick.joyid, &joy);
815
816                         if (CHStickHack) {
817                                 if (joy.dwPOV == JOY_POVCENTERED && joy.dwButtons > 0) {                  
818                                         value = (1 << (joy.dwButtons-1));
819                                 }
820                                 else value = 0;
821                                 mprintf_at((0, 2, 32, "RAW:%08x OUR:%08x\n", joy.dwButtons, value));
822                         }       
823                         else {
824                                 value = joy.dwButtons;
825                         }
826                         break;
827         }
828
829         new_time = timer_get_fixed_seconds();
830         if (new_time < old_time) old_time = abs(new_time - old_time);
831         interval_time = new_time - old_time;
832
833         for (i = 0; i < MAX_BUTTONS; i++)
834         {
835         //      Check status of each button and translate information to the button
836         // structure.
837                 button = &joystick.buttons[i];
838                 
839                 if (!button->ignore) {
840                         if ( i < (MAX_BUTTONS-4) ) state = (value >> i) & 1;
841                         else state = 0;
842
843                         if ( button->last_state == state )      {
844                                 if (state) {
845                                         button->timedown += interval_time;      //interval_ms;
846                                 }
847                         } else {
848                                 if (state)      {
849                                         button->downcount += state;
850                                         button->state = 1;
851                                 } else {        
852                                         button->upcount += button->state;
853                                         button->state = 0;
854                                 }
855                                 button->last_state = state;
856                         }
857                 }
858         }
859
860         old_time = new_time;
861         return 0;
862 }               
863
864
865 void joy_stop_poll()
866 {
867         joyReleaseCapture(joystick.joyid);
868 }
869
870
871 void joy_start_poll()
872 {
873         joySetCapture(GetLibraryWindow(), 
874                                                 joystick.joyid, 
875                                                 JOY_POLL_RATE, 
876                                                 FALSE);
877 }
878
879
880 //      OBSOLETE!!!!
881
882 //      joy_get/set_timer_rate
883 //              these functions are currently implemented for compatability with 
884 //              DOS Descent2, but may be unecessary for now.
885
886 void joy_set_timer_rate(int max_value ) 
887 {
888 //      No real effect, since Joystick runs on its own timer in Windows, for now.
889 }
890
891
892 int joy_get_timer_rate()        
893 {
894         return joystick.max_timer;
895 }
896
897 void joy_handler(int ticks_this_time)   
898 {
899 //      replaced by joy_handler_win for Windows
900 }
901
902 void joy_set_slow_reading(int flag)
903 {
904 //      No need to do this.  In Windows, there are only slow readings.
905 }
906
907 void joy_poll()
908 {
909
910 }
911
912
913