d534a300b35c195930410102a4f71263c3c3c566
[blender-staging.git] / intern / ghost / intern / GHOST_SystemWin32.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file ghost/intern/GHOST_SystemWin32.h
29  *  \ingroup GHOST
30  * Declaration of GHOST_SystemWin32 class.
31  */
32
33 #ifndef __GHOST_SYSTEMWIN32_H__
34 #define __GHOST_SYSTEMWIN32_H__
35
36 #ifndef WIN32
37 #error WIN32 only!
38 #endif // WIN32
39
40 #ifndef __MINGW64__
41 #  undef _WIN32_WINNT
42 #  define _WIN32_WINNT 0x501 // require Windows XP or newer
43 #endif
44 #define WIN32_LEAN_AND_MEAN
45 #include <windows.h>
46 #include <ole2.h> // for drag-n-drop
47
48 #include "GHOST_System.h"
49
50 class GHOST_EventButton;
51 class GHOST_EventCursor;
52 class GHOST_EventKey;
53 class GHOST_EventWheel;
54 class GHOST_EventWindow;
55 class GHOST_EventDragnDrop;
56
57 class GHOST_WindowWin32;
58
59 /**
60  * WIN32 Implementation of GHOST_System class.
61  * \see GHOST_System.
62  * \author      Maarten Gribnau
63  * \date        May 10, 2001
64  */
65 class GHOST_SystemWin32 : public GHOST_System {
66 public:
67         /**
68          * Constructor.
69          */
70         GHOST_SystemWin32();
71
72         /**
73          * Destructor.
74          */
75         ~GHOST_SystemWin32();
76
77         /***************************************************************************************
78          ** Time(r) functionality
79          ***************************************************************************************/
80
81         /**
82          * Returns the system time.
83          * Returns the number of milliseconds since the start of the system process.
84          * This overloaded method uses the high frequency timer if available.
85          * \return The number of milliseconds.
86          */
87         GHOST_TUns64 getMilliSeconds() const;
88
89         /***************************************************************************************
90          ** Display/window management functionality
91          ***************************************************************************************/
92
93         /**
94          * Returns the number of displays on this system.
95          * \return The number of displays.
96          */
97         GHOST_TUns8 getNumDisplays() const;
98
99         /**
100          * Returns the dimensions of the main display on this system.
101          * \return The dimension of the main display.
102          */
103         void getMainDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const;
104
105         /**
106          * Returns the dimensions of all displays on this system.
107          * \return The dimension of the main display.
108          */
109         void getAllDisplayDimensions(GHOST_TUns32& width, GHOST_TUns32& height) const;
110
111         /**
112          * Create a new window.
113          * The new window is added to the list of windows managed. 
114          * Never explicitly delete the window, use disposeWindow() instead.
115          * \param       title   The name of the window (displayed in the title bar of the window if the OS supports it).
116          * \param       left    The coordinate of the left edge of the window.
117          * \param       top             The coordinate of the top edge of the window.
118          * \param       width   The width the window.
119          * \param       height  The height the window.
120          * \param       state   The state of the window when opened.
121          * \param       type    The type of drawing context installed in this window.
122          * \param glSettings: Misc OpenGL settings.
123          * \param exclusive: Use to show the window ontop and ignore others (used fullscreen).
124          * \param       parentWindow    Parent (embedder) window
125          * \return      The new window (or 0 if creation failed).
126          */
127         GHOST_IWindow *createWindow(
128             const STR_String& title,
129             GHOST_TInt32 left, GHOST_TInt32 top, GHOST_TUns32 width, GHOST_TUns32 height,
130             GHOST_TWindowState state, GHOST_TDrawingContextType type,
131             GHOST_GLSettings glSettings,
132             const bool exclusive = false,
133             const GHOST_TEmbedderWindowID parentWindow = 0);
134
135         /***************************************************************************************
136          ** Event management functionality
137          ***************************************************************************************/
138
139         /**
140          * Gets events from the system and stores them in the queue.
141          * \param waitForEvent Flag to wait for an event (or return immediately).
142          * \return Indication of the presence of events.
143          */
144         bool processEvents(bool waitForEvent);
145         
146
147         /***************************************************************************************
148          ** Cursor management functionality
149          ***************************************************************************************/
150
151         /**
152          * Returns the current location of the cursor (location in screen coordinates)
153          * \param x                     The x-coordinate of the cursor.
154          * \param y                     The y-coordinate of the cursor.
155          * \return                      Indication of success.
156          */
157         GHOST_TSuccess getCursorPosition(GHOST_TInt32& x, GHOST_TInt32& y) const;
158
159         /**
160          * Updates the location of the cursor (location in screen coordinates).
161          * \param x                     The x-coordinate of the cursor.
162          * \param y                     The y-coordinate of the cursor.
163          * \return                      Indication of success.
164          */
165         GHOST_TSuccess setCursorPosition(GHOST_TInt32 x, GHOST_TInt32 y);
166
167         /***************************************************************************************
168          ** Access to mouse button and keyboard states.
169          ***************************************************************************************/
170
171         /**
172          * Returns the state of all modifier keys.
173          * \param keys  The state of all modifier keys (true == pressed).
174          * \return              Indication of success.
175          */
176         GHOST_TSuccess getModifierKeys(GHOST_ModifierKeys& keys) const;
177
178         /**
179          * Returns the state of the mouse buttons (ouside the message queue).
180          * \param buttons       The state of the buttons.
181          * \return                      Indication of success.
182          */
183         GHOST_TSuccess getButtons(GHOST_Buttons& buttons) const;
184
185         /**
186          * Returns unsigned char from CUT_BUFFER0
187          * \param selection             Used by X11 only
188          * \return                              Returns the Clipboard
189          */
190         GHOST_TUns8 *getClipboard(bool selection) const;
191         
192         /**
193          * Puts buffer to system clipboard
194          * \param selection             Used by X11 only
195          * \return                              No return
196          */
197         void putClipboard(GHOST_TInt8 *buffer, bool selection) const;
198
199         /**
200          * Creates a drag'n'drop event and pushes it immediately onto the event queue. 
201          * Called by GHOST_DropTargetWin32 class.
202          * \param eventType The type of drag'n'drop event
203          * \param draggedObjectType The type object concerned (currently array of file names, string, ?bitmap)
204          * \param mouseX x mouse coordinate (in window coordinates)
205          * \param mouseY y mouse coordinate
206          * \param window The window on which the event occurred
207          * \return Indication whether the event was handled.
208          */
209         static GHOST_TSuccess pushDragDropEvent(GHOST_TEventType eventType, GHOST_TDragnDropTypes draggedObjectType, GHOST_WindowWin32 *window, int mouseX, int mouseY, void *data);
210         
211 /**
212  * Confirms quitting he program when there is just one window left open
213  * in the application
214  */
215         int confirmQuit(GHOST_IWindow *window) const;
216
217 protected:
218         /**
219          * Initializes the system.
220          * For now, it just registers the window class (WNDCLASS).
221          * \return A success value.
222          */
223         GHOST_TSuccess init();
224
225         /**
226          * Closes the system down.
227          * \return A success value.
228          */
229         GHOST_TSuccess exit();
230         
231         /**
232          * Converts raw WIN32 key codes from the wndproc to GHOST keys.
233          * \param vKey          The virtual key from hardKey
234          * \param ScanCode      The ScanCode of pressed key (similar to PS/2 Set 1)
235          * \param extend        Flag if key is not primly (left or right)
236          * \return The GHOST key (GHOST_kKeyUnknown if no match).
237          */
238         GHOST_TKey convertKey(short vKey, short ScanCode, short extend) const;
239
240         /**
241          * Catches raw WIN32 key codes from WM_INPUT in the wndproc.
242          * \param raw           RawInput structure with detailed info about the key event
243          * \param keyDown       Pointer flag that specify if a key is down
244          * \param vk            Pointer to virtual key
245          * \return The GHOST key (GHOST_kKeyUnknown if no match).
246          */
247         GHOST_TKey hardKey(RAWINPUT const& raw, int *keyDown, char *vk);
248
249         /**
250          * Creates mouse button event.
251          * \param type          The type of event to create.
252          * \param window        The window receiving the event (the active window).
253          * \param mask          The button mask of this event.
254          * \return The event created.
255          */
256         static GHOST_EventButton *processButtonEvent(GHOST_TEventType type, GHOST_WindowWin32 *window, GHOST_TButtonMask mask);
257
258         /**
259          * Creates cursor event.
260          * \param type          The type of event to create.
261          * \param window        The window receiving the event (the active window).
262          * \return The event created.
263          */
264         static GHOST_EventCursor *processCursorEvent(GHOST_TEventType type, GHOST_WindowWin32 *window);
265
266         /**
267          * Handles a mouse wheel event.
268          * \param window        The window receiving the event (the active window).
269          * \param wParam        The wParam from the wndproc
270          * \param lParam        The lParam from the wndproc
271          */
272         static void processWheelEvent(GHOST_WindowWin32 *window, WPARAM wParam, LPARAM lParam);
273
274         /**
275          * Creates a key event and updates the key data stored locally (m_modifierKeys).
276          * In most cases this is a straightforward conversion of key codes.
277          * For the modifier keys however, we want to distinguish left and right keys.
278          * \param window        The window receiving the event (the active window).
279          * \param raw           RawInput structure with detailed info about the key event
280          */
281         static GHOST_EventKey *processKeyEvent(GHOST_WindowWin32 *window, RAWINPUT const& raw);
282
283         /**
284          * Process special keys (VK_OEM_*), to see if current key layout
285          * gives us anything special, like ! on french AZERTY.
286          * \param vKey          The virtual key from hardKey
287          * \param scanCode      The ScanCode of pressed key (simular to PS/2 Set 1)
288          */
289         GHOST_TKey processSpecialKey(short vKey, short scanCode) const;
290
291         /** 
292          * Creates a window event.
293          * \param type          The type of event to create.
294          * \param window        The window receiving the event (the active window).
295          * \return The event created.
296          */
297         static GHOST_Event *processWindowEvent(GHOST_TEventType type, GHOST_WindowWin32 *window);
298
299 #ifdef WITH_INPUT_IME
300         /**
301          * Creates a IME event.
302          * \param type          The type of event to create.
303          * \param window                The window receiving the event (the active window).
304          * \param data          IME data.
305          * \return The event created.
306          */
307         static GHOST_Event *processImeEvent(GHOST_TEventType type, GHOST_WindowWin32 *window, GHOST_TEventImeData *data);
308 #endif // WITH_INPUT_IME
309
310         /**
311          * Handles minimum window size.
312          * \param minmax        The MINMAXINFO structure.
313          */
314         static void processMinMaxInfo(MINMAXINFO *minmax);
315
316 #ifdef WITH_INPUT_NDOF
317         /**
318          * Handles Motion and Button events from a SpaceNavigator or related device.
319          * Instead of returning an event object, this function communicates directly
320          * with the GHOST_NDOFManager.
321          * \param raw           RawInput structure with detailed info about the NDOF event
322          * \return Whether an event was generated and sent.
323          */
324         bool processNDOF(RAWINPUT const& raw);
325 #endif
326
327         /**
328          * Returns the local state of the modifier keys (from the message queue).
329          * \param keys The state of the keys.
330          */
331         inline void retrieveModifierKeys(GHOST_ModifierKeys& keys) const;
332
333         /**
334          * Stores the state of the modifier keys locally.
335          * For internal use only!
336          * param keys The new state of the modifier keys.
337          */
338         inline void storeModifierKeys(const GHOST_ModifierKeys& keys);
339         
340         /**
341          * Check current key layout for AltGr
342          */
343         inline void handleKeyboardChange(void);
344
345         /**
346          * Windows call back routine for our window class.
347          */
348         static LRESULT WINAPI s_wndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
349
350         /**
351          * Toggles console
352          * \param action
353          * - 0 - Hides
354          * - 1 - Shows
355          * - 2 - Toggles
356          * - 3 - Hides if it runs not from  command line
357          * - * - Does nothing
358          * \return current status (1 -visible, 0 - hidden)
359          */
360         int toggleConsole(int action);
361         
362         /** The current state of the modifier keys. */
363         GHOST_ModifierKeys m_modifierKeys;
364         /** State variable set at initialization. */
365         bool m_hasPerformanceCounter;
366         /** High frequency timer variable. */
367         __int64 m_freq;
368         /** High frequency timer variable. */
369         __int64 m_start;
370         /** AltGr on current keyboard layout. */
371         bool m_hasAltGr;
372         /** language identifier. */
373         WORD m_langId;
374         /** stores keyboard layout. */
375         HKL m_keylayout;
376
377         /** Console status */
378         int m_consoleStatus;
379
380         /** Wheel delta accumulator **/
381         int m_wheelDeltaAccum;
382 };
383
384 inline void GHOST_SystemWin32::retrieveModifierKeys(GHOST_ModifierKeys& keys) const
385 {
386         keys = m_modifierKeys;
387 }
388
389 inline void GHOST_SystemWin32::storeModifierKeys(const GHOST_ModifierKeys& keys)
390 {
391         m_modifierKeys = keys;
392 }
393
394 inline void GHOST_SystemWin32::handleKeyboardChange(void)
395 {
396         m_keylayout = GetKeyboardLayout(0); // get keylayout for current thread
397         int i;
398         SHORT s;
399
400         // save the language identifier.
401         m_langId = LOWORD(m_keylayout);
402
403         for (m_hasAltGr = false, i = 32; i < 256; ++i) {
404                 s = VkKeyScanEx((char)i, m_keylayout);
405                 // s == -1 means no key that translates passed char code
406                 // high byte contains shift state. bit 2 ctrl pressed, bit 4 alt pressed
407                 // if both are pressed, we have AltGr keycombo on keylayout
408                 if (s != -1 && (s & 0x600) == 0x600) {
409                         m_hasAltGr = true;
410                         break;
411                 }
412         }
413 }
414 #endif // __GHOST_SYSTEMWIN32_H__