f1146db50f8d7e9daa8e297516adc20d680e0964
[blender-staging.git] / intern / ghost / intern / GHOST_WindowX11.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_WindowX11.h
29  *  \ingroup GHOST
30  * Declaration of GHOST_WindowX11 class.
31  */
32
33 #ifndef _GHOST_WINDOWX11_H_
34 #define _GHOST_WINDOWX11_H_
35
36 #include "GHOST_Window.h"
37 #include <X11/Xlib.h>
38 #include <GL/glx.h>
39 // For tablets
40 #ifdef WITH_X11_XINPUT
41 #  include <X11/extensions/XInput.h>
42 #endif
43
44 #include <map>
45
46 class STR_String;
47 class GHOST_SystemX11;
48
49 /**
50  * X11 implementation of GHOST_IWindow.
51  * Dimensions are given in screen coordinates that are relative to the upper-left corner of the screen. 
52  * @author      Laurence Bourn
53  * @date        October 26, 2001
54  */
55
56 class GHOST_WindowX11 : public GHOST_Window
57 {
58 public:
59         /**
60          * Constructor.
61          * Creates a new window and opens it.
62          * To check if the window was created properly, use the getValid() method.
63          * @param title         The text shown in the title bar of the window.
64          * @param left          The coordinate of the left edge of the window.
65          * @param top           The coordinate of the top edge of the window.
66          * @param width         The width the window.
67          * @param height        The height the window.
68          * @param state         The state the window is initially opened with.
69          * @param parentWindow  Parent (embedder) window
70          * @param type          The type of drawing context installed in this window.
71          * @param stereoVisual  Stereo visual for quad buffered stereo.
72          * @param numOfAASamples        Number of samples used for AA (zero if no AA)
73          */
74         GHOST_WindowX11(
75                 GHOST_SystemX11 *system,
76                 Display * display,
77                 const STR_String& title, 
78                 GHOST_TInt32 left,
79                 GHOST_TInt32 top,
80                 GHOST_TUns32 width,     
81                 GHOST_TUns32 height,
82                 GHOST_TWindowState state,
83                 const GHOST_TEmbedderWindowID parentWindow,
84                 GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
85                 const bool stereoVisual = false,
86                 const GHOST_TUns16 numOfAASamples = 0
87         );
88
89                 bool 
90         getValid(
91         ) const;
92
93                 void 
94         setTitle(const STR_String& title);
95
96                 void 
97         getTitle(
98                 STR_String& title
99         ) const;
100
101                 void 
102         getWindowBounds(
103                 GHOST_Rect& bounds
104         ) const;
105         
106                 void 
107         getClientBounds(
108                 GHOST_Rect& bounds
109         ) const;
110
111                 GHOST_TSuccess 
112         setClientWidth(
113                 GHOST_TUns32 width
114         );
115
116                 GHOST_TSuccess 
117         setClientHeight(
118                 GHOST_TUns32 height
119         );
120
121                 GHOST_TSuccess 
122         setClientSize(
123                 GHOST_TUns32 width,
124                 GHOST_TUns32 height
125         );
126
127                 void 
128         screenToClient(
129                 GHOST_TInt32 inX,
130                 GHOST_TInt32 inY,
131                 GHOST_TInt32& outX,
132                 GHOST_TInt32& outY
133         ) const;
134
135                 void 
136         clientToScreen(
137                 GHOST_TInt32 inX,
138                 GHOST_TInt32 inY,
139                 GHOST_TInt32& outX,
140                 GHOST_TInt32& outY
141         ) const;
142         
143                 GHOST_TWindowState 
144         getState(
145         ) const ;
146
147                 GHOST_TSuccess 
148         setState(
149                 GHOST_TWindowState state
150         );
151         
152                 GHOST_TSuccess 
153         setOrder(
154                 GHOST_TWindowOrder order
155         );
156         
157                 GHOST_TSuccess 
158         swapBuffers(
159         );
160         
161                 GHOST_TSuccess 
162         activateDrawingContext(
163         );
164                 GHOST_TSuccess 
165         invalidate(
166         );
167
168         /**
169          * Destructor.
170          * Closes the window and disposes resources allocated.
171          */
172          ~GHOST_WindowX11();
173
174         /**
175          * @section x11specific X11 system specific calls
176          */
177
178         /**
179          * The reverse of invalidate! Tells this window
180          * that all events for it have been pushed into
181          * the GHOST event queue.
182          */
183
184                 void
185         validate(
186         );      
187
188         /**     
189          * Return a handle to the x11 window type.
190          */
191                 Window 
192         getXWindow(
193         );      
194 #ifdef WITH_X11_XINPUT
195         class XTablet
196         {
197         public:
198                 GHOST_TabletData CommonData;
199
200                 XDevice* StylusDevice;
201                 XDevice* EraserDevice;
202
203                 XID StylusID, EraserID;
204
205                 int MotionEvent;
206                 int ProxInEvent;
207                 int ProxOutEvent;
208
209                 int PressureLevels;
210                 int XtiltLevels, YtiltLevels;
211         };
212
213         XTablet& GetXTablet()
214         { return m_xtablet; }
215
216         const GHOST_TabletData* GetTabletData()
217         { return &m_xtablet.CommonData; }
218 #else // WITH_X11_XINPUT
219         const GHOST_TabletData* GetTabletData()
220         { return NULL; }
221 #endif // WITH_X11_XINPUT
222
223 #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
224         XIC getX11_XIC() { return m_xic; }
225 #endif
226
227         /*
228          * Need this in case that we want start the window
229          * in FullScree or Maximized state.
230          * Check GHOST_WindowX11.cpp
231          */
232         bool m_post_init;
233         GHOST_TWindowState m_post_state;
234
235 protected:
236         /**
237          * Tries to install a rendering context in this window.
238          * @param type  The type of rendering context installed.
239          * @return Indication as to whether installation has succeeded.
240          */
241                 GHOST_TSuccess 
242         installDrawingContext(
243                 GHOST_TDrawingContextType type
244         );
245
246         /**
247          * Removes the current drawing context.
248          * @return Indication as to whether removal has succeeded.
249          */
250                 GHOST_TSuccess 
251         removeDrawingContext(
252         );
253
254         /**
255          * Sets the cursor visibility on the window using
256          * native window system calls.
257          */
258                 GHOST_TSuccess 
259         setWindowCursorVisibility(
260                 bool visible
261         );
262         
263         /**
264          * Sets the cursor grab on the window using
265          * native window system calls.
266          * @param warp  Only used when grab is enabled, hides the mouse and allows gragging outside the screen.
267          */
268                 GHOST_TSuccess 
269         setWindowCursorGrab(
270                 GHOST_TGrabCursorMode mode
271         );
272
273                 GHOST_TGrabCursorMode
274         getWindowCursorGrab() const;
275
276         /**
277          * Sets the cursor shape on the window using
278          * native window system calls.
279          */
280                 GHOST_TSuccess 
281         setWindowCursorShape(
282                 GHOST_TStandardCursor shape
283         );
284
285         /**
286          * Sets the cursor shape on the window using
287          * native window system calls.
288          */
289                 GHOST_TSuccess
290         setWindowCustomCursorShape(
291                 GHOST_TUns8 bitmap[16][2], 
292                 GHOST_TUns8 mask[16][2], 
293                 int hotX, 
294                 int hotY
295         );
296         
297         /**
298          * Sets the cursor shape on the window using
299          * native window system calls (Arbitrary size/color).
300          */
301                 GHOST_TSuccess
302         setWindowCustomCursorShape(
303                 GHOST_TUns8 *bitmap, 
304                 GHOST_TUns8 *mask, 
305                 int sizex, 
306                 int sizey,
307                 int hotX, 
308                 int hotY,
309                 int fg_color, 
310                 int bg_color
311         );
312
313 private :
314
315         /// Force use of public constructor.
316         
317         GHOST_WindowX11(
318         );
319
320         GHOST_WindowX11(
321                 const GHOST_WindowX11 &
322         );
323
324                 Cursor
325         getStandardCursor(
326                 GHOST_TStandardCursor g_cursor
327         );
328         
329                 Cursor 
330         getEmptyCursor(
331         );
332
333 #ifdef WITH_X11_XINPUT
334         void initXInputDevices();
335 #endif
336         
337         GLXContext      m_context;
338         Window  m_window;
339         Display         *m_display;
340         XVisualInfo     *m_visual;
341         GHOST_TWindowState m_normal_state;
342
343         /** The first created OpenGL context (for sharing display lists) */
344         static GLXContext s_firstContext;
345
346         /// A pointer to the typed system class.
347         
348         GHOST_SystemX11 * m_system;
349
350         bool m_valid_setup;
351
352         /** Used to concatenate calls to invalidate() on this window. */
353         bool m_invalid_window;
354
355         /** XCursor structure of an empty (blank) cursor */
356         Cursor m_empty_cursor;
357         
358         /** XCursor structure of the custom cursor */
359         Cursor m_custom_cursor;
360         
361         /** Cache of XC_* ID's to XCursor structures */
362         std::map<unsigned int, Cursor> m_standard_cursors;
363
364 #ifdef WITH_X11_XINPUT
365         /* Tablet devices */
366         XTablet m_xtablet;
367 #endif
368
369 #if defined(WITH_X11_XINPUT) && defined(X_HAVE_UTF8_STRING)
370         XIC m_xic;
371 #endif
372
373         void icccmSetState(int state);
374         int icccmGetState() const;
375
376         void netwmMaximized(bool set);
377         bool netwmIsMaximized() const;
378
379         void netwmFullScreen(bool set);
380         bool netwmIsFullScreen() const;
381
382         void motifFullScreen(bool set);
383         bool motifIsFullScreen() const;
384 };
385
386
387 #endif // _GHOST_WINDOWX11_H_