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