GHost: Code cleanup, prepare for strict C++ flags
[blender.git] / intern / ghost / intern / GHOST_SystemX11.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_SystemX11.h
29  *  \ingroup GHOST
30  * Declaration of GHOST_SystemX11 class.
31  */
32
33 #ifndef __GHOST_SYSTEMX11_H__
34 #define __GHOST_SYSTEMX11_H__
35
36 #include <X11/Xlib.h>
37
38 #include "GHOST_System.h"
39 #include "../GHOST_Types.h"
40
41 // For tablets
42 #ifdef WITH_X11_XINPUT
43 #  include <X11/extensions/XInput.h>
44 #endif
45
46 #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
47 #  define GHOST_X11_RES_NAME  "Blender" /* res_name */
48 #  define GHOST_X11_RES_CLASS "Blender" /* res_class */
49 #endif
50
51 /* generic error handlers */
52 int GHOST_X11_ApplicationErrorHandler(Display *display, XErrorEvent *theEvent);
53 int GHOST_X11_ApplicationIOErrorHandler(Display *display);
54
55 class GHOST_WindowX11;
56
57 /**
58  * X11 Implementation of GHOST_System class.
59  * \see GHOST_System.
60  * \author      Laurence Bourn
61  * \date        October 26, 2001
62  */
63
64 class GHOST_SystemX11 : public GHOST_System {
65 public:
66
67         /**
68          * Constructor
69          * this class should only be instanciated by GHOST_ISystem.
70          */
71
72         GHOST_SystemX11(
73             );
74         
75         /**
76          * Destructor.
77          */
78         ~GHOST_SystemX11();
79
80
81         GHOST_TSuccess
82         init(
83             );
84
85
86         /**
87          * \section Interface Inherited from GHOST_ISystem
88          */
89
90         /**
91          * Returns the system time.
92          * Returns the number of milliseconds since the start of the system process.
93          * \return The number of milliseconds.
94          */
95         GHOST_TUns64
96         getMilliSeconds(
97             ) const;
98         
99
100         /**
101          * Returns the number of displays on this system.
102          * \return The number of displays.
103          */
104         GHOST_TUns8
105         getNumDisplays(
106             ) const;
107
108         /**
109          * Returns the dimensions of the main display on this system.
110          * \return The dimension of the main display.
111          */
112         void
113         getMainDisplayDimensions(
114             GHOST_TUns32& width,
115             GHOST_TUns32& height
116             ) const;
117
118         /**
119          * Returns the dimensions of all displays on this system.
120          * \return The dimension of the main display.
121          */
122         void
123         getAllDisplayDimensions(
124             GHOST_TUns32& width,
125             GHOST_TUns32& height
126             ) const;
127
128         /**
129          * Create a new window.
130          * The new window is added to the list of windows managed. 
131          * Never explicitly delete the window, use disposeWindow() instead.
132          * \param       title   The name of the window (displayed in the title bar of the window if the OS supports it).
133          * \param       left            The coordinate of the left edge of the window.
134          * \param       top             The coordinate of the top edge of the window.
135          * \param       width           The width the window.
136          * \param       height          The height the window.
137          * \param       state           The state of the window when opened.
138          * \param       type            The type of drawing context installed in this window.
139          * \param       stereoVisual    Create a stereo visual for quad buffered stereo.
140          * \param       exclusive       Use to show the window ontop and ignore others
141          *                                              (used fullscreen).
142          * \param       parentWindow    Parent (embedder) window
143          * \return      The new window (or 0 if creation failed).
144          */
145         GHOST_IWindow *
146         createWindow(
147             const STR_String& title,
148             GHOST_TInt32 left,
149             GHOST_TInt32 top,
150             GHOST_TUns32 width,
151             GHOST_TUns32 height,
152             GHOST_TWindowState state,
153             GHOST_TDrawingContextType type,
154             GHOST_GLSettings glSettings,
155             const bool exclusive = false,
156             const GHOST_TEmbedderWindowID parentWindow = 0
157             );
158
159         /**
160          * \section Interface Inherited from GHOST_ISystem
161          */
162
163         /**
164          * Retrieves events from the system and stores them in the queue.
165          * \param waitForEvent Flag to wait for an event (or return immediately).
166          * \return Indication of the presence of events.
167          */
168         bool
169         processEvents(
170             bool waitForEvent
171             );
172
173         /**
174          * \section Interface Inherited from GHOST_System
175          */
176         GHOST_TSuccess
177         getCursorPosition(
178             GHOST_TInt32& x,
179             GHOST_TInt32& y
180             ) const;
181         
182         GHOST_TSuccess
183         setCursorPosition(
184             GHOST_TInt32 x,
185             GHOST_TInt32 y
186             );
187
188         /**
189          * Returns the state of all modifier keys.
190          * \param keys  The state of all modifier keys (true == pressed).
191          * \return              Indication of success.
192          */
193         GHOST_TSuccess
194         getModifierKeys(
195             GHOST_ModifierKeys& keys
196             ) const;
197
198         /**
199          * Returns the state of the mouse buttons (ouside the message queue).
200          * \param buttons       The state of the buttons.
201          * \return                      Indication of success.
202          */
203         GHOST_TSuccess
204         getButtons(
205             GHOST_Buttons& buttons
206             ) const;
207
208         /**
209          * \section Interface Dirty
210          * Flag a window as dirty. This will
211          * generate a GHOST window update event on a call to processEvents() 
212          */
213
214         void
215         addDirtyWindow(
216             GHOST_WindowX11 *bad_wind
217             );
218   
219  
220         /**
221          * return a pointer to the X11 display structure
222          */
223
224         Display *
225         getXDisplay(
226                 ) {
227                 return m_display;
228         }       
229
230 #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
231         XIM
232         getX11_XIM()
233         {
234                 return m_xim;
235         }
236 #endif
237
238         /* Helped function for get data from the clipboard. */
239         void getClipboard_xcout(const XEvent *evt, Atom sel, Atom target,
240                                 unsigned char **txt, unsigned long *len,
241                                 unsigned int *context) const;
242
243         /**
244          * Returns unsinged char from CUT_BUFFER0
245          * \param selection             Get selection, X11 only feature
246          * \return                              Returns the Clipboard indicated by Flag
247          */
248         GHOST_TUns8 *getClipboard(bool selection) const;
249         
250         /**
251          * Puts buffer to system clipboard
252          * \param buffer        The buffer to copy to the clipboard
253          * \param selection     Set the selection into the clipboard, X11 only feature
254          */
255         void putClipboard(GHOST_TInt8 *buffer, bool selection) const;
256
257 #ifdef WITH_XDND
258         /**
259          * Creates a drag'n'drop event and pushes it immediately onto the event queue. 
260          * Called by GHOST_DropTargetX11 class.
261          * \param eventType The type of drag'n'drop event
262          * \param draggedObjectType The type object concerned (currently array of file names, string, ?bitmap)
263          * \param mouseX x mouse coordinate (in window coordinates)
264          * \param mouseY y mouse coordinate
265          * \param window The window on which the event occurred
266          * \return Indication whether the event was handled. 
267          */
268         static GHOST_TSuccess pushDragDropEvent(GHOST_TEventType eventType, GHOST_TDragnDropTypes draggedObjectType, GHOST_IWindow *window, int mouseX, int mouseY, void *data);
269 #endif
270
271         /**
272          * \see GHOST_ISystem
273          */
274         int toggleConsole(int /*action*/) {
275                 return 0;
276         }
277
278 #ifdef WITH_X11_XINPUT
279         typedef struct GHOST_TabletX11 {
280                 XDevice *StylusDevice;
281                 XDevice *EraserDevice;
282
283                 XID StylusID, EraserID;
284
285                 int MotionEvent;
286                 int ProxInEvent;
287                 int ProxOutEvent;
288                 int PressEvent;
289
290                 int MotionEventEraser;
291                 int ProxInEventEraser;
292                 int ProxOutEventEraser;
293                 int PressEventEraser;
294
295                 int PressureLevels;
296                 int XtiltLevels, YtiltLevels;
297         } GHOST_TabletX11;
298
299         GHOST_TabletX11 &GetXTablet()
300         {
301                 return m_xtablet;
302         }
303 #endif // WITH_X11_XINPUT
304
305         struct {
306                 /**
307                  * Atom used for ICCCM, WM-spec and Motif.
308                  * We only need get this atom at the start, it's relative
309                  * to the display not the window and are public for every
310                  * window that need it.
311                  */
312                 Atom WM_STATE;
313                 Atom WM_CHANGE_STATE;
314                 Atom _NET_WM_STATE;
315                 Atom _NET_WM_STATE_MAXIMIZED_HORZ;
316                 Atom _NET_WM_STATE_MAXIMIZED_VERT;
317                 Atom _NET_WM_STATE_FULLSCREEN;
318                 Atom _MOTIF_WM_HINTS;
319                 Atom WM_TAKE_FOCUS;
320                 Atom WM_PROTOCOLS;
321                 Atom WM_DELETE_WINDOW;
322
323                 /* Atoms for Selection, copy & paste. */
324                 Atom TARGETS;
325                 Atom STRING;
326                 Atom COMPOUND_TEXT;
327                 Atom TEXT;
328                 Atom CLIPBOARD;
329                 Atom PRIMARY;
330                 Atom XCLIP_OUT;
331                 Atom INCR;
332                 Atom UTF8_STRING;
333 #ifdef WITH_X11_XINPUT
334                 Atom TABLET;
335 #endif
336         } m_atom;
337
338 private:
339
340         Display *m_display;
341 #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
342         XIM m_xim;
343 #endif
344
345 #ifdef WITH_X11_XINPUT
346         /* Tablet devices */
347         GHOST_TabletX11 m_xtablet;
348 #endif
349
350         /// The vector of windows that need to be updated.
351         std::vector<GHOST_WindowX11 *> m_dirty_windows;
352
353         /// Start time at initialization.
354         GHOST_TUns64 m_start_time;
355
356         /// A vector of keyboard key masks
357         char m_keyboard_vector[32];
358
359         /* to prevent multiple warp, we store the time of the last warp event
360          *  and stop accumulating all events generated before that */
361         Time m_last_warp;
362
363         /* detect autorepeat glitch */
364         unsigned int m_last_release_keycode;
365         Time m_last_release_time;
366
367         /**
368          * Return the ghost window associated with the
369          * X11 window xwind
370          */
371
372 #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
373         bool openX11_IM();
374 #endif
375
376 #ifdef WITH_X11_XINPUT
377         void initXInputDevices();
378 #endif
379
380         GHOST_WindowX11 *
381         findGhostWindow(
382             Window xwind
383             ) const;
384
385         void
386         processEvent(
387             XEvent *xe
388             );
389
390         Time
391         lastEventTime(
392             Time default_time
393             );
394
395         bool
396         generateWindowExposeEvents(
397             );
398 };
399
400 #endif
401