Add support for GHOST_kWindowState* to Linux.
[blender.git] / intern / ghost / intern / GHOST_WindowX11.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL 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. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31 /**
32  * @file        GHOST_WindowX11.h
33  * Declaration of GHOST_WindowX11 class.
34  */
35
36 #ifndef _GHOST_WINDOWX11_H_
37 #define _GHOST_WINDOWX11_H_
38
39 #include "GHOST_Window.h"
40 #include <X11/Xlib.h>
41 #include <GL/glx.h>
42 // For tablets
43 #include <X11/extensions/XInput.h>
44
45 #include <map>
46
47 class STR_String;
48 class GHOST_SystemX11;
49
50 /**
51  * X11 implementation of GHOST_IWindow.
52  * Dimensions are given in screen coordinates that are relative to the upper-left corner of the screen. 
53  * @author      Laurence Bourn
54  * @date        October 26, 2001
55  */
56
57 class GHOST_WindowX11 : public GHOST_Window
58 {
59 public:
60         /**
61          * Constructor.
62          * Creates a new window and opens it.
63          * To check if the window was created properly, use the getValid() method.
64          * @param title         The text shown in the title bar of the window.
65          * @param left          The coordinate of the left edge of the window.
66          * @param top           The coordinate of the top edge of the window.
67          * @param width         The width the window.
68          * @param height        The height the window.
69          * @param state         The state the window is initially opened with.
70          * @param type          The type of drawing context installed in this window.
71          * @param stereoVisual  Stereo visual for quad buffered stereo.
72          */
73         GHOST_WindowX11(
74                 GHOST_SystemX11 *system,
75                 Display * display,
76                 const STR_String& title, 
77                 GHOST_TInt32 left,
78                 GHOST_TInt32 top,
79                 GHOST_TUns32 width,     
80                 GHOST_TUns32 height,
81                 GHOST_TWindowState state,
82                 GHOST_TDrawingContextType type = GHOST_kDrawingContextTypeNone,
83                 const bool stereoVisual = false
84         );
85
86                 bool 
87         getValid(
88         ) const;
89
90                 void 
91         setTitle(const STR_String& title);
92
93                 void 
94         getTitle(
95                 STR_String& title
96         ) const;
97
98                 void 
99         getWindowBounds(
100                 GHOST_Rect& bounds
101         ) const;
102         
103                 void 
104         getClientBounds(
105                 GHOST_Rect& bounds
106         ) const;
107
108                 GHOST_TSuccess 
109         setClientWidth(
110                 GHOST_TUns32 width
111         );
112
113                 GHOST_TSuccess 
114         setClientHeight(
115                 GHOST_TUns32 height
116         );
117
118                 GHOST_TSuccess 
119         setClientSize(
120                 GHOST_TUns32 width,
121                 GHOST_TUns32 height
122         );
123
124                 void 
125         screenToClient(
126                 GHOST_TInt32 inX,
127                 GHOST_TInt32 inY,
128                 GHOST_TInt32& outX,
129                 GHOST_TInt32& outY
130         ) const;
131
132                 void 
133         clientToScreen(
134                 GHOST_TInt32 inX,
135                 GHOST_TInt32 inY,
136                 GHOST_TInt32& outX,
137                 GHOST_TInt32& outY
138         ) const;
139         
140                 GHOST_TWindowState 
141         getState(
142         ) const ;
143
144                 GHOST_TSuccess 
145         setState(
146                 GHOST_TWindowState state
147         );
148         
149                 GHOST_TSuccess 
150         setOrder(
151                 GHOST_TWindowOrder order
152         );
153         
154                 GHOST_TSuccess 
155         swapBuffers(
156         );
157         
158                 GHOST_TSuccess 
159         activateDrawingContext(
160         );
161                 GHOST_TSuccess 
162         invalidate(
163         );
164
165         /**
166          * Destructor.
167          * Closes the window and disposes resources allocated.
168          */
169          ~GHOST_WindowX11();
170
171         /**
172          * @section 
173          * X11 system specific calls.
174          */
175
176         /**
177          * The reverse of invalidate! Tells this window
178          * that all events for it have been pushed into
179          * the GHOST event queue.
180          */
181
182                 void
183         validate(
184         );      
185
186         /**     
187          * Return a handle to the x11 window type.
188          */
189                 Window 
190         getXWindow(
191         );      
192
193         class XTablet
194         {
195         public:
196                 GHOST_TabletData CommonData;
197
198                 XDevice* StylusDevice;
199                 XDevice* EraserDevice;
200
201                 XID StylusID, EraserID;
202
203                 int MotionEvent;
204                 int ProxInEvent;
205                 int ProxOutEvent;
206
207                 int PressureLevels;
208                 int XtiltLevels, YtiltLevels;
209         };
210
211         XTablet& GetXTablet()
212         { return m_xtablet; }
213
214         const GHOST_TabletData* GetTabletData()
215         { return &m_xtablet.CommonData; }
216
217         /*
218          * Need this in case that we want start the window
219          * in FullScree or Maximized state.
220          * Check GHOST_WindowX11.cpp
221          */
222         bool m_post_init;
223         GHOST_TWindowState m_post_state;
224
225 protected:
226         /**
227          * Tries to install a rendering context in this window.
228          * @param type  The type of rendering context installed.
229          * @return Indication as to whether installation has succeeded.
230          */
231                 GHOST_TSuccess 
232         installDrawingContext(
233                 GHOST_TDrawingContextType type
234         );
235
236         /**
237          * Removes the current drawing context.
238          * @return Indication as to whether removal has succeeded.
239          */
240                 GHOST_TSuccess 
241         removeDrawingContext(
242         );
243
244         /**
245          * Sets the cursor visibility on the window using
246          * native window system calls.
247          */
248                 GHOST_TSuccess 
249         setWindowCursorVisibility(
250                 bool visible
251         );
252         
253         /**
254          * Sets the cursor shape on the window using
255          * native window system calls.
256          */
257                 GHOST_TSuccess 
258         setWindowCursorShape(
259                 GHOST_TStandardCursor shape
260         );
261
262         /**
263          * Sets the cursor shape on the window using
264          * native window system calls.
265          */
266                 GHOST_TSuccess
267         setWindowCustomCursorShape(
268                 GHOST_TUns8 bitmap[16][2], 
269                 GHOST_TUns8 mask[16][2], 
270                 int hotX, 
271                 int hotY
272         );
273         
274         /**
275          * Sets the cursor shape on the window using
276          * native window system calls (Arbitrary size/color).
277          */
278                 GHOST_TSuccess
279         setWindowCustomCursorShape(
280                 GHOST_TUns8 *bitmap, 
281                 GHOST_TUns8 *mask, 
282                 int sizex, 
283                 int sizey,
284                 int hotX, 
285                 int hotY,
286                 int fg_color, 
287                 int bg_color
288         );
289
290 private :
291
292         /// Force use of public constructor.
293         
294         GHOST_WindowX11(
295         );
296
297         GHOST_WindowX11(
298                 const GHOST_WindowX11 &
299         );
300
301                 Cursor
302         getStandardCursor(
303                 GHOST_TStandardCursor g_cursor
304         );
305         
306                 Cursor 
307         getEmptyCursor(
308         );
309
310         void initXInputDevices();
311         
312         GLXContext      m_context;
313         Window  m_window;
314         Display         *m_display;
315         XVisualInfo     *m_visual;
316
317         /** The first created OpenGL context (for sharing display lists) */
318         static GLXContext s_firstContext;
319
320         /// A pointer to the typed system class.
321         
322         GHOST_SystemX11 * m_system;
323
324         bool m_valid_setup;
325
326         /** Used to concatenate calls to invalidate() on this window. */
327         bool m_invalid_window;
328
329         /** XCursor structure of an empty (blank) cursor */
330         Cursor m_empty_cursor;
331         
332         /** XCursor structure of the custom cursor */
333         Cursor m_custom_cursor;
334         
335         /** Cache of XC_* ID's to XCursor structures */
336         std::map<unsigned int, Cursor> m_standard_cursors;
337
338         /* Tablet devices */
339         XTablet m_xtablet;
340
341         void icccmSetState(int state);
342         int icccmGetState() const;
343
344         void netwmMaximized(bool set);
345         bool netwmIsMaximized() const;
346
347         void netwmFullScreen(bool set);
348         bool netwmIsFullScreen() const;
349
350         void motifFullScreen(bool set);
351         bool motifIsFullScreen() const;
352 };
353
354
355 #endif // _GHOST_WINDOWX11_H_