diff -r 000000000000 -r 6474c204b198 gfx/skia/trunk/src/views/unix/SkOSWindow_Unix.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gfx/skia/trunk/src/views/unix/SkOSWindow_Unix.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,430 @@
+
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/XKBlib.h>
+#include <GL/glx.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#include "SkWindow.h"
+
+#include "SkBitmap.h"
+#include "SkCanvas.h"
+#include "SkColor.h"
+#include "SkEvent.h"
+#include "SkKey.h"
+#include "SkWindow.h"
+#include "XkeysToSkKeys.h"
+extern "C" {
+    #include "keysym2ucs.h"
+}
+
+const int WIDTH = 500;
+const int HEIGHT = 500;
+
+// Determine which events to listen for.
+const long EVENT_MASK = StructureNotifyMask|ButtonPressMask|ButtonReleaseMask
+        |ExposureMask|PointerMotionMask|KeyPressMask|KeyReleaseMask;
+
+SkOSWindow::SkOSWindow(void*)
+    : fVi(NULL)
+    , fMSAASampleCount(0) {
+    fUnixWindow.fDisplay = NULL;
+    fUnixWindow.fGLContext = NULL;
+    this->initWindow(0, NULL);
+    this->resize(WIDTH, HEIGHT);
+}
+
+SkOSWindow::~SkOSWindow() {
+    this->closeWindow();
+}
+
+void SkOSWindow::closeWindow() {
+    if (NULL != fUnixWindow.fDisplay) {
+        this->detach();
+        SkASSERT(NULL != fUnixWindow.fGc);
+        XFreeGC(fUnixWindow.fDisplay, fUnixWindow.fGc);
+        fUnixWindow.fGc = NULL;
+        XDestroyWindow(fUnixWindow.fDisplay, fUnixWindow.fWin);
+        fVi = NULL;
+        XCloseDisplay(fUnixWindow.fDisplay);
+        fUnixWindow.fDisplay = NULL;
+        fMSAASampleCount = 0;
+    }
+}
+
+void SkOSWindow::initWindow(int requestedMSAASampleCount, AttachmentInfo* info) {
+    if (fMSAASampleCount != requestedMSAASampleCount) {
+        this->closeWindow();
+    }
+    // presence of fDisplay means we already have a window
+    if (NULL != fUnixWindow.fDisplay) {
+        if (NULL != info) {
+            if (NULL != fVi) {
+                glXGetConfig(fUnixWindow.fDisplay, fVi, GLX_SAMPLES_ARB, &info->fSampleCount);
+                glXGetConfig(fUnixWindow.fDisplay, fVi, GLX_STENCIL_SIZE, &info->fStencilBits);
+            } else {
+                info->fSampleCount = 0;
+                info->fStencilBits = 0;
+            }
+        }
+        return;
+    }
+    fUnixWindow.fDisplay = XOpenDisplay(NULL);
+    Display* dsp = fUnixWindow.fDisplay;
+    if (NULL == dsp) {
+        SkDebugf("Could not open an X Display");
+        return;
+    }
+    // Attempt to create a window that supports GL
+    GLint att[] = {
+        GLX_RGBA,
+        GLX_DEPTH_SIZE, 24,
+        GLX_DOUBLEBUFFER,
+        GLX_STENCIL_SIZE, 8,
+        None
+    };
+    SkASSERT(NULL == fVi);
+    if (requestedMSAASampleCount > 0) {
+        static const GLint kAttCount = SK_ARRAY_COUNT(att);
+        GLint msaaAtt[kAttCount + 4];
+        memcpy(msaaAtt, att, sizeof(att));
+        SkASSERT(None == msaaAtt[kAttCount - 1]);
+        msaaAtt[kAttCount - 1] = GLX_SAMPLE_BUFFERS_ARB;
+        msaaAtt[kAttCount + 0] = 1;
+        msaaAtt[kAttCount + 1] = GLX_SAMPLES_ARB;
+        msaaAtt[kAttCount + 2] = requestedMSAASampleCount;
+        msaaAtt[kAttCount + 3] = None;
+        fVi = glXChooseVisual(dsp, DefaultScreen(dsp), msaaAtt);
+        fMSAASampleCount = requestedMSAASampleCount;
+    }
+    if (NULL == fVi) {
+        fVi = glXChooseVisual(dsp, DefaultScreen(dsp), att);
+        fMSAASampleCount = 0;
+    }
+
+    if (fVi) {
+        if (NULL != info) {
+            glXGetConfig(dsp, fVi, GLX_SAMPLES_ARB, &info->fSampleCount);
+            glXGetConfig(dsp, fVi, GLX_STENCIL_SIZE, &info->fStencilBits);
+        }
+        Colormap colorMap = XCreateColormap(dsp,
+                                            RootWindow(dsp, fVi->screen),
+                                            fVi->visual,
+                                             AllocNone);
+        XSetWindowAttributes swa;
+        swa.colormap = colorMap;
+        swa.event_mask = EVENT_MASK;
+        fUnixWindow.fWin = XCreateWindow(dsp,
+                                         RootWindow(dsp, fVi->screen),
+                                         0, 0, // x, y
+                                         WIDTH, HEIGHT,
+                                         0, // border width
+                                         fVi->depth,
+                                         InputOutput,
+                                         fVi->visual,
+                                         CWEventMask | CWColormap,
+                                         &swa);
+    } else {
+        if (NULL != info) {
+            info->fSampleCount = 0;
+            info->fStencilBits = 0;
+        }
+        // Create a simple window instead.  We will not be able to show GL
+        fUnixWindow.fWin = XCreateSimpleWindow(dsp,
+                                               DefaultRootWindow(dsp),
+                                               0, 0,  // x, y
+                                               WIDTH, HEIGHT,
+                                               0,     // border width
+                                               0,     // border value
+                                               0);    // background value
+    }
+    this->mapWindowAndWait();
+    fUnixWindow.fGc = XCreateGC(dsp, fUnixWindow.fWin, 0, NULL);
+}
+
+static unsigned getModi(const XEvent& evt) {
+    static const struct {
+        unsigned    fXMask;
+        unsigned    fSkMask;
+    } gModi[] = {
+        // X values found by experiment. Is there a better way?
+        { 1,    kShift_SkModifierKey },
+        { 4,    kControl_SkModifierKey },
+        { 8,    kOption_SkModifierKey },
+    };
+
+    unsigned modi = 0;
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gModi); ++i) {
+        if (evt.xkey.state & gModi[i].fXMask) {
+            modi |= gModi[i].fSkMask;
+        }
+    }
+    return modi;
+}
+
+static SkMSec gTimerDelay;
+
+static bool MyXNextEventWithDelay(Display* dsp, XEvent* evt) {
+    // Check for pending events before entering the select loop. There might
+    // be events in the in-memory queue but not processed yet.
+    if (XPending(dsp)) {
+        XNextEvent(dsp, evt);
+        return true;
+    }
+
+    SkMSec ms = gTimerDelay;
+    if (ms > 0) {
+        int x11_fd = ConnectionNumber(dsp);
+        fd_set input_fds;
+        FD_ZERO(&input_fds);
+        FD_SET(x11_fd, &input_fds);
+
+        timeval tv;
+        tv.tv_sec = ms / 1000;              // seconds
+        tv.tv_usec = (ms % 1000) * 1000;    // microseconds
+
+        if (!select(x11_fd + 1, &input_fds, NULL, NULL, &tv)) {
+            if (!XPending(dsp)) {
+                return false;
+            }
+        }
+    }
+    XNextEvent(dsp, evt);
+    return true;
+}
+
+SkOSWindow::NextXEventResult SkOSWindow::nextXEvent() {
+    XEvent evt;
+    Display* dsp = fUnixWindow.fDisplay;
+
+    if (!MyXNextEventWithDelay(fUnixWindow.fDisplay, &evt)) {
+        return kContinue_NextXEventResult;
+    }
+
+    switch (evt.type) {
+        case Expose:
+            if (0 == evt.xexpose.count) {
+                return kPaintRequest_NextXEventResult;
+            }
+            break;
+        case ConfigureNotify:
+            this->resize(evt.xconfigure.width, evt.xconfigure.height);
+            break;
+        case ButtonPress:
+            if (evt.xbutton.button == Button1)
+                this->handleClick(evt.xbutton.x, evt.xbutton.y,
+                            SkView::Click::kDown_State, NULL, getModi(evt));
+            break;
+        case ButtonRelease:
+            if (evt.xbutton.button == Button1)
+                this->handleClick(evt.xbutton.x, evt.xbutton.y,
+                              SkView::Click::kUp_State, NULL, getModi(evt));
+            break;
+        case MotionNotify:
+            this->handleClick(evt.xmotion.x, evt.xmotion.y,
+                           SkView::Click::kMoved_State, NULL, getModi(evt));
+            break;
+        case KeyPress: {
+            int shiftLevel = (evt.xkey.state & ShiftMask) ? 1 : 0;
+            KeySym keysym = XkbKeycodeToKeysym(dsp, evt.xkey.keycode,
+                                               0, shiftLevel);
+            if (keysym == XK_Escape) {
+                return kQuitRequest_NextXEventResult;
+            }
+            this->handleKey(XKeyToSkKey(keysym));
+            long uni = keysym2ucs(keysym);
+            if (uni != -1) {
+                this->handleChar((SkUnichar) uni);
+            }
+            break;
+        }
+        case KeyRelease:
+            this->handleKeyUp(XKeyToSkKey(XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, 0)));
+            break;
+        default:
+            // Do nothing for other events
+            break;
+    }
+    return kContinue_NextXEventResult;
+}
+
+void SkOSWindow::loop() {
+    Display* dsp = fUnixWindow.fDisplay;
+    if (NULL == dsp) {
+        return;
+    }
+    Window win = fUnixWindow.fWin;
+
+    XSelectInput(dsp, win, EVENT_MASK);
+
+    bool sentExposeEvent = false;
+
+    for (;;) {
+        SkEvent::ServiceQueueTimer();
+
+        bool moreToDo = SkEvent::ProcessEvent();
+
+        if (this->isDirty() && !sentExposeEvent) {
+            sentExposeEvent = true;
+
+            XEvent evt;
+            sk_bzero(&evt, sizeof(evt));
+            evt.type = Expose;
+            evt.xexpose.display = dsp;
+            XSendEvent(dsp, win, false, ExposureMask, &evt);
+        }
+
+        if (XPending(dsp) || !moreToDo) {
+            switch (this->nextXEvent()) {
+                case kContinue_NextXEventResult:
+                    break;
+                case kPaintRequest_NextXEventResult:
+                    sentExposeEvent = false;
+                    if (this->isDirty()) {
+                        this->update(NULL);
+                    }
+                    this->doPaint();
+                    break;
+                case kQuitRequest_NextXEventResult:
+                    return;
+            }
+        }
+    }
+}
+
+void SkOSWindow::mapWindowAndWait() {
+    SkASSERT(NULL != fUnixWindow.fDisplay);
+    Display* dsp = fUnixWindow.fDisplay;
+    Window win = fUnixWindow.fWin;
+    XMapWindow(dsp, win);
+
+    long eventMask = StructureNotifyMask;
+    XSelectInput(dsp, win, eventMask);
+
+    // Wait until screen is ready.
+    XEvent evt;
+    do {
+        XNextEvent(dsp, &evt);
+    } while(evt.type != MapNotify);
+
+}
+
+bool SkOSWindow::attach(SkBackEndTypes, int msaaSampleCount, AttachmentInfo* info) {
+    this->initWindow(msaaSampleCount, info);
+
+    if (NULL == fUnixWindow.fDisplay) {
+        return false;
+    }
+    if (NULL == fUnixWindow.fGLContext) {
+        SkASSERT(NULL != fVi);
+
+        fUnixWindow.fGLContext = glXCreateContext(fUnixWindow.fDisplay,
+                                                  fVi,
+                                                  NULL,
+                                                  GL_TRUE);
+        if (NULL == fUnixWindow.fGLContext) {
+            return false;
+        }
+    }
+    glXMakeCurrent(fUnixWindow.fDisplay,
+                   fUnixWindow.fWin,
+                   fUnixWindow.fGLContext);
+    glViewport(0, 0,
+               SkScalarRoundToInt(this->width()),
+               SkScalarRoundToInt(this->height()));
+    glClearColor(0, 0, 0, 0);
+    glClearStencil(0);
+    glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+    return true;
+}
+
+void SkOSWindow::detach() {
+    if (NULL == fUnixWindow.fDisplay || NULL == fUnixWindow.fGLContext) {
+        return;
+    }
+    glXMakeCurrent(fUnixWindow.fDisplay, None, NULL);
+    glXDestroyContext(fUnixWindow.fDisplay, fUnixWindow.fGLContext);
+    fUnixWindow.fGLContext = NULL;
+}
+
+void SkOSWindow::present() {
+    if (NULL != fUnixWindow.fDisplay && NULL != fUnixWindow.fGLContext) {
+        glXSwapBuffers(fUnixWindow.fDisplay, fUnixWindow.fWin);
+    }
+}
+
+void SkOSWindow::onSetTitle(const char title[]) {
+    if (NULL == fUnixWindow.fDisplay) {
+        return;
+    }
+    XTextProperty textProp;
+    textProp.value = (unsigned char*)title;
+    textProp.format = 8;
+    textProp.nitems = strlen((char*)textProp.value);
+    textProp.encoding = XA_STRING;
+    XSetWMName(fUnixWindow.fDisplay, fUnixWindow.fWin, &textProp);
+}
+
+static bool convertBitmapToXImage(XImage& image, const SkBitmap& bitmap) {
+    sk_bzero(&image, sizeof(image));
+
+    int bitsPerPixel = bitmap.bytesPerPixel() * 8;
+    image.width = bitmap.width();
+    image.height = bitmap.height();
+    image.format = ZPixmap;
+    image.data = (char*) bitmap.getPixels();
+    image.byte_order = LSBFirst;
+    image.bitmap_unit = bitsPerPixel;
+    image.bitmap_bit_order = LSBFirst;
+    image.bitmap_pad = bitsPerPixel;
+    image.depth = 24;
+    image.bytes_per_line = bitmap.rowBytes() - bitmap.width() * 4;
+    image.bits_per_pixel = bitsPerPixel;
+    return XInitImage(&image);
+}
+
+void SkOSWindow::doPaint() {
+    if (NULL == fUnixWindow.fDisplay) {
+        return;
+    }
+    // If we are drawing with GL, we don't need XPutImage.
+    if (NULL != fUnixWindow.fGLContext) {
+        return;
+    }
+    // Draw the bitmap to the screen.
+    const SkBitmap& bitmap = getBitmap();
+    int width = bitmap.width();
+    int height = bitmap.height();
+
+    XImage image;
+    if (!convertBitmapToXImage(image, bitmap)) {
+        return;
+    }
+
+    XPutImage(fUnixWindow.fDisplay,
+              fUnixWindow.fWin,
+              fUnixWindow.fGc,
+              &image,
+              0, 0,     // src x,y
+              0, 0,     // dst x,y
+              width, height);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SkEvent::SignalNonEmptyQueue() {
+    // nothing to do, since we spin on our event-queue, polling for XPending
+}
+
+void SkEvent::SignalQueueTimer(SkMSec delay) {
+    // just need to record the delay time. We handle waking up for it in
+    // MyXNextEventWithDelay()
+    gTimerDelay = delay;
+}