MingW apparently doesn't know about RIM_INPUTSINK, define it if it isn't already.
[blender-staging.git] / intern / ghost / intern / GHOST_SystemWin32.h
1 /*
2  * $Id$
3  * ***** BEGIN GPL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
20  * All rights reserved.
21  *
22  * The Original Code is: all of this file.
23  *
24  * Contributor(s): none yet.
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 /** \file ghost/intern/GHOST_SystemWin32.h
30  *  \ingroup GHOST
31  * Declaration of GHOST_SystemWin32 class.
32  */
33
34 #ifndef _GHOST_SYSTEM_WIN32_H_
35 #define _GHOST_SYSTEM_WIN32_H_
36
37 #ifndef WIN32
38 #error WIN32 only!
39 #endif // WIN32
40
41 #include <windows.h>
42
43 #include "GHOST_System.h"
44
45 #if defined(__CYGWIN32__)
46 #       define __int64 long long
47 #endif
48
49 #ifndef WM_INPUT
50 #define WM_INPUT 0x00FF
51 #endif 
52 #ifndef RID_INPUT
53 #define RID_INPUT 0x10000003
54 #endif
55 #ifndef RIM_INPUTSINK
56 #define RIM_INPUTSINK 0x1
57 #endif
58 #ifndef RI_KEY_BREAK
59 #define RI_KEY_BREAK 0x1
60 #endif
61 #ifndef RI_KEY_E0
62 #define RI_KEY_E0 0x2
63 #endif
64 #ifndef RI_KEY_E1
65 #define RI_KEY_E1 0x4
66 #endif
67 #ifndef RIM_TYPEMOUSE
68 #define RIM_TYPEMOUSE           0x0
69 #define RIM_TYPEKEYBOARD        0x1
70 #define RIM_TYPEHID                     0x2
71
72 typedef struct tagRAWINPUTDEVICE {
73         USHORT usUsagePage;
74         USHORT usUsage;
75         DWORD dwFlags;
76         HWND hwndTarget;
77 } RAWINPUTDEVICE;
78
79
80
81 typedef struct tagRAWINPUTHEADER {
82         DWORD dwType;
83         DWORD dwSize;
84         HANDLE hDevice;
85         WPARAM wParam;
86 } RAWINPUTHEADER;
87
88 typedef struct tagRAWMOUSE {
89         USHORT usFlags;
90         union {
91                 ULONG ulButtons;
92                 struct  {
93                         USHORT  usButtonFlags;
94                         USHORT  usButtonData;
95                 };
96         };
97         ULONG   ulRawButtons;
98         LONG    lLastX;
99         LONG    lLastY;
100         ULONG   ulExtraInformation;
101 } RAWMOUSE;
102
103 typedef struct tagRAWKEYBOARD {
104         USHORT  MakeCode;
105         USHORT  Flags;
106         USHORT  Reserved;
107         USHORT  VKey;
108         UINT    Message;
109         ULONG   ExtraInformation;
110 } RAWKEYBOARD;
111
112 typedef struct tagRAWHID {
113         DWORD   dwSizeHid;
114         DWORD   dwCount;
115         BYTE    bRawData[1];
116 } RAWHID;
117
118 typedef struct tagRAWINPUT {
119         RAWINPUTHEADER header;
120         union {
121                 RAWMOUSE        mouse;
122                 RAWKEYBOARD keyboard;
123                 RAWHID      hid;
124         } data;
125 } RAWINPUT;
126
127 DECLARE_HANDLE(HRAWINPUT);
128 #endif
129
130 #ifdef FREE_WINDOWS
131 #define NEED_RAW_PROC
132 typedef BOOL (WINAPI * LPFNDLLRRID)(RAWINPUTDEVICE*,UINT, UINT);
133 #define RegisterRawInputDevices(pRawInputDevices, uiNumDevices, cbSize) ((pRegisterRawInputDevices)?pRegisterRawInputDevices(pRawInputDevices, uiNumDevices, cbSize):0)
134
135
136 typedef UINT (WINAPI * LPFNDLLGRID)(HRAWINPUT, UINT, LPVOID, PUINT, UINT);
137 #define GetRawInputData(hRawInput, uiCommand, pData, pcbSize, cbSizeHeader) ((pGetRawInputData)?pGetRawInputData(hRawInput, uiCommand, pData, pcbSize, cbSizeHeader):(UINT)-1)
138 #endif
139
140 class GHOST_EventButton;
141 class GHOST_EventCursor;
142 class GHOST_EventKey;
143 class GHOST_EventWheel;
144 class GHOST_EventWindow;
145 class GHOST_EventDragnDrop;
146
147 /**
148  * WIN32 Implementation of GHOST_System class.
149  * @see GHOST_System.
150  * @author      Maarten Gribnau
151  * @date        May 10, 2001
152  */
153 class GHOST_SystemWin32 : public GHOST_System {
154 public:
155         /**
156          * Constructor.
157          */
158         GHOST_SystemWin32();
159
160         /**
161          * Destructor.
162          */
163         virtual ~GHOST_SystemWin32();
164
165         /***************************************************************************************
166          ** Time(r) functionality
167          ***************************************************************************************/
168
169         /**
170          * Returns the system time.
171          * Returns the number of milliseconds since the start of the system process.
172          * This overloaded method uses the high frequency timer if available.
173          * @return The number of milliseconds.
174          */
175         virtual GHOST_TUns64 getMilliSeconds() const;
176
177         /***************************************************************************************
178          ** Display/window management functionality
179          ***************************************************************************************/
180
181         /**
182          * Returns the number of displays on this system.
183          * @return The number of displays.
184          */
185         virtual GHOST_TUns8 getNumDisplays() const;
186
187         /**
188          * Returns the dimensions of the main display on this system.
189          * @return The dimension of the main display.
190          */
191         virtual void getMainDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const;
192         
193         /**
194          * Create a new window.
195          * The new window is added to the list of windows managed. 
196          * Never explicitly delete the window, use disposeWindow() instead.
197          * @param       title   The name of the window (displayed in the title bar of the window if the OS supports it).
198          * @param       left    The coordinate of the left edge of the window.
199          * @param       top             The coordinate of the top edge of the window.
200          * @param       width   The width the window.
201          * @param       height  The height the window.
202          * @param       state   The state of the window when opened.
203          * @param       type    The type of drawing context installed in this window.
204          * @param       stereoVisual    Stereo visual for quad buffered stereo.
205          * @param       numOfAASamples  Number of samples used for AA (zero if no AA)
206          * @param       parentWindow    Parent (embedder) window
207          * @return      The new window (or 0 if creation failed).
208          */
209         virtual GHOST_IWindow* createWindow(
210                 const STR_String& title,
211                 GHOST_TInt32 left, GHOST_TInt32 top, GHOST_TUns32 width, GHOST_TUns32 height,
212                 GHOST_TWindowState state, GHOST_TDrawingContextType type,
213                 const bool stereoVisual = false,
214                 const GHOST_TUns16 numOfAASamples = 0,
215                 const GHOST_TEmbedderWindowID parentWindow = 0 );
216
217         /***************************************************************************************
218          ** Event management functionality
219          ***************************************************************************************/
220
221         /**
222          * Gets events from the system and stores them in the queue.
223          * @param waitForEvent Flag to wait for an event (or return immediately).
224          * @return Indication of the presence of events.
225          */
226         virtual bool processEvents(bool waitForEvent);
227         
228
229         /***************************************************************************************
230          ** Cursor management functionality
231          ***************************************************************************************/
232
233         /**
234          * Returns the current location of the cursor (location in screen coordinates)
235          * @param x                     The x-coordinate of the cursor.
236          * @param y                     The y-coordinate of the cursor.
237          * @return                      Indication of success.
238          */
239         virtual GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const;
240
241         /**
242          * Updates the location of the cursor (location in screen coordinates).
243          * @param x                     The x-coordinate of the cursor.
244          * @param y                     The y-coordinate of the cursor.
245          * @return                      Indication of success.
246          */
247         virtual GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y);
248
249         /***************************************************************************************
250          ** Access to mouse button and keyboard states.
251          ***************************************************************************************/
252
253         /**
254          * Returns the state of all modifier keys.
255          * @param keys  The state of all modifier keys (true == pressed).
256          * @return              Indication of success.
257          */
258         virtual GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys& keys) const;
259
260         /**
261          * Returns the state of the mouse buttons (ouside the message queue).
262          * @param buttons       The state of the buttons.
263          * @return                      Indication of success.
264          */
265         virtual GHOST_TSuccess getButtons(GHOST_Buttons& buttons) const;
266
267         /**
268          * Returns unsinged char from CUT_BUFFER0
269          * @param selection             Used by X11 only
270          * @return                              Returns the Clipboard
271          */
272         virtual GHOST_TUns8* getClipboard(bool selection) const;
273         
274         /**
275          * Puts buffer to system clipboard
276          * @param selection             Used by X11 only
277          * @return                              No return
278          */
279         virtual void putClipboard(GHOST_TInt8 *buffer, bool selection) const;
280
281         /**
282          * Creates a drag'n'drop event and pushes it immediately onto the event queue. 
283          * Called by GHOST_DropTargetWin32 class.
284          * @param eventType The type of drag'n'drop event
285          * @param draggedObjectType The type object concerned (currently array of file names, string, ?bitmap)
286          * @param mouseX x mouse coordinate (in window coordinates)
287          * @param mouseY y mouse coordinate
288          * @param window The window on which the event occurred
289          * @return Indication whether the event was handled. 
290          */
291         static GHOST_TSuccess pushDragDropEvent(GHOST_TEventType eventType, GHOST_TDragnDropTypes draggedObjectType,GHOST_IWindow* window, int mouseX, int mouseY, void* data);
292          
293 protected:
294         /**
295          * Initializes the system.
296          * For now, it justs registers the window class (WNDCLASS).
297          * @return A success value.
298          */
299         virtual GHOST_TSuccess init();
300
301         /**
302          * Closes the system down.
303          * @return A success value.
304          */
305         virtual GHOST_TSuccess exit();
306         
307         /**
308          * Converts raw WIN32 key codes from the wndproc to GHOST keys.
309          * @param window->      The window for this handling
310          * @param vKey          The virtual key from hardKey
311          * @param ScanCode      The ScanCode of pressed key (simular to PS/2 Set 1)
312          * @param extend        Flag if key is not primerly (left or right)
313          * @return The GHOST key (GHOST_kKeyUnknown if no match).
314          */
315         virtual GHOST_TKey convertKey(GHOST_IWindow *window, short vKey, short ScanCode, short extend) const;
316
317         /**
318          * Catches raw WIN32 key codes from WM_INPUT in the wndproc.
319          * @param window->      The window for this handling
320          * @param wParam        The wParam from the wndproc
321          * @param lParam        The lParam from the wndproc
322          * @param keyDown       Pointer flag that specify if a key is down
323          * @param vk            Pointer to virtual key
324          * @return The GHOST key (GHOST_kKeyUnknown if no match).
325          */
326         virtual GHOST_TKey hardKey(GHOST_IWindow *window, WPARAM wParam, LPARAM lParam, int * keyDown, char * vk);
327
328         /**
329          * Creates modifier key event(s) and updates the key data stored locally (m_modifierKeys).
330          * With the modifier keys, we want to distinguish left and right keys.
331          * Sometimes this is not possible (Windows ME for instance). Then, we want
332          * events generated for both keys.
333          * @param window        The window receiving the event (the active window).
334          */
335         GHOST_EventKey* processModifierKeys(GHOST_IWindow *window);
336
337         /**
338          * Creates mouse button event.
339          * @param type          The type of event to create.
340          * @param window        The window receiving the event (the active window).
341          * @param mask          The button mask of this event.
342          * @return The event created.
343          */
344         static GHOST_EventButton* processButtonEvent(GHOST_TEventType type, GHOST_IWindow *window, GHOST_TButtonMask mask);
345
346         /**
347          * Creates cursor event.
348          * @param type          The type of event to create.
349          * @param window        The window receiving the event (the active window).
350          * @return The event created.
351          */
352         static GHOST_EventCursor* processCursorEvent(GHOST_TEventType type, GHOST_IWindow *Iwindow);
353
354         /**
355          * Creates a mouse wheel event.
356          * @param window        The window receiving the event (the active window).
357          * @param wParam        The wParam from the wndproc
358          * @param lParam        The lParam from the wndproc
359          */
360         static GHOST_EventWheel* processWheelEvent(GHOST_IWindow *window, WPARAM wParam, LPARAM lParam);
361
362         /**
363          * Creates a key event and updates the key data stored locally (m_modifierKeys).
364          * In most cases this is a straightforward conversion of key codes.
365          * For the modifier keys however, we want to distinguish left and right keys.
366          * @param window        The window receiving the event (the active window).
367          * @param wParam        The wParam from the wndproc
368          * @param lParam        The lParam from the wndproc
369          */
370         static GHOST_EventKey* processKeyEvent(GHOST_IWindow *window, WPARAM wParam, LPARAM lParam);
371
372         /**
373          * Process special keys (VK_OEM_*), to see if current key layout
374          * gives us anything special, like ! on french AZERTY.
375          * @param window        The window receiving the event (the active window).
376          * @param vKey          The virtual key from hardKey
377          * @param ScanCode      The ScanCode of pressed key (simular to PS/2 Set 1)
378          */
379         virtual GHOST_TKey processSpecialKey(GHOST_IWindow *window, short vKey, short scanCode) const;
380
381         /** 
382          * Creates a window event.
383          * @param type          The type of event to create.
384          * @param window        The window receiving the event (the active window).
385          * @return The event created.
386          */
387         static GHOST_Event* processWindowEvent(GHOST_TEventType type, GHOST_IWindow* window);
388         /** 
389          * Handles minimum window size.
390          * @param minmax        The MINMAXINFO structure.
391          */
392         static void processMinMaxInfo(MINMAXINFO * minmax);
393         
394         /**
395          * Returns the local state of the modifier keys (from the message queue).
396          * @param keys The state of the keys.
397          */
398         inline virtual void retrieveModifierKeys(GHOST_ModifierKeys& keys) const;
399
400         /**
401          * Stores the state of the modifier keys locally.
402          * For internal use only!
403          * @param keys The new state of the modifier keys.
404          */
405         inline virtual void storeModifierKeys(const GHOST_ModifierKeys& keys);
406         
407         /**
408          * Check current key layout for AltGr
409          */
410         inline virtual void handleKeyboardChange(void);
411
412         /**
413          * Windows call back routine for our window class.
414          */
415         static LRESULT WINAPI s_wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
416
417         /**
418          * Initiates WM_INPUT messages from keyboard 
419          */
420         GHOST_TInt32 initKeyboardRawInput(void);
421
422         /**
423  * Toggles console
424  * @action      0 - Hides
425  *                      1 - Shows
426  *                      2 - Toggles
427  *                      3 - Hides if it runs not from  command line
428  *                      * - Does nothing
429  * @return current status (1 -visible, 0 - hidden)
430  */
431         int toggleConsole(int action);
432         
433         /** The current state of the modifier keys. */
434         GHOST_ModifierKeys m_modifierKeys;
435         /** State variable set at initialization. */
436         bool m_hasPerformanceCounter;
437         /** High frequency timer variable. */
438         __int64 m_freq;
439         /** High frequency timer variable. */
440         __int64 m_start;
441         /** AltGr on current keyboard layout. */
442         bool m_hasAltGr;
443         /** language identifier. */
444         WORD m_langId;
445         /** stores keyboard layout. */
446         HKL m_keylayout;
447
448         /** Console status */
449         int m_consoleStatus;
450
451         /** handle for user32.dll*/
452         HMODULE user32;
453         #ifdef NEED_RAW_PROC
454         /* pointer to RegisterRawInputDevices function */
455         LPFNDLLRRID pRegisterRawInputDevices;
456         /* pointer to GetRawInputData function */
457         LPFNDLLGRID pGetRawInputData;
458         #endif
459 };
460
461 inline void GHOST_SystemWin32::retrieveModifierKeys(GHOST_ModifierKeys& keys) const
462 {
463         keys = m_modifierKeys;
464 }
465
466 inline void GHOST_SystemWin32::storeModifierKeys(const GHOST_ModifierKeys& keys)
467 {
468         m_modifierKeys = keys;
469 }
470
471 inline void GHOST_SystemWin32::handleKeyboardChange(void)
472 {
473         m_keylayout = GetKeyboardLayout(0); // get keylayout for current thread
474         int i;
475         SHORT s;
476
477         // save the language identifier.
478         m_langId = LOWORD(m_keylayout);
479
480         for(m_hasAltGr = false, i = 32; i < 256; ++i) {
481                 s = VkKeyScanEx((char)i, m_keylayout);
482                 // s == -1 means no key that translates passed char code
483                 // high byte contains shift state. bit 2 ctrl pressed, bit 4 alt pressed
484                 // if both are pressed, we have AltGr keycombo on keylayout
485                 if(s!=-1 && (s & 0x600) == 0x600) {
486                         m_hasAltGr = true;
487                         break;
488                 }
489         }
490 }
491 #endif // _GHOST_SYSTEM_WIN32_H_
492