]> git.tdb.fi Git - libs/gui.git/blob - source/graphics/x11/window.cpp
e33511e888b17f57a82646416239841f9a8bc26c
[libs/gui.git] / source / graphics / x11 / window.cpp
1 #include "window.h"
2 #include "window_private.h"
3 #include <vector>
4 #include <X11/Xatom.h>
5 #include <X11/Xutil.h>
6 #include <msp/core/systemerror.h>
7 #include "display_private.h"
8
9 using namespace std;
10
11 namespace {
12
13 Bool match_event_type(Display *, XEvent *event, XPointer arg)
14 {
15         return event->type==*reinterpret_cast<int *>(arg);
16 }
17
18 }
19
20 namespace Msp {
21 namespace Graphics {
22
23 void Window::platform_init()
24 {
25         DisplayHandle dpy = display.get_private().display;
26
27         priv->wm_delete_window = XInternAtom(dpy, "WM_DELETE_WINDOW", true);
28
29         XSetWindowAttributes attr;
30         attr.override_redirect = options.fullscreen;
31         attr.event_mask = ButtonPressMask|ButtonReleaseMask|PointerMotionMask|KeyPressMask|KeyReleaseMask|StructureNotifyMask|EnterWindowMask|ExposureMask|FocusChangeMask;
32
33         // User position is set when the window is mapped
34         int x = 0;
35         int y = 0;
36         if(options.fullscreen && !options.fullscreen_exclusive)
37         {
38                 const Monitor::Settings &ms = options.fullscreen_monitor->current_settings;
39                 x = ms.x;
40                 y = ms.y;
41         }
42
43         priv->window = XCreateWindow(dpy,
44                 display.get_private().root_window,
45                 x, y,
46                 options.width, options.height,
47                 0,
48                 CopyFromParent,
49                 InputOutput,
50                 CopyFromParent,
51                 CWOverrideRedirect|CWEventMask, &attr);
52
53         XSetWMProtocols(dpy, priv->window, &priv->wm_delete_window, 1);
54
55         if(!options.resizable)
56         {
57                 XSizeHints hints;
58                 hints.flags = PMinSize|PMaxSize;
59                 hints.min_width = hints.max_width = options.width;
60                 hints.min_height = hints.max_height = options.height;
61                 XSetWMNormalHints(dpy, priv->window, &hints);
62         }
63 }
64
65 void Window::platform_cleanup()
66 {
67         if(priv->window)
68                 XDestroyWindow(display.get_private().display, priv->window);
69
70         if(priv->invisible_cursor)
71                 XFreeCursor(display.get_private().display, priv->invisible_cursor);
72 }
73
74 void Window::set_title(const string &title)
75 {
76         vector<unsigned char> buf(title.begin(), title.end());
77         XTextProperty prop;
78         prop.value = &buf[0];
79         prop.encoding = XA_STRING;
80         prop.format = 8;
81         prop.nitems = title.size();
82         XSetWMName(display.get_private().display, priv->window, &prop);
83         display.check_error();
84 }
85
86 void Window::platform_reconfigure(bool fullscreen_changed)
87 {
88         DisplayHandle dpy = display.get_private().display;
89
90         bool was_visible = visible;
91         if(fullscreen_changed)
92         {
93                 if(was_visible)
94                 {
95                         hide();
96
97                         // Wait for the window to be unmapped.  This makes window managers happy.
98                         XEvent ev;
99                         int ev_type = UnmapNotify;
100                         XPeekIfEvent(dpy, &ev, match_event_type, reinterpret_cast<char *>(&ev_type));
101                 }
102
103                 XSetWindowAttributes attr;
104                 attr.override_redirect = options.fullscreen;
105                 XChangeWindowAttributes(dpy, priv->window, CWOverrideRedirect, &attr);
106         }
107
108         XSizeHints hints;
109         if(options.resizable)
110                 hints.flags = 0;
111         else
112         {
113                 hints.flags = PMinSize|PMaxSize;
114                 hints.min_width = hints.max_width = options.width;
115                 hints.min_height = hints.max_height = options.height;
116         }
117         XSetWMNormalHints(dpy, priv->window, &hints);
118
119         if(options.fullscreen)
120         {
121                 if(options.fullscreen_exclusive)
122                         XMoveResizeWindow(dpy, priv->window, 0, 0, options.width, options.height);
123                 else
124                 {
125                         const Monitor::Settings &ms = options.fullscreen_monitor->current_settings;
126                         XMoveResizeWindow(dpy, priv->window, ms.x, ms.y, options.width, options.height);
127                 }
128         }
129         else if(options.user_position)
130                 XMoveResizeWindow(dpy, priv->window, options.x, options.y, options.width, options.height);
131         else
132                 XResizeWindow(dpy, priv->window, options.width, options.height);
133
134         if(fullscreen_changed && was_visible)
135                 show();
136 }
137
138 void Window::show_cursor(bool s)
139 {
140         DisplayHandle dpy = display.get_private().display;
141
142         if(s)
143                 XUndefineCursor(dpy, priv->window);
144         else
145         {
146                 if(!priv->invisible_cursor)
147                 {
148                         int screen = DefaultScreen(dpy);
149
150                         Pixmap pm = XCreatePixmap(dpy, priv->window, 1, 1, 1);
151                         GC gc = XCreateGC(dpy, pm, 0, 0);
152                         XSetFunction(dpy, gc, GXclear);
153                         XDrawPoint(dpy, pm, gc, 0, 0);
154                         XFreeGC(dpy, gc);
155
156                         XColor black;
157                         black.pixel = BlackPixel(dpy, screen);
158                         XQueryColor(dpy, DefaultColormap(dpy, screen), &black);
159
160                         priv->invisible_cursor = XCreatePixmapCursor(dpy, pm, pm, &black, &black, 0, 0);
161
162                         XFreePixmap(dpy, pm);
163                 }
164                 XDefineCursor(dpy, priv->window, priv->invisible_cursor);
165         }
166 }
167
168 void Window::warp_pointer(int x, int y)
169 {
170         XWarpPointer(display.get_private().display, None, priv->window, 0, 0, 0, 0, x, y);
171 }
172
173 void Window::platform_set_touch_input()
174 {
175 }
176
177 void Window::platform_show()
178 {
179         DisplayHandle dpy = display.get_private().display;
180         XMapRaised(dpy, priv->window);
181         if(options.user_position && !options.fullscreen)
182                 XMoveWindow(dpy, priv->window, options.x, options.y);
183 }
184
185 void Window::platform_hide()
186 {
187         XUnmapWindow(display.get_private().display, priv->window);
188 }
189
190 bool Window::event(const Event &evnt)
191 {
192         const XEvent &ev = evnt.xevent;
193         switch(ev.type)
194         {
195         case ButtonPress:
196         case ButtonRelease:
197         case MotionNotify:
198         case KeyPress:
199         case KeyRelease:
200                 signal_input_event.emit(evnt);
201                 break;
202         case ConfigureNotify:
203                 if((ev.xconfigure.width==static_cast<int>(options.width) && ev.xconfigure.height==static_cast<int>(options.height)) == resizing)
204                 {
205                         options.width = ev.xconfigure.width;
206                         options.height = ev.xconfigure.height;
207                         resizing = false;
208                         signal_resize.emit(options.width, options.height);
209                 }
210
211                 {
212                         int x = ev.xconfigure.x;
213                         int y = ev.xconfigure.y;
214
215                         if(priv->reparented)
216                         {
217                                 if(!ev.xconfigure.send_event)
218                                 {
219                                         /* If the window manager reparented us, the coordinates of a
220                                         real event are in the parent window's space. */
221                                         priv->rel_x = ev.xconfigure.x;
222                                         priv->rel_y = ev.xconfigure.y;
223
224                                         const Display::Private &dpy_priv = display.get_private();
225                                         WindowHandle dummy;
226                                         XTranslateCoordinates(dpy_priv.display, priv->window, dpy_priv.root_window, 0, 0, &x, &y, &dummy);
227                                 }
228
229                                 // Use the coordinates of the window manager frame
230                                 x -= priv->rel_x;
231                                 y -= priv->rel_y;
232                         }
233
234                         if((x==options.x && y==options.y) == moving)
235                         {
236                                 options.x = x;
237                                 options.y = y;
238                                 moving = false;
239                                 signal_move.emit(options.x, options.y);
240                         }
241                 }
242
243                 break;
244         case ReparentNotify:
245                 priv->reparented = (ev.xreparent.parent!=display.get_private().root_window);
246                 if(!priv->reparented)
247                 {
248                         priv->rel_x = 0;
249                         priv->rel_y = 0;
250                 }
251                 break;
252         case ClientMessage:
253                 if(ev.xclient.data.l[0]==static_cast<long>(priv->wm_delete_window))
254                         signal_close.emit();
255                 break;
256         case EnterNotify:
257                 if(options.fullscreen)
258                         XSetInputFocus(display.get_private().display, priv->window, RevertToParent, CurrentTime);
259                 break;
260         case MapNotify:
261                 if(options.fullscreen && options.fullscreen_exclusive)
262                         XGrabPointer(display.get_private().display, priv->window, true, None, GrabModeAsync, GrabModeAsync, priv->window, None, CurrentTime);
263                 break;
264         case Expose:
265                 signal_expose.emit(ev.xexpose.x, ev.xexpose.y, ev.xexpose.width, ev.xexpose.height, evnt);
266                 break;
267         case FocusIn:
268                 signal_got_focus.emit();
269                 break;
270         case FocusOut:
271                 signal_lost_focus.emit();
272                 break;
273         default:
274                 return false;
275         }
276
277         return true;
278 }
279
280 } // namespace Graphics
281 } // namespace Msp