1
2 /*
3 * Copyright 2011 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8 #include <X11/Xlib.h>
9 #include <X11/Xatom.h>
10 #include <X11/XKBlib.h>
11 #include <GL/glx.h>
12 #include <GL/gl.h>
13 #include <GL/glu.h>
14
15 #include "SkWindow.h"
16
17 #include "SkBitmap.h"
18 #include "SkCanvas.h"
19 #include "SkColor.h"
20 #include "SkEvent.h"
21 #include "SkKey.h"
22 #include "SkWindow.h"
23 #include "XkeysToSkKeys.h"
24 extern "C" {
25 #include "keysym2ucs.h"
26 }
27
28 const int WIDTH = 500;
29 const int HEIGHT = 500;
30
31 // Determine which events to listen for.
32 const long EVENT_MASK = StructureNotifyMask|ButtonPressMask|ButtonReleaseMask
33 |ExposureMask|PointerMotionMask|KeyPressMask|KeyReleaseMask;
34
SkOSWindow(void *)35 SkOSWindow::SkOSWindow(void*)
36 : fVi(NULL)
37 , fMSAASampleCount(0) {
38 fUnixWindow.fDisplay = NULL;
39 fUnixWindow.fGLContext = NULL;
40 this->initWindow(0, NULL);
41 this->resize(WIDTH, HEIGHT);
42 }
43
~SkOSWindow()44 SkOSWindow::~SkOSWindow() {
45 this->closeWindow();
46 }
47
closeWindow()48 void SkOSWindow::closeWindow() {
49 if (NULL != fUnixWindow.fDisplay) {
50 this->detach();
51 SkASSERT(NULL != fUnixWindow.fGc);
52 XFreeGC(fUnixWindow.fDisplay, fUnixWindow.fGc);
53 fUnixWindow.fGc = NULL;
54 XDestroyWindow(fUnixWindow.fDisplay, fUnixWindow.fWin);
55 fVi = NULL;
56 XCloseDisplay(fUnixWindow.fDisplay);
57 fUnixWindow.fDisplay = NULL;
58 fMSAASampleCount = 0;
59 }
60 }
61
initWindow(int requestedMSAASampleCount,AttachmentInfo * info)62 void SkOSWindow::initWindow(int requestedMSAASampleCount, AttachmentInfo* info) {
63 if (fMSAASampleCount != requestedMSAASampleCount) {
64 this->closeWindow();
65 }
66 // presence of fDisplay means we already have a window
67 if (NULL != fUnixWindow.fDisplay) {
68 if (NULL != info) {
69 if (NULL != fVi) {
70 glXGetConfig(fUnixWindow.fDisplay, fVi, GLX_SAMPLES_ARB, &info->fSampleCount);
71 glXGetConfig(fUnixWindow.fDisplay, fVi, GLX_STENCIL_SIZE, &info->fStencilBits);
72 } else {
73 info->fSampleCount = 0;
74 info->fStencilBits = 0;
75 }
76 }
77 return;
78 }
79 fUnixWindow.fDisplay = XOpenDisplay(NULL);
80 Display* dsp = fUnixWindow.fDisplay;
81 if (NULL == dsp) {
82 SkDebugf("Could not open an X Display");
83 return;
84 }
85 // Attempt to create a window that supports GL
86 GLint att[] = {
87 GLX_RGBA,
88 GLX_DEPTH_SIZE, 24,
89 GLX_DOUBLEBUFFER,
90 GLX_STENCIL_SIZE, 8,
91 None
92 };
93 SkASSERT(NULL == fVi);
94 if (requestedMSAASampleCount > 0) {
95 static const GLint kAttCount = SK_ARRAY_COUNT(att);
96 GLint msaaAtt[kAttCount + 4];
97 memcpy(msaaAtt, att, sizeof(att));
98 SkASSERT(None == msaaAtt[kAttCount - 1]);
99 msaaAtt[kAttCount - 1] = GLX_SAMPLE_BUFFERS_ARB;
100 msaaAtt[kAttCount + 0] = 1;
101 msaaAtt[kAttCount + 1] = GLX_SAMPLES_ARB;
102 msaaAtt[kAttCount + 2] = requestedMSAASampleCount;
103 msaaAtt[kAttCount + 3] = None;
104 fVi = glXChooseVisual(dsp, DefaultScreen(dsp), msaaAtt);
105 fMSAASampleCount = requestedMSAASampleCount;
106 }
107 if (NULL == fVi) {
108 fVi = glXChooseVisual(dsp, DefaultScreen(dsp), att);
109 fMSAASampleCount = 0;
110 }
111
112 if (fVi) {
113 if (NULL != info) {
114 glXGetConfig(dsp, fVi, GLX_SAMPLES_ARB, &info->fSampleCount);
115 glXGetConfig(dsp, fVi, GLX_STENCIL_SIZE, &info->fStencilBits);
116 }
117 Colormap colorMap = XCreateColormap(dsp,
118 RootWindow(dsp, fVi->screen),
119 fVi->visual,
120 AllocNone);
121 XSetWindowAttributes swa;
122 swa.colormap = colorMap;
123 swa.event_mask = EVENT_MASK;
124 fUnixWindow.fWin = XCreateWindow(dsp,
125 RootWindow(dsp, fVi->screen),
126 0, 0, // x, y
127 WIDTH, HEIGHT,
128 0, // border width
129 fVi->depth,
130 InputOutput,
131 fVi->visual,
132 CWEventMask | CWColormap,
133 &swa);
134 } else {
135 if (NULL != info) {
136 info->fSampleCount = 0;
137 info->fStencilBits = 0;
138 }
139 // Create a simple window instead. We will not be able to show GL
140 fUnixWindow.fWin = XCreateSimpleWindow(dsp,
141 DefaultRootWindow(dsp),
142 0, 0, // x, y
143 WIDTH, HEIGHT,
144 0, // border width
145 0, // border value
146 0); // background value
147 }
148 this->mapWindowAndWait();
149 fUnixWindow.fGc = XCreateGC(dsp, fUnixWindow.fWin, 0, NULL);
150 }
151
getModi(const XEvent & evt)152 static unsigned getModi(const XEvent& evt) {
153 static const struct {
154 unsigned fXMask;
155 unsigned fSkMask;
156 } gModi[] = {
157 // X values found by experiment. Is there a better way?
158 { 1, kShift_SkModifierKey },
159 { 4, kControl_SkModifierKey },
160 { 8, kOption_SkModifierKey },
161 };
162
163 unsigned modi = 0;
164 for (size_t i = 0; i < SK_ARRAY_COUNT(gModi); ++i) {
165 if (evt.xkey.state & gModi[i].fXMask) {
166 modi |= gModi[i].fSkMask;
167 }
168 }
169 return modi;
170 }
171
172 static SkMSec gTimerDelay;
173
MyXNextEventWithDelay(Display * dsp,XEvent * evt)174 static bool MyXNextEventWithDelay(Display* dsp, XEvent* evt) {
175 SkMSec ms = gTimerDelay;
176 if (ms > 0) {
177 int x11_fd = ConnectionNumber(dsp);
178 fd_set input_fds;
179 FD_ZERO(&input_fds);
180 FD_SET(x11_fd, &input_fds);
181
182 timeval tv;
183 tv.tv_sec = ms / 1000; // seconds
184 tv.tv_usec = (ms % 1000) * 1000; // microseconds
185
186 if (!select(x11_fd + 1, &input_fds, NULL, NULL, &tv)) {
187 if (!XPending(dsp)) {
188 return false;
189 }
190 }
191 }
192 XNextEvent(dsp, evt);
193 return true;
194 }
195
nextXEvent()196 SkOSWindow::NextXEventResult SkOSWindow::nextXEvent() {
197 XEvent evt;
198 Display* dsp = fUnixWindow.fDisplay;
199
200 if (!MyXNextEventWithDelay(fUnixWindow.fDisplay, &evt)) {
201 return kContinue_NextXEventResult;
202 }
203
204 switch (evt.type) {
205 case Expose:
206 if (0 == evt.xexpose.count) {
207 return kPaintRequest_NextXEventResult;
208 }
209 break;
210 case ConfigureNotify:
211 this->resize(evt.xconfigure.width, evt.xconfigure.height);
212 break;
213 case ButtonPress:
214 if (evt.xbutton.button == Button1)
215 this->handleClick(evt.xbutton.x, evt.xbutton.y,
216 SkView::Click::kDown_State, NULL, getModi(evt));
217 break;
218 case ButtonRelease:
219 if (evt.xbutton.button == Button1)
220 this->handleClick(evt.xbutton.x, evt.xbutton.y,
221 SkView::Click::kUp_State, NULL, getModi(evt));
222 break;
223 case MotionNotify:
224 this->handleClick(evt.xmotion.x, evt.xmotion.y,
225 SkView::Click::kMoved_State, NULL, getModi(evt));
226 break;
227 case KeyPress: {
228 int shiftLevel = (evt.xkey.state & ShiftMask) ? 1 : 0;
229 KeySym keysym = XkbKeycodeToKeysym(dsp, evt.xkey.keycode,
230 0, shiftLevel);
231 if (keysym == XK_Escape) {
232 return kQuitRequest_NextXEventResult;
233 }
234 this->handleKey(XKeyToSkKey(keysym));
235 long uni = keysym2ucs(keysym);
236 if (uni != -1) {
237 this->handleChar((SkUnichar) uni);
238 }
239 break;
240 }
241 case KeyRelease:
242 this->handleKeyUp(XKeyToSkKey(XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, 0)));
243 break;
244 default:
245 // Do nothing for other events
246 break;
247 }
248 return kContinue_NextXEventResult;
249 }
250
loop()251 void SkOSWindow::loop() {
252 Display* dsp = fUnixWindow.fDisplay;
253 if (NULL == dsp) {
254 return;
255 }
256 Window win = fUnixWindow.fWin;
257
258 XSelectInput(dsp, win, EVENT_MASK);
259
260 bool sentExposeEvent = false;
261
262 for (;;) {
263 SkEvent::ServiceQueueTimer();
264
265 bool moreToDo = SkEvent::ProcessEvent();
266
267 if (this->isDirty() && !sentExposeEvent) {
268 sentExposeEvent = true;
269
270 XEvent evt;
271 sk_bzero(&evt, sizeof(evt));
272 evt.type = Expose;
273 evt.xexpose.display = dsp;
274 XSendEvent(dsp, win, false, ExposureMask, &evt);
275 }
276
277 if (XPending(dsp) || !moreToDo) {
278 switch (this->nextXEvent()) {
279 case kContinue_NextXEventResult:
280 break;
281 case kPaintRequest_NextXEventResult:
282 sentExposeEvent = false;
283 if (this->isDirty()) {
284 this->update(NULL);
285 }
286 this->doPaint();
287 break;
288 case kQuitRequest_NextXEventResult:
289 return;
290 }
291 }
292 }
293 }
294
mapWindowAndWait()295 void SkOSWindow::mapWindowAndWait() {
296 SkASSERT(NULL != fUnixWindow.fDisplay);
297 Display* dsp = fUnixWindow.fDisplay;
298 Window win = fUnixWindow.fWin;
299 XMapWindow(dsp, win);
300
301 long eventMask = StructureNotifyMask;
302 XSelectInput(dsp, win, eventMask);
303
304 // Wait until screen is ready.
305 XEvent evt;
306 do {
307 XNextEvent(dsp, &evt);
308 } while(evt.type != MapNotify);
309
310 }
311
attach(SkBackEndTypes,int msaaSampleCount,AttachmentInfo * info)312 bool SkOSWindow::attach(SkBackEndTypes, int msaaSampleCount, AttachmentInfo* info) {
313 this->initWindow(msaaSampleCount, info);
314
315 if (NULL == fUnixWindow.fDisplay) {
316 return false;
317 }
318 if (NULL == fUnixWindow.fGLContext) {
319 SkASSERT(NULL != fVi);
320
321 fUnixWindow.fGLContext = glXCreateContext(fUnixWindow.fDisplay,
322 fVi,
323 NULL,
324 GL_TRUE);
325 if (NULL == fUnixWindow.fGLContext) {
326 return false;
327 }
328 }
329 glXMakeCurrent(fUnixWindow.fDisplay,
330 fUnixWindow.fWin,
331 fUnixWindow.fGLContext);
332 glViewport(0, 0,
333 SkScalarRound(this->width()), SkScalarRound(this->height()));
334 glClearColor(0, 0, 0, 0);
335 glClearStencil(0);
336 glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
337 return true;
338 }
339
detach()340 void SkOSWindow::detach() {
341 if (NULL == fUnixWindow.fDisplay || NULL == fUnixWindow.fGLContext) {
342 return;
343 }
344 glXMakeCurrent(fUnixWindow.fDisplay, None, NULL);
345 glXDestroyContext(fUnixWindow.fDisplay, fUnixWindow.fGLContext);
346 fUnixWindow.fGLContext = NULL;
347 }
348
present()349 void SkOSWindow::present() {
350 if (NULL != fUnixWindow.fDisplay && NULL != fUnixWindow.fGLContext) {
351 glXSwapBuffers(fUnixWindow.fDisplay, fUnixWindow.fWin);
352 }
353 }
354
onSetTitle(const char title[])355 void SkOSWindow::onSetTitle(const char title[]) {
356 if (NULL == fUnixWindow.fDisplay) {
357 return;
358 }
359 XTextProperty textProp;
360 textProp.value = (unsigned char*)title;
361 textProp.format = 8;
362 textProp.nitems = strlen((char*)textProp.value);
363 textProp.encoding = XA_STRING;
364 XSetWMName(fUnixWindow.fDisplay, fUnixWindow.fWin, &textProp);
365 }
366
convertBitmapToXImage(XImage & image,const SkBitmap & bitmap)367 static bool convertBitmapToXImage(XImage& image, const SkBitmap& bitmap) {
368 sk_bzero(&image, sizeof(image));
369
370 int bitsPerPixel = bitmap.bytesPerPixel() * 8;
371 image.width = bitmap.width();
372 image.height = bitmap.height();
373 image.format = ZPixmap;
374 image.data = (char*) bitmap.getPixels();
375 image.byte_order = LSBFirst;
376 image.bitmap_unit = bitsPerPixel;
377 image.bitmap_bit_order = LSBFirst;
378 image.bitmap_pad = bitsPerPixel;
379 image.depth = 24;
380 image.bytes_per_line = bitmap.rowBytes() - bitmap.width() * 4;
381 image.bits_per_pixel = bitsPerPixel;
382 return XInitImage(&image);
383 }
384
doPaint()385 void SkOSWindow::doPaint() {
386 if (NULL == fUnixWindow.fDisplay) {
387 return;
388 }
389 // If we are drawing with GL, we don't need XPutImage.
390 if (NULL != fUnixWindow.fGLContext) {
391 return;
392 }
393 // Draw the bitmap to the screen.
394 const SkBitmap& bitmap = getBitmap();
395 int width = bitmap.width();
396 int height = bitmap.height();
397
398 XImage image;
399 if (!convertBitmapToXImage(image, bitmap)) {
400 return;
401 }
402
403 XPutImage(fUnixWindow.fDisplay,
404 fUnixWindow.fWin,
405 fUnixWindow.fGc,
406 &image,
407 0, 0, // src x,y
408 0, 0, // dst x,y
409 width, height);
410 }
411
412 ///////////////////////////////////////////////////////////////////////////////
413
SignalNonEmptyQueue()414 void SkEvent::SignalNonEmptyQueue() {
415 // nothing to do, since we spin on our event-queue, polling for XPending
416 }
417
SignalQueueTimer(SkMSec delay)418 void SkEvent::SignalQueueTimer(SkMSec delay) {
419 // just need to record the delay time. We handle waking up for it in
420 // MyXNextEventWithDelay()
421 gTimerDelay = delay;
422 }
423