Change the callback declarations to a safer format.
[wine] / windows / keyboard.c
1 /*
2  * KEYBOARD driver
3  *
4  * Copyright 1993 Bob Amstadt
5  * Copyright 1996 Albrecht Kleine 
6  * Copyright 1997 David Faure
7  * Copyright 1998 Morten Welinder
8  * Copyright 1998 Ulrich Weigand
9  *
10  */
11
12 #include <stdlib.h>
13 #include <string.h>
14 #include <ctype.h>
15
16 #include "windef.h"
17 #include "winbase.h"
18 #include "wingdi.h"
19 #include "winuser.h"
20 #include "wine/keyboard16.h"
21 #include "win.h"
22 #include "heap.h"
23 #include "keyboard.h"
24 #include "user.h"
25 #include "message.h"
26 #include "callback.h"
27 #include "builtin16.h"
28 #include "debugtools.h"
29 #include "winerror.h"
30
31 DEFAULT_DEBUG_CHANNEL(keyboard);
32 DECLARE_DEBUG_CHANNEL(event);
33
34 /**********************************************************************/
35
36 static LPKEYBD_EVENT_PROC DefKeybEventProc = NULL;
37 LPBYTE pKeyStateTable = NULL;
38
39 /***********************************************************************
40  *              Inquire (KEYBOARD.1)
41  */
42 WORD WINAPI KEYBOARD_Inquire(LPKBINFO kbInfo) 
43 {
44   kbInfo->Begin_First_Range = 0;
45   kbInfo->End_First_Range = 0;
46   kbInfo->Begin_Second_Range = 0;
47   kbInfo->End_Second_Range = 0;
48   kbInfo->StateSize = 16; 
49   
50   return sizeof(KBINFO);
51 }
52
53 /***********************************************************************
54  *              Enable (KEYBOARD.2)
55  */
56 VOID WINAPI KEYBOARD_Enable( LPKEYBD_EVENT_PROC lpKeybEventProc, 
57                              LPBYTE lpKeyState )
58 {
59   static BOOL initDone = FALSE;
60
61   THUNK_Free( (FARPROC)DefKeybEventProc );
62   
63   DefKeybEventProc = lpKeybEventProc;
64   pKeyStateTable = lpKeyState;
65   
66   /* all states to false */
67   memset( lpKeyState, 0, 256 );
68   
69   if (!initDone) USER_Driver.pInitKeyboard();
70   initDone = TRUE;
71 }
72
73 /**********************************************************************/
74
75 static VOID WINAPI KEYBOARD_CallKeybdEventProc( FARPROC16 proc,
76                                                 BYTE bVk, BYTE bScan,
77                                                 DWORD dwFlags, DWORD dwExtraInfo )
78 {
79     CONTEXT86 context;
80
81     memset( &context, 0, sizeof(context) );
82     context.SegCs = SELECTOROF( proc );
83     context.Eip   = OFFSETOF( proc );
84     context.Eax   = bVk | ((dwFlags & KEYEVENTF_KEYUP)? 0x8000 : 0);
85     context.Ebx   = bScan | ((dwFlags & KEYEVENTF_EXTENDEDKEY) ? 0x100 : 0);
86     context.Esi   = LOWORD( dwExtraInfo );
87     context.Edi   = HIWORD( dwExtraInfo );
88
89     wine_call_to_16_regs_short( &context, 0 );
90 }
91
92 /**********************************************************************/
93
94 VOID WINAPI WIN16_KEYBOARD_Enable( FARPROC16 proc, LPBYTE lpKeyState )
95 {
96     LPKEYBD_EVENT_PROC thunk = 
97       (LPKEYBD_EVENT_PROC)THUNK_Alloc( proc, (RELAY)KEYBOARD_CallKeybdEventProc );
98
99     KEYBOARD_Enable( thunk, lpKeyState );
100 }
101
102 /***********************************************************************
103  *              Disable (KEYBOARD.3)
104  */
105 VOID WINAPI KEYBOARD_Disable(VOID)
106 {
107   THUNK_Free( (FARPROC)DefKeybEventProc );
108   
109   DefKeybEventProc = NULL;
110   pKeyStateTable = NULL;
111 }
112
113 /***********************************************************************
114  *           KEYBOARD_SendEvent
115  */
116 void KEYBOARD_SendEvent( BYTE bVk, BYTE bScan, DWORD dwFlags,
117                          DWORD posX, DWORD posY, DWORD time )
118 {
119   WINE_KEYBDEVENT wke;
120   int iWndsLocks;
121   
122   if ( !DefKeybEventProc ) return;
123   
124   TRACE_(event)("(%d,%d,%04lX)\n", bVk, bScan, dwFlags );
125   
126   wke.magic = WINE_KEYBDEVENT_MAGIC;
127   wke.posX  = posX;
128   wke.posY  = posY;
129   wke.time  = time;
130   
131   /* To avoid deadlocks, we have to suspend all locks on windows structures
132      before the program control is passed to the keyboard driver */
133   iWndsLocks = WIN_SuspendWndsLock();
134   DefKeybEventProc( bVk, bScan, dwFlags, (DWORD)&wke );
135   WIN_RestoreWndsLock(iWndsLocks);
136 }
137
138 /**********************************************************************
139  *              SetSpeed (KEYBOARD.7)
140  */
141 WORD WINAPI SetSpeed16(WORD unused)
142 {
143     FIXME("(%04x): stub\n", unused);
144     return 0xffff;
145 }
146
147 /**********************************************************************
148  *              ScreenSwitchEnable (KEYBOARD.100)
149  */
150 VOID WINAPI ScreenSwitchEnable16(WORD unused)
151 {
152   FIXME("(%04x): stub\n", unused);
153 }
154
155 /**********************************************************************
156  *              OemKeyScan (KEYBOARD.128) (USER32.@)
157  */
158 DWORD WINAPI OemKeyScan(WORD wOemChar)
159 {
160   TRACE("*OemKeyScan (%d)\n", wOemChar);
161
162   return wOemChar;
163 }
164
165 /**********************************************************************
166  *              VkKeyScan (KEYBOARD.129)
167  *
168  * VkKeyScan translates an ANSI character to a virtual-key and shift code
169  * for the current keyboard.
170  * high-order byte yields :
171  *      0       Unshifted
172  *      1       Shift
173  *      2       Ctrl
174  *      3-5     Shift-key combinations that are not used for characters
175  *      6       Ctrl-Alt
176  *      7       Ctrl-Alt-Shift
177  *      I.e. :  Shift = 1, Ctrl = 2, Alt = 4.
178  * FIXME : works ok except for dead chars :
179  * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
180  * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
181  */
182
183 WORD WINAPI VkKeyScan16(CHAR cChar)
184 {
185     return USER_Driver.pVkKeyScan(cChar);
186 }
187
188 /******************************************************************************
189  *              GetKeyboardType (KEYBOARD.130)
190  */
191 INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
192 {
193   TRACE("(%d)\n", nTypeFlag);
194   switch(nTypeFlag)
195     {
196     case 0:      /* Keyboard type */
197       return 4;    /* AT-101 */
198       break;
199     case 1:      /* Keyboard Subtype */
200       return 0;    /* There are no defined subtypes */
201       break;
202     case 2:      /* Number of F-keys */
203       return 12;   /* We're doing an 101 for now, so return 12 F-keys */
204       break;
205     default:     
206       WARN("Unknown type\n");
207       return 0;    /* The book says 0 here, so 0 */
208     }
209 }
210
211 /******************************************************************************
212  *              MapVirtualKey (KEYBOARD.131)
213  *
214  * MapVirtualKey translates keycodes from one format to another
215  */
216 UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
217 {
218     return USER_Driver.pMapVirtualKey(wCode,wMapType);
219 }
220
221 /****************************************************************************
222  *              GetKBCodePage (KEYBOARD.132)
223  */
224 INT16 WINAPI GetKBCodePage16(void)
225 {
226     return GetKBCodePage();
227 }
228
229 /****************************************************************************
230  *              GetKeyNameText (KEYBOARD.133)
231  */
232 INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
233 {
234     return USER_Driver.pGetKeyNameText(lParam, lpBuffer, nSize);
235 }
236
237 /****************************************************************************
238  *              ToAscii (KEYBOARD.4)
239  *
240  * The ToAscii function translates the specified virtual-key code and keyboard
241  * state to the corresponding Windows character or characters.
242  *
243  * If the specified key is a dead key, the return value is negative. Otherwise,
244  * it is one of the following values:
245  * Value        Meaning
246  * 0    The specified virtual key has no translation for the current state of the keyboard.
247  * 1    One Windows character was copied to the buffer.
248  * 2    Two characters were copied to the buffer. This usually happens when a
249  *      dead-key character (accent or diacritic) stored in the keyboard layout cannot
250  *      be composed with the specified virtual key to form a single character.
251  *
252  * FIXME : should do the above (return 2 for non matching deadchar+char combinations)
253  *
254  */
255 INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState, 
256                        LPVOID lpChar, UINT16 flags) 
257 {
258     return ToAscii( virtKey, scanCode, lpKeyState, lpChar, flags );
259 }
260
261 /***********************************************************************
262  *              KEYBOARD_GetBeepActive
263  */
264 BOOL KEYBOARD_GetBeepActive()
265 {
266     return USER_Driver.pGetBeepActive();
267 }
268
269 /***********************************************************************
270  *              KEYBOARD_SetBeepActive
271  */
272 void KEYBOARD_SetBeepActive(BOOL bActivate)
273 {
274     USER_Driver.pSetBeepActive(bActivate);
275 }
276
277 /***********************************************************************
278  *              MessageBeep (USER.104)
279  */
280 void WINAPI MessageBeep16( UINT16 i )
281 {
282     MessageBeep( i );
283 }
284
285 /***********************************************************************
286  *              MessageBeep (USER32.@)
287  */
288 BOOL WINAPI MessageBeep( UINT i )
289 {
290     USER_Driver.pBeep();
291     return TRUE;
292 }