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 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 44 SkOSWindow::~SkOSWindow() { 45 this->closeWindow(); 46 } 47 48 void SkOSWindow::closeWindow() { 49 if (fUnixWindow.fDisplay) { 50 this->detach(); 51 SkASSERT(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 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 (fUnixWindow.fDisplay) { 68 if (info) { 69 if (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 (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 (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 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 174 static bool MyXNextEventWithDelay(Display* dsp, XEvent* evt) { 175 // Check for pending events before entering the select loop. There might 176 // be events in the in-memory queue but not processed yet. 177 if (XPending(dsp)) { 178 XNextEvent(dsp, evt); 179 return true; 180 } 181 182 SkMSec ms = gTimerDelay; 183 if (ms > 0) { 184 int x11_fd = ConnectionNumber(dsp); 185 fd_set input_fds; 186 FD_ZERO(&input_fds); 187 FD_SET(x11_fd, &input_fds); 188 189 timeval tv; 190 tv.tv_sec = ms / 1000; // seconds 191 tv.tv_usec = (ms % 1000) * 1000; // microseconds 192 193 if (!select(x11_fd + 1, &input_fds, NULL, NULL, &tv)) { 194 if (!XPending(dsp)) { 195 return false; 196 } 197 } 198 } 199 XNextEvent(dsp, evt); 200 return true; 201 } 202 203 static Atom wm_delete_window_message; 204 205 SkOSWindow::NextXEventResult SkOSWindow::nextXEvent() { 206 XEvent evt; 207 Display* dsp = fUnixWindow.fDisplay; 208 209 if (!MyXNextEventWithDelay(dsp, &evt)) { 210 return kContinue_NextXEventResult; 211 } 212 213 switch (evt.type) { 214 case Expose: 215 if (0 == evt.xexpose.count) { 216 return kPaintRequest_NextXEventResult; 217 } 218 break; 219 case ConfigureNotify: 220 this->resize(evt.xconfigure.width, evt.xconfigure.height); 221 break; 222 case ButtonPress: 223 if (evt.xbutton.button == Button1) 224 this->handleClick(evt.xbutton.x, evt.xbutton.y, 225 SkView::Click::kDown_State, NULL, getModi(evt)); 226 break; 227 case ButtonRelease: 228 if (evt.xbutton.button == Button1) 229 this->handleClick(evt.xbutton.x, evt.xbutton.y, 230 SkView::Click::kUp_State, NULL, getModi(evt)); 231 break; 232 case MotionNotify: 233 this->handleClick(evt.xmotion.x, evt.xmotion.y, 234 SkView::Click::kMoved_State, NULL, getModi(evt)); 235 break; 236 case KeyPress: { 237 int shiftLevel = (evt.xkey.state & ShiftMask) ? 1 : 0; 238 KeySym keysym = XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 239 0, shiftLevel); 240 if (keysym == XK_Escape) { 241 return kQuitRequest_NextXEventResult; 242 } 243 this->handleKey(XKeyToSkKey(keysym)); 244 long uni = keysym2ucs(keysym); 245 if (uni != -1) { 246 this->handleChar((SkUnichar) uni); 247 } 248 break; 249 } 250 case KeyRelease: 251 this->handleKeyUp(XKeyToSkKey(XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, 0))); 252 break; 253 case ClientMessage: 254 if ((Atom)evt.xclient.data.l[0] == wm_delete_window_message) { 255 return kQuitRequest_NextXEventResult; 256 } 257 // fallthrough 258 default: 259 // Do nothing for other events 260 break; 261 } 262 return kContinue_NextXEventResult; 263 } 264 265 void SkOSWindow::loop() { 266 Display* dsp = fUnixWindow.fDisplay; 267 if (NULL == dsp) { 268 return; 269 } 270 Window win = fUnixWindow.fWin; 271 272 wm_delete_window_message = XInternAtom(dsp, "WM_DELETE_WINDOW", False); 273 XSetWMProtocols(dsp, win, &wm_delete_window_message, 1); 274 275 XSelectInput(dsp, win, EVENT_MASK); 276 277 bool sentExposeEvent = false; 278 279 for (;;) { 280 SkEvent::ServiceQueueTimer(); 281 282 bool moreToDo = SkEvent::ProcessEvent(); 283 284 if (this->isDirty() && !sentExposeEvent) { 285 sentExposeEvent = true; 286 287 XEvent evt; 288 sk_bzero(&evt, sizeof(evt)); 289 evt.type = Expose; 290 evt.xexpose.display = dsp; 291 XSendEvent(dsp, win, false, ExposureMask, &evt); 292 } 293 294 if (XPending(dsp) || !moreToDo) { 295 switch (this->nextXEvent()) { 296 case kContinue_NextXEventResult: 297 break; 298 case kPaintRequest_NextXEventResult: 299 sentExposeEvent = false; 300 if (this->isDirty()) { 301 this->update(NULL); 302 } 303 this->doPaint(); 304 break; 305 case kQuitRequest_NextXEventResult: 306 return; 307 } 308 } 309 } 310 } 311 312 void SkOSWindow::mapWindowAndWait() { 313 SkASSERT(fUnixWindow.fDisplay); 314 Display* dsp = fUnixWindow.fDisplay; 315 Window win = fUnixWindow.fWin; 316 XMapWindow(dsp, win); 317 318 long eventMask = StructureNotifyMask; 319 XSelectInput(dsp, win, eventMask); 320 321 // Wait until screen is ready. 322 XEvent evt; 323 do { 324 XNextEvent(dsp, &evt); 325 } while(evt.type != MapNotify); 326 327 } 328 329 bool SkOSWindow::attach(SkBackEndTypes, int msaaSampleCount, AttachmentInfo* info) { 330 this->initWindow(msaaSampleCount, info); 331 332 if (NULL == fUnixWindow.fDisplay) { 333 return false; 334 } 335 if (NULL == fUnixWindow.fGLContext) { 336 SkASSERT(fVi); 337 338 fUnixWindow.fGLContext = glXCreateContext(fUnixWindow.fDisplay, 339 fVi, 340 NULL, 341 GL_TRUE); 342 if (NULL == fUnixWindow.fGLContext) { 343 return false; 344 } 345 } 346 glXMakeCurrent(fUnixWindow.fDisplay, 347 fUnixWindow.fWin, 348 fUnixWindow.fGLContext); 349 glViewport(0, 0, 350 SkScalarRoundToInt(this->width()), 351 SkScalarRoundToInt(this->height())); 352 glClearColor(0, 0, 0, 0); 353 glClearStencil(0); 354 glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); 355 return true; 356 } 357 358 void SkOSWindow::detach() { 359 if (NULL == fUnixWindow.fDisplay || NULL == fUnixWindow.fGLContext) { 360 return; 361 } 362 glXMakeCurrent(fUnixWindow.fDisplay, None, NULL); 363 glXDestroyContext(fUnixWindow.fDisplay, fUnixWindow.fGLContext); 364 fUnixWindow.fGLContext = NULL; 365 } 366 367 void SkOSWindow::present() { 368 if (fUnixWindow.fDisplay && fUnixWindow.fGLContext) { 369 glXSwapBuffers(fUnixWindow.fDisplay, fUnixWindow.fWin); 370 } 371 } 372 373 void SkOSWindow::onSetTitle(const char title[]) { 374 if (NULL == fUnixWindow.fDisplay) { 375 return; 376 } 377 XTextProperty textProp; 378 textProp.value = (unsigned char*)title; 379 textProp.format = 8; 380 textProp.nitems = strlen((char*)textProp.value); 381 textProp.encoding = XA_STRING; 382 XSetWMName(fUnixWindow.fDisplay, fUnixWindow.fWin, &textProp); 383 } 384 385 static bool convertBitmapToXImage(XImage& image, const SkBitmap& bitmap) { 386 sk_bzero(&image, sizeof(image)); 387 388 int bitsPerPixel = bitmap.bytesPerPixel() * 8; 389 image.width = bitmap.width(); 390 image.height = bitmap.height(); 391 image.format = ZPixmap; 392 image.data = (char*) bitmap.getPixels(); 393 image.byte_order = LSBFirst; 394 image.bitmap_unit = bitsPerPixel; 395 image.bitmap_bit_order = LSBFirst; 396 image.bitmap_pad = bitsPerPixel; 397 image.depth = 24; 398 image.bytes_per_line = bitmap.rowBytes() - bitmap.width() * 4; 399 image.bits_per_pixel = bitsPerPixel; 400 return XInitImage(&image); 401 } 402 403 void SkOSWindow::doPaint() { 404 if (NULL == fUnixWindow.fDisplay) { 405 return; 406 } 407 // If we are drawing with GL, we don't need XPutImage. 408 if (fUnixWindow.fGLContext) { 409 return; 410 } 411 // Draw the bitmap to the screen. 412 const SkBitmap& bitmap = getBitmap(); 413 int width = bitmap.width(); 414 int height = bitmap.height(); 415 416 XImage image; 417 if (!convertBitmapToXImage(image, bitmap)) { 418 return; 419 } 420 421 XPutImage(fUnixWindow.fDisplay, 422 fUnixWindow.fWin, 423 fUnixWindow.fGc, 424 &image, 425 0, 0, // src x,y 426 0, 0, // dst x,y 427 width, height); 428 } 429 430 /////////////////////////////////////////////////////////////////////////////// 431 432 void SkEvent::SignalNonEmptyQueue() { 433 // nothing to do, since we spin on our event-queue, polling for XPending 434 } 435 436 void SkEvent::SignalQueueTimer(SkMSec delay) { 437 // just need to record the delay time. We handle waking up for it in 438 // MyXNextEventWithDelay() 439 gTimerDelay = delay; 440 } 441
